lambda_wrap 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f48ab03f6ee01f4084324fd582489720820a060
+  data.tar.gz: f7a1b100285e4fd602f654211dc0ac6a34cf1a8c
+SHA512:
+  metadata.gz: ed51f65ba43fe439c31319287b33e4f04e5f59f1d4385c05408713354e1529a20f1cf99f83ae1bca4ce7866fb9a7cd9af2ed504064b4e51eb29b5ebd7a77dbf8
+  data.tar.gz: 4fece3ef3a2758a300cb838ab295fdabbf502a3576b30fd307e19666b0061594fc3d50438b4becc1942e7057eb414f2b767fbeec96e0c510fe78ce2b1c5bdde0

data/lib/lambda_wrap.rb

@@ -0,0 +1,5 @@
+# :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

@@ -0,0 +1,100 @@
+require 'aws-sdk'
+require_relative 'aws_setup'
+
+module LambdaWrap
+	
+	class ApiGatewayManager
+		
+		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')
+		end
+		
+		def download_apigateway_importer(s3_bucket, s3_key)	
+			unless File.exist?(@jarpath)
+				puts 'Downloading aws-apigateway-importer jar'
+				s3 = Aws::S3::Client.new		
+				obj = s3.get_object(response_target:@jarpath, bucket:s3_bucket, key:s3_key)
+			end		
+		end
+		
+		def setup_apigateway(api_name, env, swagger_file)
+			
+			# ensure API is created
+			api_id = get_existing_rest_api(api_name)
+			api_id = setup_apigateway_create_rest_api(api_name) 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
+		
+		def shutdown_apigateway(api_name, env)
+		
+			api_id = get_existing_rest_api(api_name)
+			delete_stage(api_id, env)
+			
+		end
+		
+		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
+		
+		def setup_apigateway_create_rest_api(api_name)
+			
+			puts 'Creating API with name ' + api_name
+			api = @client.create_rest_api({name: api_name})
+			
+			return api.id
+			
+		end
+		
+		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
+		
+		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
+		
+		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
+		
+	end
+	
+end

data/lib/lambda_wrap/aws_setup.rb

@@ -0,0 +1,20 @@
+require 'aws-sdk'
+
+module LambdaWrap
+
+    class AwsSetup
+        
+        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

data/lib/lambda_wrap/dynamo_db_manager.rb

@@ -0,0 +1,95 @@
+require 'aws-sdk'
+require_relative 'aws_setup'
+
+module LambdaWrap
+	
+	class DynamoDbManager
+
+		def initialize()
+			AwsSetup.new.validate()
+			# AWS dynamodb client
+			@client = Aws::DynamoDB::Client.new()
+		end
+		
+		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
+		
+		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
+		
+		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
+
+	end
+
+end

data/lib/lambda_wrap/lambda_manager.rb

@@ -0,0 +1,115 @@
+require 'aws-sdk'
+require_relative 'aws_setup'
+
+module LambdaWrap
+	
+	class LambdaManager
+		
+		def initialize()
+			AwsSetup.new.validate()
+			# AWS lambda client
+			@client = Aws::Lambda::Client.new()
+		end
+		
+		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
+		
+		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
+		
+		def deploy_lambda(version_id, function_name, handler)
+	
+			# 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: S3_BUCKET, s3_key: S3_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: 'nodejs', role: LAMBDA_ROLE_ARN, handler: handler, code: { s3_bucket: S3_BUCKET, s3_key: S3_KEY }, timeout: 5, memory_size: 128, publish: true, description: 'created by an automated script'}).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
+		
+		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
+		
+		def remove_alias(function_name, alias_name)
+			
+			@client.delete_alias({function_name: function_name, name: alias_name})
+			
+		end
+		
+		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
+		
+	end
+
+end

data/lib/lambda_wrap/zip_file_generator.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'zip'
+# 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()
+
+module LambdaWrap
+
+    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

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: lambda_wrap
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Markus Thurner
+- Dorota Ruta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '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
+  backed by API Gateway and DynamoDB.
+email: 
+executables: []
+extensions: []
+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
+homepage: 
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Easy deployment of AWS Lambda functions and dependencies.
+test_files: []