lambda_wrap 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 967cbf57b49c5c9089d2b7fb499e918e06b0c2cd
-  data.tar.gz: e04be077d970608457c40613e8c42cb41364822f
+  metadata.gz: 538942578f2271e578436d168e5cbc84e7691bb0
+  data.tar.gz: 6f25cf394a08908a0bbb39bf924a75c9dc36d216
 SHA512:
-  metadata.gz: ce0921cb5e342d7b6dee2caec10bc1c0f7ac73f240f3fd3a8afd0dff72cf7137bdd1b0203871713eac296384352a095c59fdd4a2857cd751d466dbb5f293bfe7
-  data.tar.gz: 722c438455fc50aabdb5528ee568679f6920aef78291591ae9b249c785f1ff09dd2989e754b5ca684443fb0f5cb2141704236e6faadca3887570edbe231f58ec
+  metadata.gz: 06931dad00016c68f3b5064b6a368f9833dd4f818e5e3a09eb2f5467353773c6f37cd2194ab00e76647bfc7ec3d20c361801bd1962eac4da7cb7ef31b0203d88
+  data.tar.gz: 6128b14ac5a3cc406b0e604b9a509f00bc7b536c3a350f829e7f7fb85ca3d4c7384bbc4758ddaeaf49265d8ad001210c275d363f76114dc19e297a506993fca2

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,188 +1,194 @@
-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.
-    # [runtime] The runtime the code is written for.
-    def deploy_lambda(
-      bucket, key, version_id, function_name, handler, lambda_role, lambda_description = 'Deployed with LambdaWrap',
-      vpc_subnet_ids = [], vpc_security_group_ids = [], runtime = 'nodejs4.3'
-    )
-      # 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
-        vpc_configuration = { subnet_ids: vpc_subnet_ids, security_group_ids: vpc_security_group_ids } unless (vpc_subnet_ids.empty? && vpc_security_group_ids.empty?)
-        func_config = @client.update_function_configuration(function_name: function_name, role: lambda_role, runtime: runtime,
-                                                            handler: handler, timeout: 5, memory_size: 128,
-                                                            description: lambda_description,
-                                                            vpc_config: vpc_configuration).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: runtime, 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.
+    # [runtime] The runtime the code is written for.
+    # [timeout] The integer value of seconds until the lambda timesout. Minimum 1, Maximum 300
+    # [memory_size] The Memory/ProcessingPower allocated for the Lambda. Minimum 128. Maximum 1536. Only accepts
+    #               integers in multiples of 64.
+    def deploy_lambda(
+      bucket, key, version_id, function_name, handler, lambda_role, lambda_description = 'Deployed with LambdaWrap',
+      vpc_subnet_ids = [], vpc_security_group_ids = [], runtime = 'nodejs4.3', timeout = 5, memory_size = 128
+    )
+      # create or update function
+
+      begin
+        @client.get_function(function_name: function_name)
+        vpc_configuration = { subnet_ids: vpc_subnet_ids, security_group_ids: vpc_security_group_ids } unless (vpc_subnet_ids.empty? && vpc_security_group_ids.empty?)
+        func_config = @client.update_function_configuration(function_name: function_name, role: lambda_role, runtime: runtime,
+                                                            handler: handler, timeout: timeout, memory_size: memory_size,
+                                                            description: lambda_description,
+                                                            vpc_config: vpc_configuration).data
+        puts func_config
+
+        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: runtime, role: lambda_role,
+          handler: handler, code: { s3_bucket: bucket, s3_key: key }, timeout: timeout, memory_size: memory_size, 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)
+
+      # return the version of the new code, not the config.
+      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

@@ -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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lambda_wrap
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Markus Thurner
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-07 00:00:00.000000000 Z
+date: 2016-10-13 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.6.7
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Easy deployment of AWS Lambda functions and dependencies.