softlayer 0.0.7 → 0.0.8

data/lib/softlayer/network/storage.rb

@@ -119,113 +119,118 @@ module Softlayer
       attr_accessor :webcc_account
       attr_accessor :weekly_schedule
 
-      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
 
@@ -233,13 +238,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, message)
       end
 
@@ -247,18 +252,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
 
@@ -266,28 +271,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
 
@@ -295,8 +305,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
 
@@ -316,28 +326,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
 
@@ -385,8 +396,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
 
@@ -418,8 +430,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
 
@@ -427,8 +439,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
 
@@ -444,8 +457,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
 
@@ -493,8 +508,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
 
@@ -526,8 +541,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
 
@@ -659,128 +674,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/subnet/ip_address/global.rb

@@ -39,8 +39,8 @@ module Softlayer
             request(:get_object, Softlayer::Network::Subnet::IpAddress::Global)
           end
 
-          def route(new_end_point_ip_address = nil)
-            message = {new_end_point_ip_address: new_end_point_ip_address}
+          # new_end_point_ip_address
+          def route(message)
             request(:route, Softlayer::Provisioning::Version1::Transaction, message)
           end
 

data/lib/softlayer/network/subnet/ip_address.rb

@@ -57,28 +57,28 @@ module Softlayer
         attr_accessor :virtual_guest
         attr_accessor :virtual_licenses
 
-        def allow_access_to_network_storage(network_storage_template_object = nil)
-          message = {network_storage_template_object: network_storage_template_object}
+        # network_storage_template_object
+        def allow_access_to_network_storage(message)
           request(:allow_access_to_network_storage, Boolean, message)
         end
 
-        def allow_access_to_network_storage_list(network_storage_template_objects = nil)
-          message = {network_storage_template_objects: network_storage_template_objects}
+        # network_storage_template_objects
+        def allow_access_to_network_storage_list(message)
           request(:allow_access_to_network_storage_list, 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 self.edit_objects(template_objects = nil)
-          message = {template_objects: template_objects}
+        # template_objects
+        def self.edit_objects(message)
           request(:edit_objects, Boolean, message)
         end
 
-        def self.find_by_ipv4_address(ip_address = nil)
-          message = {ip_address: ip_address}
+        # ip_address
+        def self.find_by_ipv4_address(message)
           request(:find_by_ipv4_address, Softlayer::Network::Subnet::IpAddress, message)
         end
 
@@ -98,18 +98,18 @@ module Softlayer
           request(:get_application_delivery_controller, Softlayer::Network::Application::Delivery::Controller)
         end
 
-        def get_attached_network_storages(nas_type = nil)
-          message = {nas_type: nas_type}
+        # nas_type
+        def get_attached_network_storages(message)
           request(:get_attached_network_storages, Array[Softlayer::Network::Storage], message)
         end
 
-        def get_available_network_storages(nas_type = nil)
-          message = {nas_type: nas_type}
+        # nas_type
+        def get_available_network_storages(message)
           request(:get_available_network_storages, Array[Softlayer::Network::Storage], message)
         end
 
-        def self.get_by_ip_address(ip_address = nil)
-          message = {ip_address: ip_address}
+        # ip_address
+        def self.get_by_ip_address(message)
           request(:get_by_ip_address, Softlayer::Network::Subnet::IpAddress, message)
         end
 
@@ -209,8 +209,8 @@ module Softlayer
           request(:get_virtual_licenses, Array[Softlayer::Software::VirtualLicense])
         end
 
-        def remove_access_to_network_storage_list(network_storage_template_objects = nil)
-          message = {network_storage_template_objects: network_storage_template_objects}
+        # network_storage_template_objects
+        def remove_access_to_network_storage_list(message)
           request(:remove_access_to_network_storage_list, Boolean, message)
         end
 

data/lib/softlayer/network/subnet/registration/details.rb

@@ -12,8 +12,8 @@ module Softlayer
           attr_accessor :detail
           attr_accessor :registration
 
-          def self.create_object(template_object = nil)
-            message = {template_object: template_object}
+          # template_object
+          def self.create_object(message)
             request(:create_object, Softlayer::Network::Subnet::Registration::Details, message)
           end