aws-sdk-euca 1.8.5

data/lib/aws/simple_email_service/identity_collection.rb

@@ -0,0 +1,81 @@
+# 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 SimpleEmailService
+    class IdentityCollection
+
+      include Core::Collection::WithLimitAndNextToken
+
+      # @private
+      def initialize options = {}
+        @type = options[:type]
+        super
+      end
+
+      # Request verification for an email address or a domain.
+      # @param [String] email_or_domain
+      # @return [Identity] Returns an {Identity} object.  Identities for
+      #   domains will have a #verification_token.
+      def verify email_or_domain
+
+        resp = email_or_domain =~ /@/ ?
+          client.verify_email_identity(:email_address => email_or_domain) :
+          client.verify_domain_identity(:domain => email_or_domain)
+
+        Identity.new(email_or_domain,
+          :verification_token => resp.data[:verification_token],
+          :config => config)
+
+      end
+      alias_method :create, :verify
+
+      # @param [String] email_or_domain
+      # @return [DomainIdentity,EmailIdentity] Returns an {Identity} with
+      #   the given email address or domain name.
+      def [] email_or_domain
+        Identity.new(email_or_domain, :config => config)
+      end
+
+      # @return [IdentityCollection] Returns a collection that only
+      #   enumerates email addresses.
+      def email_addresses
+        self.class.new(:type => 'EmailAddress', :config => config)
+      end
+
+      # @return [IdentityCollection] Returns a collection that only
+      #   enumerates domains.
+      def domains
+        self.class.new(:type => 'Domain', :config => config)
+      end
+
+      protected
+
+      def _each_item next_token, limit, options = {}, &block
+
+        options[:max_items] = limit if limit
+        options[:next_token] = next_token if next_token
+        options[:identity_type] = @type if @type
+
+        resp = client.list_identities(options)
+        resp.data[:identities].each do |identity|
+          yield(self[identity])
+        end
+
+        resp.data[:next_token]
+
+      end
+
+    end
+  end
+end

data/lib/aws/simple_email_service/quotas.rb

@@ -0,0 +1,64 @@
+# 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 SimpleEmailService
+
+    # Returns information about your SimpleEmailService quotas.
+    class Quotas
+
+      include Core::Model
+
+      # @return [Integer] The maximum number of emails the user is allowed
+      #   to send in a 24-hour interval.
+      def max_24_hour_send
+        to_h[:max_24_hour_send]
+      end
+
+      # @return [Float] The maximum number of emails the user is allowed 
+      #   to send per second.
+      def max_send_rate
+        to_h[:max_send_rate]
+      end
+
+      # @return [Integer] Returns the number of emails sent during the 
+      #   previous 24 hours.
+      def sent_last_24_hours
+        to_h[:sent_last_24_hours]
+      end
+
+      # Returns a hash of the SES quotas.
+      #
+      #   @ses.quotas.to_hash
+      #   # {:max_24_hour_send=>200, :max_send_rate=>1.0, :sent_last_24_hours=>22}
+      #
+      # @return [Hash] 
+      #
+      def to_hash
+        response = client.get_send_quota
+        {
+          :max_24_hour_send => response.max_24_hour_send.to_i,
+          :max_send_rate => response.max_send_rate.to_f,
+          :sent_last_24_hours => response.sent_last_24_hours.to_i,  
+        }
+      end
+      alias_method :to_h, :to_hash
+
+      # @private
+      def inspect
+        "<#{self.class} #{to_hash.inspect}>"
+      end
+        
+    end
+  end
+end

data/lib/aws/simple_email_service/request.rb

@@ -0,0 +1,27 @@
+# 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 SimpleEmailService
+    # @private
+    class Request < Core::Http::Request
+
+      include Core::Signature::Version4
+
+      def service
+        'ses'
+      end
+
+    end
+  end
+end

data/lib/aws/simple_workflow.rb

