lambda_wrap 0.14.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a768d452eb54ba635015184a2aca9df160b8e3e7
-  data.tar.gz: bf2f039cdedc097c13dc99088081ccdafcf186d8
+  metadata.gz: 79ae4cfdc2ed44b009d04a29372cb322ed040130
+  data.tar.gz: ebda47ad69d8a654f692889ef1244e97322edd96
 SHA512:
-  metadata.gz: f7ada31848484a06eac240266a0f43e27f218556ff25648f3b00c1c160d92f60cde8725c2f7dd95dc033b74efe90552f161cdb5f15b63007e941ccf852959e7d
-  data.tar.gz: ee600ffb27b596f93b799ce68d1ccc53d2b4068cb2d94c20c0b7460d2ef911ae97ec653da81bbd54c54b514a20c15a1d3c1c9e0d3b142667ba243f4892a50adc
+  metadata.gz: 5be6e9c59c7d93797b868e12dba43aa2f44d2e4e000c8da59edb222c36e17b1ece6cd830b0a03bf5a36962ee0eeea63cd31c72f25da1bcc6c3380ebba284a31b
+  data.tar.gz: b36aeade9223a9dac371dfc544a998dbee00a1c5ef0456aa51a84bc9b39e1704b970aef166ac9a645d4d9e03cf0304094697b6ea2e469b3b57da15979e09d50d

data/lib/lambda_wrap.rb

@@ -1,5 +1,5 @@
-# :nodoc:
-Dir["#{File.expand_path(File.dirname(__FILE__))}/**/*.rb"].each { |f| require f }
-
-STDOUT.sync = true
-STDERR.sync = true
+# :nodoc:
+Dir["#{File.expand_path(File.dirname(__FILE__))}/**/*.rb"].each { |f| require f }
+
+STDOUT.sync = true
+STDERR.sync = true

data/lib/lambda_wrap/api_gateway_manager.rb

