aws-sdk-resources 2.11.549

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c24aca2605287ac2f68422f15fd61da45f9ebacc7449a5fef118df22eb7d8fa7
+  data.tar.gz: cf15ec889d63c546e1eab715aa13ef62fc3ea77bd10752546e590428ca2f52a9
+SHA512:
+  metadata.gz: 2f61b440ca06fbffc4c2cf82dbb2c202a8f1d9bf86cf1bb49e3e43519cb794645a14c21b7be91fe3626e51e3fb1ffa823053b16ff579ef2b404f2ad442e2fa04
+  data.tar.gz: 1d8e32e797be5c217f760fb44a738fe6339a587bca103ec00c4006229aff08a538c23ffb6a4b7342a64afb12b61b2511c86d73534733ce012370f91095632173

data/lib/aws-sdk-resources.rb

@@ -0,0 +1,91 @@
+require 'aws-sdk-core'
+
+module Aws
+
+  module Resources
+    autoload :Batch, 'aws-sdk-resources/batch'
+    autoload :Builder, 'aws-sdk-resources/builder'
+    autoload :BuilderSources, 'aws-sdk-resources/builder_sources'
+    autoload :Collection, 'aws-sdk-resources/collection'
+    autoload :Definition, 'aws-sdk-resources/definition'
+    autoload :Documenter, 'aws-sdk-resources/documenter'
+    autoload :Errors, 'aws-sdk-resources/errors'
+    autoload :OperationMethods, 'aws-sdk-resources/operation_methods'
+    autoload :Operations, 'aws-sdk-resources/operations'
+    autoload :Options, 'aws-sdk-resources/options'
+    autoload :Request, 'aws-sdk-resources/request'
+    autoload :RequestParams, 'aws-sdk-resources/request_params'
+    autoload :Resource, 'aws-sdk-resources/resource'
+    autoload :Source, 'aws-sdk-resources/source'
+  end
+
+  service_added do |name, svc_module, options|
+    definition = options[:resources]
+    definition = case definition
+      when nil then Resources::Definition.new({})
+      when Resources::Definition then definition
+      when Hash then Resources::Definition.new(definition)
+      when String
+        Resources::Definition.new(Json.load_file(definition), source_path: definition)
+      else raise ArgumentError, "invalid resource definition #{definition}"
+    end
+    definition.apply(svc_module)
+
+    # load customizations
+    svc = File.join(
+      File.dirname(__FILE__),
+      'aws-sdk-resources',
+      'services',
+      "#{name.downcase}.rb")
+
+    require(svc) if File.exist?(svc)
+  end
+
+  # In version 2.2, all batch resource operations were renamed:
+  #
+  # * All operations are now prefixed with `batch_`, e.g. `#start`
+  #   became `#batch_start`.
+  #
+  # * All batch operations with "delete" or "terminate" in the name
+  #   are now suffixed with `!`, e.g. `#delete` is now `#batch_delete!`
+  #
+  # For backwards compatibility, existing batch methods must still respond
+  # to their old names. This callback registers these methods with their
+  # old names.
+  service_added do |name, svc_module, options|
+    unless ENV['DOCSTRINGS']
+      case name
+      when 'EC2'
+        {
+          'create_tags' => 'batch_create_tags',
+          'monitor' => 'batch_create_tags',
+          'reboot' => 'batch_reboot',
+          'start' => 'batch_start',
+          'stop' => 'batch_stop',
+          'terminate' => 'batch_terminate!',
+          'unmonitor' => 'batch_unmonitor',
+        }.each do |deprecated_name, correct_name|
+          Resources::Operations::DeprecatedOperation.define({
+            resource_class: EC2::Instance,
+            deprecated_name: deprecated_name,
+            name: correct_name,
+          })
+        end
+        Resources::Operations::DeprecatedOperation.define({
+          resource_class: EC2::Tag,
+          deprecated_name: 'delete',
+          name: 'batch_delete!',
+        })
+      when 'S3'
+        [S3::Object, S3::ObjectSummary, S3::ObjectVersion].each do |klass|
+          Resources::Operations::DeprecatedOperation.define({
+            resource_class: klass,
+            deprecated_name: 'delete',
+            name: 'batch_delete!',
+          })
+        end
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,143 @@
+module Aws
+  module Resources
+
+    # A batch provides array like access to a list of resources. Batches
+    # also provide the ability to invoke certain operations against
+    # the entire batch.
+    #
+    # ## Getting a Batch
+    #
+    # You should normally not need to construct a batch. Anywhere a list
+    # of resources is returned, they are returned as a batch:
+    #
+    #     # security_groups is a batch
+    #     security_groups = ec2.instance('i-12345678').security_groups
+    #
+    # When the possible number of resources is unknown or large, the
+    # resources will be returned in a collection. Collections can enumerate
+    # individual resources or batches. They manage paging over the
+    # AWS request/responses to produce batches.
+    #
+    #     # objects is a collection
+    #     objects = s3.bucket('aws-sdk').objects
+    #
+    # You can invoke batch operations against collections and they will
+    # invoke them on each batch.
+    #
+    #     # delete all objects in this bucket in batches of 1k
+    #     objects = s3.bucket('aws-sdk').objects
+    #     objects.delete
+    #
+    # ## Batch Operations
+    #
+    # Batches provide operations that operate on the entire batch. These
+    # operations are only defined for resources where the AWS API accepts
+    # multiple inputs. This means a batch operation for n resources will
+    # only make one request.
+    #
+    # Resource classes document each of their own batch operations.
+    # See {S3::Object} for an example.
+    #
+    class Batch
+
+      include Enumerable
+
+      # @param [Array<Resource>] resources
+      # @option options [Seahorse::Client::Response] :response
+      def initialize(resource_class, resources, options = {})
+        @resource_class = resource_class
+        @resources = resources
+        @response = options[:response]
+        @size = resources.size
+        @options = options
+      end
+
+      # @return [Class<Resource>]
+      attr_reader :resource_class
+
+      # @return [Seahorse::Client::Response, nil]
+      attr_reader :response
+
+      # @return [Integer]
+      attr_reader :size
+
+      alias count size
+
+      # @param [Integer] index
+      # @return [Resource]
+      def [](index)
+        @resources[index]
+      end
+
+      # Yields each resource of the batch, one at a time.
+      def each(&block)
+        enum = @resources.to_enum
+        enum.each(&block) if block_given?
+        enum
+      end
+
+      # @param [Integer] count
+      # @return [Resource, Batch]
+      def first(count = nil)
+        if count
+          self.class.new(@resource_class, @resources.first(count), @options)
+        else
+          @resources.first
+        end
+      end
+
+      # @return [Boolean]
+      def empty?
+        @resources.empty?
+      end
+
+      # @api private
+      def inspect
+        "#<#{self.class.name} resources=#{@resources.inspect}>"
+      end
+
+      # @api private
+      def respond_to?(method_name, *args)
+        if @resource_class.batch_operation_names.include?(method_name.to_sym)
+          true
+        else
+          super
+        end
+      end
+
+      # @api private
+      def method_missing(method_name, *args, &block)
+        if respond_to?(method_name)
+          invoke_batch_operation(method_name, args, block) unless empty?
+        else
+          super
+        end
+      end
+
+      private
+
+      def invoke_batch_operation(method_name, args, block)
+        self.class.validate_batch_args!(args)
+        operation = @resource_class.batch_operation(method_name)
+        operation.call(resource:self, args:args, block:block)
+      end
+
+      class << self
+
+        # @api private
+        def validate_batch_args!(args)
+          case args.count
+          when 0
+          when 1
+            unless Hash === args.first
+              raise ArgumentError, "expected options to be a hash"
+            end
+          else
+            raise ArgumentError, "wrong number of arguments, expected 0 or 1"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Aws
+  module Resources
+
+    # A {Builder} construct resource objects.  It extracts resource identifiers
+    # for the objects it builds from another resource object and/or an
+    # AWS response.
+    class Builder
+
+      include Options
+
+      # @option options [required, Class<Resource>] resource_class
+      # @option options [Array<BuilderSources::Source>] :sources ([])
+      def initialize(options = {})
+        @resource_class = options[:resource_class]
+        @sources = options[:sources] || []
+      end
+
+      # @return [Class<Resource>]
+      attr_reader :resource_class
+
+      # @return [Array<BuilderSources::Source>] A list of resource
+      #   identifier sources.
+      attr_reader :sources
+
+      # @return [Boolean] Returns `true` if this builder returns an array
+      #   of resource objects from {#build}.
+      def plural?
+        @sources.any?(&:plural?)
+      end
+
+      # @option [Resource] :resource
+      # @option [Seahorse::Client::Response] :response
+      # @return [Resource, Array<Resource>] Returns a resource object or an
+      #   array of resource objects if {#plural?}.
+      def build(options = {})
+        identifier_map = @sources.each.with_object({}) do |source, hash|
+          hash[source.target] = source.extract(options)
+        end
+        if plural?
+          build_batch(identifier_map, options)
+        else
+          build_one(identifier_map, options)
+        end
+      end
+
+      private
+
+      def build_batch(identifier_map, options, &block)
+        resources = (0...resource_count(identifier_map)).collect do |n|
+          identifiers = @sources.inject({}) do |hash, source|
+            value = identifier_map[source.target]
+            value = value[n] if source.plural?
+            hash[source.target] = value
+            hash
+          end
+          resource = build_one(identifiers, options)
+          yield(resource) if block_given?
+          resource
+        end
+        Batch.new(resource_class, resources, options)
+      end
+
+      def build_one(identifiers, options)
+        if identifiers.count > 0 && identifiers.values.any?(&:nil?)
+          nil
+        else
+          @resource_class.new(identifiers.merge(
+            client: client(options)
+          ))
+        end
+      end
+
+      def resource_count(identifier_map)
+        identifier_map.values.inject(0) do |max, values|
+          [max, values.is_a?(Array) ? values.size : 0].max
+        end
+      end
+
+      def client(options)
+        Array(options[:resource]).first.client
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Aws
+  module Resources
+    module BuilderSources
+
+      module Source
+
+        def initialize(options)
+          @source = options[:source]
+          @target = options[:target].to_sym
+        end
+
+        # @return [String, nil]
+        attr_reader :source
+
+        # @return [Symbol]
+        attr_reader :target
+
+        # @return [Boolean]
+        def plural?
+          !!(@source && @source.include?('['))
+        end
+
+      end
+
+      class Argument
+
+        include Source
+
+        # @option [required, String] :argument
+        def extract(options)
+          (options[:args] || [])[@source]
+        end
+
+        def plural?
+          false
+        end
+
+      end
+
+      # Extracts an identifier from a parent resource identifier.  Used
+      # when building a {Resource} from the context of another resource.
+      class Identifier
+
+        include Source
+
+        # @option [required, Resource] :resource
+        def extract(options)
+          options[:resource].send(@source)
+        end
+
+      end
+
+      # Extracts an identifier from the data of a parent resource.  Used
+      # when building a {Resource} from the context of another resource.
+      class DataMember
+
+        include Source
+
+        # @option [required, Resource] :resource
+        def extract(options)
+          JMESPath.search(@source, options[:resource].data)
+        end
+
+      end
+
+      # Extracts an identifier from the request parameters used to generate
+      # a response.  Used when building a {Resource} object from the response
+      # of an operation.
+      class RequestParameter
+
+        include Source
+
+        # @option [required, Seahorse::Client::Response] :response
+        def extract(options)
+          JMESPath.search(@source, options[:response].context.params)
+        end
+
+      end
+
+      # Extracts an identifier from the data of a response.  Used when
+      # building a {Resource} object from the response of an operation.
+      class ResponsePath
+
+        include Source
+
+        # @option [required, Seahorse::Client::Response] :response
+        def extract(options)
+          JMESPath.search(@source, options[:response].data)
+        end
+
+      end
+
+      # Supplies a string literal.
+      class StringLiteral
+
+        include Source
+
+        def extract(options)
+          @source
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module Aws
+  module Resources
+    class Collection
+
+      include Enumerable
+
+      # @param [HasManyOperation] operation
+      # @option (see HasManyOperation#call)
+      # @api private
+      def initialize(operation, options)
+        @operation = operation
+        @options = options
+      end
+
+      # @return [Enumerator<Resource>]
+      def each(&block)
+        if block_given?
+          batches.each { |batch| batch.each(&block) }
+        else
+          self
+        end
+      end
+
+      # @api private
+      # @return [Enumerator<Batch>]
+      def batches(&block)
+        @operation.batches(@options)
+      end
+
+      # Specifies the maximum number of items to enumerate.
+      #
+      #     collection.limit(10).each do |resource|
+      #       # yields at most 10 times
+      #     end
+      #
+      # @param [Integer] limit The maximum number of items to yield
+      #   via {#each} or {#batches}.
+      # @return [Collection]
+      def limit(limit)
+        self.class.new(@operation, @options.merge(limit: limit))
+      end
+
+      # Returns the first resource from the collection.
+      #
+      #     resource = collection.first
+      #
+      # If you pass a count, then the first `count` resources are returned in
+      # a single batch. See the resource specific batch documentation for
+      # a list of supported batch methods.
+      #
+      #     resources = collection.first(10)
+      #     resources.delete
+      #
+      # @return [Resource, Batch]
+      def first(count = 1)
+        if count == 1
+          limit(1).to_a.first
+        else
+          Batch.new(resource_class, limit(count).to_a)
+        end
+      end
+
+      # @api private
+      def respond_to?(method_name, *args)
+        if resource_class.batch_operation_names.include?(method_name.to_sym)
+          true
+        else
+          super
+        end
+      end
+
+      # @api private
+      def method_missing(method_name, *args, &block)
+        if respond_to?(method_name)
+          Batch.validate_batch_args!(args)
+          batches.each do |batch|
+            batch.send(method_name, *args, &block)
+          end
+        else
+          super
+        end
+      end
+
+      # @api private
+      def inspect
+        parts = {}
+        parts[:type] = resource_class.name
+        parts[:limit] = @options[:limit]
+        parts[:params] = @options[:params] || {}
+        parts = parts.inject("") {|s,(k,v)| s << " #{k}=#{v.inspect}" }
+        ['#<', self.class.name, parts, '>'].join
+      end
+
+      private
+
+      # @api private
+      def limit_key
+        @operation.limit_key
+      end
+
+      def resource_class
+        @operation.builder.resource_class
+      end
+
+    end
+  end
+end