softlayer_api 3.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db7fb619e9abee8aa3716ef5cc5e88b29ee86232
-  data.tar.gz: a4544cc335c39b45149616d1e725b65bb1115484
+  metadata.gz: 21403d80bc5530202d1f40ceda6e67404de66717
+  data.tar.gz: 8879bb889d5418a4a3f2853d754565e794e3ab41
 SHA512:
-  metadata.gz: a9919fb7d7cd6f2a4a7b071970212257d2364821be75d96cf3c56ab3806d65f0f28438b892ffd85503d41be10cd53e7c71f21bb38b08f2fbaa4c0a10df28c785
-  data.tar.gz: ad1fdd2a7317e8d87c6285a0a95a77906a70ed8f1382fd29862af9f27256613d30462ef8c5dff45ac601fd0faea8b78ee353327b6367bf2a7c9e865531ff9b82
+  metadata.gz: 584069e9c12b5922e1d7fae1c0004f1deb3f0435401cac9e7bbafd0bb713b7868eeea37c6dcc560a15dc8fb2dca9001d654464cd05bb263d4f181b8d52c1a535
+  data.tar.gz: fe1a472fa84d6e23468ef538a0653623ef37c2a501f5a179b4cf17144aa12288c52e81b3f492d0f354360cec31516536826fd024e01645e38c950e8c56461b2d

data/CHANGELOG.textile

@@ -1,3 +1,6 @@
+*3.1.0*
+* Many SoftLayer Attributes are now shadowed with snake_case names.  The old CamelCase versions are deprecated and will be removed in the next major release
+* New functionality related to network monitoring has been added
 *3.0*
 * Substantially rewrote the ObjectFilter class. ObjectFilters used to be hashes which made it easy to manipulate their content incorrectly. The new implementation has a strict interface that makes it harder to manipulate filters incorrectly.
 * Added a model for Virtual Server Image Templates (SoftLayer::ImageTemplate) - VirtualServerOrder now requires an instance of this class rather than allowing you to provide the global_id of an image

data/lib/softlayer/Account.rb

@@ -8,19 +8,43 @@ module SoftLayer
   class Account < SoftLayer::ModelBase
     include ::SoftLayer::DynamicAttribute
 
+    ##
+    # :attr_reader: company_name
+    # The company name of the primary contact
+    sl_attr :company_name, 'companyName'
+
     ##
     # :attr_reader:
     # The company name of the primary contact
+    #
+    # DEPRECATION WARNING: This attribute is deprecated in favor of company_name
+    # and will be removed in the next major release.
     sl_attr :companyName
 
+    ##
+    # :attr_reader: first_name
+    # The given name name of the primary contact
+    sl_attr :first_name, 'firstName'
+
     ##
     # :attr_reader:
     # The given name name of the primary contact
+    #
+    # DEPRECATION WARNING: This attribute is deprecated in favor of first_name
+    # and will be removed in the next major release.
     sl_attr :firstName
 
+    ##
+    # :attr_reader: last_name
+    # The surname of the primary contact
+    sl_attr :last_name, 'lastName'
+
     ##
     # :attr_reader:
     # The surname of the primary contact
+    #
+    # DEPRECATION WARNING: This attribute is deprecated in favor of last_name
+    # and will be removed in the next major release.
     sl_attr :lastName
 
     ##
@@ -51,18 +75,34 @@ module SoftLayer
     # The country stored as part of the primary contact's address
     sl_attr :country
 
+    ##
+    # :attr_reader: postal_code
+    # The postal code (in the US, aka. zip code) of the primary contact's address
+    sl_attr :postal_code, 'postalCode'
+
     ##
     # :attr_reader:
     # The postal code (in the US, aka. zip code) of the primary contact's address
+    #
+    # DEPRECATION WARNING: This attribute is deprecated in favor of postal_code
+    # and will be removed in the next major release.
     sl_attr :postalCode
 