@@ -1,155 +1,158 @@
-require 'aws-sdk'
-
-module LambdaWrap
-  # The ApiGatewayManager simplifies downloading the aws-apigateway-importer binary,
-  # importing a {swagger configuration}[http://swagger.io], and managing API Gateway stages.
-
-  # Note: The concept of an environment of the LambdaWrap gem matches a stage in AWS ApiGateway terms.
-  class ApiGatewayManager
-    #
-    # The constructor does some basic setup
-    # * Validating basic AWS configuration
-    # * Creating the underlying client to interact with the AWS SDK.
-    # * Defining the temporary path of the api-gateway-importer jar file
-    def initialize
-      # AWS api gateway client
-      @client = Aws::APIGateway::Client.new
-      # path to apigateway-importer jar
-      @jarpath = File.join(Dir.tmpdir, 'aws-apigateway-importer-1.0.3-SNAPSHOT-jar-with-dependencies.jar')
-      @versionpath = File.join(Dir.tmpdir, 'aws-apigateway-importer-1.0.3-SNAPSHOT-jar-with-dependencies.s3version')
-    end
-
-    ##
-    # Downloads the aws-apigateway-importer jar from an S3 bucket.
-    # This is a workaround since aws-apigateway-importer does not provide a binary.
-    # Once a binary is available on the public internet, we'll start using this instead
-    # of requiring users of this gem to upload their custom binary to an S3 bucket.
-    #
-    # *Arguments*
-    # [s3_bucket]		An S3 bucket from where the aws-apigateway-importer binary can be downloaded.
-    # [s3_key]			The path (key) to the aws-apigateay-importer binary on the s3 bucket.
-    def download_apigateway_importer(s3_bucket, s3_key)
-      s3 = Aws::S3::Client.new
-
-      # current version
-      current_s3_version = File.open(@versionpath, 'rb').read if File.exist?(@versionpath)
-
-      # online s3 version
-      desired_s3_version = s3.head_object(bucket: s3_bucket, key: s3_key).version_id
-
-      # compare local with remote version
-      if current_s3_version != desired_s3_version || !File.exist?(@jarpath)
-        puts "Downloading aws-apigateway-importer jar with S3 version #{desired_s3_version}"
-        s3.get_object(response_target: @jarpath, bucket: s3_bucket, key: s3_key)
-        File.write(@versionpath, desired_s3_version)
-      end
-    end
-
-    ##
-    # Sets up the API gateway by searching whether the API Gateway already exists
-    # and updates it with the latest information from the swagger file.
-    #
-    # *Arguments*
-    # [api_name]		The name of the API to which the swagger file should be applied to.
-    # [env]				The environment where it should be published (which is matching an API gateway stage)
-    # [swagger_file]	A handle to a swagger file that should be used by aws-apigateway-importer
-    # [api_description]	The description of the API to be displayed.
-    # [stage_variables] A Hash of stage variables to be deployed with the stage. Adds an 'environment' by default.
-    # [region] The region to deploy the API. Defaults to what is set as an environment variable.
-    def setup_apigateway(api_name, env, swagger_file, api_description = 'Deployed with LambdaWrap',
-                         stage_variables = {}, region = ENV['AWS_REGION'])
-      # ensure API is created
-      api_id = get_existing_rest_api(api_name)
-      api_id = setup_apigateway_create_rest_api(api_name, api_description) unless api_id
-
-      # create resources
-      setup_apigateway_create_resources(api_id, swagger_file, region)
-
-      # create stages
-      stage_variables.store('environment', env)
-      create_stages(api_id, env, stage_variables)
-
-      # return URI of created stage
-      "https://#{api_id}.execute-api.#{region}.amazonaws.com/#{env}/"
-    end
-
-    ##
-    # Shuts down an environment from the API Gateway. This basically deletes the stage
-    # from the API Gateway, but does not delete the API Gateway itself.
-    #
-    # *Argument*
-    # [api_name]		The name of the API where the environment should be shut down.
-    # [env]				The environment (matching an API Gateway stage) to shutdown.
-    def shutdown_apigateway(api_name, env)
-      api_id = get_existing_rest_api(api_name)
-      delete_stage(api_id, env)
-    end
-
-    ##
-    # Gets the ID of an existing API Gateway api, or nil if it doesn't exist
-    #
-    # *Arguments*
-    # [api_name]		The name of the API to be checked for existance
-    def get_existing_rest_api(api_name)
-      apis = @client.get_rest_apis(limit: 500).data
-      api = apis.items.select { |a| a.name == api_name }.first
-
-      return api.id if api
-      # nil is returned otherwise
-    end
-
-    ##
-    # Creates the API with a given name and returns the id
-    #
-    # *Arguments*
-    # [api_name]		The name of the API to be created
-    def setup_apigateway_create_rest_api(api_name, api_description)
-      puts 'Creating API with name ' + api_name
-      api = @client.create_rest_api(name: api_name, description: api_description)
-      api.id
-    end
-
-    ##
-    # Invokes the aws-apigateway-importer jar with the required parameter
-    #
-    # *Arguments*
-    # [api_id]			The AWS ApiGateway id where the swagger file should be applied to.
-    # [swagger_file]	The handle to a swagger definition file that should be imported into API Gateway
-    def setup_apigateway_create_resources(api_id, swagger_file, region)
-      raise 'API ID not provided' unless api_id
-
-      cmd = "java -jar #{@jarpath} --update #{api_id} --region #{region} #{swagger_file}"
-      raise 'API gateway not created' unless system(cmd)
-    end
-
-    ##
-    # Creates a stage of the currently set resources
-    #
-    # *Arguments*
-    # [api_id]			The AWS ApiGateway id where the stage should be created at.
-    # [env]				The environment (which matches the stage in API Gateway) to create.
-    def create_stages(api_id, env, stage_variables)
-      deployment_description = 'Deployment of service to ' + env
-      deployment = @client.create_deployment(
-        rest_api_id: api_id, stage_name: env, cache_cluster_enabled: false, description: deployment_description,
-        variables: stage_variables
-      ).data
-      puts deployment
-    end
-
-    ##
-    # Deletes a stage of the API Gateway
-    #
-    # *Arguments*
-    # [api_id]			The AWS ApiGateway id from which the stage should be deleted from.
-    # [env]				The environment (which matches the stage in API Gateway) to delete.
-    def delete_stage(_, env)
-      puts 'Deleted API gateway stage ' + env
-    rescue Aws::APIGateway::Errors::NotFoundException
-      puts 'API Gateway stage ' + env + ' does not exist. Nothing to delete.'
-    end
-
-    private :get_existing_rest_api, :setup_apigateway_create_rest_api, :setup_apigateway_create_resources,
-            :create_stages, :delete_stage
-  end
-end
+require 'aws-sdk'
+
+module LambdaWrap
+  # The ApiGatewayManager simplifies downloading the aws-apigateway-importer binary,
+  # importing a {swagger configuration}[http://swagger.io], and managing API Gateway stages.
+
+  # Note: The concept of an environment of the LambdaWrap gem matches a stage in AWS ApiGateway terms.
+  class ApiGatewayManager
+    #
+    # The constructor does some basic setup
+    # * Validating basic AWS configuration
+    # * Creating the underlying client to interact with the AWS SDK.
+    # * Defining the temporary path of the api-gateway-importer jar file
+    def initialize
+      # AWS api gateway client
+      @client = Aws::APIGateway::Client.new
+      # path to apigateway-importer jar
+      @jarpath = File.join(Dir.tmpdir, 'aws-apigateway-importer-1.0.3-SNAPSHOT-jar-with-dependencies.jar')
+      @versionpath = File.join(Dir.tmpdir, 'aws-apigateway-importer-1.0.3-SNAPSHOT-jar-with-dependencies.s3version')
+    end
+
+    ##
+    # Downloads the aws-apigateway-importer jar from an S3 bucket.
+    # This is a workaround since aws-apigateway-importer does not provide a binary.
+    # Once a binary is available on the public internet, we'll start using this instead
+    # of requiring users of this gem to upload their custom binary to an S3 bucket.
+    #
+    # *Arguments*
+    # [s3_bucket]		An S3 bucket from where the aws-apigateway-importer binary can be downloaded.
+    # [s3_key]			The path (key) to the aws-apigateay-importer binary on the s3 bucket.
+    def download_apigateway_importer(s3_bucket, s3_key)
+      s3 = Aws::S3::Client.new
+
+      # current version
+      current_s3_version = File.open(@versionpath, 'rb').read if File.exist?(@versionpath)
+
+      # online s3 version
+      desired_s3_version = s3.head_object(bucket: s3_bucket, key: s3_key).version_id
+
+      # compare local with remote version
+      if current_s3_version != desired_s3_version || !File.exist?(@jarpath)
+        puts "Downloading aws-apigateway-importer jar with S3 version #{desired_s3_version}"
+        s3.get_object(response_target: @jarpath, bucket: s3_bucket, key: s3_key)
+        File.write(@versionpath, desired_s3_version)
+      end
+    end
+
+    ##
+    # Sets up the API gateway by searching whether the API Gateway already exists
+    # and updates it with the latest information from the swagger file.
+    #
+    # *Arguments*
+    # [api_name]		The name of the API to which the swagger file should be applied to.
+    # [env]				The environment where it should be published (which is matching an API gateway stage)
+    # [swagger_file]	A handle to a swagger file that should be used by aws-apigateway-importer
+    # [api_description]	The description of the API to be displayed.
+    # [stage_variables] A Hash of stage variables to be deployed with the stage. Adds an 'environment' by default.
+    # [region] The region to deploy the API. Defaults to what is set as an environment variable.
+    def setup_apigateway(api_name, env, swagger_file, api_description = 'Deployed with LambdaWrap',
+                         stage_variables = {}, region = ENV['AWS_REGION'])
+      # ensure API is created
+      api_id = get_existing_rest_api(api_name)
+      api_id = setup_apigateway_create_rest_api(api_name, api_description) unless api_id
+
+      # create resources
+      setup_apigateway_create_resources(api_id, swagger_file, region)
+
+      # create stages
+      stage_variables.store('environment', env)
+      create_stages(api_id, env, stage_variables)
+
+      # return URI of created stage
+      "https://#{api_id}.execute-api.#{region}.amazonaws.com/#{env}/"
+    end
+
+    ##
+    # Shuts down an environment from the API Gateway. This basically deletes the stage
+    # from the API Gateway, but does not delete the API Gateway itself.
+    #
+    # *Argument*
+    # [api_name]		The name of the API where the environment should be shut down.
+    # [env]				The environment (matching an API Gateway stage) to shutdown.
+    def shutdown_apigateway(api_name, env)
+      api_id = get_existing_rest_api(api_name)
+      delete_stage(api_id, env)
+    end
+
+    ##
+    # Gets the ID of an existing API Gateway api, or nil if it doesn't exist
+    #
+    # *Arguments*
+    # [api_name]		The name of the API to be checked for existance
+    def get_existing_rest_api(api_name)
+      apis = @client.get_rest_apis(limit: 500).data
+      api = apis.items.select { |a| a.name == api_name }.first
+
+      return api.id if api
+      # nil is returned otherwise
+    end
+
+    ##
+    # Creates the API with a given name and returns the id
+    #
+    # *Arguments*
+    # [api_name]		The name of the API to be created
+    def setup_apigateway_create_rest_api(api_name, api_description)
+      puts 'Creating API with name ' + api_name
+      api = @client.create_rest_api(name: api_name, description: api_description)
+      api.id
+    end
+
+    ##
+    # Invokes the aws-apigateway-importer jar with the required parameter
+    #
+    # *Arguments*
+    # [api_id]			The AWS ApiGateway id where the swagger file should be applied to.
+    # [swagger_file]	The handle to a swagger definition file that should be imported into API Gateway
+    def setup_apigateway_create_resources(api_id, swagger_file, region)
+      raise 'API ID not provided' unless api_id
+
+      cmd = "java -jar #{@jarpath} --update #{api_id} --region #{region} #{swagger_file}"
+      raise 'API gateway not created' unless system(cmd)
+    end
+
+    ##
+    # Creates a stage of the currently set resources
+    #
+    # *Arguments*
+    # [api_id]			The AWS ApiGateway id where the stage should be created at.
+    # [env]				The environment (which matches the stage in API Gateway) to create.
+    def create_stages(api_id, env, stage_variables)
+      deployment_description = 'Deployment of service to ' + env
+      deployment = @client.create_deployment(
+        rest_api_id: api_id, stage_name: env, cache_cluster_enabled: false, description: deployment_description,
+        variables: stage_variables
+      ).data
+      puts deployment
+    end
+
+    ##
+    # Deletes a stage of the API Gateway
+    #
+    # *Arguments*
+    # [api_id]			The AWS ApiGateway id from which the stage should be deleted from.
+    # [env]				The environment (which matches the stage in API Gateway) to delete.
+    def delete_stage(api_id, env)
+      begin
+        @client.delete_stage({rest_api_id: api_id, stage_name: env})
+        puts 'Deleted API gateway stage ' + env
+      rescue Aws::APIGateway::Errors::NotFoundException
+        puts 'API Gateway stage ' + env + ' does not exist. Nothing to delete.'
+      end
+    end
+
+    private :get_existing_rest_api, :setup_apigateway_create_rest_api, :setup_apigateway_create_resources,
+            :create_stages, :delete_stage
+  end
+end

