aws-sdk-core 2.0.0.rc15 → 2.0.0.rc16

data/apis/OpsWorks.resources.json

@@ -0,0 +1,181 @@
+{
+  "service": {
+    "actions": {
+      "CreateStack": {
+        "request": {
+          "operation": "CreateStack"
+        },
+        "resource": {
+          "type": "Stack",
+          "identifiers": [
+            {
+              "target": "Id",
+              "sourceType": "responsePath",
+              "source": "StackId"
+            }
+          ]
+        }
+      }
+    },
+    "hasMany": {
+      "Stacks": {
+        "request": {
+          "operation": "DescribeStacks"
+        },
+        "resource": {
+          "type": "Stack",
+          "identifiers": [
+            {
+              "target": "Id",
+              "sourceType": "responsePath",
+              "source": "Stacks[].StackId"
+            }
+          ]
+        },
+        "path": "Stacks[]"
+      }
+    }
+  },
+  "resources": {
+    "Layer": {
+      "identifiers": [
+        { "name": "Id" }
+      ],
+      "shape": "Layer",
+      "load": {
+        "request": {
+          "operation": "DescribeLayers",
+          "params": [
+            {
+              "target": "LayerIds[]",
+              "sourceType": "identifier",
+              "source": "Id"
+            }
+          ]
+        },
+        "path": "Layers[0]"
+      },
+      "actions": {
+        "Delete": {
+          "request": {
+            "operation": "DeleteLayer",
+            "params": [
+              {
+                "target": "LayerId",
+                "sourceType": "identifier",
+                "source": "Id"
+              }
+            ]
+          }
+        }
+      },
+      "hasOne": {
+        "Stack": {
+          "resource": {
+            "type": "Stack",
+            "identifiers": [
+              {
+                "target": "Id",
+                "sourceType": "dataMember",
+                "source": "StackId"
+              }
+            ]
+          }
+        }
+      }
+    },
+    "Stack": {
+      "identifiers": [
+        { "name": "Id" }
+      ],
+      "shape": "Stack",
+      "load": {
+        "request": {
+          "operation": "DescribeStacks",
+          "params": [
+            {
+              "target": "StackIds[]",
+              "sourceType": "identifier",
+              "source": "Id"
+            }
+          ]
+        },
+        "path": "Stacks[0]"
+      },
+      "actions": {
+        "CreateLayer": {
+          "request": {
+            "operation": "CreateLayer",
+            "params": [
+              {
+                "target": "StackId",
+                "sourceType": "identifier",
+                "source": "Id"
+              }
+            ]
+          },
+          "resource": {
+            "type": "Layer",
+            "identifiers": [
+              {
+                "target": "Id",
+                "sourceType": "responsePath",
+                "source": "LayerId"
+              }
+            ]
+          }
+        },
+        "GetSummary": {
+          "request": {
+            "operation": "DescribeStackSummary",
+            "params": [
+              {
+                "target": "StackId",
+                "sourceType": "identifier",
+                "source": "Id"
+              }
+            ]
+          },
+          "path": "StackSummary"
+        },
+        "Delete": {
+          "request": {
+            "operation": "DeleteStack",
+            "params": [
+              {
+                "target": "StackId",
+                "sourceType": "identifier",
+                "source": "Id"
+              }
+            ]
+          }
+        }
+      },
+      "hasMany": {
+        "Layers": {
+          "request": {
+            "operation": "DescribeLayers",
+            "params": [
+              {
+                "target": "StackId",
+                "sourceType": "identifier",
+                "source": "Id"
+              }
+            ]
+          },
+          "resource": {
+            "type": "Layer",
+            "identifiers": [
+              {
+                "target": "Id",
+                "sourceType": "responsePath",
+                "source": "Layers[].LayerId"
+              }
+            ]
+          },
+          "path": "Layers[]"
+        }
+      }
+    }
+  }
+}

data/apis/S3.resources.json

