aws-sdk-resources 2.11.549

data/lib/aws-sdk-resources/options.rb

@@ -0,0 +1,17 @@
+module Aws
+  module Resources
+    module Options
+
+      private
+
+      def option(key, options)
+        if options[key].nil?
+          raise Errors::DefinitionError, "missing required option #{key.inspect}"
+        else
+          options[key]
+        end
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-resources/request.rb

@@ -0,0 +1,39 @@
+module Aws
+  module Resources
+    class Request
+
+      # @option options [required, String] :method_name
+      # @option options [Array<RequestParams::Param>] :params ([]) A list of
+      #   request params to apply to the request when called.
+      def initialize(options = {})
+        @method_name = options[:method_name]
+        @params = options[:params] || []
+      end
+
+      # @return [String] Name of the method called on the client when this
+      #   operation is called.
+      attr_reader :method_name
+
+      # @return [Array<RequestParams::Param>]
+      attr_reader :params
+
+      # @option options [required, Resource] :resource
+      # @option options [Array<Mixed>] :args
+      # @return [Seahorse::Client::Response]
+      def call(options)
+        client(options).send(@method_name, req_params(options), &options[:block])
+      end
+
+      private
+
+      def client(options)
+        Array(options[:resource]).first.client
+      end
+
+      def req_params(options)
+        RequestParams::ParamHash.new(@params).build(options)
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-resources/request_params.rb

@@ -0,0 +1,140 @@
+module Aws
+  module Resources
+    module RequestParams
+
+      # @api private
+      class ParamHash
+
+        # @param [Array<RequestParams::Param>] params
+        def initialize(params)
+          @params = params
+        end
+
+        # @option options [required,Resource] :resource
+        # @option options [required,Array<Mixed>] :args
+        # @return [Hash]
+        def build(options = {})
+          deep_merge(user_params(options), computed_params(options))
+        end
+
+        private
+
+        def user_params(options)
+          args = options[:args] || []
+          args.last.is_a?(Hash) ? args.last : {}
+        end
+
+        def computed_params(options)
+          params_hash = {}
+          Array(options[:resource]).each.with_index do |resource, n|
+            @params.each do |param|
+              param.apply(params_hash, options.merge(resource: resource, n: n))
+            end
+          end
+          params_hash
+        end
+
+        def deep_merge(obj1, obj2)
+          case obj1
+          when Hash then obj1.merge(obj2) { |key, v1, v2| deep_merge(v1, v2) }
+          when Array then obj2 + obj1
+          else obj2
+          end
+        end
+
+      end
+
+      module Param
+
+        def initialize(options)
+          @target = options[:target].to_s
+          @steps = []
+          @target.scan(/\w+|\[\]|\[\*\]|\[[0-9]+\]/) do |step|
+            case step
+            when /\[\d+\]/ then @steps += [:array, step[1..-2].to_i]
+            when /\[\*\]/ then @steps += [:array, :n]
+            when '[]' then @steps += [:array, -1]
+            else @steps += [:hash, step.to_sym]
+            end
+          end
+          @steps.shift
+          @final = @steps.pop
+        end
+
+        # @return [String] target
+        attr_reader :target
+
+        def apply(params, options = {})
+          if @final == -1
+            build_context(params, options[:n]) << value(options)
+          else
+            build_context(params, options[:n])[@final] = value(options)
+          end
+          params
+        end
+
+        private
+
+        def build_context(params, n)
+          @steps.each_slice(2).inject(params) do |context, (key, type)|
+            entry = type == :array ? [] : {}
+            if key == -1
+              context << entry
+              entry
+            elsif key == :n
+              context[n] ||= entry
+            else
+              context[key] ||= entry
+            end
+          end
+        end
+
+      end
+
+      class Identifier
+
+        include Param
+
+        def initialize(options)
+          @identifier_name = options[:name]
+          super
+        end
+
+        def value(options)
+          options[:resource].send(@identifier_name)
+        end
+
+      end
+
+      class DataMember
+
+        include Param
+
+        def initialize(options)
+          @path = options[:path]
+          super
+        end
+
+        def value(options)
+          JMESPath.search(@path, options[:resource].data)
+        end
+
+      end
+
+      class Literal
+
+        include Param
+
+        def initialize(options)
+          @value = options[:value]
+          super
+        end
+
+        def value(*args)
+          @value
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-resources/resource.rb

