class AWS::Flow::GenericClient

A generic activity client. This class is not usually used directly; it serves as the base class for both activity and workflow client classes.

Attributes

option_map[RW]

The option map for the client.

Public Class Methods

new(*args) click to toggle source

Creates a new generic client.

# File lib/aws/decider/generic_client.rb, line 27
def initialize(*args)
  @option_map = {}
end

Public Instance Methods

_retry(method_name, retry_function, block, args = NoInput.new) click to toggle source

Retries the given method using an optional retry function and block of {RetryOptions}.

@param (see retry)

@api private

# File lib/aws/decider/generic_client.rb, line 170
def _retry(method_name, retry_function, block, args = NoInput.new)
  bail_if_external
  retry_options = Utilities::interpret_block_for_options(ExponentialRetryOptions, block)
  _retry_with_options(lambda { self.send(method_name, *args) }, retry_function, retry_options)
end
_retry_with_options(lambda_to_execute, retry_function, retry_options, args = NoInput.new) click to toggle source

Used by {#retry}

@api private

# File lib/aws/decider/generic_client.rb, line 138
def _retry_with_options(lambda_to_execute, retry_function, retry_options, args = NoInput.new)
  retry_policy = RetryPolicy.new(retry_function, retry_options)
  output = Utilities::AddressableFuture.new
  result = nil
  failure = nil
  error_handler do |t|
    t.begin do
      async_retrying_executor = AsyncRetryingExecutor.new(retry_policy, self.decision_context.workflow_clock, self.decision_context.workflow_context.decision_task.workflow_execution.run_id, retry_options.return_on_start)
      result = async_retrying_executor.execute(lambda_to_execute)
    end
    t.rescue(Exception) do |error|
      failure = error
    end
    t.ensure do
      if failure.nil?
        output.set(result)
      else
        output.set(nil)
      end
    end
  end
  return output if retry_options.return_on_start
  output.get
  raise failure unless failure.nil?
  return output.get
end
bail_if_external() click to toggle source

@api private

# File lib/aws/decider/generic_client.rb, line 64
def bail_if_external
  raise "You cannot use this function outside of a workflow definition" if Utilities::is_external
end
decision_context() click to toggle source

Returns the decision context for this client.

@return The decision context.

# File lib/aws/decider/generic_client.rb, line 206
def decision_context
  FlowFiber.current[:decision_context]
end
exponential_retry(method_name, *args, &block) click to toggle source

Retries the given method using an exponential fallback function.

@param method_name

The method to retry.

@param args

Arguments (parameters) that are passed to the method specified in
*method_name*.

@param block

A block of {RetryOptions} used to specify retry behavior.
# File lib/aws/decider/generic_client.rb, line 130
def exponential_retry(method_name, *args, &block)
  future = self._retry(method_name, FlowConstants.exponential_retry_function, block, args)
  Utilities::drill_on_future(future)
end
reconfigure(*method_names, &block) click to toggle source

Reconfigures an activity client with a block of passed-in options.

@note This functionality is limited to activity clients only.

@param method_names

The activity methods to modify with the options passed in.

@param block

A block of {ActivityOptions} to use to reconfigure the client.
# File lib/aws/decider/generic_client.rb, line 58
def reconfigure(*method_names, &block)
  options = Utilities::interpret_block_for_options(self.class.default_option_class, block)
  method_names.each { |method_name| @option_map[method_name.to_sym] = options }
end
retry(method_name, retry_function, *args, &block) click to toggle source

Retries the given method using an optional retry function and block of {RetryOptions}.

@param method_name

The method to retry.

@param retry_function

The function to use in order to determine if a retry should be
attempted.

@param args

Arguments to send to the method provided in the *method_name*
parameter.

@param block

A block of {RetryOptions} used to specify retry behavior.
# File lib/aws/decider/generic_client.rb, line 193
def retry(method_name, retry_function, *args, &block)
  if retry_function.is_a? Fixnum
    retry_time = retry_function
    retry_function = lambda {|first_attempt, time_of_failure, attempt| retry_time}
  end
  future = self._retry(method_name, retry_function, block, args)
  Utilities::drill_on_future(future)
end
send_async(task, *args, &block) click to toggle source

Starts an asynchronous execution of a task. This method returns immediately; it does not wait for the task to complete.

@note Trying to use {#send_async} outside of a workflow will fail with

an exception.

@param task The task to execute.

@param args A number of arguments used to start the task execution.

@param block

A code block with additional options to start the task execution.

@example The following two calls are equivalent.

foo.send_async :bar # plus args and block if appropriate

task do
  foo.send :bar # plus args and block if appropriate
end
# File lib/aws/decider/generic_client.rb, line 88
def send_async(task, *args, &block)
  bail_if_external
  # If there is no block, just make a block for immediate return.
  if block.nil?
    modified_options = Proc.new{ {:return_on_start => true } }
    # If there is a block, and it doesn't take any arguments, it will
    # evaluate to a hash. Add an option to the hash.
  elsif block.arity == 0
    modified_options = Proc.new do
      result = block.call
      # We need to copy the hash to make sure that we don't mutate it
      result = result.dup
      result[:return_on_start] = true
      result
    end
    # Otherwise, it will expect an options object passed in, and will do
    # things on that object. So make our new Proc do that, and add an
    # option.
  else modified_options = Proc.new do |x|
      result = block.call(x)
      # Same as the above dup, we'll copy to avoid any possible mutation
      # of inputted objects
      result = result.dup
      result.return_on_start = true
      result
    end
  end
  self.send(task, *args, &modified_options)
end
with_opts(opts = {}) click to toggle source

Creates a new client that is a copy of this client instance, modified by a hash of passed-in options.

@param opts

The options to set on the new client. Any options that are not set
here are copied from the original client.

@return [GenericClient] A new client instance.

# File lib/aws/decider/generic_client.rb, line 40
def with_opts(opts = {})
  modified_instance = self.dup
  opts.each_pair do |key, value|
    modified_instance.options.send("#{key}=", value) if modified_instance.options.methods.map(&:to_sym).include? "#{key}=".to_sym
  end
  modified_instance
end