@@ -521,7 +521,7 @@
         },
         "InitiateMultipartUpload": {
           "request": {
-            "operation": "InitiateMultipartUpload",
+            "operation": "CreateMultipartUpload",
             "params": [
               { "target":"Bucket", "sourceType":"identifier", "source":"BucketName" },
               { "target":"Key", "sourceType":"identifier", "source":"Key" }
@@ -547,7 +547,7 @@
         },
         "CopyFrom": {
           "request": {
-            "operation": "PutObjectCopy",
+            "operation": "CopyObject",
             "params": [
               { "target":"Bucket", "sourceType":"identifier", "source":"BucketName" },
               { "target":"Key", "sourceType":"identifier", "source":"Key" }
@@ -564,6 +564,17 @@
           }
         }
       },
+      "batchActions": {
+        "Delete": {
+          "request": {
+            "operation": "DeleteObjects",
+            "params": [
+              { "target":"Bucket", "sourceType":"identifier", "source":"BucketName" },
+              { "target":"Delete.Objects[].Key", "sourceType":"identifier", "source":"Key" }
+            ]
+          }
+        }
+      },
       "subResources": {
         "resources": [
           "ObjectAcl",

data/apis/SQS.resources.json

@@ -169,16 +169,6 @@
             ]
           }
         }
-      },
-      "hasOne": {
-        "Queue": {
-          "resource": {
-            "type":"Queue",
-            "identifiers": [
-              { "target":"Url", "sourceType":"identifier", "source":"QueueUrl" }
-            ]
-          }
-        }
       }
     }
   }

data/bin/aws.rb

@@ -94,6 +94,15 @@ end
 
 require 'aws-sdk-core'
 
+begin
+  # attempt to load aws-sdk-resources, checking first for source from
+  # a relative path in the repo, otherwise will check for the installed gem
+  lib = File.join(File.dirname(__FILE__), '..', '..', 'aws-sdk-resources', 'lib')
+  $LOAD_PATH.unshift(lib) if File.directory?(lib)
+  require 'aws-sdk-resources'
+rescue LoadError
+end
+
 # configure the aws-sdk gem
 
 cfg = {}

data/lib/aws.rb

@@ -33,6 +33,7 @@ module Aws
   module Api
     autoload :Customizer, "#{SRC}/api/customizer"
     autoload :Documenter, "#{SRC}/api/documenter"
+    autoload :Docstrings, "#{SRC}/api/docstrings"
     autoload :Manifest, "#{SRC}/api/manifest"
     autoload :ManifestBuilder, "#{SRC}/api/manifest_builder"
     autoload :OperationDocumenter, "#{SRC}/api/operation_documenter"
@@ -115,9 +116,17 @@ module Aws
     autoload :V4, "#{SRC}/signers/v4"
   end
 
+  module Waiters
+    autoload :Errors, "#{SRC}/waiters/errors"
+    autoload :NullProvider, "#{SRC}/waiters/null_provider"
+    autoload :Provider, "#{SRC}/waiters/provider"
+    autoload :Waiter, "#{SRC}/waiters/waiter"
+  end
+
   # @api private
   module Xml
     autoload :Builder, "#{SRC}/xml/builder"
+    autoload :DefaultList,  "#{SRC}/xml/default_list"
     autoload :ErrorHandler,  "#{SRC}/xml/error_handler"
     autoload :Parser, "#{SRC}/xml/parser"
     autoload :RestHandler, "#{SRC}/xml/rest_handler"
@@ -176,7 +185,6 @@ module Aws
 
     # @api private
     def load_json(path)