data/lib/lambda_wrap/dynamo_db_manager.rb

@@ -1,121 +1,121 @@
-require 'aws-sdk'
-
-module LambdaWrap
-  # The DynamoDBManager simplifies setting up and destroying a DynamoDB database.
-  #
-  # Note: In case an environment specific DynamoDB tablename such as +<baseTableName>-production+ should be used, then
-  # it has to be injected directly to the methods since not all environments necessarily need separated databases.
-  class DynamoDbManager
-    ##
-    # The constructor does some basic setup
-    # * Validating basic AWS configuration
-    # * Creating the underlying client to interact with the AWS SDK.
-    def initialize
-      # AWS dynamodb client
-      @client = Aws::DynamoDB::Client.new
-    end
-
-    def set_table_capacity(table_name, read_capacity, write_capacity)
-      puts "Updating new read/write capacity for table #{table_name}.
-       Read #{table_details.provisioned_throughput.read_capacity_units} ==> #{read_capacity}.
-       Write #{table_details.provisioned_throughput.write_capacity_units} ==> #{write_capacity}."
-      @client.update_table(
-        table_name: table_name,
-        provisioned_throughput: { read_capacity_units: read_capacity, write_capacity_units: write_capacity }
-      )
-    end
-
-    ##
-    # Publishes the database and awaits until it is fully available. If the table already exists,
-    # it only adjusts the read and write
-    # capacities upwards (it doesn't downgrade them to avoid a production environment being impacted with
-    # a default setting of an automated script).
-    #
-    # *Arguments*
-    # [table_name]        The table name of the dynamoDB to be created.
-    # [attribute_definitions]  The dynamoDB attribute definitions to be used when the table is created.
-    # [key_schema]        The dynamoDB key definitions to be used when the table is created.
-    # [read_capacity]      The read capacity to configure for the dynamoDB table.
-    # [write_capacity]      The write capacity to configure for the dynamoDB table.
-    def publish_database(table_name, attribute_definitions, key_schema, read_capacity, write_capacity)
-      has_updates = false
-
-      # figure out whether the table exists
-      begin
-        table_details = @client.describe_table(table_name: table_name).table
-      rescue Aws::DynamoDB::Errors::ResourceNotFoundException
-        # skip this exception because we are using it for control flow.
-        table_details = nil
-      end
-
-      if table_details
-        wait_until_table_available(table_name) if table_details.table_status != 'ACTIVE'
-
-        if read_capacity > table_details.provisioned_throughput.read_capacity_units ||
-           write_capacity > table_details.provisioned_throughput.write_capacity_units
-
-          set_table_capacity read_capacity, write_capacity
-          has_updates = true
-        else
-          puts "Table #{table_name} already exists and the desired read capacity of #{read_capacity} and " \
-          "write capacity of #{write_capacity} has at least been configured. Downgrading capacity units is not " \
-          'supported. No changes were applied.'
-        end
-      else
-        puts "Creating table #{table_name}."
-        ad = attribute_definitions || [{ attribute_name: 'Id', attribute_type: 'S' }]
-        ks = key_schema || [{ attribute_name: 'Id', key_type: 'HASH' }]
-        @client.create_table(table_name: table_name, key_schema: ks, attribute_definitions: ad,
-                             provisioned_throughput:
-                               { read_capacity_units: read_capacity, write_capacity_units: write_capacity })
-        has_updates = true
-      end
-
-      if has_updates
-        wait_until_table_available(table_name)
-        puts "DynamoDB table #{table_name} is now fully available."
-      end
-    end
-
-    ##
-    # Deletes a DynamoDB table. It does not wait until the table has been deleted.
-    #
-    # *Arguments*
-    # [table_name]  The dynamoDB table name to delete.
-    def delete_database(table_name)
-      table_details = @client.describe_table(table_name: table_name).table
-      wait_until_table_available(table_name) if table_details.table_status != 'ACTIVE'
-      @client.delete_table(table_name: table_name)
-    rescue Aws::DynamoDB::Errors::ResourceNotFoundException
-      puts 'Table did not exist. Nothing to delete.'
-    end
-
-    ##
-    # Awaits a given status of a table.
-    #
-    # *Arguments*
-    # [table_name]  The dynamoDB table name to watch until it reaches an active status.
-    def wait_until_table_available(table_name)
-      max_attempts = 24
-      delay_between_attempts = 5
-
-      # wait until the table has updated to being fully available
-      # waiting for ~2min at most; an error will be thrown afterwards
-      begin
-        @client.wait_until(:table_exists, table_name: table_name) do |w|
-          w.max_attempts = max_attempts
-          w.delay = delay_between_attempts
-          w.before_wait do |attempts, _|
-            puts "Waiting until table becomes available. Attempt #{attempts}/#{max_attempts} " \
-                 "with polling interval #{delay_between_attempts}."
-          end
-        end
-      rescue Aws::Waiters::Errors::TooManyAttemptsError => e
-        puts "Table #{table_name} did not become available after #{e.attempts} attempts. " \
-        'Try again later or inspect the AWS console.'
-      end
-    end
-
-    private :wait_until_table_available
-  end
-end
+require 'aws-sdk'
+
+module LambdaWrap
+  # The DynamoDBManager simplifies setting up and destroying a DynamoDB database.
+  #
+  # Note: In case an environment specific DynamoDB tablename such as +<baseTableName>-production+ should be used, then
+  # it has to be injected directly to the methods since not all environments necessarily need separated databases.
+  class DynamoDbManager
+    ##
+    # The constructor does some basic setup
+    # * Validating basic AWS configuration
+    # * Creating the underlying client to interact with the AWS SDK.
+    def initialize
+      # AWS dynamodb client
+      @client = Aws::DynamoDB::Client.new
+    end
+
+    def set_table_capacity(table_name, read_capacity, write_capacity)
+      puts "Updating new read/write capacity for table #{table_name}.
+       Read #{table_details.provisioned_throughput.read_capacity_units} ==> #{read_capacity}.
+       Write #{table_details.provisioned_throughput.write_capacity_units} ==> #{write_capacity}."
+      @client.update_table(
+        table_name: table_name,
+        provisioned_throughput: { read_capacity_units: read_capacity, write_capacity_units: write_capacity }
+      )
+    end
+
+    ##
+    # Publishes the database and awaits until it is fully available. If the table already exists,
+    # it only adjusts the read and write
+    # capacities upwards (it doesn't downgrade them to avoid a production environment being impacted with
+    # a default setting of an automated script).
+    #
+    # *Arguments*
+    # [table_name]        The table name of the dynamoDB to be created.
+    # [attribute_definitions]  The dynamoDB attribute definitions to be used when the table is created.
+    # [key_schema]        The dynamoDB key definitions to be used when the table is created.
+    # [read_capacity]      The read capacity to configure for the dynamoDB table.
+    # [write_capacity]      The write capacity to configure for the dynamoDB table.
+    def publish_database(table_name, attribute_definitions, key_schema, read_capacity, write_capacity)
+      has_updates = false
+
+      # figure out whether the table exists
+      begin
+        table_details = @client.describe_table(table_name: table_name).table
+      rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+        # skip this exception because we are using it for control flow.
+        table_details = nil
+      end
+
+      if table_details
+        wait_until_table_available(table_name) if table_details.table_status != 'ACTIVE'
+
+        if read_capacity > table_details.provisioned_throughput.read_capacity_units ||
+           write_capacity > table_details.provisioned_throughput.write_capacity_units
+
+          set_table_capacity read_capacity, write_capacity
+          has_updates = true
+        else
+          puts "Table #{table_name} already exists and the desired read capacity of #{read_capacity} and " \
+          "write capacity of #{write_capacity} has at least been configured. Downgrading capacity units is not " \
+          'supported. No changes were applied.'
+        end
+      else
+        puts "Creating table #{table_name}."
+        ad = attribute_definitions || [{ attribute_name: 'Id', attribute_type: 'S' }]
+        ks = key_schema || [{ attribute_name: 'Id', key_type: 'HASH' }]
+        @client.create_table(table_name: table_name, key_schema: ks, attribute_definitions: ad,
+                             provisioned_throughput:
+                               { read_capacity_units: read_capacity, write_capacity_units: write_capacity })
+        has_updates = true
+      end
+
+      if has_updates
+        wait_until_table_available(table_name)
+        puts "DynamoDB table #{table_name} is now fully available."
+      end
+    end
+
+    ##
+    # Deletes a DynamoDB table. It does not wait until the table has been deleted.
+    #
+    # *Arguments*
+    # [table_name]  The dynamoDB table name to delete.
+    def delete_database(table_name)
+      table_details = @client.describe_table(table_name: table_name).table
+      wait_until_table_available(table_name) if table_details.table_status != 'ACTIVE'
+      @client.delete_table(table_name: table_name)
+    rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+      puts 'Table did not exist. Nothing to delete.'
+    end
+
+    ##
+    # Awaits a given status of a table.
+    #
+    # *Arguments*
+    # [table_name]  The dynamoDB table name to watch until it reaches an active status.
+    def wait_until_table_available(table_name)
+      max_attempts = 24
+      delay_between_attempts = 5
+
+      # wait until the table has updated to being fully available
+      # waiting for ~2min at most; an error will be thrown afterwards
+      begin
+        @client.wait_until(:table_exists, table_name: table_name) do |w|
+          w.max_attempts = max_attempts
+          w.delay = delay_between_attempts
+          w.before_wait do |attempts, _|
+            puts "Waiting until table becomes available. Attempt #{attempts}/#{max_attempts} " \
+                 "with polling interval #{delay_between_attempts}."
+          end
+        end
+      rescue Aws::Waiters::Errors::TooManyAttemptsError => e
+        puts "Table #{table_name} did not become available after #{e.attempts} attempts. " \
+        'Try again later or inspect the AWS console.'
+      end
+    end
+
+    private :wait_until_table_available
+  end
+end

