softlayer 0.0.7 → 0.0.8

data/lib/softlayer/network/storage/backup/evault.rb

@@ -6,113 +6,118 @@ module Softlayer
           SERVICE = 'SoftLayer_Network_Storage_Backup_Evault'
           autoload :Version6, 'softlayer/network/storage/backup/evault/version6'
 
-          def allow_access_from_hardware(hardware_object_template = nil)
-            message = {hardware_object_template: hardware_object_template}
+          # hardware_object_template
+          def allow_access_from_hardware(message)
             request(:allow_access_from_hardware, Boolean, message)
           end
 
-          def allow_access_from_hardware_list(hardware_object_templates = nil)
-            message = {hardware_object_templates: hardware_object_templates}
+          # hardware_object_templates
+          def allow_access_from_hardware_list(message)
             request(:allow_access_from_hardware_list, Boolean, message)
           end
 
-          def allow_access_from_host(type_class_name = nil, host_id = nil)
-            message = {type_class_name: type_class_name, host_id: host_id}
+          # type_class_name
+          # host_id
+          def allow_access_from_host(message)
             request(:allow_access_from_host, Softlayer::Network::Storage::Allowed::Host, message)
           end
 
-          def allow_access_from_host_list(host_object_templates = nil)
-            message = {host_object_templates: host_object_templates}
+          # host_object_templates
+          def allow_access_from_host_list(message)
             request(:allow_access_from_host_list, Array[Softlayer::Network::Storage::Allowed::Host], message)
           end
 
-          def allow_access_from_ip_address(ip_address_object_template = nil)
-            message = {ip_address_object_template: ip_address_object_template}
+          # ip_address_object_template
+          def allow_access_from_ip_address(message)
             request(:allow_access_from_ip_address, Boolean, message)
           end
 
-          def allow_access_from_ip_address_list(ip_address_object_templates = nil)
-            message = {ip_address_object_templates: ip_address_object_templates}
+          # ip_address_object_templates
+          def allow_access_from_ip_address_list(message)
             request(:allow_access_from_ip_address_list, Boolean, message)
           end
 
-          def allow_access_from_subnet(subnet_object_template = nil)
-            message = {subnet_object_template: subnet_object_template}
+          # subnet_object_template
+          def allow_access_from_subnet(message)
             request(:allow_access_from_subnet, Boolean, message)
           end
 
-          def allow_access_from_subnet_list(subnet_object_templates = nil)
-            message = {subnet_object_templates: subnet_object_templates}
+          # subnet_object_templates
+          def allow_access_from_subnet_list(message)
             request(:allow_access_from_subnet_list, Boolean, message)
           end
 
-          def allow_access_from_virtual_guest(virtual_guest_object_template = nil)
-            message = {virtual_guest_object_template: virtual_guest_object_template}
+          # virtual_guest_object_template
+          def allow_access_from_virtual_guest(message)
             request(:allow_access_from_virtual_guest, Boolean, message)
           end
 
