_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 30
4.3k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1200 | Lex.Linter.validate_tokens | train | def validate_tokens(lexer)
if lexer.lex_tokens.empty?
complain("No token list defined")
end
if !lexer.lex_tokens.respond_to?(:to_ary)
complain("Tokens must be a list or enumerable")
end
terminals = []
lexer.lex_tokens.each do |token|
if !identifier?(token) | ruby | {
"resource": ""
} |
q1201 | Lex.Linter.validate_states | train | def validate_states(lexer)
if !lexer.state_info.respond_to?(:each_pair)
complain("States must be defined as a hash")
end
lexer.state_info.each do |state_name, state_type|
if ![:inclusive, :exclusive].include?(state_type)
complain("State type for state #{state_name}" \
" must be :inclusive or :exclusive")
end
if state_type == :exclusive
if !lexer.state_error.key?(state_name)
lexer.logger.warn("No error rule is defined " \
| ruby | {
"resource": ""
} |
q1202 | Scorched.Response.body= | train | def body=(value)
value = [] if !value || value | ruby | {
"resource": ""
} |
q1203 | Scorched.Response.finish | train | def finish(*args, &block)
self['Content-Type'] ||= 'text/html;charset=utf-8'
@block = block if block
if [204, 205, 304].include?(status.to_i)
header.delete "Content-Type"
| ruby | {
"resource": ""
} |
q1204 | Scorched.Controller.try_matches | train | def try_matches
eligable_matches.each do |match,idx|
request.breadcrumb << match
catch(:pass) {
dispatch(match)
| ruby | {
"resource": ""
} |
q1205 | Scorched.Controller.dispatch | train | def dispatch(match)
@_dispatched = true
target = match.mapping[:target]
response.merge! begin
if Proc === target
instance_exec(&target)
else
target.call(env.merge(
'SCRIPT_NAME' => request.matched_path.chomp('/'),
| ruby | {
"resource": ""
} |
q1206 | Scorched.Controller.matches | train | def matches
@_matches ||= begin
to_match = request.unmatched_path
to_match = to_match.chomp('/') if config[:strip_trailing_slash] == :ignore && to_match =~ %r{./$}
mappings.map { |mapping|
mapping[:pattern].match(to_match) do |match_data|
if match_data.pre_match == ''
if match_data.names.empty?
captures = match_data.captures
else
captures = Hash[match_data.names.map {|v| v.to_sym}.zip(match_data.captures)]
captures.each do | ruby | {
"resource": ""
} |
q1207 | Scorched.Controller.eligable_matches | train | def eligable_matches
@_eligable_matches ||= begin
matches.select { |m| m.failed_condition.nil? }.each_with_index.sort_by do |m,idx|
priority = m.mapping[:priority] || 0
media_type_rank = [*m.mapping[:conditions][:media_type]].map { |type|
| ruby | {
"resource": ""
} |
q1208 | Scorched.Controller.check_for_failed_condition | train | def check_for_failed_condition(conds)
failed = (conds || []).find { |c, v| !check_condition?(c, v) }
if failed
| ruby | {
"resource": ""
} |
q1209 | Scorched.Controller.check_condition? | train | def check_condition?(c, v)
c = c[0..-2].to_sym if invert = (c[-1] == '!')
raise Error, "The condition `#{c}` either does | ruby | {
"resource": ""
} |
q1210 | Scorched.Controller.redirect | train | def redirect(url, status: (env['HTTP_VERSION'] == 'HTTP/1.1') ? 303 : 302, halt: true) | ruby | {
"resource": ""
} |
q1211 | Scorched.Controller.flash | train | def flash(key = :flash)
raise Error, "Flash session data cannot be used without a valid Rack session" unless session
flash_hash = env['scorched.flash'] ||= {}
| ruby | {
"resource": ""
} |
q1212 | Scorched.Controller.run_filters | train | def run_filters(type)
halted = false
tracker = env['scorched.executed_filters'] ||= {before: Set.new, after: Set.new}
filters[type].reject { |f| tracker[type].include?(f) | ruby | {
"resource": ""
} |
q1213 | Scorched.Request.unescaped_path | train | def unescaped_path
path_info.split(/(%25|%2F)/i).each_slice(2).map | ruby | {
"resource": ""
} |
q1214 | SoftLayer.Server.reboot! | train | def reboot!(reboot_technique = :default_reboot)
case reboot_technique
when :default_reboot
self.service.rebootDefault
when :os_reboot
| ruby | {
"resource": ""
} |
q1215 | SoftLayer.Server.notes= | train | def notes=(new_notes)
raise ArgumentError, "The new notes cannot be nil" unless new_notes
| ruby | {
"resource": ""
} |
q1216 | SoftLayer.Server.set_hostname! | train | def set_hostname!(new_hostname)
raise ArgumentError, "The new hostname cannot be nil" unless new_hostname
raise ArgumentError, "The new hostname cannot be empty" if new_hostname.empty?
edit_template = { | ruby | {
"resource": ""
} |
q1217 | SoftLayer.Server.set_domain! | train | def set_domain!(new_domain)
raise ArgumentError, "The new hostname cannot be nil" unless new_domain
raise ArgumentError, "The new hostname cannot be empty" if new_domain.empty?
edit_template = {
| ruby | {
"resource": ""
} |
q1218 | SoftLayer.Server.change_port_speed | train | def change_port_speed(new_speed, public = true)
if public
self.service.setPublicNetworkInterfaceSpeed(new_speed)
| ruby | {
"resource": ""
} |
q1219 | SoftLayer.Server.reload_os! | train | def reload_os!(token = '', provisioning_script_uri = nil, ssh_keys = nil)
configuration = {}
configuration['customProvisionScriptUri'] = provisioning_script_uri if provisioning_script_uri
| ruby | {
"resource": ""
} |
q1220 | Drone.Plugin.parse | train | def parse
self.result ||= Payload.new.tap do |payload|
PayloadRepresenter.new(
payload
).from_json(
input
| ruby | {
"resource": ""
} |
q1221 | SoftLayer.APIParameterFilter.object_filter | train | def object_filter(filter)
raise ArgumentError, "object_filter expects an instance of SoftLayer::ObjectFilter" if filter.nil? || !filter.kind_of?(SoftLayer::ObjectFilter)
# we create a new object in case the user wants to store | ruby | {
"resource": ""
} |
q1222 | SoftLayer.VirtualServerUpgradeOrder.verify | train | def verify()
if has_order_items?
order_template = order_object
order_template = yield order_object if block_given?
| ruby | {
"resource": ""
} |
q1223 | SoftLayer.VirtualServerUpgradeOrder.place_order! | train | def place_order!()
if has_order_items?
order_template = order_object
order_template = yield order_object if block_given?
| ruby | {
"resource": ""
} |
q1224 | SoftLayer.VirtualServerUpgradeOrder._item_prices_in_category | train | def _item_prices_in_category(which_category)
@virtual_server.upgrade_options.select { |item_price| item_price['categories'].find { | ruby | {
"resource": ""
} |
q1225 | SoftLayer.VirtualServerUpgradeOrder._item_price_with_capacity | train | def _item_price_with_capacity(which_category, capacity)
_item_prices_in_category(which_category).find { |item_price| | ruby | {
"resource": ""
} |
q1226 | SoftLayer.VirtualServerUpgradeOrder.order_object | train | def order_object
prices = []
cores_price_item = @cores ? _item_price_with_capacity("guest_core", @cores) : nil
ram_price_item = @ram ? _item_price_with_capacity("ram", @ram) : nil
max_port_speed_price_item = @max_port_speed ? _item_price_with_capacity("port_speed", @max_port_speed) : nil
prices << { "id" => cores_price_item['id'] } if cores_price_item
| ruby | {
"resource": ""
} |
q1227 | SoftLayer.NetworkStorage.assign_credential | train | def assign_credential(username)
raise ArgumentError, "The username cannot be nil" unless username
raise ArgumentError, "The username cannot be empty" if username.empty?
| ruby | {
"resource": ""
} |
q1228 | SoftLayer.NetworkStorage.password= | train | def password=(password)
raise ArgumentError, "The new password cannot be nil" unless password
raise ArgumentError, | ruby | {
"resource": ""
} |
q1229 | SoftLayer.NetworkStorage.remove_credential | train | def remove_credential(username)
raise ArgumentError, "The username cannot be nil" unless username
raise ArgumentError, "The username cannot be empty" if username.empty?
| ruby | {
"resource": ""
} |
q1230 | SoftLayer.NetworkStorage.softlayer_properties | train | def softlayer_properties(object_mask = nil)
my_service = self.service
if(object_mask)
my_service = my_service.object_mask(object_mask)
else
my_service | ruby | {
"resource": ""
} |
q1231 | SoftLayer.NetworkStorage.update_credential_password | train | def update_credential_password(username, password)
raise ArgumentError, "The new password cannot be nil" unless password
raise ArgumentError, "The new username cannot be nil" unless username
raise ArgumentError, "The new password cannot be empty" | ruby | {
"resource": ""
} |
q1232 | SoftLayer.ProductPackage.items_with_description | train | def items_with_description(expected_description)
filter = ObjectFilter.new { |filter| filter.accept("items.description").when_it is(expected_description) }
items_data = self.service.object_filter(filter).getItems()
items_data.collect | ruby | {
"resource": ""
} |
q1233 | SoftLayer.ImageTemplate.available_datacenters | train | def available_datacenters
datacenters_data = self.service.getStorageLocations()
datacenters_data.collect { |datacenter_data| | ruby | {
"resource": ""
} |
q1234 | SoftLayer.ImageTemplate.shared_with_accounts= | train | def shared_with_accounts= (account_id_list)
already_sharing_with = self.shared_with_accounts
accounts_to_add = account_id_list.select { |account_id| !already_sharing_with.include?(account_id) }
# Note, using the network API, it is possible to "unshare" an image template
# with the account that owns it, however, this leads to a rather odd state
# where the image has allocated resources (that the account may be charged for)
# but no | ruby | {
"resource": ""
} |
q1235 | SoftLayer.ImageTemplate.wait_until_ready | train | def wait_until_ready(max_trials, seconds_between_tries = 2)
# pessimistically assume the server is not ready
num_trials = 0
begin
self.refresh_details()
parent_ready = !(has_sl_property? :transactionId) || (self[:transactionId] == "")
children_ready = (nil == self['children'].find { |child| child['transactionId'] != "" })
ready = parent_ready && children_ready
| ruby | {
"resource": ""
} |
q1236 | SoftLayer.ServerFirewallOrder.verify | train | def verify()
order_template = firewall_order_template
order_template = yield order_template if block_given?
| ruby | {
"resource": ""
} |
q1237 | SoftLayer.VLANFirewall.cancel! | train | def cancel!(notes = nil)
user = self.softlayer_client[:Account].object_mask("mask[id,account.id]").getCurrentUser
notes = "Cancelled by a call to #{__method__} in the softlayer_api gem" if notes == nil || notes == ""
cancellation_request = {
'accountId' => user['account']['id'],
'userId' => user['id'],
'items' => | ruby | {
"resource": ""
} |
q1238 | SoftLayer.VLANFirewall.change_rules_bypass! | train | def change_rules_bypass!(bypass_symbol)
change_object = {
"firewallContextAccessControlListId" => rules_ACL_id(),
"rules" => self.rules
}
case bypass_symbol
when :apply_firewall_rules
change_object['bypassFlag'] = false
self.softlayer_client[:Network_Firewall_Update_Request].createObject(change_object)
when :bypass_firewall_rules
change_object['bypassFlag'] = | ruby | {
"resource": ""
} |
q1239 | SoftLayer.VLANFirewall.change_routing_bypass! | train | def change_routing_bypass!(routing_symbol)
vlan_firewall_id = self['networkVlanFirewall']['id']
raise "Could not identify the device for a VLAN firewall" if !vlan_firewall_id
case routing_symbol
when :route_through_firewall
self.softlayer_client[:Network_Vlan_Firewall].object_with_id(vlan_firewall_id).updateRouteBypass(false)
| ruby | {
"resource": ""
} |
q1240 | SoftLayer.VLANFirewall.rules_ACL_id | train | def rules_ACL_id
outside_interface_data = self['firewallInterfaces'].find { |interface_data| interface_data['name'] == 'outside' }
incoming_ACL = outside_interface_data['firewallContextAccessControlLists'].find | ruby | {
"resource": ""
} |
q1241 | SoftLayer.VirtualServerOrder.place_order! | train | def place_order!()
order_template = virtual_guest_template
order_template = yield order_template if block_given?
virtual_server_hash | ruby | {
"resource": ""
} |
q1242 | SoftLayer.Software.delete_user_password! | train | def delete_user_password!(username)
user_password = self.passwords.select { |sw_pw| sw_pw.username == username.to_s }
| ruby | {
"resource": ""
} |
q1243 | Danger.DangerTodoist.print_todos_table | train | def print_todos_table
find_todos if @todos.nil?
return if @todos.empty?
markdown("#### Todos left in files")
@todos
| ruby | {
"resource": ""
} |
q1244 | SoftLayer.VirtualServerOrder_Package.virtual_server_order | train | def virtual_server_order
product_order = {
'packageId' => @package.id,
'useHourlyPricing' => !!@hourly,
'virtualGuests' => [{
'domain' => @domain,
'hostname' => @hostname
}]
}
#Note that the use of image_template and SoftLayer::ProductPackage os/guest_diskX configuration category
#item prices is mutually exclusive.
product_order['imageTemplateGlobalIdentifier'] = @image_template.global_id if @image_template
product_order['location'] = @datacenter.id if @datacenter
| ruby | {
"resource": ""
} |
q1245 | SoftLayer.VirtualServer.capture_image | train | def capture_image(image_name, include_attached_storage = false, image_notes = '')
image_notes = '' if !image_notes
image_name = 'Captured Image' if !image_name
disk_filter = lambda { |disk| disk['device'] == '0' }
disk_filter = lambda { |disk| disk['device'] != '1' } if include_attached_storage
disks = | ruby | {
"resource": ""
} |
q1246 | SoftLayer.VirtualServer.wait_until_ready | train | def wait_until_ready(max_trials, wait_for_transactions = false, seconds_between_tries = 2)
# pessimistically assume the server is not ready
num_trials = 0
begin
self.refresh_details()
has_os_reload = has_sl_property? :lastOperatingSystemReload
has_active_transaction = has_sl_property? :activeTransaction
reloading_os = has_active_transaction && has_os_reload && (self.last_operating_system_reload['id'] == self.active_transaction['id'])
| ruby | {
"resource": ""
} |
q1247 | SoftLayer.Account.find_vlan_with_number | train | def find_vlan_with_number(vlan_number)
filter = SoftLayer::ObjectFilter.new() { |filter|
filter.accept('networkVlans.vlanNumber').when_it is vlan_number
}
vlan_data = | ruby | {
"resource": ""
} |
q1248 | SoftLayer.Client.service_named | train | def service_named(service_name, service_options = {})
raise ArgumentError,"Please provide a service name" if service_name.nil? || service_name.empty?
# Strip whitespace from service_name and ensure that it starts with "SoftLayer_".
# If it does not, then add the prefix.
full_name = service_name.to_s.strip
| ruby | {
"resource": ""
} |
q1249 | SoftLayer.Service.call_softlayer_api_with_params | train | def call_softlayer_api_with_params(method_name, parameters, args)
additional_headers = {};
# The client knows about authentication, so ask him for the auth headers
authentication_headers = self.client.authentication_headers
additional_headers.merge!(authentication_headers)
if parameters && parameters.server_object_filter
additional_headers.merge!("#{@service_name}ObjectFilter" => parameters.server_object_filter)
end
# Object masks go into the headers too.
if parameters && parameters.server_object_mask
object_mask = parameters.server_object_mask
additional_headers.merge!("SoftLayer_ObjectMask" => { "mask" => object_mask }) unless object_mask.empty?
end
# Result limits go into the headers
if (parameters && parameters.server_result_limit)
additional_headers.merge!("resultLimit" => { "limit" => parameters.server_result_limit, "offset" => (parameters.server_result_offset || 0) })
end
# Add an object id to the headers.
if parameters && parameters.server_object_id
additional_headers.merge!("#{@service_name}InitParameters" => { "id" => parameters.server_object_id })
end
# This is a workaround for a potential problem that arises from mis-using the
# API. If you call SoftLayer_Virtual_Guest and you call the getObject method
# but pass a virtual guest as a parameter, what happens is the getObject method
# is called through an HTTP POST verb and the API creates a new VirtualServer that
# is a copy of the one you passed in.
#
| ruby | {
"resource": ""
} |
q1250 | ILO_SDK.BiosHelper.set_bios_settings | train | def set_bios_settings(options, system_id = 1)
r = response_handler(rest_patch("/redfish/v1/Systems/#{system_id}/bios/Settings/", | ruby | {
"resource": ""
} |
q1251 | ILO_SDK.BiosHelper.set_uefi_shell_startup | train | def set_uefi_shell_startup(uefi_shell_startup, uefi_shell_startup_location, uefi_shell_startup_url)
new_action = {
'UefiShellStartup' => uefi_shell_startup,
'UefiShellStartupLocation' => uefi_shell_startup_location,
'UefiShellStartupUrl' => uefi_shell_startup_url
| ruby | {
"resource": ""
} |
q1252 | ILO_SDK.BiosHelper.get_bios_dhcp | train | def get_bios_dhcp
response = rest_get('/redfish/v1/Systems/1/bios/Settings/')
bios = response_handler(response)
{
'Dhcpv4' => bios['Dhcpv4'],
'Ipv4Address' => bios['Ipv4Address'],
'Ipv4Gateway' => bios['Ipv4Gateway'],
| ruby | {
"resource": ""
} |
q1253 | ILO_SDK.BiosHelper.set_bios_dhcp | train | def set_bios_dhcp(dhcpv4, ipv4_address = '', ipv4_gateway = '', ipv4_primary_dns = '', ipv4_secondary_dns = '', ipv4_subnet_mask = '')
new_action = {
'Dhcpv4' => dhcpv4,
'Ipv4Address' => ipv4_address,
'Ipv4Gateway' => ipv4_gateway,
'Ipv4PrimaryDNS' => ipv4_primary_dns,
'Ipv4SecondaryDNS' => ipv4_secondary_dns,
| ruby | {
"resource": ""
} |
q1254 | ILO_SDK.BiosHelper.set_url_boot_file | train | def set_url_boot_file(url_boot_file)
new_action = { 'UrlBootFile' => url_boot_file }
| ruby | {
"resource": ""
} |
q1255 | ILO_SDK.BiosHelper.set_bios_service | train | def set_bios_service(name, email)
new_action = {
'ServiceName' => name,
'ServiceEmail' => | ruby | {
"resource": ""
} |
q1256 | ILO_SDK.LogEntryHelper.clear_logs | train | def clear_logs(log_type)
new_action = { 'Action' => 'ClearLog' }
response | ruby | {
"resource": ""
} |
q1257 | ILO_SDK.LogEntryHelper.get_logs | train | def get_logs(severity_level, duration, log_type)
response = rest_get("#{uri_for_log_type(log_type)}Entries/")
entries = response_handler(response)['Items']
start_time = Time.now.utc - | ruby | {
"resource": ""
} |
q1258 | ILO_SDK.ComputerDetailsHelper.get_computer_details | train | def get_computer_details
general_computer_details = get_general_computer_details
computer_network_details = get_computer_network_details
| ruby | {
"resource": ""
} |
q1259 | ILO_SDK.ComputerDetailsHelper.get_general_computer_details | train | def get_general_computer_details
response = rest_get('/redfish/v1/Systems/1/')
details = response_handler(response)
{
'GeneralDetails' => {
'manufacturer' => details['Manufacturer'],
'model' => details['Model'],
'AssetTag' => details['AssetTag'],
'bios_version' => details['Bios']['Current']['VersionString'],
| ruby | {
"resource": ""
} |
q1260 | ILO_SDK.ComputerDetailsHelper.get_computer_network_details | train | def get_computer_network_details
network_adapters = []
response = rest_get('/redfish/v1/Systems/1/NetworkAdapters/')
networks = response_handler(response)['links']['Member']
networks.each do |network|
response = rest_get(network['href'])
detail = response_handler(response)
physical_ports = []
detail['PhysicalPorts'].each do |port|
n = {
'Name' => port['Name'],
'StructuredName' => port['Oem']['Hp']['StructuredName'],
'MacAddress' => port['MacAddress'],
'State' => port['Status']['State']
}
physical_ports.push(n)
| ruby | {
"resource": ""
} |
q1261 | ILO_SDK.FirmwareUpdateHelper.set_fw_upgrade | train | def set_fw_upgrade(uri, tpm_override_flag = true)
new_action = { 'Action' => 'InstallFromURI', 'FirmwareURI' => uri, 'TPMOverrideFlag' => tpm_override_flag }
| ruby | {
"resource": ""
} |
q1262 | Sprockets.Helpers.asset_path | train | def asset_path(source, options = {})
uri = URI.parse(source)
return source if uri.absolute?
options[:prefix] = Sprockets::Helpers.prefix unless options[:prefix]
if Helpers.debug || options[:debug]
options[:manifest] = false
options[:digest] = false
options[:asset_host] = false
end
source_ext = File.extname(source)
| ruby | {
"resource": ""
} |
q1263 | ILO_SDK.ChassisHelper.get_power_metrics | train | def get_power_metrics
chassis = rest_get('/redfish/v1/Chassis/')
chassis_uri = response_handler(chassis)['links']['Member'][0]['href']
power_metrics_uri = response_handler(rest_get(chassis_uri))['links']['PowerMetrics']['href']
response = rest_get(power_metrics_uri)
metrics = response_handler(response)
power_supplies = []
metrics['PowerSupplies'].each do |ps|
power_supply = {
'LineInputVoltage' => ps['LineInputVoltage'],
'LineInputVoltageType' => ps['LineInputVoltageType'],
'PowerCapacityWatts' => ps['PowerCapacityWatts'],
'PowerSupplyType' => ps['PowerSupplyType'],
'Health' => ps['Status']['Health'],
| ruby | {
"resource": ""
} |
q1264 | ILO_SDK.ChassisHelper.get_thermal_metrics | train | def get_thermal_metrics
chassis = rest_get('/redfish/v1/Chassis/')
chassis_uri = response_handler(chassis)['links']['Member'][0]['href']
thermal_metrics_uri = response_handler(rest_get(chassis_uri))['links']['ThermalMetrics']['href']
response = rest_get(thermal_metrics_uri)
temperatures = response_handler(response)['Temperatures']
| ruby | {
"resource": ""
} |
q1265 | ILO_SDK.DateTimeHelper.set_time_zone | train | def set_time_zone(time_zone)
time_response = rest_get('/redfish/v1/Managers/1/DateTime/')
new_time_zone = response_handler(time_response)['TimeZoneList'].select { |timezone| timezone['Name'] == time_zone }
new_action = { 'TimeZone' => { | ruby | {
"resource": ""
} |
q1266 | ILO_SDK.DateTimeHelper.set_ntp | train | def set_ntp(use_ntp)
new_action = { 'Oem' => { 'Hp' => { 'DHCPv4' => { 'UseNTPServers' => use_ntp } } } }
| ruby | {
"resource": ""
} |
q1267 | ILO_SDK.DateTimeHelper.set_ntp_servers | train | def set_ntp_servers(ntp_servers)
new_action = { 'StaticNTPServers' => ntp_servers }
response = rest_patch('/redfish/v1/Managers/1/DateTime/', | ruby | {
"resource": ""
} |
q1268 | ILO_SDK.Cli.output | train | def output(data = {}, indent = 0)
case @options['format']
when 'json'
puts JSON.pretty_generate(data)
when 'yaml'
puts data.to_yaml
else
# rubocop:disable Metrics/BlockNesting
if data.class == Hash
data.each do |k, v|
if v.class == Hash || v.class == Array
puts "#{' ' * indent}#{k.nil? ? 'nil' : k}:"
output(v, indent + 2)
| ruby | {
"resource": ""
} |
q1269 | ILO_SDK.BootSettingsHelper.set_boot_order | train | def set_boot_order(boot_order)
new_action = { 'PersistentBootConfigOrder' => boot_order } | ruby | {
"resource": ""
} |
q1270 | ILO_SDK.BootSettingsHelper.set_temporary_boot_order | train | def set_temporary_boot_order(boot_target)
response = rest_get('/redfish/v1/Systems/1/')
boottargets = response_handler(response)['Boot']['BootSourceOverrideSupported']
unless boottargets.include? boot_target
raise "BootSourceOverrideTarget value - #{boot_target} is not supported. Valid values are: #{boottargets}"
end
new_action = { | ruby | {
"resource": ""
} |
q1271 | ILO_SDK.ServiceRootHelper.get_schema | train | def get_schema(schema_prefix)
response = rest_get('/redfish/v1/Schemas/')
schemas = response_handler(response)['Items']
schema = schemas.select { |s| s['Schema'].start_with?(schema_prefix) }
raise "NO schema found with this schema prefix : #{schema_prefix}" if schema.empty?
info = []
schema.each do | ruby | {
"resource": ""
} |
q1272 | ILO_SDK.ServiceRootHelper.get_registry | train | def get_registry(registry_prefix)
response = rest_get('/redfish/v1/Registries/')
registries = response_handler(response)['Items']
registry = registries.select { |reg| reg['Schema'].start_with?(registry_prefix) }
info = []
registry.each | ruby | {
"resource": ""
} |
q1273 | ILO_SDK.ManagerNetworkProtocolHelper.set_timeout | train | def set_timeout(timeout)
new_action = { 'SessionTimeoutMinutes' => timeout }
| ruby | {
"resource": ""
} |
q1274 | ILO_SDK.EthernetInterfaceHelper.set_ilo_ipv4_dhcp | train | def set_ilo_ipv4_dhcp(manager_id: 1, ethernet_interface: 1)
new_action = {
'Oem' => {
'Hp' => {
'DHCPv4' => {
'Enabled' => true,
'UseDNSServers' => true,
'UseDomainName' => true,
'UseGateway' => true,
'UseNTPServers' => true,
'UseStaticRoutes' => true,
'UseWINSServers' => true
| ruby | {
"resource": ""
} |
q1275 | ILO_SDK.EthernetInterfaceHelper.set_ilo_ipv4_static | train | def set_ilo_ipv4_static(ip:, netmask:, gateway: '0.0.0.0', manager_id: 1, ethernet_interface: 1)
new_action = {
'Oem' => { 'Hp' => { 'DHCPv4' => { 'Enabled' => false } } },
'IPv4Addresses' => [
'Address' => ip, 'SubnetMask' => netmask, 'Gateway' => gateway
]
| ruby | {
"resource": ""
} |
q1276 | ILO_SDK.EthernetInterfaceHelper.set_ilo_ipv4_dns_servers | train | def set_ilo_ipv4_dns_servers(dns_servers:, manager_id: 1, ethernet_interface: 1)
new_action = {
'Oem' => {
'Hp' => {
'DHCPv4' => { 'UseDNSServers' => false },
'IPv4' => { 'DNSServers' => dns_servers }
}
| ruby | {
"resource": ""
} |
q1277 | ILO_SDK.EthernetInterfaceHelper.set_ilo_hostname | train | def set_ilo_hostname(hostname:, domain_name: nil, manager_id: 1, ethernet_interface: 1)
new_action = { 'Oem' => { 'Hp' => { 'HostName' => hostname } } }
new_action['Oem']['Hp'].merge!('DHCPv4' => {}, 'DHCPv6' => {}) if domain_name
new_action['Oem']['Hp']['DHCPv4']['UseDomainName'] = false if domain_name
new_action['Oem']['Hp']['DHCPv6']['UseDomainName'] = false if domain_name
| ruby | {
"resource": ""
} |
q1278 | ILO_SDK.Rest.rest_api | train | def rest_api(type, path, options = {})
raise InvalidRequest, 'Must specify path' unless path
raise InvalidRequest, 'Must specify type' unless type
@logger.debug "Making :#{type} rest call to #{@host}#{path}"
uri = URI.parse(URI.escape("#{@host}#{path}"))
http = @disable_proxy ? Net::HTTP.new(uri.host, uri.port, nil, nil) : Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true if uri.scheme == 'https'
http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @ssl_enabled
request = build_request(type, uri, options)
response = http.request(request)
@logger.debug " Response: Code=#{response.code}. Headers=#{response.to_hash}\n Body=#{response.body}"
response
rescue OpenSSL::SSL::SSLError => e
msg = 'SSL verification failed for the request. Please either:'
msg | ruby | {
"resource": ""
} |
q1279 | ILO_SDK.Rest.response_handler | train | def response_handler(response)
case response.code.to_i
when RESPONSE_CODE_OK # Synchronous read/query
begin
return JSON.parse(response.body)
rescue JSON::ParserError => e
@logger.warn "Failed to parse JSON response. #{e}"
return response.body
end
when RESPONSE_CODE_CREATED # Synchronous add
return JSON.parse(response.body)
when RESPONSE_CODE_ACCEPTED # Asynchronous add, update or delete
return JSON.parse(response.body) # TODO: Remove when tested
# TODO: Make this actually wait for the task
# @logger.debug "Waiting for task: #{response.header['location']}"
# task = wait_for(response.header['location'])
# return true unless task['associatedResource'] && task['associatedResource']['resourceUri']
# resource_data = rest_get(task['associatedResource']['resourceUri'])
# return JSON.parse(resource_data.body)
| ruby | {
"resource": ""
} |
q1280 | ILO_SDK.ManagerAccountHelper.get_account_privileges | train | def get_account_privileges(username)
response = rest_get('/redfish/v1/AccountService/Accounts/')
accounts = response_handler(response)['Items']
accounts.each do |account|
if | ruby | {
"resource": ""
} |
q1281 | ILO_SDK.ManagerAccountHelper.set_account_privileges | train | def set_account_privileges(username, privileges)
response = rest_get('/redfish/v1/AccountService/Accounts/')
accounts = response_handler(response)['Items']
id = '0'
accounts.each do |account|
if account['Oem']['Hp']['LoginName'] == username
id = account['Id']
break
end
end
new_action = {
'Oem' => {
'Hp' | ruby | {
"resource": ""
} |
q1282 | ILO_SDK.HttpsCertHelper.get_certificate | train | def get_certificate
uri = URI.parse(URI.escape(@host))
options = { use_ssl: true, verify_mode: | ruby | {
"resource": ""
} |
q1283 | ILO_SDK.HttpsCertHelper.generate_csr | train | def generate_csr(country, state, city, org_name, org_unit, common_name)
new_action = {
'Action' => 'GenerateCSR',
'Country' => country,
'State' => state,
'City' => city,
'OrgName' => org_name,
'OrgUnit' => org_unit,
| ruby | {
"resource": ""
} |
q1284 | ILO_SDK.SecureBootHelper.set_uefi_secure_boot | train | def set_uefi_secure_boot(secure_boot_enable)
new_action = { 'SecureBootEnable' => secure_boot_enable }
response = | ruby | {
"resource": ""
} |
q1285 | ILO_SDK.PowerHelper.set_power_state | train | def set_power_state(state)
new_action = { 'Action' => 'Reset', 'ResetType' => state }
response = | ruby | {
"resource": ""
} |
q1286 | ILO_SDK.SNMPServiceHelper.set_snmp | train | def set_snmp(snmp_mode, snmp_alerts)
new_action = { 'Mode' => snmp_mode, 'AlertsEnabled' => snmp_alerts }
response = | ruby | {
"resource": ""
} |
q1287 | ILO_SDK.VirtualMediaHelper.get_virtual_media | train | def get_virtual_media
response = rest_get('/redfish/v1/Managers/1/VirtualMedia/')
media = {}
response_handler(response)['links']['Member'].each do |vm|
| ruby | {
"resource": ""
} |
q1288 | ILO_SDK.VirtualMediaHelper.insert_virtual_media | train | def insert_virtual_media(id, image)
new_action = {
'Action' => 'InsertVirtualMedia',
'Target' => '/Oem/Hp',
'Image' => image
} | ruby | {
"resource": ""
} |
q1289 | ILO_SDK.VirtualMediaHelper.eject_virtual_media | train | def eject_virtual_media(id)
new_action = {
'Action' => 'EjectVirtualMedia',
'Target' => '/Oem/Hp' | ruby | {
"resource": ""
} |
q1290 | ILO_SDK.ComputerSystemHelper.set_asset_tag | train | def set_asset_tag(asset_tag)
@logger.warn '[Deprecated] `set_asset_tag` is deprecated. Please use `set_system_settings(AssetTag: <tag>)` instead.'
new_action = { 'AssetTag' => asset_tag }
| ruby | {
"resource": ""
} |
q1291 | ILO_SDK.ComputerSystemHelper.set_indicator_led | train | def set_indicator_led(state)
@logger.warn '[Deprecated] `set_indicator_led` is deprecated. Please use `set_system_settings(IndicatorLED: <state>)` instead.'
new_action = { 'IndicatorLED' => state }
| ruby | {
"resource": ""
} |
q1292 | ILO_SDK.AccountServiceHelper.userhref | train | def userhref(uri, username)
response = rest_get(uri)
items = response_handler(response)['Items']
items.each do |it|
return | ruby | {
"resource": ""
} |
q1293 | ILO_SDK.AccountServiceHelper.create_user | train | def create_user(username, password)
new_action = { 'UserName' => username, 'Password' => password, 'Oem' => { 'Hp' => | ruby | {
"resource": ""
} |
q1294 | ILO_SDK.AccountServiceHelper.change_password | train | def change_password(username, password)
new_action = { 'Password' => password }
userhref = userhref('/redfish/v1/AccountService/Accounts/', username)
response = | ruby | {
"resource": ""
} |
q1295 | ILO_SDK.AccountServiceHelper.delete_user | train | def delete_user(username)
userhref = userhref('/redfish/v1/AccountService/Accounts/', username)
response = | ruby | {
"resource": ""
} |
q1296 | Proxmox.Proxmox.templates | train | def templates
data = http_action_get "nodes/#{@node}/storage/local/content"
template_list = {}
| ruby | {
"resource": ""
} |
q1297 | Proxmox.Proxmox.openvz_get | train | def openvz_get
data = http_action_get "nodes/#{@node}/openvz"
ve_list = {}
data.each do |ve|
| ruby | {
"resource": ""
} |
q1298 | Proxmox.Proxmox.openvz_post | train | def openvz_post(ostemplate, vmid, config = {})
config['vmid'] = vmid
config['ostemplate'] = "local%3Avztmpl%2F#{ostemplate}.tar.gz"
vm_definition = config.to_a.map | ruby | {
"resource": ""
} |
q1299 | Proxmox.Proxmox.create_ticket | train | def create_ticket
post_param = { username: @username, realm: @realm, password: @password }
@site['access/ticket'].post post_param do |response, _request, _result, &_block|
if response.code == 200
| ruby | {
"resource": ""
} |