+    ##
+    # :attr_reader: office_phone
+    # The office phone number listed for the primary contact
+    sl_attr :office_phone, 'officePhone'
+
     ##
     # :attr_reader:
-    # The office phone nubmer listed for the primary contact
+    # The office phone number listed for the primary contact
+    #
+    # DEPRECATION WARNING: This attribute is deprecated in favor of office_phone
+    # and will be removed in the next major release.
     sl_attr :officePhone
 
     ##
-    # The Bare Metal Servers (physical hardware) associated with the
+    # Retrieve the Bare Metal Servers (physical hardware) associated with the
     # account. Unless you force these to update, they will be refreshed every
     # five minutes.
     # :call-seq:
@@ -82,6 +122,8 @@ module SoftLayer
     ##
     # Retrieve an account's master EVault user. This is only used when an account
     # has an EVault service.
+    # :call-seq:
+    #   evault_master_users(force_update=false)
     sl_dynamic_attr :evault_master_users do |evault_users|
       evault_users.should_update? do
         @evault_master_users == nil
@@ -94,7 +136,10 @@ module SoftLayer
     end
 
     ##
-    # Retrieve an account's image templates
+    # Retrieve an account's image templates. Unless you force 
+    # these to update, they will be refreshed every five minutes
+    # :call-seq:
+    #   image_templates(force_update=false)
     sl_dynamic_attr :image_templates do |image_templates|
       image_templates.should_update? do
         @last_image_template_update ||= Time.at(0)
@@ -108,7 +153,9 @@ module SoftLayer
     end
 
     ##
-    # Retrieve an account's network message delivery acounts.
+    # Retrieve an account's network message delivery accounts.
+    # :call-seq:
+    #   network_message_delivery_accounts(force_update=false)
     sl_dynamic_attr :network_message_delivery_accounts do |net_msg_deliv_accts|
       net_msg_deliv_accts.should_update? do
         @network_message_delivery_accounts == nil
@@ -122,6 +169,8 @@ module SoftLayer
 
     ##
     # Retrieve an account's network storage groups.
+    # :call-seq:
+    #   network_storage_groups(force_update=false)
     sl_dynamic_attr :network_storage_groups do |net_stor_groups|
       net_stor_groups.should_update? do
         @network_storage_groups == nil
@@ -134,7 +183,10 @@ module SoftLayer
     end
 
     ##
-    # Retrieve an account's open tickets
+    # Retrieve an account's open tickets. Unless you force these 
+    # to update, they will be refreshed every five minutes
+    # :call-seq:
+    #   open_tickets(force_update=false)
     sl_dynamic_attr :open_tickets do |open_tickets|
       open_tickets.should_update? do
         @last_open_tickets_update ||= Time.at(0)
@@ -150,6 +202,8 @@ module SoftLayer
 
     ##
     # Retrieve an account's portal users.
+    # :call-seq:
+    #   users(force_update=false)
     sl_dynamic_attr :users do |users|
       users.should_update? do
         @users == nil
@@ -162,7 +216,10 @@ module SoftLayer
     end
 
     ##
-    # Retrieve an account's virtual disk images
+    # Retrieve an account's virtual disk images. Unless you force 
+    # these to update, they will be refreshed every five minutes
+    # :call-seq:
+    #   virtual_disk_images(force_update=false)
     sl_dynamic_attr :virtual_disk_images do |virtual_disk_images|
       virtual_disk_images.should_update? do
         @last_virtual_disk_images_update ||= Time.at(0)
@@ -177,7 +234,7 @@ module SoftLayer
     end
 
     ##
-    # The virtual servers (aka. CCIs or Virtual_Guests) associated with the
+    # Retrieve the virtual servers (aka. CCIs or Virtual_Guests) associated with the
     # account. Unless you force these to update, they will be refreshed every
     # five minutes.
     # :call-seq:
@@ -207,6 +264,26 @@ module SoftLayer
     # The IDs of the different segments can be helpful for ordering
     # firewalls.
     #
+    def find_vlan_with_number(vlan_number)
+      filter = SoftLayer::ObjectFilter.new() { |filter|
+        filter.accept('networkVlans.vlanNumber').when_it is vlan_number
+      }
+
+      vlan_data = self.service.object_mask("mask[id,vlanNumber,primaryRouter,networkSpace]").object_filter(filter).getNetworkVlans
+      return vlan_data
+    end
+
+    ##
+    # Searches the account's list of VLANs for the ones with the given
+    # vlan number. This may return multiple results because a VLAN can
+    # span different routers and you will get a separate segment for
+    # each router.
+    #
+    # The IDs of the different segments can be helpful for ordering
+    # firewalls.
+    #
+    # DEPRECATION WARNING: This method is deprecated in favor of find_vlan_with_number
+    # and will be removed in the next major release.
     def find_VLAN_with_number(vlan_number)
       filter = SoftLayer::ObjectFilter.new() { |filter|
         filter.accept('networkVlans.vlanNumber').when_it is vlan_number
@@ -226,7 +303,7 @@ module SoftLayer
 
       account_service = softlayer_client[:Account]
       network_hash = account_service.getObject()
-      new(softlayer_client, network_hash)
+      Account.new(softlayer_client, network_hash)
     end
 
     ##

data/lib/softlayer/AccountPassword.rb

@@ -32,6 +32,8 @@ module SoftLayer
 
     ##
     # A description of the use for the account username/password combination.
+    # :call-seq:
+    #   description(force_update=false)
     sl_dynamic_attr :description do |resource|
       resource.should_update? do
         #only retrieved once per instance
@@ -74,13 +76,21 @@ module SoftLayer
     # 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 account passwords from servers matching this datacenter
-    # * <b>+:domain+</b>                      (string) - Include network storage account passwords from servers matching this domain
-    # * <b>+:hostname+</b>                    (string) - 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>+:tags+</b>                        (Array)  - Include network storage account passwords from servers matching these tags
-    # * <b>+:username+</b>                    (string) - Include network storage account passwords with this username only
+    # * <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> (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
@@ -119,10 +129,12 @@ module SoftLayer
         :account_password => {
           :username       => "accountPassword.username"
         },
-        :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               },
-        :tags             => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.tagReferences.tag.name' ].join }
+        :network_storage  => {
+          :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               },
+          :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]
@@ -134,24 +146,13 @@ module SoftLayer
       if options_hash[:network_storage_server_type]
         network_storage_type = options_hash[:network_storage_type] || :network_storage
 
-        [ :datacenter, :domain, :hostname ].each do |option|
+        option_to_filter_path[:network_storage].keys.each do |option|
           if options_hash[option]
             network_storage_object_filter.modify do |filter|
-              filter.accept(option_to_filter_path[option].call(network_storage_type, options_hash[:network_storage_server_type])).when_it is(options_hash[option])
+              filter.accept(option_to_filter_path[:network_storage][option].call(network_storage_type, options_hash[:network_storage_server_type])).when_it is(options_hash[option])
             end
           end
         end
-
-        if options_hash[:tags]
-          network_storage_object_filter.set_criteria_for_key_path(option_to_filter_path[:tags].call(network_storage_type, options_hash[:network_storage_server_type]),
-                                                                  {
-                                                                    'operation' => 'in',
-                                                                    'options' => [{
-                                                                                    'name' => 'data',
-                                                                                    'value' => options_hash[:tags].collect{ |tag_value| tag_value.to_s }
-                                                                                  }]
-                                                                  })
-        end
       end
 
       option_to_filter_path[:account_password].each do |option, filter_path|
@@ -201,13 +202,21 @@ module SoftLayer
     # 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 webcc passwords from servers matching this datacenter