data/lib/lambda_wrap/lambda_manager.rb

@@ -1,181 +1,181 @@
-require 'aws-sdk'
-
-module LambdaWrap
-  ##
-  # The LambdaManager simplifies creating a package, publishing to S3, deploying a new version, & setting permissions.
-  #
-  # Note: The concept of an environment of the LambdaWrap gem matches an alias of AWS Lambda.
-  class LambdaManager
-    ##
-    # The constructor does some basic setup
-    # * Validating basic AWS configuration
-    # * Creating the underlying client to interace with the AWS SDK
-    def initialize
-      # AWS lambda client
-      @client = Aws::Lambda::Client.new
-    end
-
-    ##
-    # Packages a set of files and node modules into a deployable package.
-    #
-    # *Arguments*
-    # [directory]    A temporary directory to copy all related files before they are packages into a single zip file.
-    # [zipfile]      A path where the deployable package, a zip file, should be stored.
-    # [input_filenames]  A list of file names that contain the source code.
-    # [node_modules]  A list of node modules that need to be included in the package.
-    def package(directory, zipfile, input_filenames, node_modules)
-      FileUtils.mkdir_p directory
-      FileUtils.mkdir_p File.join(directory, 'node_modules')
-
-      input_filenames.each do |filename|
-        FileUtils.copy_file(File.join(filename), File.join(directory, File.basename(filename)))
-      end
-
-      node_modules.each do |dir|
-        FileUtils.cp_r(File.join('node_modules', dir), File.join(directory, 'node_modules'))
-      end
-
-      ZipFileGenerator.new(directory, zipfile).write
-    end
-
-    ##
-    # Publishes a package to S3 so it can be deployed as a lambda function.
-    #
-    # *Arguments*
-    # [local_lambda_file]  The location of the package that needs to be deployed.
-    # [bucket]        The s3 bucket where the file needs to be uploaded to.
-    # [key]          The S3 path (key) where the package should be stored.
-    def publish_lambda_to_s3(local_lambda_file, bucket, key)
-      # get s3 object
-      s3 = Aws::S3::Resource.new
-      obj = s3.bucket(bucket).object(key)
-
-      # upload
-      version_id = nil
-      File.open(local_lambda_file, 'rb') do |file|
-        version_id = obj.put(body: file).version_id
-      end
-      raise 'Upload to S3 failed' unless version_id
-
-      puts 'Uploaded object to S3 with version ' + version_id
-      version_id
-    end
-
-    ##
-    # Deploys a package that has been uploaded to S3.
-    #
-    # *Arguments*
-    # [bucket]      The S3 bucket where the package can be retrieved from.
-    # [key]        The S3 path (key) where the package can be retrieved from.
-    # [version_id]    The version of the file on S3 to retrieve.
-    # [function_name]  The name of the lambda function.
-    # [handler]      The handler that should be executed for this lambda function.
-    # [lambda_role]    The arn of the IAM role that should be used when executing the lambda function.
-    # [lambda_description]    The description of the lambda function.
-    # [vpc_subnet_ids]  A list of subnet ids for the lambda's VPC configuration. All subnets must be on the same VPC.
-    # [vpc_security_group_ids]  A list of security group ids for the lambda's VPC configuration. All of the
-    #                           security_group_ids must be on the same VPC.
-    def deploy_lambda(
-      bucket, key, version_id, function_name, handler, lambda_role,
-      lambda_description = 'Deployed with LambdaWrap', vpc_subnet_ids = [], vpc_security_group_ids = []
-    )
-      # create or update function
-
-      begin
-        @client.get_function(function_name: function_name)
-        func_config = @client.update_function_code(function_name: function_name, s3_bucket: bucket, s3_key: key,
-                                                   s3_object_version: version_id, publish: true).data
-        puts func_config
-        func_version = func_config.version
-        raise 'Error while publishing existing lambda function ' + function_name unless func_version
-      rescue Aws::Lambda::Errors::ResourceNotFoundException
-        # check if vpc_subnet_ids and vpc_security_group_ids are empty or not and set the vpc_config accordingly.
-        vpc_Configuration = nil
-        vpc_Configuration = { subnet_ids: vpc_subnet_ids, security_group_ids: vpc_security_group_ids } unless (vpc_subnet_ids.empty? && vpc_security_group_ids.empty?)
-
-        # if we cannot find it, we have to create it instead of updating it
-        func_config = @client.create_function(
-          function_name: function_name, runtime: 'nodejs4.3', role: lambda_role,
-          handler: handler, code: { s3_bucket: bucket, s3_key: key }, timeout: 5, memory_size: 128, publish: true,
-          description: lambda_description,
-          vpc_config: vpc_Configuration
-        ).data
-        puts func_config
-        func_version = func_config.version
-        raise "Error while publishing new lambda function #{function_name}" unless func_version
-      end
-
-      add_api_gateway_permissions(function_name, nil)
-
-      func_version
-    end
-
-    ##
-    # Creates an alias for a given lambda function version.
-    #
-    # *Arguments*
-    # [function_name]    The lambda function name for which the alias should be created.
-    # [func_version]    The lambda function versino to which the alias should point.
-    # [alias_name]      The name of the alias, matching the LambdaWrap environment concept.
-    def create_alias(function_name, func_version, alias_name)
-      # create or update alias
-      func_alias = @client.list_aliases(function_name: function_name).aliases.select { |a| a.name == alias_name }.first
-      if !func_alias
-        a = @client.create_alias(
-          function_name: function_name, name: alias_name, function_version: func_version,
-          description: 'created by an automated script'
-        ).data
-      else
-        a = @client.update_alias(
-          function_name: function_name, name: alias_name, function_version: func_version,
-          description: 'updated by an automated script'
-        ).data
-      end
-      puts a
-
-      add_api_gateway_permissions(function_name, alias_name)
-    end
-
-    ##
-    # Removes an alias for a function.
-    #
-    # *Arguments*
-    # [function_name]  The lambda function name for which the alias should be removed.
-    # [alias_name]    The alias to remove.
-    def remove_alias(function_name, alias_name)
-      @client.delete_alias(function_name: function_name, name: alias_name)
-    end
-
-    ##
-    # Adds permissions for API gateway to execute this function.
-    #
-    # *Arguments*
-    # [function_name]    The function name which needs to be executed from API Gateway.
-    # [env]          The environment (matching the function's alias) which needs to be executed from API Gateway.
-    # =>             If nil, the permissions are set of the $LATEST version.
-    def add_api_gateway_permissions(function_name, env)
-      # permissions to execute lambda
-      suffix = (':' + env if env) || ''
-      func = @client.get_function(function_name: function_name + suffix).data.configuration
-      statement_id = func.function_name + (('-' + env if env) || '')
-      begin
-        existing_policies = @client.get_policy(function_name: func.function_arn).data
-        existing_policy = JSON.parse(existing_policies.policy)
-        policy_exists = existing_policy['Statement'].select { |s| s['Sid'] == statement_id }.any?
-      rescue Aws::Lambda::Errors::ResourceNotFoundException
-        # policy does not exist, and that is ok
-        policy_exists = false
-      end
-
-      unless policy_exists
-        perm_add = @client.add_permission(
-          function_name: func.function_arn, statement_id: statement_id,
-          action: 'lambda:*', principal: 'apigateway.amazonaws.com'
-        )
-        puts perm_add.data
-      end
-    end
-
-    private :add_api_gateway_permissions
-  end
-end
+require 'aws-sdk'
+
+module LambdaWrap
+  ##
+  # The LambdaManager simplifies creating a package, publishing to S3, deploying a new version, & setting permissions.
+  #
+  # Note: The concept of an environment of the LambdaWrap gem matches an alias of AWS Lambda.
+  class LambdaManager
+    ##
+    # The constructor does some basic setup
+    # * Validating basic AWS configuration
+    # * Creating the underlying client to interace with the AWS SDK
+    def initialize
+      # AWS lambda client
+      @client = Aws::Lambda::Client.new
+    end
+
+    ##
+    # Packages a set of files and node modules into a deployable package.
+    #
+    # *Arguments*
+    # [directory]    A temporary directory to copy all related files before they are packages into a single zip file.
+    # [zipfile]      A path where the deployable package, a zip file, should be stored.
+    # [input_filenames]  A list of file names that contain the source code.
+    # [node_modules]  A list of node modules that need to be included in the package.
+    def package(directory, zipfile, input_filenames, node_modules)
+      FileUtils.mkdir_p directory
+      FileUtils.mkdir_p File.join(directory, 'node_modules')
+
+      input_filenames.each do |filename|
+        FileUtils.copy_file(File.join(filename), File.join(directory, File.basename(filename)))
+      end
+
+      node_modules.each do |dir|
+        FileUtils.cp_r(File.join('node_modules', dir), File.join(directory, 'node_modules'))
+      end
+
+      ZipFileGenerator.new(directory, zipfile).write
+    end
+
+    ##
+    # Publishes a package to S3 so it can be deployed as a lambda function.
+    #
+    # *Arguments*
+    # [local_lambda_file]  The location of the package that needs to be deployed.
+    # [bucket]        The s3 bucket where the file needs to be uploaded to.
+    # [key]          The S3 path (key) where the package should be stored.
+    def publish_lambda_to_s3(local_lambda_file, bucket, key)
+      # get s3 object
+      s3 = Aws::S3::Resource.new
+      obj = s3.bucket(bucket).object(key)
+
+      # upload
+      version_id = nil
+      File.open(local_lambda_file, 'rb') do |file|
+        version_id = obj.put(body: file).version_id
+      end
+      raise 'Upload to S3 failed' unless version_id
+
+      puts 'Uploaded object to S3 with version ' + version_id
+      version_id
+    end
+
+    ##
+    # Deploys a package that has been uploaded to S3.
+    #
+    # *Arguments*
+    # [bucket]      The S3 bucket where the package can be retrieved from.
+    # [key]        The S3 path (key) where the package can be retrieved from.
+    # [version_id]    The version of the file on S3 to retrieve.
+    # [function_name]  The name of the lambda function.
+    # [handler]      The handler that should be executed for this lambda function.
+    # [lambda_role]    The arn of the IAM role that should be used when executing the lambda function.
+    # [lambda_description]    The description of the lambda function.
+    # [vpc_subnet_ids]  A list of subnet ids for the lambda's VPC configuration. All subnets must be on the same VPC.
+    # [vpc_security_group_ids]  A list of security group ids for the lambda's VPC configuration. All of the
+    #                           security_group_ids must be on the same VPC.
+    def deploy_lambda(
+      bucket, key, version_id, function_name, handler, lambda_role,
+      lambda_description = 'Deployed with LambdaWrap', vpc_subnet_ids = [], vpc_security_group_ids = []
+    )
+      # create or update function
+
+      begin
+        @client.get_function(function_name: function_name)
+        func_config = @client.update_function_code(function_name: function_name, s3_bucket: bucket, s3_key: key,
+                                                   s3_object_version: version_id, publish: true).data
+        puts func_config
+        func_version = func_config.version
+        raise 'Error while publishing existing lambda function ' + function_name unless func_version
+      rescue Aws::Lambda::Errors::ResourceNotFoundException
+        # check if vpc_subnet_ids and vpc_security_group_ids are empty or not and set the vpc_config accordingly.
+        vpc_Configuration = nil
+        vpc_Configuration = { subnet_ids: vpc_subnet_ids, security_group_ids: vpc_security_group_ids } unless (vpc_subnet_ids.empty? && vpc_security_group_ids.empty?)
+
+        # if we cannot find it, we have to create it instead of updating it
+        func_config = @client.create_function(
+          function_name: function_name, runtime: 'nodejs4.3', role: lambda_role,
+          handler: handler, code: { s3_bucket: bucket, s3_key: key }, timeout: 5, memory_size: 128, publish: true,
+          description: lambda_description,
+          vpc_config: vpc_Configuration
+        ).data
+        puts func_config
+        func_version = func_config.version
+        raise "Error while publishing new lambda function #{function_name}" unless func_version
+      end
+
+      add_api_gateway_permissions(function_name, nil)
+
+      func_version
+    end
+
+    ##
+    # Creates an alias for a given lambda function version.
+    #
+    # *Arguments*
+    # [function_name]    The lambda function name for which the alias should be created.
+    # [func_version]    The lambda function versino to which the alias should point.
+    # [alias_name]      The name of the alias, matching the LambdaWrap environment concept.
+    def create_alias(function_name, func_version, alias_name)
+      # create or update alias
+      func_alias = @client.list_aliases(function_name: function_name).aliases.select { |a| a.name == alias_name }.first
+      if !func_alias
+        a = @client.create_alias(
+          function_name: function_name, name: alias_name, function_version: func_version,
+          description: 'created by an automated script'
+        ).data
+      else
+        a = @client.update_alias(
+          function_name: function_name, name: alias_name, function_version: func_version,
+          description: 'updated by an automated script'
+        ).data
+      end
+      puts a
+
+      add_api_gateway_permissions(function_name, alias_name)
+    end
+
+    ##
+    # Removes an alias for a function.
+    #
+    # *Arguments*
+    # [function_name]  The lambda function name for which the alias should be removed.
+    # [alias_name]    The alias to remove.
+    def remove_alias(function_name, alias_name)
+      @client.delete_alias(function_name: function_name, name: alias_name)
+    end
+
+    ##
+    # Adds permissions for API gateway to execute this function.
+    #
+    # *Arguments*
+    # [function_name]    The function name which needs to be executed from API Gateway.
+    # [env]          The environment (matching the function's alias) which needs to be executed from API Gateway.
+    # =>             If nil, the permissions are set of the $LATEST version.
+    def add_api_gateway_permissions(function_name, env)
+      # permissions to execute lambda
+      suffix = (':' + env if env) || ''
+      func = @client.get_function(function_name: function_name + suffix).data.configuration
+      statement_id = func.function_name + (('-' + env if env) || '')
+      begin
+        existing_policies = @client.get_policy(function_name: func.function_arn).data
+        existing_policy = JSON.parse(existing_policies.policy)
+        policy_exists = existing_policy['Statement'].select { |s| s['Sid'] == statement_id }.any?
+      rescue Aws::Lambda::Errors::ResourceNotFoundException
+        # policy does not exist, and that is ok
+        policy_exists = false
+      end
+
+      unless policy_exists
+        perm_add = @client.add_permission(
+          function_name: func.function_arn, statement_id: statement_id,
+          action: 'lambda:*', principal: 'apigateway.amazonaws.com'
+        )
+        puts perm_add.data
+      end
+    end
+
+    private :add_api_gateway_permissions
+  end
+end

