aws-sdk-code-generator 0.2.0.pre → 0.2.1.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4894f20ce7d85b716b2c70eb94ab224ae37262f9b325fec17fe45529cd0cf2fa
-  data.tar.gz: 5c0547128fce67627df4e291d97b6fd9a05eb7cd8e09431ba3ca5594dc5c5192
+  metadata.gz: a65077a940c697e439cae503d4683f5aec9dd5aee7a154b63f380543786d524c
+  data.tar.gz: 197c2c803eb600eb4d68f3b36a4ed0acec2effa7f3de11ec2dc610b610fd7765
 SHA512:
-  metadata.gz: 7857e3fd7e22f68d17cd4c9cff65e9d80f9e8e0bd526b2c4395bbf2d9f2f215f83694a56179844b46d7f9e302f2fb4eb90dbb810b182e4f001428ba0e3ba9fa5
-  data.tar.gz: 7c41c3cac485f1a10305f987db7861051d32fcd9f34eac72f32ec1ec0da9e157c5c00ddb302772d5ff8affc9eb8b51b1213492751084758a31fd6b40a9aa8714
+  metadata.gz: 0403d7112475a44303431fbb706b7aa7fbf2d5422cfb8ba3d9f240e13e85ea638f358e19d9678d16ea8b6f87745728a55fdf20193c86e504c3828c0f6476fb1f
+  data.tar.gz: e0623c91975e000b312db4d0106280b9655a0c1985e8684249dfd41171aeba38fe218ae88574e012b1d8a4879bfe03df3aa0515567fb05fe116c7567bb04e604

data/templates/apig_endpoint_class.mustache

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module {{module_name}}
+  module Plugins
+
+    class APIGEndpoint < Seahorse::Client::Plugin
+
+      def after_initialize(client)
+        if client.config.endpoint.nil?
+          client.config.endpoint = '{{default_endpoint}}'
+        end
+      end
+
+    end
+  end
+end

data/templates/apig_readme.mustache

