# File lib/softlayer/Service.rb, line 79
    def initialize (service_name, options = {})
      raise ArgumentError,"Please provide a service name" if service_name.nil? || service_name.empty?

      # remember the service name
      @service_name = service_name;

      # Collect the keys relevant to client creation and pass them on to construct
      # the client if one is needed.
      client_keys = [:username, :api_key, :endpoint_url]
      client_options = options.inject({}) do |new_hash, pair|
        if client_keys.include? pair[0]
          new_hash[pair[0]] = pair[1]
        end

        new_hash
      end

      # if the options hash already has a client
      # go ahead and use it
      if options.has_key? :client
        if !client_options.empty?
          raise RuntimeError, "Attempting to construct a service both with a client, and with client initialization options. Only one or the other should be provided."
        end

        @client = options[:client]
      else
        # Accepting client initialization options here
        # is a backward-compatibility feature.

        if $DEBUG
          $stderr.puts %q{
Creating services with Client initialization options is deprecated and may be removed
in a future release. Please change your code to create a client and obtain a service
using either client.service_named('<service_name_here>') or client['<service_name_here>']}
        end

        @client = SoftLayer::Client.new(client_options)
      end

      # this has proven to be very helpful during debugging. It helps prevent infinite recursion
      # when you don't get a method call just right
      @method_missing_call_depth = 0 if $DEBUG
    end

# File lib/softlayer/Service.rb, line 221
def call_softlayer_api_with_params(method_name, parameters, args)
  additional_headers = {};

  # The client knows about authentication, so ask him for the auth headers
  authentication_headers = self.client.authentication_headers
  additional_headers.merge!(authentication_headers)

  if parameters && parameters.server_object_filter
    additional_headers.merge!("#{@service_name}ObjectFilter" => parameters.server_object_filter)
  end

  # Object masks go into the headers too.
  if parameters && parameters.server_object_mask
    object_mask = parameters.server_object_mask
    additional_headers.merge!("SoftLayer_ObjectMask" => { "mask" => object_mask }) unless object_mask.empty?
  end

  # Result limits go into the headers
  if (parameters && parameters.server_result_limit)
    additional_headers.merge!("resultLimit" => { "limit" => parameters.server_result_limit, "offset" => (parameters.server_result_offset || 0) })
  end

  # Add an object id to the headers.
  if parameters && parameters.server_object_id
    additional_headers.merge!("#{@service_name}InitParameters" => { "id" => parameters.server_object_id })
  end

  # This is a workaround for a potential problem that arises from mis-using the
  # API. If you call SoftLayer_Virtual_Guest and you call the getObject method
  # but pass a virtual guest as a parameter, what happens is the getObject method
  # is called through an HTTP POST verb and the API creates a new VirtualServer that
  # is a copy of the one you passed in.
  #
  # The counter-intuitive creation of a new Virtual Server is unexpected and, even worse,
  # is something you can be billed for. To prevent that, we ignore the request
  # body on a "getObject" call and print out a warning.
  if (method_name == :getObject) && (nil != args) && (!args.empty?) then
    $stderr.puts "Warning - The getObject method takes no parameters. The parameters you have provided will be ignored."
    args = nil
  end

  # Collect all the different header pieces into a single hash that
  # will become the first argument to the call.
  call_headers = {
    "headers" => additional_headers
  }

  begin
    call_value = xmlrpc_client.call(method_name.to_s, call_headers, *args)
  rescue XMLRPC::FaultException => e
    puts "A XMLRPC Fault was returned #{e}" if $DEBUG
    raise
  end

  return call_value
end

# File lib/softlayer/Service.rb, line 180
def method_missing(method_name, *args, &block)
  # During development, if you end up with a stray name in some
  # code, you can end up in an infinite recursive loop as method_missing
  # tries to resolve that name (believe me... it happens).
  # This mechanism looks for what it considers to be an unreasonable call
  # depth and kills the loop quickly.
  if($DEBUG)
    @method_missing_call_depth += 1
    if @method_missing_call_depth > 3 # 3 is somewhat arbitrary... really the call depth should only ever be 1
      @method_missing_call_depth = 0
      raise "stop infinite recursion #{method_name}, #{args.inspect}"
    end
  end

  # if we're in debug mode, we put out a little helpful information
  puts "SoftLayer::Service#method_missing called #{method_name}, #{args.inspect}" if $DEBUG

  if(!block && method_name.to_s.match(/[[:alnum:]]+/))
    result = call_softlayer_api_with_params(method_name, nil, args);
  else
    result = super
  end

  if($DEBUG)
    @method_missing_call_depth -= 1
  end

  return result
end

# File lib/softlayer/Service.rb, line 172
def object_filter(filter)
  proxy = APIParameterFilter.new(self)
  return proxy.object_filter(filter)
end

# File lib/softlayer/Service.rb, line 156
def object_mask(*args)
  proxy = APIParameterFilter.new(self)
  return proxy.object_mask(*args)
end

# File lib/softlayer/Service.rb, line 143
def object_with_id(object_of_interest)
  proxy = APIParameterFilter.new(self)
  return proxy.object_with_id(object_of_interest)
end

# File lib/softlayer/Service.rb, line 125
def related_service_named(service_name)
  @client.service_named(service_name)
end

# File lib/softlayer/Service.rb, line 166
def result_limit(offset, limit)
  proxy = APIParameterFilter.new(self)
  return proxy.result_limit(offset, limit)
end

# File lib/softlayer/Service.rb, line 132
def target
  return self
end

# File lib/softlayer/Service.rb, line 282
def to_ary
  nil
end