Cleanup rdoc for available options, object mask, and result limit and add result limit where it was missing

Author: ju2wheels

lib/softlayer/Account.rb

@@ -283,7 +283,7 @@ def self.account_for_client(client = nil)
 
       account_service = softlayer_client[:Account]
       network_hash = account_service.getObject()
-      new(softlayer_client, network_hash)
+      Account.new(softlayer_client, network_hash)
     end
 
     ##

lib/softlayer/AccountPassword.rb

@@ -79,11 +79,19 @@ def password=(password)
     # * <b>+:datacenter+</b>                  (string/array) - Include network storage account passwords from servers matching this datacenter
     # * <b>+:domain+</b>                      (string/array) - Include network storage account passwords from servers matching this domain
     # * <b>+:hostname+</b>                    (string/array) - Include network storage account passwords from servers matching this hostname
-    # * <b>+:network_storage_server_type+</b> (string)       - Include network storage account passwords attached to this server type
-    # * <b>+:network_storage_type+</b>        (string)       - Include network storage account passwords from devices of this storage type
+    # * <b>+:network_storage_server_type+</b> (symbol)       - Include network storage account passwords attached to this server type
+    # * <b>+:network_storage_type+</b>        (symbol)       - Include network storage account passwords from devices of this storage type
     # * <b>+:tags+</b>                        (string/array) - Include network storage account passwords from servers matching these tags
     # * <b>+:username+</b>                    (string/array) - Include network storage account passwords with this username only
     #
+    # Additionally you may provide options related to the request itself:
+    # * <b>*:account_password_object_filter*</b> (ObjectFilter) - Include network storage account passwords for account passwords that match the
+    #                                                             criteria of this object filter
+    # * <b>*:account_password_object_mask*</b>   (string)       - The object mask of properties you wish to receive for the items returned.
+    #                                                             If not provided, the result will use the default object mask
+    # * <b>*:network_storage_object_filter*</b>  (ObjectFilter) - Include network storage account passwords from network storage that matches the
+    #                                                             criteria of this object filter
+    #
     def self.find_network_storage_account_passwords(options_hash = {})
       softlayer_client = options_hash[:client] || Client.default_client
       raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client
@@ -197,11 +205,19 @@ def self.find_network_storage_account_passwords(options_hash = {})
     # * <b>+:datacenter+</b>                  (string/array) - Include network storage webcc passwords from servers matching this datacenter
     # * <b>+:domain+</b>                      (string/array) - Include network storage webcc passwords from servers matching this domain
     # * <b>+:hostname+</b>                    (string/array) - Include network storage webcc passwords from servers matching this hostname
-    # * <b>+:network_storage_server_type+</b> (string)       - Include network storage webcc passwords attached to this server type
-    # * <b>+:network_storage_type+</b>        (string)       - Include network storage webcc passwords from devices of this storage type
+    # * <b>+:network_storage_server_type+</b> (symbol)       - Include network storage webcc passwords attached to this server type
+    # * <b>+:network_storage_type+</b>        (symbol)       - Include network storage webcc passwords from devices of this storage type
     # * <b>+:tags+</b>                        (string/array) - Include network storage webcc passwords from servers matching these tags
     # * <b>+:username+</b>                    (string/array) - Include network storage webcc passwords with this username only
     #
+    # Additionally you may provide options related to the request itself:
+    # * <b>*:network_storage_object_filter*</b>  (ObjectFilter) - Include network storage account passwords from network storage that matches the
+    #                                                             criteria of this object filter
+    # * <b>*:webcc_password_object_filter*</b>   (ObjectFilter) - Include network storage account passwords for webcc passwords that match the
+    #                                                             criteria of this object filter
+    # * <b>*:webcc_password_object_mask*</b>     (string)       - The object mask of properties you wish to receive for the items returned.
+    #                                                             If not provided, the result will use the default object mask
+    #
     def self.find_network_storage_webcc_passwords(options_hash = {})
       softlayer_client = options_hash[:client] || Client.default_client
       raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client

lib/softlayer/BareMetalServer.rb

@@ -155,6 +155,10 @@ def firewall_port_speed
     #
     # If no client is given, then the routine will try to use Client.default_client
     # If no client can be found the routine will raise an error.
+    #
+    # Additionally you may provide options related to the request itself:
+    # * <b>*:object_mask*</b>   (string) - The object mask of properties you wish to receive for the items returned.
+    #                                      If not provided, the result will use the default object mask
     def self.server_with_id(server_id, options = {})
       softlayer_client = options[:client] || Client.default_client
       raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client
@@ -194,9 +198,11 @@ def self.server_with_id(server_id, options = {})
     # * <b>+:private_ip+</b> (string/array) - same as :public_ip, but for private IP addresses
     #
     # Additionally you may provide options related to the request itself:
-    #
-    # * <b>+:object_mask+</b> (string, hash, or array) - The object mask of properties you wish to receive for the items returned If not provided, the result will use the default object mask
-    # * <b>+:result_limit+</b> (hash with :limit, and :offset keys) - Limit the scope of results returned.
+    # * <b>*:object_filter*</b> (ObjectFilter)                       - Include hardware servers for servers that matche the
+    #                                                                  criteria of this object filter
+    # * <b>+:object_mask+</b>   (string, hash, or array)             - The object mask of properties you wish to receive for the items returned.
+    #                                                                  If not provided, the result will use the default object mask
+    # * <b>+:result_limit+</b>  (hash with :limit, and :offset keys) - Limit the scope of results returned.
     #
     def self.find_servers(options_hash = {})
       softlayer_client = options_hash[:client] || Client.default_client
@@ -231,16 +237,10 @@ def self.find_servers(options_hash = {})
       account_service = softlayer_client[:Account]
       account_service = account_service.object_filter(object_filter) unless object_filter.empty?
       account_service = account_service.object_mask(default_object_mask.to_sl_object_mask)
+      account_service = account_service.object_mask(options_hash[:object_mask]) if options_hash[:object_mask]
 
-      if(options_hash.has_key? :object_mask)
-        account_service = account_service.object_mask(options_hash[:object_mask])
-      end
-
-      if options_hash.has_key?(:result_limit)
-        offset = options[:result_limit][:offset]
-        limit = options[:result_limit][:limit]
-
-        account_service = account_service.result_limit(offset, limit)
+      if options_hash[:result_limit] && options_hash[:result_limit][:offset] && options_hash[:result_limit][:limit]
+        account_service = account_service.result_limit(options_hash[:result_limit][:offset], options_hash[:result_limit][:limit])
       end
 
       bare_metal_data = account_service.getHardware()

lib/softlayer/ImageTemplate.rb

@@ -212,6 +212,14 @@ def softlayer_properties(object_mask = nil)
     # * <b>+:name+</b>      (string/array) - Return templates with the given name
     # * <b>+:global_id+</b> (string/array) - Return templates with the given global identifier
     # * <b>+:tags+</b>      (string/array) - Return templates with the tags
+    #
+    # Additionally you may provide options related to the request itself:
+    #
+    # * <b>*:object_filter*</b> (ObjectFilter)                       - Include private image templates for templates that matche the
+    #                                                                  criteria of this object filter
+    # * <b>+:object_mask+</b>   (string, hash, or array)             - The object mask of properties you wish to receive for the items returned.
+    #                                                                  If not provided, the result will use the default object mask
+    # * <b>+:result_limit+</b>  (hash with :limit, and :offset keys) - Limit the scope of results returned.
     def self.find_private_templates(options_hash = {})
       softlayer_client = options_hash[:client] || Client.default_client
       raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client
@@ -239,20 +247,14 @@ def self.find_private_templates(options_hash = {})
       account_service = softlayer_client[:Account]
       account_service = account_service.object_filter(object_filter) unless object_filter.empty?
       account_service = account_service.object_mask(default_object_mask)
+      account_service = account_service.object_mask(options_hash[:object_mask]) if options_hash[:object_mask]
 
-      if options_hash.has_key? :object_mask
-        account_service = account_service.object_mask(options_hash[:object_mask])
-      end
-
-      if options_hash.has_key?(:result_limit)
-        offset = options[:result_limit][:offset]
-        limit = options[:result_limit][:limit]
-
-        account_service = account_service.result_limit(offset, limit)
+      if options_hash[:result_limit] && options_hash[:result_limit][:offset] && options_hash[:result_limit][:limit]
+        account_service = account_service.result_limit(options_hash[:result_limit][:offset], options_hash[:result_limit][:limit])
       end
 
       templates_data = account_service.getPrivateBlockDeviceTemplateGroups
-      templates_data.collect { |template_data| new(softlayer_client, template_data) }
+      templates_data.collect { |template_data| ImageTemplate.new(softlayer_client, template_data) }
     end
 
     ##
@@ -269,6 +271,14 @@ def self.find_private_templates(options_hash = {})
     # * <b>+:name+</b>      (string/array) - Return templates with the given name
     # * <b>+:global_id+</b> (string/array) - Return templates with the given global identifier
     # * <b>+:tags+</b>      (string/array) - Return templates with the tags
+    #
+    # Additionally you may provide options related to the request itself:
+    #
+    # * <b>*:object_filter*</b> (ObjectFilter)                       - Include public image templates for templates that matche the
+    #                                                                  criteria of this object filter
+    # * <b>+:object_mask+</b>   (string, hash, or array)             - The object mask of properties you wish to receive for the items returned.
+    #                                                                  If not provided, the result will use the default object mask
+    # * <b>+:result_limit+</b>  (hash with :limit, and :offset keys) - Limit the scope of results returned.
     def self.find_public_templates(options_hash = {})
       softlayer_client = options_hash[:client] || Client.default_client
       raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client
@@ -296,20 +306,14 @@ def self.find_public_templates(options_hash = {})
       template_service = softlayer_client[:Virtual_Guest_Block_Device_Template_Group]
       template_service = template_service.object_filter(object_filter) unless object_filter.empty?
       template_service = template_service.object_mask(default_object_mask)