@@ -0,0 +1,228 @@
+# 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.
+
+require 'aws/core'
+require 'aws/simple_workflow/config'
+
+module AWS
+
+  # This is the starting point for working with Amazon Simple Workflow Service.
+  #
+  # = Domains
+  #
+  # To get started, you need to first create a domain.  Domains are used to 
+  # organize related tasks and activities.  
+  #
+  #   swf = AWS::SimpleWorkflow.new
+  #
+  #   # name the domain and specify the retention period (in days)
+  #   domain = swf.domains.create('my-domain', 10)
+  #
+  # You can reference existing domains as well.
+  #
+  #   domain = swf.domains['my-domain']
+  #
+  # = Workflow and Activity Types
+  #
+  # Once you have a domain you can create a workflow and
+  # activity types.  Both types (workflow and activity) are templates that
+  # can be used to start workflow executions or schedule activity tasks.
+  #
+  # Workflow and Activity types both have a number of default values
+  # (e.g. default task list, timeouts, etc).  If you do not specify these
+  # optional default values when creating the type, you *MUST* specify
+  # the actual values when starting a workflow execution or scheduling
+  # an activity task.
+  #
+  # == Sample Workflow type and activity type
+  #
+  #   # register an workflow type with the version id '1'
+  #   workflow_type = domain.workflow_types.create('my-long-processes', '1',
+  #     :default_task_list => 'my-task-list',
+  #     :default_child_policy => :request_cancel,
+  #     :default_task_start_to_close_timeout => 3600,
+  #     :default_execution_start_to_close_timeout => 24 * 3600)
+  # 
+  #   # register an activity type, with the version id '1'
+  #   activity_type = domain.activity_types.create('do-something', '1', 
+  #     :default_task_list => 'my-task-list',
+  #     :default_task_heartbeat_timeout => 900,
+  #     :default_task_schedule_to_start_timeout => 60,
+  #     :default_task_schedule_to_close_timeout => 3660,
+  #     :default_task_start_to_close_timeout => 3600)
+  #
+  # = Starting a Workflow Execution
+  #
+  # Once you have a domain and at least one workflow type you can
+  # start a workflow execution.  You may provide a workflow id, or a
+  # random one will be generated.  You may also provide optional
+  # input and override any of the defaults registered with the 
+  # workflow type.
+  #
+  #   workflow_execution = workflow_type.start_execution :input => '...'
+  #
+  #   workflow_execution.workflow_id #=> "5abbdd75-70c7-4af3-a324-742cd29267c2"
+  #   workflow_execution.run_id #=> "325a8c34-d133-479e-9ecf-5a61286d165f"
+  #
+  # = Decision Tasks
+  #
+  # Once a workflow execution has been started, it will start to generate
+  # decision tasks.  You poll for decision tasks from a task list.
+  # Yielded decision tasks provide access to the history of events
+  # for the workflow execution.  You can also enumerate only new
+  # events since the last decision.
+  # 
+  # To make decisions you call methods from the list below.  You can call
+  # any number of decision methods any number of times.
+  #
+  # * schedule_activity_task
+  # * request_cancel_activity_task
+  # * complete_workflow_execution
+  # * fail_workflow_execution
+  # * cancel_workflow_execution
+  # * continue_as_new_workflow_execution
+  # * record_marker
+  # * start_timer
+  # * cancel_timer
+  # * signal_external_workflow_execution
+  # * request_cancel_external_workflow_execution workflow_execution, options = {}
+  # * start_child_workflow_execution workflow_type, options = {}
+  #
+  # This sample gets a decision task and responds based on the events
+  # by scheduling an activity task or completing the workflow execution.
+  #
+  #   # poll for decision tasks from 'my-task-list'
+  #   domain.decision_tasks.poll('my-task-list') do |task|
+  #
+  #     # investigate new events and make decisions
+  #     task.new_events.each do |event|
+  #       case event.event_type
+  #       when 'WorkflowExecutionStarted'
+  #         task.schedule_activity_task 'do-something', :input => 'abc xyz'
+  #       when 'ActivityTaskCompleted'
+  #         task.complete_workflow_execution :result => event.attributes.result
+  #       end
+  #     end
+  #
+  #   end # decision task is completed here
+  #
+  # When you are done calling decision methods, you need to complete the
+  # decision task.  This is done by default if you pass a block to
+  # +poll+ or +poll_for_single_task+.
+  #
+  # = Activity Tasks
+  #
+  # The only way to spawn activity tasks is to call +schedule_activity_task+
+  # on a decision task.  Scheduled activity tasks are returned when you
+  # poll for activity tasks.
+  #
+  #   # poll 'my-task-list' for activities
+  #   domain.activity_tasks.poll('my-task-list') do |activity_task|
+  #
+  #     case activity_task.activity_type.name
+  #     when 'do-something' 
+  #       # ...
+  #     else
+  #       activity_task.fail! :reason => 'unknown activity task type'
+  #     end
+  #     
+  #   end
+  #
+  # == Activity Task Heartbeats
+  #
+  # When you receive an activity task, you need to update the service
+  # with status messages.  This is called recording a heartbeat.#
+  # To record a heartbeat, just call {ActivityTask#record_heartbeat!}.  
+  # When you call +record_heartbeat+ you should rescue 
+  # {ActivityTask::CancelRequestedError}.  These are thrown when a task
+  # should be canceled.  You can cleanup the task and then call 
+  # +cancel!+ when you are finished.
+  #
+  #   # poll 'my-task-list' for activities
+  #   domain.activity_tasks.poll('my-task-list') do |activity_task|
+  #     begin
+  #
+  #       # do stuff ...
+  #
+  #       activity_task.record_heartbeat! :details => '25%'
+  #
+  #       # do more stuff ...
+  #
+  #       activity_task.record_heartbeat! :details => '50%'
+  #
+  #       # do more stuff ...
+  #
+  #       activity_task.record_heartbeat! :details => '75%'
+  #
+  #       # do more stuff ...
+  #
+  #     rescue ActivityTask::CancelRequestedError
+  #       # cleanup after ourselves
+  #       activity_task.cancel!
+  #     end
+  #   end
+  #   
+  # Like decision tasks, activity tasks are auto-completed at the 
+  # end of a poll block.
+  #
+  # = History Events
+  #
+  # You might want to view the event history for a running workflow
+  # execution.  You can get a workflow execution by its workflow
+  # id (you may optionally provide the run id as well).
+  #
+  #   execution = domain.workflow_executions['workflow-id']
+  #   execution.events.each do |event|
+  #     puts event.attributes.to_h.inspect
+  #   end
+  #
+  # See {HistoryEvent} and {HistoryEvent::Attributes} for more information.
+  #
+  # @!attribute [r] client
+  #   @return [Client] the low-level SimpleWorkflow client object
+  class SimpleWorkflow
+
+    AWS.register_autoloads(self, 'aws/simple_workflow') do
+      autoload :ActivityType,                'activity_type'
+      autoload :ActivityTypeCollection,      'activity_type_collection'
+      autoload :ActivityTask,                'activity_task'
+      autoload :ActivityTaskCollection,      'activity_task_collection'
+      autoload :Client,                      'client'
+      autoload :Count,                       'count'
+      autoload :DecisionTask,                'decision_task'
+      autoload :DecisionTaskCollection,      'decision_task_collection'
+      autoload :Domain,                      'domain'
+      autoload :DomainCollection,            'domain_collection'
+      autoload :Errors,                      'errors'
+      autoload :HistoryEvent,                'history_event'
+      autoload :HistoryEventCollection,      'history_event_collection'
+      autoload :OptionFormatters,            'option_formatters'
+      autoload :Request,                     'request'
+      autoload :Resource,                    'resource'
+      autoload :Type,                        'type'
+      autoload :TypeCollection,              'type_collection'
+      autoload :WorkflowExecution,           'workflow_execution'
+      autoload :WorkflowExecutionCollection, 'workflow_execution_collection'
+      autoload :WorkflowType,                'workflow_type'
+      autoload :WorkflowTypeCollection,      'workflow_type_collection'
+    end
+
+    include Core::ServiceInterface
+
+    # @return [DomainCollection]
+    def domains
+      DomainCollection.new(:config => config)
+    end
+
+  end
+end

