lambda_wrap 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb1eb756df3c76832fbe546394984c6342e38ee5
-  data.tar.gz: a3016f7a3880c7137be66c68ef8baf0c0851cdc6
+  metadata.gz: d97a3646f6a910220435cc9631b671ef63089d0f
+  data.tar.gz: 3c46b725cbf0934aa83b937051bcba028a0321bd
 SHA512:
-  metadata.gz: d65978e2e7be1c2ea4015b2fa55a1775c680ad2ca0c609386baf779a93f16f937e68e4c8e587c86cca6f15dddc1e7c119e112ce9dc48fcc66c2f91e4af7caff3
-  data.tar.gz: 9eed6b47faf86c479bb861d6a329107d34623f606caa7c53eabc5f9d58ad4d1d8f2aa25a911af4285f8ca9521257ba57521dc0fca45afe9e2efe3115afe6ebd3
+  metadata.gz: 7c471f0e67052c94f555df32e17863058c05a67648daa53475db759c9a8f932f9d0ee631d2d3e98c19b48de6dc50de49ff9e3a8d673348a5124277656a5ffb2e
+  data.tar.gz: aa02fa599624407e03ab4c8a558f3f082e2dcea2cd53f83f571684e9c666c5bcc149b67950e29f0d49b5b24c808a25495a395dec69a511b6badabdcf8b7d8001

data/lib/lambda_wrap.rb

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

data/lib/lambda_wrap/api_gateway_manager.rb

@@ -1,177 +1,151 @@
 require 'aws-sdk'
-require_relative 'aws_setup'
 
 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()
-			AwsSetup.new.validate()
-			# 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.exists?(@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.exists?(@jarpath)
-				puts "Downloading aws-apigateway-importer jar with S3 version #{desired_s3_version}"
-				obj = 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. 
-		def setup_apigateway(api_name, env, swagger_file, api_description = "Deployed with LambdaWrap")
-			
-			# ensure API is created
-			api_id = get_existing_rest_api(api_name)
-			api_id = setup_apigateway_create_rest_api(api_name, api_description) if !api_id
-			
-			# create resources
-			setup_apigateway_create_resources(api_id, swagger_file)
-			
-			# create stages
-			create_stages(api_id, env)
-			
-			# return URI of created stage
-			return "https://#{api_id}.execute-api.#{ENV['AWS_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{ |api| api.name == api_name}.first()
-			
-			if (api)
-				return api.id
-			else
-				return nil
-			end
-			
-		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})
-			
-			return 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)
-			
-			raise 'API ID not provided' if !api_id
-			
-			cmd = "java -jar #{@jarpath} --update #{api_id} --region #{ENV['AWS_REGION']} #{swagger_file}"
-			raise 'API gateway not created' if !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)
-		
-			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: { "environment" => env}}).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
+  # 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.
+    def setup_apigateway(api_name, env, swagger_file, api_description = 'Deployed with LambdaWrap')
+      # 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)
+
+      # create stages
+      create_stages(api_id, env)
+
+      # return URI of created stage
+      "https://#{api_id}.execute-api.#{ENV['AWS_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)
+      raise 'API ID not provided' unless api_id
+
+      cmd = "java -jar #{@jarpath} --update #{api_id} #{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)
+      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: { 'environment' => env }
+      ).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

data/lib/lambda_wrap/dynamo_db_manager.rb

@@ -1,127 +1,121 @@
 require 'aws-sdk'
-require_relative 'aws_setup'
 
 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 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
 