+      template_service = template_service.object_mask(options_hash[:object_mask]) if options_hash[:object_mask]
 
-      if options_hash.has_key? :object_mask
-        template_service = template_service.object_mask(options_hash[:object_mask])
-      end
-
-      if options_hash.has_key?(:result_limit)
-        offset = options[:result_limit][:offset]
-        limit = options[:result_limit][:limit]
-
-        template_service = template_service.result_limit(offset, limit)
+      if options_hash[:result_limit] && options_hash[:result_limit][:offset] && options_hash[:result_limit][:limit]
+        template_service = template_service.result_limit(options_hash[:result_limit][:offset], options_hash[:result_limit][:limit])
       end
 
       templates_data = template_service.getPublicImages
-      templates_data.collect { |template_data| new(softlayer_client, template_data) }
+      templates_data.collect { |template_data| ImageTemplate.new(softlayer_client, template_data) }
     end
 
     ##
@@ -337,7 +341,7 @@ def self.template_with_id(id, options_hash = {})
       end
 
       template_data = service.getObject
-      new(softlayer_client, template_data)
+      ImageTemplate.new(softlayer_client, template_data)
     end
 
     ##

lib/softlayer/NetworkStorage.rb

@@ -196,13 +196,20 @@ def remove_credential(username)
     # If no client can be found the routine will raise an error.
     #
     # You may filter the list returned by adding options:
-    # * <b>+:datacenter+</b>                  (string) - Include network storage associated with servers matching this datacenter
-    # * <b>+:domain+</b>                      (string) - Include network storage associated with servers matching this domain
-    # * <b>+:hostname+</b>                    (string) - Include network storage associated with servers matching this hostname
-    # * <b>+:network_storage_server_type+</b> (string) - Include network storage associated with this server type
-    # * <b>+:network_storage_type+</b>        (string) - Include network storage from devices of this storage type
-    # * <b>+:service+</b>                     (string) - Include network storage from devices with this service fqdn
-    # * <b>+:tags+</b>                        (Array)  - Include network storage associated with servers matching these tags
+    # * <b>+:datacenter+</b>                  (string/array) - Include network storage associated with servers matching this datacenter
+    # * <b>+:domain+</b>                      (string/array) - Include network storage associated with servers matching this domain
+    # * <b>+:hostname+</b>                    (string/array) - Include network storage associated with servers matching this hostname
+    # * <b>+:network_storage_server_type+</b> (symbol)       - Include network storage associated with this server type
+    # * <b>+:network_storage_type+</b>        (symbol)       - Include network storage from devices of this storage type
+    # * <b>+:service+</b>                     (string/array) - Include network storage from devices with this service fqdn
+    # * <b>+:tags+</b>                        (string/array) - Include network storage associated with servers matching these tags
+    #
+    # Additionally you may provide options related to the request itself:
+    # * <b>*:network_storage_object_mask*</b>   (string)             - The object mask of properties you wish to receive for the items returned.
+    #                                                                  If not provided, the result will use the default object mask
+    # * <b>*:network_storage_object_filter*</b> (ObjectFilter)       - Include network storage credentials from network storage that matches the
+    #                                                                  criteria of this object filter
+    # * <b>+:result_limit+</b>  (hash with :limit, and :offset keys) - Limit the scope of results returned.
     #
     def self.find_network_storage(options_hash  = {})
       softlayer_client = options_hash[:client] || Client.default_client
@@ -231,11 +238,11 @@ def self.find_network_storage(options_hash  = {})
       }
 
       option_to_filter_path = {
-        :datacenter                 => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.datacenter.name' ].join                  },
-        :domain                     => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.domain' ].join                           },
-        :hostname                   => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.hostname' ].join                         },
-        :service                    => lambda { |storage_type|              return [ filter_label[storage_type],                                 '.serviceResource.backendIpAddress' ].join },
-        :tags                       => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.tagReferences.tag.name' ].join           },
+        :datacenter => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.datacenter.name' ].join                  },
+        :domain     => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.domain' ].join                           },
+        :hostname   => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.hostname' ].join                         },
+        :service    => lambda { |storage_type|              return [ filter_label[storage_type],                                 '.serviceResource.backendIpAddress' ].join },
+        :tags       => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.tagReferences.tag.name' ].join           },
       }
 
       if options_hash[:network_storage_type]
@@ -278,6 +285,10 @@ def self.find_network_storage(options_hash  = {})
       account_service = account_service.object_mask(NetworkStorage.default_object_mask)
       account_service = account_service.object_mask(options_hash[:network_storage_object_mask]) if options_hash[:network_storage_object_mask]
 
+      if options_hash[:result_limit] && options_hash[:result_limit][:offset] && options_hash[:result_limit][:limit]
+        account_service = account_service.result_limit(options_hash[:result_limit][:offset], options_hash[:result_limit][:limit])
+      end
+
       case options_hash[:network_storage_type]
       when :evault
         network_storage_data = account_service.getEvaultNetworkStorage