data/lib/aws/simple_workflow/activity_task.rb

@@ -0,0 +1,173 @@
+# 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
+    class ActivityTask
+
+      # Raised by {ActivityTask#record_heartbeat!} when this activity
+      # task has received a cancellation request.
+      class CancelRequestedError < StandardError; end
+
+      include Core::Model
+
+      # @private
+      def initialize domain, data, options = {}
+
+        @domain = domain
+
+        @task_token = data['taskToken']
+        @activity_id = data['activityId']
+        @started_event_id = data['startedEventId']
+        @input = data['input']
+
+        name = data['activityType']['name']
+        version = data['activityType']['version']
+        @activity_type = domain.activity_types[name,version]
+
+        workflow_id = data['workflowExecution']['workflowId']
+        run_id = data['workflowExecution']['runId']
+        @workflow_execution = domain.workflow_executions[workflow_id,run_id]
+
+        super
+
+      end
+
+      # @return [String] The opaque string used as a handle on the task. 
+      attr_reader :task_token
+
+      # @return [String] The unique identifier of this task.
+      attr_reader :activity_id
+
+      # @return [Domain] The domain this task was scheduled in.
+      attr_reader :domain
+
+      # @return [Integer] The id of the ActivityTaskStarted event recorded 
+      #   in the history.
+      attr_reader :started_event_id
+
+      # @return [String,nil] The input provided when the activity task was 
+      #   scheduled.
+      attr_reader :input
+
+      # @return [ActivityType]
+      attr_reader :activity_type
+
+      # @return [WorkflowExecution]
+      attr_reader :workflow_execution
+
+      # Reports to the service that the activity task is progressing.
+      #
+      # You can optionally specify +:details+ that describe the progress.
+      # This might be a percentage competition, step number, etc.
+      #
+      #   activity_task.record_heartbeat! :details => '.75' # 75% complete
+      #
+      # If the activity task has been canceled since it was received or
+      # since the last recorded heartbeat, this method will raise
+      # a CancelRequestedError.
+      #
+      # If you are processing the activity task inside a block passed
+      # to one of the polling methods in {ActivityTaskCollection}
+      # then untrapped CancelRequestedErrors are caught 
+      # and responded to automatically.
+      #
+      #   domain.activity_tasks.poll('task-list') do |task|
+      #
+      #     task.record_heartbeat! # raises CancelRequestedError
+      #
+      #   end # traps the error and responds activity task canceled.
+      #
+      # If you need to cleanup or provide additional details in the
+      # cancellation response, you can trap the error and
+      # respond manually.
+      #
+      #   domain.activity_tasks.poll('task-list') do |task|
+      #
+      #     task.record_heartbeat! # raises CancelRequestedError
+      #
+      #   rescue CancelRequestedError => e
+      #
+      #      # cleanup
+      #
+      #      task.respond_canceled! :details => '...'
+      #
+      #   end
+      #   
+      # @param [Hash] options
+      #
+      # @option options [String] :details (nil)
+      #   If specified, contains details about the progress of the task.
+      #
+      def record_heartbeat! options = {}
+
+        client_opts = {}
+        client_opts[:task_token] = task_token
+        client_opts[:details] = options[:details] if options[:details]
+
+        response = client.record_activity_task_heartbeat(client_opts)
+
+        raise CancelRequestedError if response.data['cancelRequested']
+
+        nil
+
+      end
+
+      # @param [Hash] options
+      #
+      # @option options [String] :result (nil)
+      #
+      # @return [nil]
+      #
+      def complete! options = {}
+        respond :completed, options
+      end
+
+      # @param [Hash] options
+      #
+      # @option options [String] :details (nil)
+      #
+      # @return [nil]
+      #
+      def cancel! options = {}
+        respond :canceled, options
+      end
+
+      # @param [Hash] options
+      #
+      # @option options [String] :details (nil)
+      #
+      # @option options [String] :reason (nil)
+      #
+      # @return [nil]
+      #
+      def fail! options = {}
+        respond :failed, options
+      end
+
+      def responded?
+        !!@responded
+      end
+
+      protected
+      def respond status, options
+        raise "already responded" if responded?
+        @responded = status
+        options[:task_token] = task_token
+        client.send("respond_activity_task_#{status}", options)
+        nil
+      end
+
+    end
+  end
+end