softlayer 0.0.7 → 0.0.8

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

@@ -6,113 +6,118 @@ module Softlayer
         autoload :EqualLogic, 'softlayer/network/storage/iscsi/equal_logic'
         autoload :Os, 'softlayer/network/storage/iscsi/os'
 
-        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::Iscsi, 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,28 +158,33 @@ module Softlayer
           request(:delete_object, Boolean)
         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
 
@@ -182,8 +192,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
 
@@ -203,28 +213,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
 
@@ -272,8 +283,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
 
@@ -305,8 +317,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
 
@@ -314,8 +326,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
 
@@ -331,8 +344,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
 
@@ -380,8 +395,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
 
@@ -413,8 +428,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
 
@@ -546,128 +561,129 @@ 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
 
-        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/schedule.rb

@@ -29,8 +29,8 @@ module Softlayer
         attr_accessor :type
         attr_accessor :volume
 
-        def self.create_object(template_object = nil)
-          message = {template_object: template_object}
+        # template_object
+        def self.create_object(message)
           request(:create_object, Softlayer::Network::Storage::Schedule, message)
         end
 
@@ -38,8 +38,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