softlayer_api 2.0.1 → 2.1.0

data/examples/ticket_info.rb

@@ -25,24 +25,23 @@ require 'softlayer_api'
 require 'pp'
 
 softlayer_client = SoftLayer::Client.new(
-  :username => "joecustomer",              # enter your username here
-  :api_key => "feeddeadbeefbadf00d..."     # enter your api key here
+#  :username => "joecustomer",              # enter your username here
+#  :api_key => "feeddeadbeefbadf00d..."     # enter your api key here
   )
 
 begin
+  # Demonstrates using the low-level capabilities of the gem to get
+  # at information.  In this case we are talking directly to the ticket
+  # service
   ticket_service = softlayer_client.service_named("Ticket");
-  ticket_ref = ticket_service.object_with_id(8172109)
+  
+  # Retrive a particular ticket by ID (you will have to substitute an existing ticket's ID here)
+  ticket_ref = ticket_service.object_with_id(12345)
 
-  ticket = ticket_ref.object_mask("mask[updates[entry,createDate],assignedUserId,attachedHardware.datacenter]".getObject
+  # Retrive very specific information about the ticket
+  ticket = ticket_ref.object_mask("mask[updates[entry,createDate],assignedUserId,attachedHardware.datacenter]").getObject
+  
   pp ticket
 rescue Exception => exception
-  puts "Unable to retrieve the ticket"
-end
-
-# update the ticket
-begin
-  updates = ticket_ref.addUpdate({"entry" => "An update from the Ruby client!"})
-  puts "Update ticket 123456. The new update's id is #{updates[0]['id']}"
-rescue Exception => exception
-  puts "Unable to update the ticket: #{exception}"
-end
+  puts "Unable to retrieve the ticket #{exception}"
+end

data/lib/softlayer/APIParameterFilter.rb

@@ -1,43 +1,76 @@
+#
+# Copyright (c) 2014 SoftLayer Technologies, Inc. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
 
 module SoftLayer
-# An <tt>APIParameterFilter</tt> is an intermediary object that understands how
+# An +APIParameterFilter+ is an intermediary object that understands how
 # to accept the other API parameter filters and carry their values to
-# <tt>method_missing</tt> in <tt>Service</tt>. Instances of this class are created
-# internally by the <tt>Service</tt> in its handling of a method call and you
+# method_missing in Service. Instances of this class are created
+# internally by the Service in its handling of a method call and you
 # should not have to create instances of this class directly.
 #
 # Instead, to use an API filter, you add a filter method to the call
-# chain when you call a method through a <tt>SoftLayer::Service</tt>
+# chain when you call a method through a Service
 #
-# For example, given a <tt>SoftLayer::Service</tt> instance called <tt>account_service</tt>
+# For example, given a Service instance called +account_service+
 # you could take advantage of the API filter that identifies a particular
-# object known to that service using the <tt>object_with_id</tt> method :
+# object known to that service using the object_with_id method :
 #
 #     account_service.object_with_id(91234).getSomeAttribute
 #
-# The invocation of <tt>object_with_id</tt> will cause an instance of this
+# The invocation of object_with_id will cause an instance of this
 # class to be created with the service as its target.
 #
 class APIParameterFilter
+  # The target of this API Parameter Filter. Should the filter
+  # receive an unknown method call, method_missing will forward
+  # the call on to the target. This is supposed to be an instance of
+  # the SoftLayer::Service class.
   attr_reader :target
+
+  # The collected parameters represented by this filter.  These parameters
+  # are passed along to the target when method_missing is forwarding
+  # a message.
   attr_reader :parameters
 
+  # Construct a filter with the given target (and starting parameters if given)
   def initialize(target, starting_parameters = nil)
     @target = target
     @parameters = starting_parameters || {}
   end
 
+  ##
   # Adds an API filter that narrows the scope of a call to an object with
-  # a particular ID.  For example, if you want to get the ticket
+  # a particular ID. For example, if you want to get the ticket
   # with an ID of 12345 from the ticket service you might use
   #
-  # ticket_service.object_with_id(12345).getObject
+  #     ticket_service.object_with_id(12345).getObject
+  #
   def object_with_id(value)
     # we create a new object in case the user wants to store off the
     # filter chain and reuse it later
     APIParameterFilter.new(self.target, @parameters.merge({ :server_object_id => value }))
   end
 
+  ##
   # Use this as part of a method call chain to add an object mask to
   # the request. The arguments to object mask should be well formed
   # Extended Object Mask strings:
@@ -47,18 +80,24 @@ class APIParameterFilter
   #     "mask(SoftLayer_Some_Type).aProperty").getObject
   #
   # The object_mask becomes part of the request sent to the server
+  # The object mask strings are parsed into ObjectMaskProperty trees
+  # and those trees are stored with the parameters. The trees are
+  # converted to strings immediately before the mask is used in a call
   #
   def object_mask(*args)
-    raise ArgumentError, "object_mask expects well-formatted root object mask strings" if args.empty? || (1 == args.count && !args[0])
-    raise ArgumentError, "object_mask expects well-formatted root object mask strings" if args.find { |arg| !(arg.kind_of?(String)) }
+    raise ArgumentError, "object_mask expects object mask strings" if args.empty? || (1 == args.count && !args[0])
+    raise ArgumentError, "object_mask expects strings" if args.find{ |arg| !arg.kind_of?(String) }
 
-    object_mask = (@parameters[:object_mask] || []) + args
+    mask_parser = ObjectMaskParser.new()
+    object_masks = args.collect { |mask_string| mask_parser.parse(mask_string)}.flatten
+    object_mask = (@parameters[:object_mask] || []) + object_masks
 
     # we create a new object in case the user wants to store off the
     # filter chain and reuse it later
     APIParameterFilter.new(self.target, @parameters.merge({ :object_mask => object_mask }));
   end
 
+  ##
   # Adds a result limit which helps you page through a long list of entities
   #
   # The offset is the index of the first item you wish to have returned
@@ -67,14 +106,16 @@ class APIParameterFilter
   # For example, if you wanted to get five open tickets from the account
   # starting with the tenth item in the open tickets list you might call
   #
-  # account_service.result_limit(10, 5).getOpenTickets
+  #     account_service.result_limit(10, 5).getOpenTickets
+  #
   def result_limit(offset, limit)
     # we create a new object in case the user wants to store off the
     # filter chain and reuse it later
     APIParameterFilter.new(self.target, @parameters.merge({ :result_offset => offset, :result_limit => limit }))
   end
 
-  # Adds an object_filter to the result.  An Object Filter allows you
+  ##
+  # Adds an object_filter to the result. An Object Filter allows you
   # to specify criteria which are used to filter the results returned
   # by the server.
   def object_filter(filter)
@@ -85,46 +126,82 @@ class APIParameterFilter
     APIParameterFilter.new(self.target, @parameters.merge({:object_filter => filter}));
   end
 
+  ##
   # A utility method that returns the server object ID (if any) stored
   # in this parameter set.
   def server_object_id
     self.parameters[:server_object_id]
   end
 
-  # a utility method that returns the object mask (if any) stored
+  ##
+  # A utility method that returns the object mask (if any) stored
   # in this parameter set.
   def server_object_mask
-    self.parameters[:object_mask]
+    if parameters[:object_mask] && !parameters[:object_mask].empty?
+
+      # Reduce the masks found in this object to a minimal set
+      #
+      # If you pass the API a mask that asks for the same property twice (within
+      # the same type scope), the API treats it as an error (and throws an exception)
+      #
+      # We get around that by parsing the various masks that have been given to us
+      # merging their properties where possible, thereby removing the duplicates
+      # from the mask that actually gets passed to the server. As a side benefit,
+      # the mask we send to the server will be streamlined; without too many extraneous
+      # characters
+      reduced_masks = parameters[:object_mask].inject([]) do |merged_masks, object_mask|
+        mergeable_mask = merged_masks.find { |mask| mask.can_merge_with? object_mask }
+        if mergeable_mask
+          mergeable_mask.merge object_mask
+        else
+          merged_masks.push object_mask
+        end
+
+        merged_masks
+      end
+
+      if reduced_masks.count == 1
+        reduced_masks[0].to_s
+      else
+        "[#{reduced_masks.collect{|mask| mask.to_s}.join(',')}]"
+      end
+    else
+      nil
+    end
   end
 
-  # a utility method that returns the starting index of the result limit (if any) stored
+  ##
+  # A utility method that returns the starting index of the result limit (if any) stored
   # in this parameter set.
   def server_result_limit
     self.parameters[:result_limit]
   end
 
-  # a utility method that returns the starting index of the result limit offset (if any) stored
+  ##
+  # A utility method that returns the starting index of the result limit offset (if any) stored
   # in this parameter set.
   def server_result_offset
     self.parameters[:result_offset]
   end
 
+  ##
+  # A utility method that returns the object filter (if any) stored with this filter.
   def server_object_filter
     self.parameters[:object_filter]
   end
 
+  ##
   # This allows the filters to be used at the end of a long chain of calls that ends
-  # at a service.
+  # at a service.  It forwards the message and the parameters to the target of this
+  # method (presumably a Service instance)
   def method_missing(method_name, *args, &block)
     puts "SoftLayer::APIParameterFilter#method_missing called #{method_name}, #{args.inspect}" if $DEBUG
 
     if(!block && method_name.to_s.match(/[[:alnum:]]+/))
-      result = @target.call_softlayer_api_with_params(method_name, self, args)
+      @target.call_softlayer_api_with_params(method_name, self, args)
     else
-      result = super
+      super
     end
-
-    result
   end
 end
 

data/lib/softlayer/Account.rb

@@ -0,0 +1,140 @@
+#
+# Copyright (c) 2014 SoftLayer Technologies, Inc. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+module SoftLayer
+  class Account < SoftLayer::ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # The company name of the primary contact
+    sl_attr :companyName
+
+    ##
+    # :attr_reader:
+    # The given name name of the primary contact
+    sl_attr :firstName
+
+    ##
+    # :attr_reader:
+    # The surname of the primary contact
+    sl_attr :lastName
+
+    ##
+    # :attr_reader:
+    # The first address line for the primary contact's address
+    sl_attr :address1
+
+    ##
+    # :attr_reader:
+    # The second address line (if any, may be nil) for the primary contact's address
+    sl_attr :address2
+
+    ##
+    # :attr_reader:
+    # The city stored as part of the primary contact's address
+    sl_attr :city
+
+    ##
+    # :attr_reader:
+    # The two character abbreviation for the state, province, or other similar national
+    # division that is part of the address of the primary contact.  For addresses
+    # outside of the US and Canada, where there may not be an equivalent to a state,
+    # this may be 'NA' (for not applicable)
+    sl_attr :state
+
+    ##
+    # :attr_reader:
+    # The country stored as part of the primary contact's address
+    sl_attr :country
+
+    ##
+    # :attr_reader:
+    # The postal code (in the US, aka. zip code) of the primary contact's address
+    sl_attr :postalCode
+
+    ##
+    # :attr_reader:
+    # The office phone nubmer listed for the primary contact
+    sl_attr :officePhone
+
+    ##
+    # 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:
+    #   bare_metal_servers(force_update=false)
+    sl_dynamic_attr :bare_metal_servers do |bare_metal|
+      bare_metal.should_update? do
+        @last_bare_metal_update ||= Time.at(0)
+        (Time.now - @last_bare_metal_update) > 5 * 60  # update every 5 minutes
+      end
+
+      bare_metal.to_update do
+        @last_bare_metal_update = Time.now
+        BareMetalServer.find_servers(:client => self.softlayer_client)
+      end
+    end
+
+    ##
+    # 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:
+    #   virtual_servers(force_update=false)
+    sl_dynamic_attr :virtual_servers do |virtual_servers|
+      virtual_servers.should_update? do
+        @last_virtual_server_update ||= Time.at(0)
+        (Time.now - @last_virtual_server_update) > 5 * 60  # update every 5 minutes
+      end
+
+      virtual_servers.to_update do
+        @last_virtual_server_update = Time.now
+        VirtualServer.find_servers(:client => self.softlayer_client)
+      end
+    end
+
+    def service
+      softlayer_client["Account"].object_with_id(self.id)
+    end
+
+    ##
+    # Using the login credentials in the client, retrieve
+    # the account associated with those credentials.
+    #
+    def self.account_for_client(client = nil)
+      softlayer_client = client || Client.default_client
+      raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client
+
+      account_service = softlayer_client['Account']
+      network_hash = account_service.getObject()
+      new(softlayer_client, network_hash)
+    end
+
+    ##
+    # Get a list of the servers for the account. The list returned
+    # includes both bare metal and virtual servers
+    def servers
+      return self.bare_metal_servers + self.virtual_servers
+    end
+  end
+end

data/lib/softlayer/BareMetalServer.rb

@@ -0,0 +1,233 @@
+#
+# Copyright (c) 2014 SoftLayer Technologies, Inc. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+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
+  # +SoftLayer_Hardware_Server+ services in the SoftLayer API
+  #
+  # http://sldn.softlayer.com/reference/datatypes/SoftLayer_Hardware
+  # http://sldn.softlayer.com/reference/datatypes/SoftLayer_Hardware_Server
+  #
+  class BareMetalServer < Server
+
+    ##
+    # Returns true if this +BareMetalServer+ is actually a Bare Metal Instance
+    # 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.
+    #
+    def bare_metal_instance?
+      if has_sl_property?(:bareMetalInstanceFlag)
+        self["bareMetalInstanceFlag"] != 0
+      else
+        false
+      end
+    end
+
+    ##
+    # Sends a ticket asking that a server be cancelled (i.e. shutdown and
+    # removed from the account).
+    #
+    # The +cancellation_reason+ parameter should be a key from the hash returned
+    # by +BareMetalServer::cancellation_reasons+.
+    #
+    # You may add your own, more specific reasons for cancelling a server in the
+    # +comments+ parameter.
+    #
+    def cancel!(reason = :unneeded, comment = '')
+      if !bare_metal_instance? then
+        cancellation_reasons = self.class.cancellation_reasons()
+        cancel_reason = cancellation_reasons[reason] || cancellation_reasons[:unneeded]
+        softlayer_client["Ticket"].createCancelServerTicket(self.id, cancel_reason, comment, true, 'HARDWARE')
+      else
+        # Note that reason and comment are ignored in this case, unfortunately
+        softlayer_client['Billing_Item'].object_with_id(self.billingItem['id'].to_i).cancelService()
+      end
+    end
+
+    ##
+    # Returns the SoftLayer 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.
+    def service
+      return softlayer_client["Hardware"].object_with_id(self.id)
+    end
+
+    ##
+    # Returns the default object mask used when fetching servers from the API when an
+    # explicit object mask is not provided.
+    def self.default_object_mask
+      sub_mask = {
+        "mask(SoftLayer_Hardware_Server)" => [
+          'bareMetalInstanceFlag',
+          'provisionDate',
+          'hardwareStatus',
+          'memoryCapacity',
+          'processorPhysicalCoreAmount',
+          'networkManagementIpAddress',
+          'networkComponents[id, status, speed, maxSpeed, name, ipmiMacAddress, ipmiIpAddress, macAddress, primaryIpAddress, port, primarySubnet]',
+          'activeTransaction[id, transactionStatus[friendlyName,name]]',
+          'hardwareChassis[id, name]'
+          ]
+        }
+
+      super.merge(sub_mask)
+    end
+
+    ##
+    # Returns a list of the cancellation reasons to use when cancelling a server.
+    #
+    # When cancelling a server with the cancel! method, the first parameter is the reason and
+    # should be one of the keys in the hash returned by this method.  This, in turn
+    # will be translated into a string which is, for all intents and purposes, a
+    # literal string constant with special meaning to the SoftLayer API.
+    #
+    def self.cancellation_reasons
+      {
+        :unneeded => 'No longer needed',
+        :closing => 'Business closing down',
+        :cost => 'Server / Upgrade Costs',
+        :migrate_larger => 'Migrating to larger server',
+        :migrate_smaller => 'Migrating to smaller server',
+        :datacenter => 'Migrating to a different SoftLayer datacenter',
+        :performance => 'Network performance / latency',
+        :support => 'Support response / timing',
+        :sales => 'Sales process / upgrades',
+        :moving => 'Moving to competitor',
+      }
+    end
+
+    ##
+    # Retrive the bare metal server with the given server ID from the
+    # SoftLayer API
+    #
+    # The options parameter should contain:
+    #
+    # <b>+:client+</b> - The client used to connect to the API
+    #
+    # 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.
+    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
+
+      hardware_service = softlayer_client["Hardware"]
+      hardware_service = hardware_service.object_mask(default_object_mask.to_sl_object_mask)
+
+      if options.has_key?(:object_mask)
+        object_mask = hardware_service.object_mask(options[:object_mask])
+      end
+
+      server_data = hardware_service.object_with_id(server_id).getObject()
+
+      return BareMetalServer.new(softlayer_client, server_data)
+    end
+
+    ##
+    # Retrieve a list of Bare Metal servers from the account
+    #
+    # The options parameter should contain:
+    #
+    # <b>+:client+</b> - The client used to connect to the API
+    #
+    # 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.
+    #
+    # 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
+    #
+    # 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.
+    #
+    def self.find_servers(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
+
+      if(options_hash.has_key? :object_filter)
+        object_filter = options_hash[:object_filter]
+      else
+        object_filter = {}
+      end
+
+      option_to_filter_path = {
+        :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"
+      }
+
+      # For each of the options in the option_to_filter_path map, if the options hash includes
+      # that particular option, add a clause to the object filter that filters for the matching
+      # value
+      option_to_filter_path.each do |option, filter_path|
+        object_filter.merge!(SoftLayer::ObjectFilter.build(filter_path, options_hash[option])) if options_hash.has_key?(option)
+      end
+
+      # Tags get a much more complex object filter operation so we handle them separately
+      if options_hash.has_key?(:tags)
+        object_filter.merge!(SoftLayer::ObjectFilter.build("hardware.tagReferences.tag.name", {
+          'operation' => 'in',
+          'options' => [{
+            'name' => 'data',
+            'value' => options_hash[:tags]
+            }]
+          } ));
+      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)
+
+      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)
+      end
+
+      bare_metal_data = account_service.getHardware()
+      bare_metal_data.collect { |server_data| BareMetalServer.new(softlayer_client, server_data) }
+    end
+  end #BareMetalServer
+end