def send_request(type, payload = nil, target = nil, options = {}, &callback)
      raise ArgumentError, "Missing block for response callback" unless callback
      build_and_send_packet(:send_request, type, payload, target, options, &callback)
    end
def send_request(type, payload = nil, target = nil, options = {}, &callback)
      raise ArgumentError, "Missing block for response callback" unless callback
      build_and_send_packet(:send_request, type, payload, target, options, &callback)
    end
Send a request to a single target with a response expected
 Automatically retry the request if a response is not received in a reasonable amount of time
 or if there is a non-delivery response indicating the target is not currently available
 Timeout the request if a response is not received in time, typically configured to 2 minutes
 Because of retries there is the possibility of duplicated requests, and these are detected and
 discarded automatically for non-idempotent actions
 Allow the request to expire per the agent's configured time-to-live, typically 1 minute
 Note that receiving a response does not guarantee that the request activity has actually
 completed since the request processing may involve other asynchronous requests

 === Parameters
 type(String):: Dispatch route for the request; typically identifies actor and action
 payload(Object):: Data to be sent with marshalling en route
 target(Hash|NilClass) Target for request, which may be a specific agent (using :agent_id),
   one chosen randomly from potentially multiple targets (using :tags, :scope), or nil to
   route solely using type:
   :agent_id(String):: serialized identity of specific target
   :tags(Array):: Tags that must all be associated with a target for it to be selected
   :scope(Hash):: Scoping to be used to restrict routing
     :account(Integer):: Restrict to agents with this account id
     :shard(Integer):: Restrict to agents with this shard id, or if value is Packet::GLOBAL,
       ones with no shard id
 options(Hash):: Request options
   :token(String):: Universally unique ID for request; defaults to random generated
   :time_to_live(Numeric):: Number of seconds before a request expires and is to be ignored;
     non-positive value or nil means never expire; defaults to configured :time_to_live

 === Block
 Required block used to process response asynchronously with the following parameter:
   result(Result):: Response with an OperationResult of SUCCESS, RETRY, NON_DELIVERY, or ERROR,
     use RightScale::OperationResult.from_results to decode

 === Return
 true:: Always return true

 === Raise
 ArgumentError:: If target invalid or block missing