aws-sdk-euca 1.8.5

data/lib/aws/simple_workflow/request.rb

@@ -0,0 +1,33 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class SimpleWorkflow
+
+    # @private
+    class Request < Core::Http::Request
+
+      include Core::Signature::Version3
+
+      def read_timeout
+        # increase read timeout for long polling
+        if headers['x-amz-target'] =~ /PollFor(Decision|Activity)Task/
+          90 
+        else
+          @read_timeout
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/simple_workflow/resource.rb

@@ -0,0 +1,94 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class SimpleWorkflow
+
+    # @private
+    class Resource < Core::Resource
+
+      # @return [Boolean] Returns true if the resource exists.
+      def exists?
+        !!get_resource
+      rescue Errors::UnknownResourceFault
+        false
+      end
+
+      # @private
+      def self.attribute name, options = {}, &block
+
+        # the simple workflow attributes are all given as 'lowerCamelCase'
+        # this converts the :snake_case name to the correct format
+        unless options[:from]
+          parts = []
+          name.to_s.split(/_/).each_with_index do |part,n|
+            parts << (n == 0 ? part : part.capitalize)
+          end
+          options[:from] = parts.join.to_sym
+        end
+
+        if options[:duration]
+          super(name, options) do
+            translates_output do |v| 
+              v.to_s =~ /^\d+$/ ? v.to_i : v.downcase.to_sym
+            end
+          end
+        else
+          super(name, options, &block)
+        end
+
+      end
+
+      protected
+      def get_resource attr_name = nil
+        method = "describe_#{Core::Inflection.ruby_name(self.class.name)}"
+        client.send(method, resource_options)
+      end
+
+      # @private
+      def self.type_attributes
+        @type_attributes ||= {}
+      end
+
+      # @private
+      def self.config_attributes
+        @config_attributes ||= {}
+      end
+
+      # @private
+      def self.info_attributes
+        @info_attributes ||= {}
+      end
+
+      # @private
+      def self.type_attribute name, options = {}, &block
+        options[:static] = true unless options.has_key?(:static)
+        attr = attribute(name, options, &block)
+        type_attributes[attr.name] = attr
+      end
+
+      # @private
+      def self.config_attribute name, options = {}, &block
+        attr = attribute(name, options.merge(:static => true), &block)
+        config_attributes[attr.name] = attr
+      end
+
+      # @private
+      def self.info_attribute name, options = {}
+        attr = attribute(name, options)
+        info_attributes[attr.name] = attr
+      end
+
+    end
+  end
+end

data/lib/aws/simple_workflow/type.rb

@@ -0,0 +1,89 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class SimpleWorkflow
+
+    # Base class for {WorkflowType} and {ActivityType} objects.
+    class Type < Resource
+
+      # @param [Domain] domain The domain this type is registered to.
+      # @param [String] name The name of this type.
+      # @param [String] version The version of this type.
+      def initialize domain, name, version, options = {}
+        @domain = domain
+        @name = name.to_s
+        @version = version.to_s
+        super
+      end
+
+      # @return [Domain] Returns the domain this type is registered to.
+      attr_reader :domain
+
+      # @return [String] Returns the name of this type.
+      attr_reader :name
+
+      # @return [String] Returns the version of this type.
+      attr_reader :version
+
+      # Deprecates the type. 
+      #
+      # After a type has been deprecated, you cannot create new 
+      # executions of that type. Executions that were started before the 
+      # type was deprecated will continue to run.
+      #
+      # @note This operation is eventually consistent. The results are best 
+      #   effort and may not exactly reflect recent updates and changes.
+      # 
+      # @return [nil]
+      #
+      def deprecate
+        client.send("deprecate_#{self.class.ruby_name}", resource_options)
+        nil
+      end
+      alias_method :delete, :deprecate
+
+      # @return [Boolean] Returns true if the type is deprecated.
+      def deprecated?
+        status == :deprecated
+      end
+
+      protected
+      def resource_identifiers
+        [[:domain,domain.name], [:name,name], [:version,version]]
+      end
+
+      protected
+      def resource_options
+        {
+          :domain => domain.name, 
+          :"#{self.class.ruby_name}" => { 
+            :name => name,
+            :version => version 
+          }
+        }
+      end
+
+      protected
+      def self.ruby_name
+        Core::Inflection.ruby_name(name.split(/::/).last)
+      end
+
+      protected
+      def self.type_key
+        "#{ruby_name.split(/_/).first}Type"
+      end
+
+    end
+  end
+end