-    # * <b>+:domain+</b>                      (string) - Include network storage webcc passwords from servers matching this domain
-    # * <b>+:hostname+</b>                    (string) - 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>+:tags+</b>                        (Array)  - Include network storage webcc passwords from servers matching these tags
-    # * <b>+:username+</b>                    (string) - Include network storage webcc passwords with this username only
+    # * <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> (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
@@ -243,11 +252,13 @@ module SoftLayer
       }
 
       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               },
-        :tags             => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.tagReferences.tag.name' ].join },
-        :webcc_password => {
+        :network_storage => {
+          :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               },
+          :tags             => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.tagReferences.tag.name' ].join }
+        },
+        :webcc_password  => {
           :username       => "webccAccount.username"
         }
       }
@@ -261,24 +272,13 @@ module SoftLayer
       if options_hash[:network_storage_server_type]
         network_storage_type = options_hash[:network_storage_type] || :network_storage
 
-        [ :datacenter, :domain, :hostname ].each do |option|
+        option_to_filter_path[:network_storage].keys.each do |option|
           if options_hash[option]
             network_storage_object_filter.modify do |filter|
-              filter.accept(option_to_filter_path[option].call(network_storage_type, options_hash[:network_storage_server_type])).when_it is(options_hash[option])
+              filter.accept(option_to_filter_path[:network_storage][option].call(network_storage_type, options_hash[:network_storage_server_type])).when_it is(options_hash[option])
             end
           end
         end
-
-        if options_hash[:tags]
-          network_storage_object_filter.set_criteria_for_key_path(option_to_filter_path[:tags].call(network_storage_type, options_hash[:network_storage_server_type]),
-                                                                  {
-                                                                    'operation' => 'in',
-                                                                    'options' => [{
-                                                                                    'name' => 'data',
-                                                                                    'value' => options_hash[:tags].collect{ |tag_value| tag_value.to_s }
-                                                                                  }]
-                                                                  })
-        end
       end
 
       option_to_filter_path[:webcc_password].each do |option, filter_path|

data/lib/softlayer/BareMetalServer.rb

@@ -9,7 +9,7 @@
 module SoftLayer
   #
   # This class represents a Bare Metal Server, a hardware server in contrast to a virtual machine,
-  # in the SoftLayer Environment. It corresponds rougly to the +SoftLayer_Hardware+ and
+  # in the SoftLayer Environment. It corresponds roughly to the +SoftLayer_Hardware+ and
   # +SoftLayer_Hardware_Server+ services in the SoftLayer API
   #
   # http://sldn.softlayer.com/reference/datatypes/SoftLayer_Hardware
@@ -23,7 +23,7 @@ module SoftLayer
     # a Bare Metal Instance is physical, hardware server that is is provisioned to
     # match a profile with characteristics similar to a Virtual Server
     #
-    # This is an important distincition in rare cases, like cancelling the server.
+    # This is an important distinction in rare cases, like cancelling the server.
     #
     def bare_metal_instance?
       if has_sl_property?(:bareMetalInstanceFlag)
@@ -65,7 +65,7 @@ module SoftLayer
     # Returns the typical Service used to work with this Server
     # For Bare Metal Servers that is +SoftLayer_Hardware+ though in some special cases
     # you may have to use +SoftLayer_Hardware_Server+ as a type or service.  That
-    # service object is available thorugh the hardware_server_service method
+    # service object is available through the hardware_server_service method
     def service
       return softlayer_client[:Hardware_Server].object_with_id(self.id)
     end
@@ -146,7 +146,7 @@ module SoftLayer
     end
 
     ##
-    # Retrive the bare metal server with the given server ID from the
+    # Retrieve the bare metal server with the given server ID from the
     # SoftLayer API
     #
     # The options parameter should contain:
@@ -155,6 +155,10 @@ module SoftLayer
     #
     # 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