-          def allow_access_from_virtual_guest_list(virtual_guest_object_templates = nil)
-            message = {virtual_guest_object_templates: virtual_guest_object_templates}
+          # virtual_guest_object_templates
+          def allow_access_from_virtual_guest_list(message)
             request(:allow_access_from_virtual_guest_list, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_hardware(hardware_object_template = nil)
-            message = {hardware_object_template: hardware_object_template}
+          # hardware_object_template
+          def allow_access_to_replicant_from_hardware(message)
             request(:allow_access_to_replicant_from_hardware, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_hardware_list(hardware_object_templates = nil)
-            message = {hardware_object_templates: hardware_object_templates}
+          # hardware_object_templates
+          def allow_access_to_replicant_from_hardware_list(message)
             request(:allow_access_to_replicant_from_hardware_list, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_ip_address(ip_address_object_template = nil)
-            message = {ip_address_object_template: ip_address_object_template}
+          # ip_address_object_template
+          def allow_access_to_replicant_from_ip_address(message)
             request(:allow_access_to_replicant_from_ip_address, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_ip_address_list(ip_address_object_templates = nil)
-            message = {ip_address_object_templates: ip_address_object_templates}
+          # ip_address_object_templates
+          def allow_access_to_replicant_from_ip_address_list(message)
             request(:allow_access_to_replicant_from_ip_address_list, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_subnet(subnet_object_template = nil)
-            message = {subnet_object_template: subnet_object_template}
+          # subnet_object_template
+          def allow_access_to_replicant_from_subnet(message)
             request(:allow_access_to_replicant_from_subnet, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_subnet_list(subnet_object_templates = nil)
-            message = {subnet_object_templates: subnet_object_templates}
+          # subnet_object_templates
+          def allow_access_to_replicant_from_subnet_list(message)
             request(:allow_access_to_replicant_from_subnet_list, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_virtual_guest(virtual_guest_object_template = nil)
-            message = {virtual_guest_object_template: virtual_guest_object_template}
+          # virtual_guest_object_template
+          def allow_access_to_replicant_from_virtual_guest(message)
             request(:allow_access_to_replicant_from_virtual_guest, Boolean, message)
           end
 
-          def allow_access_to_replicant_from_virtual_guest_list(virtual_guest_object_templates = nil)
-            message = {virtual_guest_object_templates: virtual_guest_object_templates}
+          # virtual_guest_object_templates
+          def allow_access_to_replicant_from_virtual_guest_list(message)
             request(:allow_access_to_replicant_from_virtual_guest_list, Boolean, message)
           end
 
-          def assign_credential(username = nil)
-            message = {username: username}
+          # username
+          def assign_credential(message)
             request(:assign_credential, Boolean, message)
           end
 
-          def assign_new_credential(type = nil)
-            message = {type: type}
+          # type
+          def assign_new_credential(message)
             request(:assign_new_credential, Softlayer::Network::Storage::Credential, message)
           end
 
-          def self.change_password(username = nil, current_password = nil, new_password = nil)
-            message = {username: username, current_password: current_password, new_password: new_password}
+          # username
+          # current_password
+          # new_password
+          def self.change_password(message)
             request(:change_password, Boolean, message)
           end
 
-          def collect_bandwidth(type = nil, start_date = nil, end_date = nil)
-            message = {type: type, start_date: start_date, end_date: end_date}
+          # type
+          # start_date
+          # end_date
+          def collect_bandwidth(message)
             request(:collect_bandwidth, BigDecimal, message)
           end
 
@@ -120,13 +125,13 @@ module Softlayer
             request(:collect_bytes_used, BigDecimal)
           end
 
-          def create_folder(folder = nil)
-            message = {folder: folder}
+          # folder
+          def create_folder(message)
             request(:create_folder, Boolean, message)
           end
 
-          def create_snapshot(notes = nil)
-            message = {notes: notes}
+          # notes
+          def create_snapshot(message)
             request(:create_snapshot, Softlayer::Network::Storage::Backup::Evault, message)
           end
 
@@ -134,18 +139,18 @@ module Softlayer
             request(:delete_all_files, Boolean)
           end
 
-          def delete_file(file_id = nil)
-            message = {file_id: file_id}
+          # file_id
+          def delete_file(message)
             request(:delete_file, Boolean, message)
           end
 
-          def delete_files(file_ids = nil)
-            message = {file_ids: file_ids}
+          # file_ids
+          def delete_files(message)
             request(:delete_files, Boolean, message)
           end
 
-          def delete_folder(folder = nil)
-            message = {folder: folder}
+          # folder
+          def delete_folder(message)
             request(:delete_folder, Boolean, message)
           end
 
@@ -153,33 +158,38 @@ module Softlayer
             request(:delete_object, Boolean)
           end
 
-          def delete_tasks(tasks = nil)
-            message = {tasks: tasks}
+          # tasks
+          def delete_tasks(message)
             request(:delete_tasks, Boolean, message)
           end
 
-          def disable_snapshots(schedule_type = nil)
-            message = {schedule_type: schedule_type}
+          # schedule_type
+          def disable_snapshots(message)
             request(:disable_snapshots, Boolean, message)
           end
 
-          def download_file(file_id = nil)
-            message = {file_id: file_id}
+          # file_id
+          def download_file(message)
             request(:download_file, Softlayer::Container::Utility::File::Entity, message)
           end
 
-          def edit_credential(username = nil, new_password = nil)
-            message = {username: username, new_password: new_password}
+          # username
+          # new_password
+          def edit_credential(message)
             request(:edit_credential, Boolean, message)
           end
 
-          def edit_object(template_object = nil)
-            message = {template_object: template_object}
+          # template_object
+          def edit_object(message)
             request(:edit_object, Boolean, message)
           end
 
-          def enable_snapshots(schedule_type = nil, retention_count = nil, minute = nil, hour = nil, day_of_week = nil)
-            message = {schedule_type: schedule_type, retention_count: retention_count, minute: minute, hour: hour, day_of_week: day_of_week}
+          # schedule_type
+          # retention_count
+          # minute
+          # hour
+          # day_of_week
+          def enable_snapshots(message)
             request(:enable_snapshots, Boolean, message)
           end
 
@@ -187,8 +197,8 @@ module Softlayer
             request(:failback_from_replicant, Boolean)
           end
 
-          def failover_to_replicant(replicant_id = nil)
-            message = {replicant_id: replicant_id}
+          # replicant_id
+          def failover_to_replicant(message)
             request(:failover_to_replicant, Boolean, message)
           end
 
@@ -208,28 +218,29 @@ module Softlayer
             request(:get_all_files, Array[Softlayer::Container::Utility::File::Entity])
           end
 
-          def get_all_files_by_filter(filter = nil)
-            message = {filter: filter}
+          # filter
+          def get_all_files_by_filter(message)
             request(:get_all_files_by_filter, Array[Softlayer::Container::Utility::File::Entity], message)
           end
 
-          def get_allowable_hardware(filter_hostname = nil)
-            message = {filter_hostname: filter_hostname}
+          # filter_hostname
+          def get_allowable_hardware(message)
             request(:get_allowable_hardware, Array[Softlayer::Hardware], message)
           end
 
-          def get_allowable_ip_addresses(subnet_id = nil, filter_ip_address = nil)
-            message = {subnet_id: subnet_id, filter_ip_address: filter_ip_address}
+          # subnet_id
+          # filter_ip_address
+          def get_allowable_ip_addresses(message)
             request(:get_allowable_ip_addresses, Array[Softlayer::Network::Subnet::IpAddress], message)
           end
 
-          def get_allowable_subnets(filter_network_identifier = nil)
-            message = {filter_network_identifier: filter_network_identifier}
+          # filter_network_identifier
+          def get_allowable_subnets(message)
             request(:get_allowable_subnets, Array[Softlayer::Network::Subnet], message)
           end
 
-          def get_allowable_virtual_guests(filter_hostname = nil)
-            message = {filter_hostname: filter_hostname}
+          # filter_hostname
+          def get_allowable_virtual_guests(message)
             request(:get_allowable_virtual_guests, Array[Softlayer::Virtual::Guest], message)
           end
 
@@ -277,8 +288,9 @@ module Softlayer
             request(:get_billing_item_category, Softlayer::Product::Item::Category)
           end
 
-          def self.get_by_username(username = nil, type = nil)
-            message = {username: username, type: type}
+          # username
+          # type
+          def self.get_by_username(message)
             request(:get_by_username, Array[Softlayer::Network::Storage], message)
           end
 
@@ -314,8 +326,8 @@ module Softlayer
             request(:get_events, Array[Softlayer::Network::Storage::Event])
           end
 
-          def get_file_by_identifier(identifier = nil)
-            message = {identifier: identifier}
+          # identifier
+          def get_file_by_identifier(message)
             request(:get_file_by_identifier, Softlayer::Container::Utility::File::Entity, message)
           end
 
@@ -323,8 +335,9 @@ module Softlayer
             request(:get_file_count, Integer)
           end
 
-          def get_file_list(folder = nil, path = nil)
-            message = {folder: folder, path: path}
+          # folder
+          # path
+          def get_file_list(message)
             request(:get_file_list, Array[Softlayer::Container::Utility::File::Entity], message)
           end
 
@@ -340,8 +353,10 @@ module Softlayer
             request(:get_folder_list, Array[Softlayer::Container::Network::Storage::Hub::ObjectStorage::Folder])
           end
 
-          def get_graph(start_date = nil, end_date = nil, type = nil)
-            message = {start_date: start_date, end_date: end_date, type: type}
+          # start_date
+          # end_date
+          # type
+          def get_graph(message)
             request(:get_graph, Softlayer::Container::Bandwidth::GraphOutputs, message)
           end
 
@@ -349,8 +364,11 @@ module Softlayer
             request(:get_hardware, Softlayer::Hardware)
           end
 
-          def self.get_hardware_with_evault_first(option = nil, exact_match = nil, criteria = nil, mode = nil)
-            message = {option: option, exact_match: exact_match, criteria: criteria, mode: mode}
+          # option
+          # exact_match
+          # criteria
+          # mode
+          def self.get_hardware_with_evault_first(message)
             request(:get_hardware_with_evault_first, Array[Softlayer::Hardware], message)
           end
 
@@ -394,8 +412,8 @@ module Softlayer
             request(:get_object_storage_connection_information, Array[Softlayer::Container::Network::Service::Resource::ObjectStorage::ConnectionInformation])
           end
 
-          def self.get_objects_by_credential(credential_object = nil)
-            message = {credential_object: credential_object}
+          # credential_object
+          def self.get_objects_by_credential(message)
             request(:get_objects_by_credential, Array[Softlayer::Network::Storage], message)
           end
 
@@ -431,8 +449,8 @@ module Softlayer
             request(:get_properties, Array[Softlayer::Network::Storage::Property])
           end
 
-          def get_recycle_bin_file_by_identifier(file_id = nil)
-            message = {file_id: file_id}
+          # file_id
+          def get_recycle_bin_file_by_identifier(message)
             request(:get_recycle_bin_file_by_identifier, Softlayer::Container::Utility::File::Entity, message)
           end
 
@@ -568,8 +586,8 @@ module Softlayer
             request(:get_weekly_schedule, Softlayer::Network::Storage::Schedule)
           end
 
-          def immediate_failover_to_replicant(replicant_id = nil)
-            message = {replicant_id: replicant_id}
+          # replicant_id
+          def immediate_failover_to_replicant(message)
             request(:immediate_failover_to_replicant, Boolean, message)
           end
 
@@ -577,128 +595,129 @@ module Softlayer
             request(:initiate_bare_metal_restore, Boolean)
           end
 
-          def initiate_bare_metal_restore_for_server(hardware_id = nil)
-            message = {hardware_id: hardware_id}
+          # hardware_id
+          def initiate_bare_metal_restore_for_server(message)
             request(:initiate_bare_metal_restore_for_server, Boolean, message)
           end
 
-          def is_blocking_operation_in_progress(exempt_status_key_names = nil)
-            message = {exempt_status_key_names: exempt_status_key_names}
+          # exempt_status_key_names
+          def is_blocking_operation_in_progress(message)
             request(:is_blocking_operation_in_progress, Boolean, message)
           end
 
-          def remove_access_from_hardware(hardware_object_template = nil)
-            message = {hardware_object_template: hardware_object_template}
+          # hardware_object_template
+          def remove_access_from_hardware(message)
             request(:remove_access_from_hardware, Boolean, message)
           end
 
-          def remove_access_from_hardware_list(hardware_object_templates = nil)
-            message = {hardware_object_templates: hardware_object_templates}
+          # hardware_object_templates
+          def remove_access_from_hardware_list(message)
             request(:remove_access_from_hardware_list, Boolean, message)
           end
 
-          def remove_access_from_host(type_class_name = nil, host_id = nil)
-            message = {type_class_name: type_class_name, host_id: host_id}
+          # type_class_name
+          # host_id
+          def remove_access_from_host(message)
             request(:remove_access_from_host, Softlayer::Network::Storage::Allowed::Host, message)
           end
 
-          def remove_access_from_host_list(host_object_templates = nil)
-            message = {host_object_templates: host_object_templates}
+          # host_object_templates
+          def remove_access_from_host_list(message)
             request(:remove_access_from_host_list, Array[Softlayer::Network::Storage::Allowed::Host], message)
           end
 
-          def remove_access_from_ip_address(ip_address_object_template = nil)
-            message = {ip_address_object_template: ip_address_object_template}
+          # ip_address_object_template
+          def remove_access_from_ip_address(message)
             request(:remove_access_from_ip_address, Boolean, message)
           end
 
-          def remove_access_from_ip_address_list(ip_address_object_templates = nil)
-            message = {ip_address_object_templates: ip_address_object_templates}
+          # ip_address_object_templates
+          def remove_access_from_ip_address_list(message)
             request(:remove_access_from_ip_address_list, Boolean, message)
           end
 
-          def remove_access_from_subnet(subnet_object_template = nil)
-            message = {subnet_object_template: subnet_object_template}
+          # subnet_object_template
+          def remove_access_from_subnet(message)
             request(:remove_access_from_subnet, Boolean, message)
           end
 
-          def remove_access_from_subnet_list(subnet_object_templates = nil)
-            message = {subnet_object_templates: subnet_object_templates}
+          # subnet_object_templates
+          def remove_access_from_subnet_list(message)
             request(:remove_access_from_subnet_list, Boolean, message)
           end
 
-          def remove_access_from_virtual_guest(virtual_guest_object_template = nil)
-            message = {virtual_guest_object_template: virtual_guest_object_template}
+          # virtual_guest_object_template
+          def remove_access_from_virtual_guest(message)
             request(:remove_access_from_virtual_guest, Boolean, message)
           end
 
-          def remove_access_from_virtual_guest_list(virtual_guest_object_templates = nil)
-            message = {virtual_guest_object_templates: virtual_guest_object_templates}
+          # virtual_guest_object_templates
+          def remove_access_from_virtual_guest_list(message)
             request(:remove_access_from_virtual_guest_list, Boolean, message)
           end
 
-          def remove_access_to_replicant_from_hardware_list(hardware_object_templates = nil)
-            message = {hardware_object_templates: hardware_object_templates}
+          # hardware_object_templates
+          def remove_access_to_replicant_from_hardware_list(message)
             request(:remove_access_to_replicant_from_hardware_list, Boolean, message)
           end
 
-          def remove_access_to_replicant_from_ip_address_list(ip_address_object_templates = nil)
-            message = {ip_address_object_templates: ip_address_object_templates}
+          # ip_address_object_templates
+          def remove_access_to_replicant_from_ip_address_list(message)
             request(:remove_access_to_replicant_from_ip_address_list, Boolean, message)
           end
 
-          def remove_access_to_replicant_from_subnet(subnet_object_template = nil)
-            message = {subnet_object_template: subnet_object_template}
+          # subnet_object_template
+          def remove_access_to_replicant_from_subnet(message)
             request(:remove_access_to_replicant_from_subnet, Boolean, message)
           end
 
-          def remove_access_to_replicant_from_subnet_list(subnet_object_templates = nil)
-            message = {subnet_object_templates: subnet_object_templates}
+          # subnet_object_templates
+          def remove_access_to_replicant_from_subnet_list(message)
             request(:remove_access_to_replicant_from_subnet_list, Boolean, message)
           end
 
-          def remove_access_to_replicant_from_virtual_guest_list(virtual_guest_object_templates = nil)
-            message = {virtual_guest_object_templates: virtual_guest_object_templates}
+          # virtual_guest_object_templates
+          def remove_access_to_replicant_from_virtual_guest_list(message)
             request(:remove_access_to_replicant_from_virtual_guest_list, Boolean, message)
           end
 
-          def remove_credential(username = nil)
-            message = {username: username}
+          # username
+          def remove_credential(message)
             request(:remove_credential, Boolean, message)
           end
 
-          def restore_file(file_id = nil)
-            message = {file_id: file_id}
+          # file_id
+          def restore_file(message)
             request(:restore_file, Softlayer::Container::Utility::File::Entity, message)
           end
 
-          def restore_from_snapshot(snapshot_id = nil)
-            message = {snapshot_id: snapshot_id}
+          # snapshot_id
+          def restore_from_snapshot(message)
             request(:restore_from_snapshot, Boolean, message)
           end
 
-          def self.send_password_reminder_email(username = nil)
-            message = {username: username}
+          # username
+          def self.send_password_reminder_email(message)
             request(:send_password_reminder_email, Boolean, message)
           end
 
-          def set_mountable(mountable = nil)
-            message = {mountable: mountable}
+          # mountable
+          def set_mountable(message)
             request(:set_mountable, Boolean, message)
           end
 
-          def set_snapshot_allocation(capacity_gb = nil)
-            message = {capacity_gb: capacity_gb}
+          # capacity_gb
+          def set_snapshot_allocation(message)
             request(:set_snapshot_allocation, nil, message)
           end
 
-          def upgrade_volume_capacity(item_id = nil)
-            message = {item_id: item_id}
+          # item_id
+          def upgrade_volume_capacity(message)
             request(:upgrade_volume_capacity, Boolean, message)
           end
 
-          def upload_file(file = nil)
-            message = {file: file}
+          # file
+          def upload_file(message)
             request(:upload_file, Softlayer::Container::Utility::File::Entity, message)
           end
 

data/lib/softlayer/network/storage/group/iscsi.rb

@@ -5,18 +5,18 @@ module Softlayer
         class Iscsi < Softlayer::Network::Storage::Group
           SERVICE = 'SoftLayer_Network_Storage_Group_Iscsi'
 
-          def add_allowed_host(allowed_host = nil)
-            message = {allowed_host: allowed_host}
+          # allowed_host
+          def add_allowed_host(message)
             request(:add_allowed_host, Boolean, message)
           end
 
-          def attach_to_volume(volume = nil)
-            message = {volume: volume}
+          # volume
+          def attach_to_volume(message)
             request(:attach_to_volume, Boolean, message)
           end
 
-          def self.create_object(template_object = nil)
-            message = {template_object: template_object}
+          # template_object
+          def self.create_object(message)
             request(:create_object, Boolean, message)
           end
 
@@ -24,8 +24,8 @@ module Softlayer
             request(:delete_object, Boolean)
           end
 
-          def edit_object(template_object = nil)
-            message = {template_object: template_object}
+          # template_object
+          def edit_object(message)
             request(:edit_object, Boolean, message)
           end
 
@@ -65,13 +65,13 @@ module Softlayer
             request(:get_service_resource, Softlayer::Network::Service::Resource)
           end
 
-          def remove_allowed_host(allowed_host = nil)
-            message = {allowed_host: allowed_host}
+          # allowed_host
+          def remove_allowed_host(message)
             request(:remove_allowed_host, Boolean, message)
           end
 
-          def remove_from_volume(volume = nil)
-            message = {volume: volume}
+          # volume
+          def remove_from_volume(message)
             request(:remove_from_volume, Boolean, message)
           end