@@ -0,0 +1,62 @@
+# {{service_name}}
+
+This is the Version {{gem_major_version}} of the {{gem_name}} gem.
+
+## WARNING
+
+Please read through this `README.md` and `{{gem_name}}.gemspec` then tailor it with your gem needs before serving it for any official usage or gem publishing. If you have any questions, issue or feature requests for this generated gem, feel free to open an issue or PR againt [`AWS SDK for Ruby`](https://github.com/aws/aws-sdk-ruby)
+
+## API Client
+
+Initialize a service client and list all operations available.
+
+```ruby
+require '{{gem_name}}'
+
+client = {{module_name}}::Client.new
+
+puts client.operation_names
+```
+
+For each operation usage example, see `lib/client.rb` documentation block per operation
+
+## Authorizer
+
+For operations used custom authorizer, you can provide your own authorizer token logic at `lib/plugins/authorizer.rb` under method `generate_token`. For more information, please see [here](http://docs.aws.amazon.com/apigateway/latest/developerguide/use-custom-authorizer.html).
+
+## AWS Credentials
+
+For those API requets that are authenticated with AWS Credentials (e.g. IAM roles), you would need to configure `:credentials` and `:region` that helps sigining request with [AWS Signature V4](http://docs.aws.amazon.com/general/latest/gr/signature-version-4.html). You can also provide those information via your environment:
+
+The SDK searches the following locations for credentials:
+
+* `ENV['AWS_ACCESS_KEY_ID']` and `ENV['AWS_SECRET_ACCESS_KEY']`
+* Unless `ENV['AWS_SDK_CONFIG_OPT_OUT']` is set, the shared configuration files (`~/.aws/credentials` and `~/.aws/config`) will be checked for a `role_arn` and `source_profile`, which if present will be used to attempt to assume a role.
+* The shared credentials ini file at `~/.aws/credentials` ([more information](http://blogs.aws.amazon.com/security/post/Tx3D6U6WSFGOK2H/A-New-and-Standardized-Way-to-Manage-Credentials-in-the-AWS-SDKs))
+* Unless `ENV['AWS_SDK_CONFIG_OPT_OUT']` is set, the shared configuration ini file at `~/.aws/config` will also be parsed for credentials.
+* From an instance profile when running on EC2, or from the ECS credential provider when running in an ECS container with that feature enabled.
+
+The SDK searches the following locations for a region:
+
+* `ENV['AWS_REGION']`
+* Unless `ENV['AWS_SDK_CONFIG_OPT_OUT']` is set, the shared configuration files (`~/.aws/credentials` and `~/.aws/config`) will also be checked for a region selection.
+
+Valid region and credentials options are:
+
+* `:region` - A string like `us-west-2`.
+* `:credentials` - An instance of one of the following classes:
+* [`Aws::Credentials`](http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Credentials.html)
+* [`Aws::SharedCredentials`](http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SharedCredentials.html)
+* [`Aws::InstanceProfileCredentials`](http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/InstanceProfileCredentials.html)
+* [`Aws::AssumeRoleCredentials`](http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/AssumeRoleCredentials.html)
+
+## API Key
+
+Simply provide an `:api_key` value when calling an API along with other params, this value will be picked up in the `x-api-key` header value.
+
+## License
+
+DEFAULT: This library is distributed under the
+[Apache License, version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
+
+Feel free to change your license specification here and at `{{gem_name}}.gemspec`

data/templates/async_client_class.mustache

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+if RUBY_VERSION >= '2.1'
+  begin
+    require 'http/2'
+  rescue LoadError; end
+end
+{{#plugin_requires}}
+require '{{.}}'
+{{/plugin_requires}}
+
+Aws::Plugins::GlobalConfiguration.add_identifier(:{{service_identifier}})
+
+module {{module_name}}
+  class AsyncClient < Seahorse::Client::AsyncBase
+
+    include Aws::AsyncClientStubs
+
+    @identifier = :{{service_identifier}}
+
+    set_api(ClientApi::API)
+
+    {{#plugin_class_names}}
+    add_plugin({{{.}}})
+    {{/plugin_class_names}}
+
+    {{#client_constructor}}
+    {{>documentation}}
+    {{/client_constructor}}
+    def initialize(*args)
+      unless Kernel.const_defined?("HTTP2")
+        raise "Must include http/2 gem to use AsyncClient instances."
+      end
+      super
+    end
+
+    # @!group API Operations
+    {{#operations}}
+
+    {{#documentation}}
+    {{>documentation}}
+    {{/documentation}}
+    # @overload {{name}}(params = {})
+    # @param [Hash] params ({})
+    def {{name}}(params = {}, options = {}{{{block_option}}})
+      params = params.dup
+      {{#eventstream_input}}
+      input_event_stream_handler = _event_stream_handler(
+        :input,
+        params.delete(:input_event_stream_handler),
+        EventStreams::{{input_eventstream_member}}
+      )
+      {{/eventstream_input}}
+      {{#eventstream_output}}
+      output_event_stream_handler = _event_stream_handler(
+        :output,
+        params.delete(:output_event_stream_handler) || params.delete(:event_stream_handler),
+        EventStreams::{{output_eventstream_member}}
+      )
+      {{/eventstream_output}}
+
+      yield({{#eventstream_output}}output_event_stream_handler{{/eventstream_output}}) if block_given?
+
+      req = build_request(:{{name}}, params)
+
+      {{#eventstream_input}}
+      req.context[:input_event_stream_handler] = input_event_stream_handler
+      req.handlers.add(Aws::Binary::EncodeHandler, priority: 95)
+      {{/eventstream_input}}
+      {{#eventstream_output}}
+      req.context[:output_event_stream_handler] = output_event_stream_handler
+      req.handlers.add(Aws::Binary::DecodeHandler, priority: 95)
+      {{/eventstream_output}}
+
+      req.send_request(options{{{block_option}}})
+    end
+    {{/operations}}
+
+    # @!endgroup
+
+    # @param params ({})
+    # @api private
+    def build_request(operation_name, params = {})
+      handlers = @handlers.for(operation_name)
+      context = Seahorse::Client::RequestContext.new(
+        operation_name: operation_name,
+        operation: config.api.operation(operation_name),
+        client: self,
+        params: params,
+        http_response: Seahorse::Client::Http::AsyncResponse.new,
+        config: config)
+      context[:gem_name] = '{{gem_name}}'
+      context[:gem_version] = '{{gem_version}}'
+      Seahorse::Client::Request.new(handlers, context)
+    end
+
+    private
+
+    def _event_stream_handler(type, handler, event_stream_class)
+      case handler
+      when event_stream_class then handler
+      when Proc then event_stream_class.new.tap(&handler)
+      when nil then event_stream_class.new
+      else
+        msg = "expected #{type}_event_stream_handler to be a block or "\
+              "instance of {{module_name}}::#{event_stream_class}"\
+              ", got `#{handler.inspect}` instead"
+        raise ArgumentError, msg
+      end
+    end
+
+    class << self
+
+      # @api private
+      attr_reader :identifier
+
+      # @api private
+      def errors_module
+        Errors
+      end
+
+    end
+  end
+end

data/templates/authorizer_class.mustache

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module {{module_name}}
+  module Plugins
+
+    # APIG Custom Authorizer, generated token will be used by API Gateway
+    # to interact with AWS Lambda for authentication
+    #
+    # More information see: http://docs.aws.amazon.com/apigateway/latest/developerguide/use-custom-authorizer.html
+    class Authorizer < Seahorse::Client::Plugin
+
+      def add_handlers(handlers, config)
+        handlers.add(CustomAuthHandler, step: :initialize)
+      end
+
+      # @api private
+      class CustomAuthHandler < Seahorse::Client::Handler
+
+        def call(context)
+          if context.operation['authtype'] == 'custom'
+            context.config.authorizer_token = generate_token(context)
+          end
+          @handler.call(context)
+        end
+
+        private
+
+        # TODO
+        # Provide your own token generation logic here
+        def generate_token(context)
+          nil
+        end
+
+      end
+    end
+  end
+end

data/templates/client_api_module.mustache

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+module {{module_name}}
+  # @api private
+  module ClientApi
+
+    include Seahorse::Model
+
+    {{#shapes}}
+    {{name}} = {{class_name}}.new({{{constructor_args}}})
+    {{/shapes}}
+
+    {{#shape_definitions}}
+    {{#lines}}
+    {{{.}}}{{/lines}}
+
+    {{/shape_definitions}}
+
+    # @api private
+    API = Seahorse::Model::Api.new.tap do |api|
+
+      api.version = "{{api_version}}"
+
+      api.metadata = {
+        {{#metadata}}
+        {{{key}}} => {{{value}}},
+        {{/metadata}}
+      }
+      {{#endpoint_operation}}
+      api.endpoint_operation = :{{endpoint_operation}}
+      {{/endpoint_operation}}
+      {{#require_endpoint_discovery}}
+      api.require_endpoint_discovery = true
+      {{/require_endpoint_discovery}}
+      {{#operations}}
+
+      api.add_operation(:{{method_name}}, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "{{name}}"
+        o.http_method = "{{http_method}}"
+        o.http_request_uri = "{{{http_request_uri}}}"
+        {{#http_checksum_required}}
+        o.http_checksum_required = true
+        {{/http_checksum_required}}
+        {{#deprecated}}
+        o.deprecated = true
+        {{/deprecated}}
+        {{#endpoint_operation}}
+        o.endpoint_operation = true
+        {{/endpoint_operation}}
+        {{#endpoint_discovery_available}}
+        o.endpoint_discovery = {
+          {{#endpoint_discovery}}
+          {{{key}}} => {{{value}}},
+          {{/endpoint_discovery}}
+        }
+        {{/endpoint_discovery_available}}
+        {{#authorizer}}
+        o.authorizer = "{{authorizer}}"
+        {{/authorizer}}
+        {{#authtype}}
+        o['authtype'] = "{{.}}"
+        {{/authtype}}
+        {{#endpoint_trait}}
+        o.endpoint_pattern = {
+          {{#endpoint_pattern}}
+          {{{key}}} => {{{value}}},
+          {{/endpoint_pattern}}
+        }
+        {{/endpoint_trait}}
+        {{#require_apikey}}
+        o.require_apikey = {{require_apikey}}
+        {{/require_apikey}}
+        {{#shape_references}}
+        {{#lines}}
+        {{{.}}}{{/lines}}
+        {{/shape_references}}
+        {{#error_shape_names}}
+        o.errors << Shapes::ShapeRef.new(shape: {{.}})
+        {{/error_shape_names}}
+        {{#pager}}
+        {{#lines}}
+        {{{.}}}{{/lines}}
+        {{/pager}}
+        {{#async}}
+        o.async = true
+        {{/async}}
+      end)
+      {{/operations}}
+      {{#apig_authorizer}}
+
+      api.add_authorizer(:{{authorizer_name}}, Seahorse::Model::Authorizer.new.tap do |a|
+        a.name = "{{name}}"{{#type}}
+        a.type = "{{type}}"{{/type}}{{#location}}
+        a.placement = {
+          :location => "{{location}}",
+          :name => "{{location_name}}"
+        }{{/location}}
+      end)
+      {{/apig_authorizer}}
+    end
+
+  end
+end

data/templates/client_class.mustache

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+{{#generated_src_warning}}
+{{generated_src_warning}}
+{{/generated_src_warning}}
+{{#plugin_requires}}
+require '{{.}}'
+{{/plugin_requires}}
+
+Aws::Plugins::GlobalConfiguration.add_identifier(:{{service_identifier}})
+
+module {{module_name}}
+  # An API client for {{service_name}}.  To construct a client, you need to configure a `:region` and `:credentials`.
+  #
+  #     client = {{module_name}}::Client.new(
+  #       region: region_name,
+  #       credentials: credentials,
+  #       # ...
+  #     )
+  #
+  # For details on configuring region and credentials see
+  # the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).
+  #
+  # See {#initialize} for a full list of supported configuration options.
+  class Client < Seahorse::Client::Base
+
+    include Aws::ClientStubs
+
+    @identifier = :{{service_identifier}}
+
+    set_api(ClientApi::API)
+
+    {{#plugin_class_names}}
+    add_plugin({{{.}}})
+    {{/plugin_class_names}}
+
+    {{#client_constructor}}
+    # @overload initialize(options)
+    #   @param [Hash] options
+    {{>documentation}}
+    #   @option options [URI::HTTP,String] :http_proxy A proxy to send
+    #     requests through.  Formatted like 'http://proxy.com:123'.
+    #
+    #   @option options [Float] :http_open_timeout (15) The number of
+    #     seconds to wait when opening a HTTP session before raising a
+    #     `Timeout::Error`.
+    #
+    #   @option options [Integer] :http_read_timeout (60) The default
+    #     number of seconds to wait for response data.  This value can
+    #     safely be set per-request on the session.
+    #
+    #   @option options [Float] :http_idle_timeout (5) The number of
+    #     seconds a connection is allowed to sit idle before it is
+    #     considered stale.  Stale connections are closed and removed
+    #     from the pool before making a request.
+    #
+    #   @option options [Float] :http_continue_timeout (1) The number of
+    #     seconds to wait for a 100-continue response before sending the
+    #     request body.  This option has no effect unless the request has
+    #     "Expect" header set to "100-continue".  Defaults to `nil` which
+    #     disables this behaviour.  This value can safely be set per
+    #     request on the session.
+    #
+    #   @option options [Boolean] :http_wire_trace (false) When `true`,
+    #     HTTP debug output will be sent to the `:logger`.
+    #
+    #   @option options [Boolean] :ssl_verify_peer (true) When `true`,
+    #     SSL peer certificates are verified when establishing a
+    #     connection.
+    #
+    #   @option options [String] :ssl_ca_bundle Full path to the SSL
+    #     certificate authority bundle file that should be used when
+    #     verifying peer certificates.  If you do not pass
+    #     `:ssl_ca_bundle` or `:ssl_ca_directory` the the system default
+    #     will be used if available.
+    #
+    #   @option options [String] :ssl_ca_directory Full path of the
+    #     directory that contains the unbundled SSL certificate
+    #     authority files for verifying peer certificates.  If you do
+    #     not pass `:ssl_ca_bundle` or `:ssl_ca_directory` the the
+    #     system default will be used if available.
+    #
+    {{/client_constructor}}
+    def initialize(*args)
+      super
+    end
+
+    # @!group API Operations
+    {{#operations}}
+
+    {{#documentation}}
+    {{>documentation}}
+    {{/documentation}}
+    # @overload {{name}}(params = {})
+    # @param [Hash] params ({})
+    def {{name}}(params = {}, options = {}{{{block_option}}})
+      {{#eventstream_output}}
+      params = params.dup
+      event_stream_handler = case handler = params.delete(:event_stream_handler)
+        when EventStreams::{{output_eventstream_member}} then handler
+        when Proc then EventStreams::{{output_eventstream_member}}.new.tap(&handler)
+        when nil then EventStreams::{{output_eventstream_member}}.new
+        else
+          msg = "expected :event_stream_handler to be a block or "\
+                "instance of {{module_name}}::EventStreams::{{output_eventstream_member}}"\
+                ", got `#{handler.inspect}` instead"
+          raise ArgumentError, msg
+        end
+
+      yield(event_stream_handler) if block_given?
+
+      {{/eventstream_output}}
+      req = build_request(:{{name}}, params)
+      {{#eventstream_output}}
+
+      req.context[:event_stream_handler] = event_stream_handler
+      req.handlers.add(Aws::Binary::DecodeHandler, priority: 95)
+
+      {{/eventstream_output}}
+      req.send_request(options{{{block_option}}})
+    end
+    {{/operations}}
+
+    # @!endgroup
+
+    # @param params ({})
+    # @api private
+    def build_request(operation_name, params = {})
+      handlers = @handlers.for(operation_name)
+      {{#authorizer?}}
+      authorizer = nil
+      if config.api.operation(operation_name).authorizer
+        authorizer_name = config.api.operation(operation_name).authorizer
+        config.api.authorizers.each do |_, auth|
+          authorizer = auth if auth.name == authorizer_name
+        end
+      end
+      {{/authorizer?}}
+      context = Seahorse::Client::RequestContext.new(
+        operation_name: operation_name,
+        operation: config.api.operation(operation_name),{{#authorizer?}}
+        authorizer: authorizer,{{/authorizer?}}
+        client: self,
+        params: params,
+        config: config)
+      context[:gem_name] = '{{gem_name}}'
+      context[:gem_version] = '{{gem_version}}'
+      Seahorse::Client::Request.new(handlers, context)
+    end
+    {{#waiters?}}
+
+    # Polls an API operation until a resource enters a desired state.
+    #
+    # ## Basic Usage
+    #
+    # A waiter will call an API operation until:
+    #
+    # * It is successful
+    # * It enters a terminal state
+    # * It makes the maximum number of attempts
+    #
+    # In between attempts, the waiter will sleep.
+    #
+    #     # polls in a loop, sleeping between attempts
+    #     client.wait_until(waiter_name, params)
+    #
+    # ## Configuration
+    #
+    # You can configure the maximum number of polling attempts, and the
+    # delay (in seconds) between each polling attempt. You can pass
+    # configuration as the final arguments hash.
+    #
+    #     # poll for ~25 seconds
+    #     client.wait_until(waiter_name, params, {
+    #       max_attempts: 5,
+    #       delay: 5,
+    #     })
+    #
+    # ## 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
+    #     client.wait_until(waiter_name, params, {
+    #
+    #       # disable max attempts
+    #       max_attempts: nil,
+    #
+    #       # poll for 1 hour, instead of a number of attempts
+    #       before_wait: -> (attempts, response) do
+    #         throw :failure if Time.now - started_at > 3600
+    #       end
+    #     })
+    #
+    # ## Handling Errors
+    #
+    # When a waiter is unsuccessful, it will raise an error.
+    # All of the failure errors extend from
+    # {Aws::Waiters::Errors::WaiterFailed}.
+    #
+    #     begin
+    #       client.wait_until(...)
+    #     rescue Aws::Waiters::Errors::WaiterFailed
+    #       # resource did not enter the desired state in time
+    #     end
+    #
+    # ## Valid Waiters
+    #
+    # The following table lists the valid waiter names, the operations they call,
+    # and the default `:delay` and `:max_attempts` values.
+    #
+    {{#waiters_markdown_table}}
+    {{#lines}}
+    # {{{.}}}{{/lines}}
+    {{/waiters_markdown_table}}
+    #
+    # @raise [Errors::FailureStateError] Raised when the waiter terminates
+    #   because the waiter has entered a state that it will not transition
+    #   out of, preventing success.
+    #
+    # @raise [Errors::TooManyAttemptsError] Raised when the configured
+    #   maximum number of attempts have been made, and the waiter is not
+    #   yet successful.
+    #
+    # @raise [Errors::UnexpectedError] Raised when an error is encounted
+    #   while polling for a resource that is not expected.
+    #
+    # @raise [Errors::NoSuchWaiterError] Raised when you request to wait
+    #   for an unknown state.
+    #
+    # @return [Boolean] Returns `true` if the waiter was successful.
+    # @param [Symbol] waiter_name
+    # @param [Hash] params ({})
+    # @param [Hash] options ({})
+    # @option options [Integer] :max_attempts
+    # @option options [Integer] :delay
+    # @option options [Proc] :before_attempt
+    # @option options [Proc] :before_wait
+    def wait_until(waiter_name, params = {}, options = {})
+      w = waiter(waiter_name, options)
+      yield(w.waiter) if block_given? # deprecated
+      w.wait(params)
+    end
+
+    # @api private
+    # @deprecated
+    def waiter_names
+      waiters.keys
+    end
+
+    private
+
+    # @param [Symbol] waiter_name
+    # @param [Hash] options ({})
+    def waiter(waiter_name, options = {})
+      waiter_class = waiters[waiter_name]
+      if waiter_class
+        waiter_class.new(options.merge(client: self))
+      else
+        raise Aws::Waiters::Errors::NoSuchWaiterError.new(waiter_name, waiters.keys)
+      end
+    end
+
+    def waiters
+      {
+        {{#waiters}}
+        {{name}}: Waiters::{{class_name}}{{^last}},{{/last}}
+        {{/waiters}}
+      }
+    end
+    {{/waiters?}}
+    {{^waiters?}}
+
+    # @api private
+    # @deprecated
+    def waiter_names
+      []
+    end
+    {{/waiters?}}
+
+    class << self
+
+      # @api private
+      attr_reader :identifier
+
+      # @api private
+      def errors_module
+        Errors
+      end
+
+    end
+  end
+end