@@ -0,0 +1,243 @@
+module Aws
+  module Resources
+    class Resource
+
+      extend OperationMethods
+
+      # @overload initialize(*identifiers, options = {})
+      #   @param [Hash] options Options except `:data` and identifier options are
+      #     used to construct a {Client} unless `:client` is given.
+      #   @option options [Client] :client
+      def initialize(*args)
+        options = args.last.is_a?(Hash) ? args.pop.dup : {}
+        @identifiers = extract_identifiers(args, options)
+        @data = options.delete(:data)
+        @client = extract_client(options)
+      end
+
+      # Marked private to prevent double documentation
+      # @return [Client]
+      attr_reader :client
+
+      # Marked private to prevent double documentation
+      # @return [Hash<Symbol,String>]
+      attr_reader :identifiers
+
+      # Waiter polls an API operation until a resource enters a desired
+      # state.
+      #
+      # @note The waiting operation is performed on a copy. The original resource remains unchanged
+      #
+      # ## Basic Usage
+      #
+      # Waiter will polls until it is successful, it fails by
+      # entering a terminal state, or until a maximum number of attempts
+      # are made.
+      #
+      #     # polls in a loop until condition is true
+      #     resource.wait_until(options) {|resource| condition}
+      #
+      # ## Example
+      #
+      #     instance.wait_until(max_attempts:10, delay:5) {|instance| instance.state.name == 'running' }
+      #
+      # ## Configuration
+      #
+      # You can configure the maximum number of polling attempts, and the
+      # delay (in seconds) between each polling attempt. The waiting condition is set
+      # by passing a block to {#wait_until}:
+      #
+      #     # poll for ~25 seconds
+      #     resource.wait_until(max_attempts:5,delay:5) {|resource|...}
+      #
+      # ## Callbacks
+      #
+      # You can be notified before each polling attempt and before each
+      # delay. If you throw `:success` or `:failure` from these callbacks,
+      # it will terminate the waiter.
+      #
+      #     started_at = Time.now
+      #     # poll for 1 hour, instead of a number of attempts
+      #     proc = Proc.new do |attempts, response|
+      #       throw :failure if Time.now - started_at > 3600
+      #     end
+      #
+      #       # disable max attempts
+      #     instance.wait_until(before_wait:proc, max_attempts:nil) {...}
+      #
+      # ## Handling Errors
+      #
+      # When a waiter is successful, it returns the Resource. When a waiter
+      # fails, it raises an error.
+      #
+      #     begin
+      #       resource.wait_until(...)
+      #     rescue Aws::Waiters::Errors::WaiterFailed
+      #       # resource did not enter the desired state in time
+      #     end
+      #
+      #
+      # @yieldparam [Resource] resource to be used in the waiting condition
+      #
+      # @raise [Aws::Waiters::Errors::FailureStateError] Raised when the waiter terminates
+      #   because the waiter has entered a state that it will not transition
+      #   out of, preventing success.
+      #
+      # @raise [Aws::Waiters::Errors::TooManyAttemptsError] Raised when the configured
+      #   maximum number of attempts have been made, and the waiter is not
+      #   yet successful.
+      #
+      # @raise [Aws::Waiters::Errors::UnexpectedError] Raised when an error is encountered
+      #   while polling for a resource that is not expected.
+      #
+      # @raise [NotImplementedError] Raised when the resource does not
+      #   support #reload operation
+      #
+      # @option options [Integer] :max_attempts (10) Maximum number of attempts
+      # @option options [Integer] :delay (10) Delay between each attempt in seconds
+      # @option options [Proc] :before_attempt (nil) Callback invoked before each attempt
+      # @option options [Proc] :before_wait (nil) Callback invoked before each wait
+      # @return [Resource] if the waiter was successful
+      def wait_until(options = {}, &block)
+        resource_copy = self.dup
+        attempts = 0
+        options[:max_attempts] = 10 unless options.key?(:max_attempts)
+        options[:delay] ||= 10
+        options[:poller] = Proc.new do
+          attempts += 1
+          if block.call(resource_copy)
+            [:success, resource_copy]
+          else
+            resource_copy.reload unless attempts == options[:max_attempts]
+            :retry
+          end
+        end
+        Waiters::Waiter.new(options).wait({})
+      end
+
+      # @return [Struct]
+      def data
+        load unless @data
+        @data
+      end
+
+      # @return [Boolean] Returns `true` if {#data} has been loaded.
+      def data_loaded?
+        !@data.nil?
+      end
+
+      # @api private
+      def exists?(options = {})
+        wait_until_exists(options) { |w| w.max_attempts = 1 }
+        true
+      rescue Waiters::Errors::UnexpectedError => e
+        raise e.error
+      rescue Waiters::Errors::WaiterFailed
+        false
+      rescue NoMethodError
+        msg = "#exists? is not implemented for #{self.class.name}"
+        raise NotImplementedError, msg
+      end
+
+      # Loads data for this resource.
+      # @note Calling this method will send a request to AWS.
+      # @return [self]
+      def load
+        if load_operation = self.class.load_operation
+          @data = load_operation.call(resource:self, client:client)
+          self
+        else
+          raise NotImplementedError, "#load not defined for #{self.class.name}"
+        end
+      end
+      alias reload load
+
+      # @api private
+      def inspect
+        identifiers = self.identifiers.map do |name, value|
+          "#{name}=#{value.inspect}"
+        end.join(', ')
+        "#<#{[self.class.name, identifiers].join(' ').strip}>"
+      end
+
+      private
+
+      def extract_client(options)
+        if options[:client]
+          options[:client]
+        else
+          self.class.client_class.new(options.merge(
+            user_agent_suffix: "resources"
+          ))
+        end
+      end
+
+      def extract_identifiers(args, options)
+        identifiers = {}
+        self.class.identifiers.each.with_index do |name, n|
+          if args[n]
+            identifiers[name] = args[n]
+          elsif options[name]
+            identifiers[name] = options.delete(name)
+          else
+            raise ArgumentError, "missing required option #{name.inspect}"
+          end
+        end
+        identifiers
+      end
+
+      class << self
+
+        # @return [String, nil] The resource name.
+        attr_accessor :resource_name
+
+        # @return [Class<Client>, nil] When constructing
+        #   a resource, the client will default to an instance of the
+        #   this class.
+        attr_accessor :client_class
+
+        # @return [Operations::LoadOperation, nil]
+        attr_accessor :load_operation
+
+        # @return [Array<Symbol>]
+        # @see add_identifier
+        # @see #identifiers
+        def identifiers
+          @identifiers.dup
+        end
+
+        # @param [Symbol] name
+        # @return [void]
+        def add_identifier(name)
+          name = name.to_sym
+          safe_define_method(name) { @identifiers[name] }
+          @identifiers << name
+        end
+
+        # Registers a data attribute.  This defines a simple getter
+        # for the attribute which will access {#data}, loading the
+        # resource if necessary.
+        # @param [Symbol] name
+        # @return [void]
+        def add_data_attribute(name)
+          safe_define_method(name) { data[name] }
+          @data_attributes << name
+        end
+
+        # @return [Array<Symbol>] Returns an array of symbolized data
+        #   attribute names.
+        def data_attributes
+          @data_attributes.dup
+        end
+
+        # @api private
+        def inherited(subclass)
+          subclass.send(:instance_variable_set, "@identifiers", [])
+          subclass.send(:instance_variable_set, "@data_attributes", [])
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-resources/services/ec2.rb

@@ -0,0 +1,21 @@
+module Aws
+  module EC2
+
+    require 'aws-sdk-resources/services/ec2/instance'
+
+    class Resource
+
+      def create_tags(options)
+        resp = @client.create_tags(options)
+        tags = []
+        options[:resources].each do |resource_id|
+          options[:tags].each do |tag|
+            tags << Tag.new(resource_id, tag[:key], tag[:value], client: @client)
+          end
+        end
+        Resources::Batch.new(Tag, tags, response: resp)
+      end
+
+    end
+  end
+end