-      path = File.join(GEM_ROOT, path) unless path.match(/^#{File::SEPARATOR}/)
       MultiJson.load(File.open(path, 'r', encoding: 'UTF-8') { |f| f.read })
     end
 
@@ -246,6 +254,27 @@ module Aws
     svc_module.const_get(:Client).paginators = paginators
   end
 
+  # build service paginators
+  service_added do |name, svc_module, options|
+    waiters = options[:waiters]
+    waiters = case waiters
+      when Waiters::Provider then waiters
+      when Hash              then Waiters::Provider.new(waiters)
+      when String            then Waiters::Provider.new(Aws.load_json(waiters))
+      when nil               then Waiters::NullProvider.new
+      else raise ArgumentError, 'invalid :waiters option'
+    end
+    if name == 'S3'
+      # temporary workaround for issue with S3 waiter definition
+      defs = waiters.instance_variable_get("@definitions")
+      defs[:bucket_exists]['ignore_errors'] = ['NotFound']
+      defs[:object_exists]['ignore_errors'] = ['NotFound']
+      defs[:bucket_not_exists]['success_value'] = 'NotFound'
+      defs[:object_not_exists]['success_value'] = 'NotFound'
+    end
+    svc_module.const_get(:Client).waiters = waiters
+  end
+
   # deprecated = define helper method for client class, this will be
   # replaced eventually with a helper that returns a resource object
   # for the service.

data/lib/aws/api/docstrings.rb

@@ -0,0 +1,35 @@
+module Aws
+  module Api
+    # @api private
+    # This module loads the API documentation for the given API.
+    module Docstrings
+
+      def self.apply(client_class, path)
+        api = client_class.api.definition
+        docs = File.open(path, 'r', encoding: 'UTF-8') { |f| f.read }
+        docs = MultiJson.load(docs)
+
+        api['documentation'] = docs['service']
+
+        docs['operations'].each do |operation, doc|
+          api['operations'][operation]['documentation'] = doc
+        end
+
+        docs['shapes'].each do |shape_name, shape|
+          api['shapes'][shape_name]['documentation'] = shape['base']
+          shape['refs'].each do |ref,doc|
+            target_shape_name, member = ref.split('$')
+            target_shape = api['shapes'][target_shape_name]
+            case target_shape['type']
+            when 'structure' then target_shape['members'][member]['documentation'] = doc
+            when 'list' then target_shape[member]['documentation'] = doc
+            when 'map' then target_shape[member]['documentation'] = doc
+            else raise 'not handled'
+            end
+          end
+        end
+        client_class.set_api(Seahorse::Model::Api.new(api))
+      end
+    end
+  end
+end

data/lib/aws/api/documenter.rb

@@ -9,12 +9,12 @@ module Aws
         @svc_module = svc_module
         @svc_name = svc_module.name.split('::').last
         @client_class = svc_module.const_get(:Client)
+        Aws::Api::Docstrings.apply(@client_class, docs_path)
         @api = @client_class.api
         @full_name = @api.metadata('serviceFullName')
         @error_names = @api.operations.map {|_,o| o.errors.map(&:name) }
         @error_names = @error_names.flatten.uniq.sort
         @namespace = YARD::Registry['Aws']
-        apply_docstrings(docs_path)
       end
 
       def apply
@@ -73,6 +73,7 @@ module Aws
         yard_class.docstring = client_docstring
         document_client_constructor(yard_class)
         document_client_operations(yard_class)
+        document_client_waiters(yard_class)
       end
 
       def client_docstring
@@ -167,6 +168,35 @@ Constructs an API client.
         DOCSTRING
       end
 
+      def document_client_waiters(yard_class)
+        m = YARD::CodeObjects::MethodObject.new(yard_class, :wait_until)
+        m.scope = :instance
+        m.parameters << ['waiter_name', nil]
+        m.parameters << ['params', '{}']
+        m.docstring = YARD::Registry['Aws::Client#wait_until'].docstring
+
+        waiters = @client_class.waiters.waiter_names.sort.inject('') do |w,name|
+          operation = @client_class.waiters.waiter(name).send(:operation_name)
+          w << "<tr><td><tt>:#{name}</tt></td><td>{##{operation}}</td></tr>"
+        end
+        docstring = <<-DOCSTRING
+Returns the list of supported waiters. The following table lists the supported
+waiters and the client method they call:
+<table>
+<thead>
+<tr><th>Waiter Name</th><th>Client Method</th></tr>
+</thead>
+<tbody>
+#{waiters}
+</tbody>
+</table>
+@return [Array<Symbol>] the list of supported waiters.
+        DOCSTRING
+        m = YARD::CodeObjects::MethodObject.new(yard_class, :waiter_names)
+        m.scope = :instance
+        m.docstring = docstring
+      end
+
       class Tabulator
 
         def initialize
@@ -202,33 +232,6 @@ Constructs an API client.
 
       end
 
-      def apply_docstrings(path)
-        docs = MultiJson.load(read(path))
-        api = @api.definition
-
-        api['documentation'] = docs['service']
-
-        docs['operations'].each do |operation, doc|
-          api['operations'][operation]['documentation'] = doc
-        end
-
-        docs['shapes'].each do |shape_name, shape|
-          api['shapes'][shape_name]['documentation'] = shape['base']
-          shape['refs'].each do |ref,doc|
-            target_shape_name, member = ref.split('$')
-            target_shape = api['shapes'][target_shape_name]
-            case target_shape['type']
-            when 'structure' then target_shape['members'][member]['documentation'] = doc
-            when 'list' then target_shape[member]['documentation'] = doc
-            when 'map' then target_shape[member]['documentation'] = doc
-            else raise 'not handled'
-            end
-          end
-        end
-
-        @api = Seahorse::Model::Api.new(api)
-      end
-
       def read(path)
         File.open(path, 'r', encoding: 'UTF-8') { |f| f.read }
       end

data/lib/aws/client.rb

@@ -2,6 +2,85 @@ module Aws
 
   # Base class for all {Aws} service clients.
   class Client < Seahorse::Client::Base
+
+    # Waits until a particular condition is satisfied. This works by
+    # polling a client request and checking for particular response
+    # data or errors. Waiters each have a default duration max attempts
+    # which are configurable.  Additionally, you can register callbacks
+    # and stop waiters by throwing `:success` or `:failure`.
+    #
+    # @example Basic usage
+    #   client.wait_until(:waiter_name)
+    #
+    # @example Configuring interval and maximum attempts
+    #   client.wait_until(:waiter_name) do |w|
+    #     w.interval = 10    # number of seconds to sleep between attempts
+    #     w.max_attempts = 6 # maximum number of polling attempts
+    #   end
+    #
+    # @example Rescuing a failed wait
+    #   begin
+    #     client.wait_until(:waiter_name)
+    #   rescue Aws::Waiters::Errors::WaiterFailed
+    #     # gave up waiting
+    #   end
+    #
+    # @example Waiting with progress callbacks
+    #   client.wait_until(:waiter_name) do |w|
+    #
+    #     # yields just before polling for change
+    #     w.before_attempt do |attempt|
+    #       # attempts - number of previous attempts made
+    #     end
+    #
+    #     # yields before sleeping
+    #     w.before_wait do |attempt, prev_response|
+    #       # attempts - number of previous attempts made
+    #       # prev_response - the last client response received
+    #     end
+    #   end
+    #
+    # @example Throw :success or :failure to terminate early
+    #   # wait for an hour, not for a number of requests
+    #   client.wait_until(:waiter_name) do |waiter|
+    #     one_hour = Time.now + 3600
+    #     waiter.max_attempts = nil
+    #     waiter.before_attempt do |attempt|
+    #       throw(:failure, 'waited to long') if Time.now > one_hour
+    #     end
+    #   end
+    #
+    # @param [Symbol] waiter_name The name of the waiter. See {#waiter_names}
+    #   for a full list of supported waiters.
+    # @param [Hash] params Additional request parameters. See the {#waiter_names}
+    #   for a list of supported waiters and what request they call. The
+    #   called request determines the list of accepted parameters.
+    # @return [Seahorse::Client::Response] Returns the client response from
+    #   the successful polling request. If `:success` is thrown from a callback,
+    #   then the 2nd argument to `#throw` is returned.
+    # @yieldparam [Waiters::Waiter] waiter Yields a {Waiters::Waiter Waiter} 
+    #   object that can be configured prior to waiting.
+    # @raise [Waiters::Errors::NoSuchWaiter] Raised when the named waiter
+    #   is not defined.
+    # @raise [Waiters::Errors::WaiterFailed] Raised when one of the
+    #   following conditions is met:
+    #
+    #   * A failure condition is detected
+    #   * The maximum number of attempts has been made without success
+    #   * `:failure` is thrown from a callback
+    #
+    def wait_until(waiter_name, params = {}, &block)
+      waiter = self.class.waiters.waiter(waiter_name)
+      yield(waiter) if block_given?
+      waiter.wait(self, params)
+    end
+
+    # Returns the list of supported waiters.
+    # @return [Array<Symbol>]
+    def waiter_names
+      self.class.waiters.waiter_names
+    end
+
     class << self
 
       # @return [Symbol]
@@ -12,6 +91,10 @@ module Aws
       # @api private
       attr_accessor :paginators
 
+      # @return [Waiters::Provider]
+      # @api private
+      attr_accessor :waiters
+
       # @api private
       def define(svc_name, options)
         client_class = Class.new(self)