data/lib/lambda_wrap/s3_bucket_manager.rb

@@ -2,7 +2,7 @@ require 'aws-sdk'
 
 module LambdaWrap
   ##
-  # The S3BucketManager simplifies would have functions to help add policies etcc to S3 bucket.
+  # The S3BucketManager would have functions to help add policies, CORS etc to S3 bucket.
   class S3BucketManager
     #
     # The constructor creates an instance of s3 bucket

data/lib/lambda_wrap/zip_file_generator.rb

@@ -1,67 +1,67 @@
-require 'rubygems'
-require 'zip'
-
-module LambdaWrap
-  ##
-  # Allows to easily zip a directory recursively. It's intended for gem internal use only.
-  #
-  # From the original example:
-  # This is a simple example which uses rubyzip to
-  # recursively generate a zip file from the contents of
-  # a specified directory. The directory itself is not
-  # included in the archive, rather just its contents.
-  #
-  # Usage:
-  # require /path/to/the/ZipFileGenerator/Class
-  # directoryToZip = "/tmp/input"
-  # outputFile = "/tmp/out.zip"
-  # zf = ZipFileGenerator.new(directoryToZip, outputFile)
-  # zf.write()
-  class ZipFileGenerator
-    ##
-    # Initialize with the directory to zip and the location of the output archive.
-    def initialize(input_dir, output_file)
-      @input_dir = input_dir
-      @output_file = output_file
-    end
-
-    ##
-    # Zip the input directory.
-    def write
-      entries = Dir.entries(@input_dir) - %w(. ..)
-
-      Zip::File.open(@output_file, Zip::File::CREATE) do |io|
-        write_entries entries, '', io
-      end
-    end
-
-    private
-
-    # A helper method to make the recursion work.
-    def write_entries(entries, path, io)
-      entries.each do |e|
-        zip_file_path = path == '' ? e : File.join(path, e)
-        disk_file_path = File.join(@input_dir, zip_file_path)
-        puts "Deflating #{disk_file_path}"
-
-        if File.directory? disk_file_path
-          recursively_deflate_directory(disk_file_path, io, zip_file_path)
-        else
-          put_into_archive(disk_file_path, io, zip_file_path)
-        end
-      end
-    end
-
-    def recursively_deflate_directory(disk_file_path, io, zip_file_path)
-      io.mkdir zip_file_path
-      subdir = Dir.entries(disk_file_path) - %w(. ..)
-      write_entries subdir, zip_file_path, io
-    end
-
-    def put_into_archive(disk_file_path, io, zip_file_path)
-      io.get_output_stream(zip_file_path) do |f|
-        f.puts(File.open(disk_file_path, 'rb').read)
-      end
-    end
-  end
-end
+require 'rubygems'
+require 'zip'
+
+module LambdaWrap
+  ##
+  # Allows to easily zip a directory recursively. It's intended for gem internal use only.
+  #
+  # From the original example:
+  # This is a simple example which uses rubyzip to
+  # recursively generate a zip file from the contents of
+  # a specified directory. The directory itself is not
+  # included in the archive, rather just its contents.
+  #
+  # Usage:
+  # require /path/to/the/ZipFileGenerator/Class
+  # directoryToZip = "/tmp/input"
+  # outputFile = "/tmp/out.zip"
+  # zf = ZipFileGenerator.new(directoryToZip, outputFile)
+  # zf.write()
+  class ZipFileGenerator
+    ##
+    # Initialize with the directory to zip and the location of the output archive.
+    def initialize(input_dir, output_file)
+      @input_dir = input_dir
+      @output_file = output_file
+    end
+
+    ##
+    # Zip the input directory.
+    def write
+      entries = Dir.entries(@input_dir) - %w(. ..)
+
+      Zip::File.open(@output_file, Zip::File::CREATE) do |io|
+        write_entries entries, '', io
+      end
+    end
+
+    private
+
+    # A helper method to make the recursion work.
+    def write_entries(entries, path, io)
+      entries.each do |e|
+        zip_file_path = path == '' ? e : File.join(path, e)
+        disk_file_path = File.join(@input_dir, zip_file_path)
+        puts "Deflating #{disk_file_path}"
+
+        if File.directory? disk_file_path
+          recursively_deflate_directory(disk_file_path, io, zip_file_path)
+        else
+          put_into_archive(disk_file_path, io, zip_file_path)
+        end
+      end
+    end
+
+    def recursively_deflate_directory(disk_file_path, io, zip_file_path)
+      io.mkdir zip_file_path
+      subdir = Dir.entries(disk_file_path) - %w(. ..)
+      write_entries subdir, zip_file_path, io
+    end
+
+    def put_into_archive(disk_file_path, io, zip_file_path)
+      io.get_output_stream(zip_file_path) do |f|
+        f.puts(File.open(disk_file_path, 'rb').read)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lambda_wrap
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Markus Thurner
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-18 00:00:00.000000000 Z
+date: 2016-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -73,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Easy deployment of AWS Lambda functions and dependencies.