data/lib/aws/simple_workflow/type_collection.rb

@@ -0,0 +1,140 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class SimpleWorkflow
+
+    # The base class for {WorkflowTypeCollection} and {ActivityTypeCollection}.
+    # @private
+    class TypeCollection
+
+      include OptionFormatters
+      include Core::Collection::WithLimitAndNextToken 
+
+      # @param [Domain] domain The domain the (workflow or activity types 
+      #   belong to.
+      def initialize domain, options = {}
+
+        @domain = domain
+
+        @named = options[:named]
+
+        @registration_status = options[:registration_status] ? 
+          options[:registration_status].to_s.upcase : 'REGISTERED'
+
+        @reverse_order = options.key?(:reverse_order) ?
+          !!options[:reverse_order] : false
+
+        super
+
+      end
+
+      # @return [Domain]
+      attr_reader :domain
+
+      # Returns the type with the given name and version.
+      #
+      #   # get a workflow type
+      #   domain.workflow_types['name','version']
+      #   domain.workflow_types.at('name','version')
+      #
+      #   # get an activity type
+      #   domain.activity_types['name','version']
+      #   domain.activity_types.at('name','version')
+      #
+      # @param [String] name Name of the type.
+      #
+      # @param [String] version Version of the type.
+      #
+      # @return [ActivityType,WorkflowType]
+      #
+      def [] name, version
+        member_class.new(domain, name, version)
+      end
+      alias_method :at, :[]
+
+      def register
+        raise NotImplementedError # implemented in subclasses
+      end
+      alias_method :create, :register
+
+      # @return [TypeCollection] Returns a collection that
+      #   will only enumerate deprecated types.
+      def deprecated
+        collection_with(:registration_status => 'DEPRECATED')
+      end
+
+      # @return [TypeCollection] Returns a collection that
+      #   enumerates types in reverse alphabetical order.  Default
+      #   ordering is alphabetical.
+      def reverse_order
+        collection_with(:reverse_order => true)
+      end
+
+      # @return [TypeCollection] Returns a collection that 
+      #   enumerates types with the given name.  Each instance
+      #   will have a different version.
+      def named name
+        collection_with(:named => name.to_s)
+      end
+
+      protected
+      def collection_with options = {}
+        self.class.new(domain, {
+          :registration_status => @registration_status,
+          :reverse_order => @reverse_order,
+          :named => @named,
+          :config => config,
+        }.merge(options))
+      end
+
+      protected
+      def member_class
+        name = self.class.name.split(/::/).last.sub(/Collection/, '')
+        SimpleWorkflow.const_get(name)
+      end
+
+      protected
+      def _each_item next_token, limit, options = {}, &block
+
+        options[:domain] = domain.name
+        options[:next_page_token] = next_token if next_token
+        options[:maximum_page_size] = limit if limit
+        options[:registration_status] ||= @registration_status
+        options[:name] ||= @named if @named # may be nil
+        options[:reverse_order] = @reverse_order unless 
+          options.has_key?(:reverse_order)
+
+
+        ruby_name = Core::Inflection.ruby_name(member_class.name)
+        type_key = member_class.type_key
+        client_method = :"list_#{ruby_name}s"
+
+        response = client.send(client_method, options)
+        response.data['typeInfos'].each do |desc|
+
+          type = member_class.new_from(client_method, desc, domain, 
+            desc[type_key]['name'], 
+            desc[type_key]['version']) 
+
+          yield(type)
+          
+        end
+
+        response.data['nextPageToken']
+
+      end
+
+    end
+  end
+end

data/lib/aws/simple_workflow/workflow_execution.rb