@@ -183,20 +187,22 @@ module SoftLayer
     #
     # You may filter the list returned by adding options:
     #
-    # * <b>+:tags+</b> (array) - an array of strings representing tags to search for on the instances
-    # * <b>+:cpus+</b> (int) - return servers with the given number of (virtual) CPUs
-    # * <b>+:memory+</b> (int) - return servers with at least the given amount of memory (in Gigabytes)
-    # * <b>+:hostname+</b> (string) - return servers whose hostnames match the query string given (see ObjectFilter::query_to_filter_operation)
-    # * <b>+:domain+</b> (string) - filter servers to those whose domain matches the query string given (see ObjectFilter::query_to_filter_operation)
-    # * <b>+:datacenter+</b> (string) - find servers whose data center name matches the query string given (see ObjectFilter::query_to_filter_operation)
-    # * <b>+:nic_speed+</b> (int) - include servers with the given nic speed (in Mbps)
-    # * <b>+:public_ip+</b> (string) - return servers whose public IP address matches the query string given (see ObjectFilter::query_to_filter_operation)
-    # * <b>+:private_ip+</b> (string) - same as :public_ip, but for private IP addresses
+    # * <b>+:tags+</b>       (string/array) - an array of strings representing tags to search for on the instances
+    # * <b>+:cpus+</b>       (int/array)    - return servers with the given number of (virtual) CPUs
+    # * <b>+:memory+</b>     (int/array)    - return servers with at least the given amount of memory (in Gigabytes)
+    # * <b>+:hostname+</b>   (string/array) - return servers whose hostnames match the query string given (see ObjectFilter::query_to_filter_operation)
+    # * <b>+:domain+</b>     (string/array) - filter servers to those whose domain matches the query string given (see ObjectFilter::query_to_filter_operation)
+    # * <b>+:datacenter+</b> (string/array) - find servers whose data center name matches the query string given (see ObjectFilter::query_to_filter_operation)
+    # * <b>+:nic_speed+</b>  (int/array)    - include servers with the given nic speed (in Mbps)
+    # * <b>+:public_ip+</b>  (string/array) - return servers whose public IP address matches the query string given (see ObjectFilter::query_to_filter_operation)
+    # * <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
@@ -210,14 +216,15 @@ module SoftLayer
       end
 
       option_to_filter_path = {
-        :cpus => "hardware.processorPhysicalCoreAmount",
-        :memory => "hardware.memoryCapacity",
-        :hostname => "hardware.hostname",
-        :domain => "hardware.domain",
+        :cpus       => "hardware.processorPhysicalCoreAmount",
+        :memory     => "hardware.memoryCapacity",
+        :hostname   => "hardware.hostname",
+        :domain     => "hardware.domain",
         :datacenter => "hardware.datacenter.name",
-        :nic_speed => "hardware.networkComponents.maxSpeed",
-        :public_ip => "hardware.primaryIpAddress",
-        :private_ip => "hardware.primaryBackendIpAddress"
+        :nic_speed  => "hardware.networkComponents.maxSpeed",
+        :public_ip  => "hardware.primaryIpAddress",
+        :private_ip => "hardware.primaryBackendIpAddress",
+        :tags       => "hardware.tagReferences.tag.name"
       }
 
       # For each of the options in the option_to_filter_path map, if the options hash includes
@@ -227,30 +234,13 @@ module SoftLayer
         object_filter.modify { |filter| filter.accept(filter_path).when_it is(options_hash[option])} if options_hash[option]
       end
 
-      # Tags get a much more complex object filter operation so we handle them separately
-      if options_hash.has_key?(:tags)
-        object_filter.set_criteria_for_key_path("hardware.tagReferences.tag.name", {
-          'operation' => 'in',
-          'options' => [{
-            'name' => 'data',
-            'value' => options_hash[:tags].collect{ |tag_value| tag_value.to_s }
-            }]
-          } );
-      end
-
       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()