-		##
-		# The constructor does some basic setup
-		# * Validating basic AWS configuration
-		# * Creating the underlying client to interact with the AWS SDK.
-		def initialize()
-			AwsSetup.new.validate()
-			# AWS dynamodb client
-			@client = Aws::DynamoDB::Client.new()
-		end
-		
-		##
-		# Publishes the database and awaits until it is fully available. If the table already exists, it only adjusts the read/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. See the AWS documentation for details.
-		# [key_schema]				The dynamoDB key definitions to be used when the table is created. See the AWS documentation for details.
-		# [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
-			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)
-					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}."
-					table = @client.update_table({
-						table_name: table_name,
-							provisioned_throughput: { read_capacity_units: read_capacity, write_capacity_units: 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" }]
-				table = @client.create_table({
-					attribute_definitions: ad,
-					table_name: table_name,
-					key_schema: ks,
-					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)
-			
-			begin
-				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
-			
-		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, response|
-						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
+    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
 
-	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
 
-end
+      # 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,172 +1,177 @@
 require 'aws-sdk'
-require_relative 'aws_setup'
 
 module LambdaWrap
-	
-	##
-	# The LambdaManager simplifies creating a package, publishing it to S3, deploying a new version, and 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()
-			AwsSetup.new.validate()
-			# 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' if !version_id
-			
-			puts 'Uploaded object to S3 with version ' + version_id
-			return 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 of the 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
-				func = @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 if !func_config.version
-			rescue Aws::Lambda::Errors::ResourceNotFoundException
-				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: {subnet_ids: vpc_subnet_ids, security_group_ids: vpc_security_group_ids} }).data
-				puts func_config
-				func_version = func_config.version
-				raise 'Error while publishing new lambda function ' + function_name if !func_config.version
-			end
-			
-			add_api_gateway_permissions(function_name, nil)
-			
-			return 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
-				puts a
-			else
-				a = @client.update_alias({function_name: function_name, name: alias_name, function_version: func_version, description: 'updated by an automated script'}).data
-				puts a
-			end
-			
-			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) || '') 
-			policy_exists = false
-			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
-			end
-			
-			if !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
+  ##
+  # 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
+        # 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: { subnet_ids: vpc_subnet_ids, security_group_ids: vpc_security_group_ids }
+        ).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/zip_file_generator.rb

@@ -2,69 +2,66 @@ 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
     ##
-    # 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(. ..)
+    # 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::File.open(@output_file, ::Zip::File::CREATE) do |io|
-            write_entries entries, '', io
-            end
-        end
+    ##
+    # Zip the input directory.
+    def write
+      entries = Dir.entries(@input_dir) - %w(. ..)
 
-        private
+      Zip::File.open(@output_file, Zip::File::CREATE) do |io|
+        write_entries entries, '', io
+      end
+    end
 
-        # 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}"
+    private
 
-            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
+    # 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}"
 
-        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
+        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 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
+    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
 
-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.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Markus Thurner
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-13 00:00:00.000000000 Z
+date: 2016-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -27,20 +27,20 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
-  name: zip
+  name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
-description: This gem wraps the AWS SDK to simplify deployment of AWS Lambda functions
+        version: '1.2'
+description: This gem wraps the AWS SDK to simplify deployment of AWSLambda functions
   backed by API Gateway and DynamoDB.
 email: 
 executables: []
@@ -49,7 +49,6 @@ extra_rdoc_files: []
 files:
 - lib/lambda_wrap.rb
 - lib/lambda_wrap/api_gateway_manager.rb
-- lib/lambda_wrap/aws_setup.rb
 - lib/lambda_wrap/dynamo_db_manager.rb
 - lib/lambda_wrap/lambda_manager.rb
 - lib/lambda_wrap/zip_file_generator.rb
@@ -73,7 +72,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.

data/lib/lambda_wrap/aws_setup.rb

@@ -1,32 +0,0 @@
-require 'aws-sdk'
-
-##
-# LambdaWrap is a ruby gem that simplifies deployment of AWS Lambda functions that are invoked through AWS API Gateway and optionally include a DynamoDB backend. 
-module LambdaWrap
-
-    ##
-    # Helper class to ensure valid configuration of AWS.
-    # This class is intended for internal use only, but clients can call it before calling any other functionality to ensure early failure. 
-    class AwsSetup
-        
-        ##
-        # Validates that the setup is correct and that the bundled AWS certificate is used for subsequent calls to the AWS SDK
-        #
-        # *Required environment variables*
-        # [AWS_ACCESS_KEY_ID]       The AWS access key to be used when calling AWS SDK functions
-        # [AWS_SECRET_ACCESS_KEY]   The AWS secret to be used when calling AWS SDK functions
-        # [AWS_REGION]              A valid AWS region to use during configuration.
-        def validate()
-            
-            # validate settings
-            raise 'AWS_ACCESS_KEY_ID not set' if !ENV['AWS_ACCESS_KEY_ID']
-            raise 'AWS_SECRET_ACCESS_KEY not set' if !ENV['AWS_SECRET_ACCESS_KEY']
-            raise 'AWS_REGION not set' if !ENV['AWS_REGION']
-
-            Aws::use_bundled_cert!
-            
-        end
-        
-    end
-    
-end