@@ -0,0 +1,386 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class SimpleWorkflow
+
+    # @attr_reader [Symbol] child_policy The policy to use for the child 
+    #   workflow executions if this workflow execution is terminated. 
+    #   The return value will be one of the following values:
+    #
+    #   * +:terminate+ - the child executions will be terminated.
+    #
+    #   * +:request_cancel+ - a request to cancel will be attempted for each
+    #     child execution by recording a WorkflowExecutionCancelRequested 
+    #     event in its history. It is up to the decider to take appropriate
+    #     actions when it receives an execution history with this event.
+    #
+    #   * +:abandon+ - no action will be taken. The child executions will 
+    #     continue to run.
+    #
+    # @attr_reader [String] start_to_close_timeout The total allowed
+    #   duration for this workflow execution.
+    #
+    #   The return value will be formatted as an ISO 8601 duration (e.g.
+    #   'PnYnMnDTnHnMnS').
+    #
+    # @attr_reader [String] task_list The task list used for the decision 
+    #   tasks generated for this workflow execution.
+    #
+    # @attr_reader [String] task_start_to_close_timeout The maximum duration
+    #   allowed for decision tasks for this workflow execution.
+    #
+    #   The return value will be formatted as an ISO 8601 duration (e.g.
+    #   'PnYnMnDTnHnMnS').
+    #
+    # @attr_reader [Time,nil] closed_at The time when the workflow execution
+    #   was closed.  Returns nil if this execution is not closed.
+    #
+    # @attr_reader [Time] started_at The time when the execution was started.
+    #   
+    # @attr_reader [Time,nil] latest_activity_task_scheduled_at The time 
+    #   when the last activity task was scheduled for this workflow execution.
+    #   You can use this information to determine if the workflow has not 
+    #   made progress for an unusually long period of time and might 
+    #   require a corrective action.
+    #
+    # @attr_reader [String,nil] latest_execution_context The latest execution
+    #   context provided by the decider for this workflow execution. A decider 
+    #   can provide an execution context, which is a free form string, when 
+    #   closing a decision task.
+    #
+    # @attr_reader [Hash] open_counts Returns a hash of counts, including:
+    #   +:open_timers+, +:open_child_workflow_executions+, +:open_decision_tasks+,
+    #   and +:open_activity_tasks+.
+    # 
+    class WorkflowExecution < Resource
+      
+      def initialize domain, workflow_id, run_id, options = {}
+        @domain = domain
+        @workflow_id = workflow_id
+        @run_id = run_id
+        super
+      end
+
+      # @return [Domain] The domain this workflow execution was started in.
+      attr_reader :domain
+
+      # @return [String] The workflow id of this execution.
+      attr_reader :workflow_id
+
+      # @return [String] The run id of this execution.
+      attr_reader :run_id
+
+      config_attribute :child_policy, :to_sym => true
+
+      config_attribute :execution_start_to_close_timeout, :duration => true
+
+      config_attribute :task_list do
+        translates_output{|v| v['name'] }
+      end
+
+      config_attribute :task_start_to_close_timeout, :duration => true
+
+      info_attribute :cancel_requested
+
+      info_attribute :close_status, :to_sym => true
+      protected :close_status
+
+      info_attribute :closed_at, :from => 'closeTimestamp', :timestamp => true
+
+      info_attribute :execution_status, :to_sym => true
+      protected :execution_status
+
+      info_attribute :parent_details, :from => 'parent', :static => true
+      protected :parent_details
+
+      info_attribute :started_at, 
+        :from => 'startTimestamp', 
+        :timestamp => true,
+        :static => true
+
+      info_attribute :tag_list, :static => true
+      protected :tag_list
+
+      info_attribute :type_details, :from => 'workflowType', :static => true
+      protected :type_details
+
+      attribute :latest_activity_task_scheduled_at, 
+        :from => 'latestActivityTaskTimestamp',
+        :timestamp => true
+
+      attribute :latest_execution_context
+
+      attribute :open_counts do
+        translates_output do |hash|
+          hash.inject({}) do |h,(k,v)|
+            h[Core::Inflection.ruby_name(k).to_sym] = v; h
+          end
+        end
+      end
+
+      # list_workflow_executions provides ONLY type attributes
+      provider(
+        :list_open_workflow_executions, 
+        :list_closed_workflow_executions
+      ) do |provider|
+        provider.provides *info_attributes.keys
+        provider.find do |resp|
+          execution = { 'workflowId' => workflow_id, 'runId' => run_id }
+          resp.data['executionInfos'].find do |desc|  
+            desc['execution'] == execution
+          end
+        end
+      end
+
+      # describe_workflow_execution provides ALL attributes
+      provider(:describe_workflow_execution) do |provider|
+        provider.provides *attributes.keys
+        provider.find do |resp|
+          execution = { 'workflowId' => workflow_id, 'runId' => run_id }
+          d = resp.data
+          if d['executionInfo']['execution'] == execution
+            d.merge(d['executionInfo']).merge(d['executionConfiguration'])
+          else
+            nil
+          end
+        end
+      end
+
+      # @return [Symbol] Returns the status of this execution. Possible
+      #   return values are:
+      #
+      #   * +:open+ - The execution is still running.
+      #   * +:completed+ - The execution was successfully completed.
+      #   * +:canceled+ - The execution was canceled, cancellation allows 
+      #      the implementation to gracefully clean up before the execution 
+      #      is closed.
+      #   * +:failed+ - The execution failed to complete.
+      #     and was automatically timed out.
+      #   * +:continued_as_new+ - The execution is logically continued. This
+      #     means the current execution was completed and a new execution 
+      #     was started to carry on the workflow.
+      #   * +:terminated+ - The execution was force terminated.
+      #   * +:timed_out+ - The execution did not complete in the allotted
+      #     time and was automatically timed out.
+      #   
+      def status
+        AWS.memoize do
+          execution_status == :open ? :open : (close_status || :closed)
+        end
+      end
+
+      # @return [Boolean] Returns true if a request was made to cancel
+      #   this workflow execution.
+      def cancel_requested?
+        cancel_requested
+      end
+
+      # @return [Boolean] Returns true if the workflow execution is still open.
+      def open?
+        status == :open
+      end
+
+      # @return [Boolean] Returns true if the workflow execution is closed.
+      def closed?
+        !open?
+      end
+
+      # @return [Boolean] Returns true if this workflow execution has an
+      #   open decision task.
+      def open_child_workflow_execution_count
+        open_counts[:open_child_workflow_executions]
+      end
+
+      # @return [Integer] Returns the number of open activity tasks.
+      def open_activity_task_count
+        open_counts[:open_activity_tasks]
+      end
+
+      # @return [Integer] Returns the number of open timers.
+      def open_timer_count
+        open_counts[:open_timers]
+      end
+
+      # @return [Integer] Returns the number of closed activity tasks.
+      def open_decision_task_count
+        open_counts[:open_decision_tasks]
+      end
+
+      # @return [Array<String>] Returns an array of tags assigned to this
+      #   execution.
+      def tags
+        tag_list || []
+      end
+
+      # @return [HistoryEventCollection] Returns a collection that enumerates
+      #   history events for this workflow execution.
+      def history_events
+        HistoryEventCollection.new(self)
+      end
+      alias_method :events, :history_events
+
+      # @return [WorkflowType] Returns the type of this workflow execution.
+      def workflow_type
+        type = self.type_details
+        WorkflowType.new(domain, type['name'], type['version'])
+      end
+
+      # @return [WorkflowExecution,nil] Returns the parent workflow execution
+      #   (if there is one).
+      def parent
+        if parent = self.parent_details
+          domain.workflow_executions[parent['workflowId'],parent['runId']]
+        else
+          nil
+        end
+      end
+
+      # Records a WorkflowExecutionSignaled event in the workflow execution 
+      # history and creates a decision task for the workflow execution.
+      #
+      #   workflow_execution.signal('signal_name', :input => '...')
+      #
+      # @param [String] signal_name The name of the signal. This name must be 
+      #   meaningful to the target workflow.
+      #
+      # @param [Hash] options
+      #
+      # @option options [String] :input (nil) Data to attach to the 
+      #   WorkflowExecutionSignaled event in the target workflow 
+      #   execution's history.
+      #
+      # @return [nil]
+      #
+      def signal signal_name, options = {}
+        options[:run_id] = run_id
+        domain.workflow_executions.signal(workflow_id, signal_name, options)
+      end
+
+      # Records a WorkflowExecutionCancelRequested event in the currently 
+      # running workflow execution. This logically requests the cancellation
+      # of the workflow execution as a whole. It is up to the decider to 
+      # take appropriate actions when it receives an execution history 
+      # with this event.
+      #
+      # @note Because this action allows the workflow to properly clean up 
+      #   and gracefully close, it should be used instead of {#terminate}
+      #   when possible.
+      #
+      # @return [nil]
+      #
+      def request_cancel
+        options = { :run_id => run_id }
+        domain.workflow_executions.request_cancel(workflow_id, options)
+      end
+
+      # Records a WorkflowExecutionTerminated event and forces closure of 
+      # the workflow execution. The child policy, registered with the 
+      # workflow type or specified when starting this execution, is applied 
+      # to any open child workflow executions of this workflow execution.
+      #
+      # @note If the workflow execution was in progress, it is terminated 
+      #   immediately.
+      #
+      # @note You should consider canceling the workflow execution 
+      #   instead because it allows the workflow to gracefully close
+      #   while terminate does not.
+      #
+      # @param [Hash] options
+      #
+      # @option options [Symbol] :child_policy (nil)
+      #   If set, specifies the policy to use for the child workflow 
+      #   executions of the workflow execution being terminated. This 
+      #   policy overrides the default child policy.  Valid policies include:
+      #
+      #   * +:terminate+ - the child executions will be terminated.
+      #
+      #   * +:request_cancel+ - a request to cancel will be attempted for each
+      #     child execution by recording a WorkflowExecutionCancelRequested 
+      #     event in its history. It is up to the decider to take appropriate
+      #     actions when it receives an execution history with this event.
+      #
+      #   * +:abandon+ - no action will be taken. The child executions will 
+      #     continue to run.
+      #
+      # @option options [String] :details (nil) Optional details for 
+      #   terminating the workflow execution.
+      #
+      # @option options [String] :reason (nil) An optional descriptive 
+      #   reason for terminating the workflow execution.
+      # 
+      # @return [nil]
+      #
+      def terminate options = {}
+        options[:run_id] = run_id
+        domain.workflow_executions.terminate(workflow_id, options)
+      end
+
+      # Counts the number of executions that share the same workflow id.
+      #
+      # @note See {WorkflowExecutionCollection#count} for a broader count.
+      #
+      # @note This operation is eventually consistent. The results are best 
+      #   effort and may not exactly reflect recent updates and changes.
+      #
+      # @param [Hash] options
+      #
+      # @option options [Symbol] :status (:open) Specifies that 
+      #   status of the workflow executions to count. Defaults to
+      #   open workflows.
+      #
+      #   * +:open+
+      #   * +:closed+
+      #
+      # @option options [Array<Time>] :started_between A start and end time
+      #   to filter workflow execution start times by.  You may pass an 
+      #   array with two time values or a range.  Times should be
+      #   timestamps (integers), Time, Date, DateTime or parseable time 
+      #   strings. 
+      #
+      #   You may not pass both +:started_between+ and +:closed_between+.
+      #
+      # @option options [Array<Time>] :closed_between A start and end time
+      #   to filter workflow execution closed times by.  You may pass an 
+      #   array with two time values or a range.  Times should be
+      #   timestamps (integers), Time, Date, DateTime or parseable time 
+      #   strings. 
+      #
+      #   You may not pass both +:started_between+ and +:closed_between+.
+      #   You may also not pass +:closed_between+ if the +:status+ is
+      #   +:open+.
+      #
+      # @return [Integer] Returns the count of executions that share
+      #   workflow id with the current execution.
+      #
+      def count_executions options = {}
+        options[:workflow_id] = workflow_id
+        domain.workflow_executions.count(options)
+      end
+
+      protected
+      def resource_identifiers
+        [[:domain,domain.name], [:workflow_id,workflow_id], [:run_id,run_id]]
+      end
+
+      protected
+      def resource_options
+        {
+          :domain => domain.name,
+          :execution => { :workflow_id => workflow_id, :run_id => run_id },
+        }
+      end
+      
+    end
+  end
+end