lambda_wrap 0.27.0 → 1.0.0

data/lib/lambda_wrap/environment.rb

@@ -0,0 +1,53 @@
+module LambdaWrap
+  # Environment class to pass to the deploy and teardown
+  #
+  # @!attribute [r] name
+  #   @return [String] The descriptive name of the environment.
+  #
+  # @!attribute [r] description
+  #   @return [String] The description of the environment.
+  #
+  # @!attribute [r] variables
+  #   @return [Hash] The Hash of environment variables to deploy with the environment.
+  #
+  # @since 1.0
+  class Environment
+    attr_reader :name
+    attr_reader :description
+    attr_reader :variables
+
+    # Constructor
+    #
+    # @param name [String] Name of the environment. Corresponds to the Lambda Alias and API Gateway Stage.
+    #  Must be at least 3 characters, and no more than 20 characters.
+    # @param variables [Hash] Environment variables to pass to the API Gateway stage. Must be a flat hash.
+    #  Each key must be Alphanumeric (underscores allowed) and no more than 64 characters. Values can have
+    #  most special characters, and no more than 512 characters.
+    # @param description [String] Description of the environment for Stage & Alias descriptions. Must not
+    #  exceed 256 characters.
+    def initialize(name, variables = {}, description = 'Managed by LambdaWrap')
+      raise ArgumentError, 'name must be provided (String)!' unless name && name.is_a?(String)
+      # Max Alias Name length is 20 characters.
+      raise ArgumentError, "Invalid name format: #{name}" unless /^[a-zA-Z0-9\-\_]{3,20}$/ =~ name
+      @name = name
+
+      raise ArgumentError, 'Variables must be a Hash!' unless variables.is_a?(Hash)
+      variables.each do |key, value|
+        next if /^[0-9a-zA-Z\_]{1,64}$/ =~ key && /^[A-Za-z0-9\-.\_~:\/?#&=,]{1,512}$/ =~ value && value.is_a?(String)
+        raise ArgumentError, "Invalid Format of variables hash: #{key} => #{value}"
+      end
+
+      variables[:environment] = name unless variables[:environment]
+      @variables = variables
+
+      raise ArgumentError, 'Description must be a String!' unless description.is_a?(String)
+      raise ArgumentError, 'Description too long (Max 256)' unless description.length < 256
+      @description = description
+    end
+
+    def to_s
+      return @name if @name && @name.is_a?(String)
+      super
+    end
+  end
+end

data/lib/lambda_wrap/lambda_manager.rb

@@ -1,208 +1,303 @@
-require 'aws-sdk'
+require 'set'
+require 'pathname'
 
 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.
+  # Lambda Manager class.
+  # Front loads the configuration to the constructor so that the developer can be more declarative with configuration
+  # and deployments.
+  # @since 1.0
+  class Lambda < AwsService
+    # Initializes a Lambda Manager. Frontloaded configuration.
     #
-    # *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') unless node_modules.empty?
+    # @param [Hash] options The Configuration for the Lambda
+    # @option options [String] :lambda_name The name you want to assign to the function you are uploading. The function
+    #  names appear in the console and are returned in the ListFunctions API. Function names are used to specify
+    #  functions to other AWS Lambda API operations, such as Invoke. Note that the length constraint applies only to
+    #  the ARN. If you specify only the function name, it is limited to 64 characters in length.
+    # @option options [String] :handler The function within your code that Lambda calls to begin execution.
+    # @option options [String] :role_arn The Amazon Resource Name (ARN) of the IAM role that Lambda assumes when it
+    #  executes your function to access any other Amazon Web Services (AWS) resources.
+    # @option options [String] :path_to_zip_file The absolute path to the Deployment Package zip file
+    # @option options [String] :runtime The runtime environment for the Lambda function you are uploading.
+    # @option options [String] :description ('Deployed with LambdaWrap') A short, user-defined function description.
+    #  Lambda does not use this value. Assign a meaningful description as you see fit.
+    # @option options [Integer] :timeout (30) The function execution time at which Lambda should terminate the function.
+    # @option options [Integer] :memory_size (128) The amount of memory, in MB, your Lambda function is given. Lambda
+    #  uses this memory size to infer the amount of CPU and memory allocated to your function. The value must be a
+    #  multiple of 64MB. Minimum: 128, Maximum: 1536.
+    # @option options [Array<String>] :subnet_ids ([]) If your Lambda function accesses resources in a VPC, you provide
+    #  this parameter identifying the list of subnet IDs. These must belong to the same VPC. You must provide at least
+    #  one security group and one subnet ID to configure VPC access.
+    # @option options [Array<String>] :security_group_ids ([]) If your Lambda function accesses resources in a VPC, you
+    #  provide this parameter identifying the list of security group IDs. These must belong to the same VPC. You must
+    #  provide at least one security group and one subnet ID.
+    # @option options [Boolean] :delete_unreferenced_versions (true) Option to delete any Lambda Function Versions upon
+    #  deployment that do not have an alias pointing to them.
+    def initialize(options)
+      defaults = {
+        description: 'Deployed with LambdaWrap', subnet_ids: [], security_group_ids: [], timeout: 30, memory_size: 128,
+        delete_unreferenced_versions: true
+      }
+      options_with_defaults = options.reverse_merge(defaults)
 
-      input_filenames.each do |filename|
-        FileUtils.copy_file(File.join(filename), File.join(directory, File.basename(filename)))
+      unless (options_with_defaults[:lambda_name]) && (options_with_defaults[:lambda_name].is_a? String)
+        raise ArgumentError, 'lambda_name must be provided (String)!'
       end
+      @lambda_name = options_with_defaults[:lambda_name]
 
-      node_modules.each do |dir|
-        FileUtils.cp_r(File.join('node_modules', dir), File.join(directory, 'node_modules'))
+      unless (options_with_defaults[:handler]) && (options_with_defaults[:handler].is_a? String)
+        raise ArgumentError, 'handler must be provided (String)!'
       end
+      @handler = options_with_defaults[:handler]
 
-      ZipFileGenerator.new(directory, zipfile).write
+      unless (options_with_defaults[:role_arn]) && (options_with_defaults[:role_arn].is_a? String)
+        raise ArgumentError, 'role_arn must be provided (String)!'
+      end
+      @role_arn = options_with_defaults[:role_arn]
+
+      unless (options_with_defaults[:path_to_zip_file]) && (options_with_defaults[:path_to_zip_file].is_a? String)
+        raise ArgumentError, 'path_to_zip_file must be provided (String)!'
+      end
+      @path_to_zip_file = options_with_defaults[:path_to_zip_file]
+
+      unless (options_with_defaults[:runtime]) && (options_with_defaults[:runtime].is_a? String)
+        raise ArgumentError, 'runtime must be provided (String)!'
+      end
+
+      case options_with_defaults[:runtime]
+      when 'nodejs' then raise ArgumentError, 'AWS Lambda Runtime NodeJS v0.10.42 is deprecated as of April 2017. \
+        Please see: https://forums.aws.amazon.com/ann.jspa?annID=4142'
+      when 'nodejs4.3', 'nodejs6.10', 'java8', 'python2.7', 'python3.6', 'dotnetcore1.0', 'nodejs4.3-edge'
+        @runtime = options_with_defaults[:runtime]
+      else
+        raise ArgumentError, "Invalid Runtime specified: #{options_with_defaults[:runtime]}. Only accepts: \
+nodejs4.3, nodejs6.10, java8, python2.7, python3.6, dotnetcore1.0, or nodejs4.3-edge"
+      end
+
+      @description = options_with_defaults[:description]
+
+      @timeout = options_with_defaults[:timeout]
+
+      unless (options_with_defaults[:memory_size] % 64).zero? && (options_with_defaults[:memory_size] >= 128) &&
+             (options_with_defaults[:memory_size] <= 1536)
+        raise ArgumentError, 'Invalid Memory Size.'
+      end
+      @memory_size = options_with_defaults[:memory_size]
+
+      # VPC
+      if options_with_defaults[:subnet_ids].empty? ^ options_with_defaults[:security_group_ids].empty?
+        raise ArgumentError, 'Must supply values for BOTH Subnet Ids and Security Group ID if VPC is desired.'
+      end
+      unless options_with_defaults[:subnet_ids].empty?
+        @vpc_configuration = {
+          subnet_ids: options_with_defaults[:subnet_ids],
+          security_group_ids: options_with_defaults[:security_group_ids]
+        }
+      end
+
+      @delete_unreferenced_versions = options_with_defaults[:delete_unreferenced_versions]
     end
 
-    ##
-    # Publishes a package to S3 so it can be deployed as a lambda function.
+    # Deploys the Lambda to the specified Environment. Creates a Lambda Function if one didn't exist.
+    # Updates the Lambda's configuration, Updates the Lambda's Code, publishes a new version, and creates
+    # an alias that points to the newly published version. If the @delete_unreferenced_versions option
+    # is enabled, all Lambda Function versions that don't have an alias pointing to them will be deleted.
     #
-    # *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)
+    # @param environment_options [LambdaWrap::Environment] The target Environment to deploy
+    # @param client [Aws::Lambda::Client] Client to use with SDK. Should be passed in by the API class.
+    # @param region [String] AWS Region string. Should be passed in by the API class.
+    def deploy(environment_options, client, region = 'AWS_REGION')
+      super
+
+      puts "Deploying Lambda: #{@lambda_name} to Environment: #{environment_options.name}"
 
-      # upload
-      version_id = nil
-      File.open(local_lambda_file, 'rb') do |file|
-        version_id = obj.put(body: file).version_id
+      unless File.exist?(@path_to_zip_file)
+        raise ArgumentError, "Deployment Package Zip File does not exist: #{@path_to_zip_file}!"
       end
-      raise 'Upload to S3 failed' unless version_id
 
-      puts 'Uploaded object to S3 with version ' + version_id
-      version_id
+      lambda_details = retrieve_lambda_details
+
+      if lambda_details.nil?
+        function_version = create_lambda
+      else
+        update_lambda_config
+        function_version = update_lambda_code
+      end
+
+      create_alias(function_version, environment_options.name, environment_options.description)
+
+      cleanup_unused_versions if @delete_unreferenced_versions
+
+      puts "Lambda: #{@lambda_name} successfully deployed!"
+      true
+    end
+
+    # Tearsdown an Environment. Deletes an alias with the same name as the environment. Deletes
+    # Unreferenced Lambda Function Versions if the option was specified.
+    #
+    # @param environment_options [LambdaWrap::Environment] The target Environment to teardown.
+    # @param client [Aws::Lambda::Client] Client to use with SDK. Should be passed in by the API class.
+    # @param region [String] AWS Region string. Should be passed in by the API class.
+    def teardown(environment_options, client, region = 'AWS_REGION')
+      super
+      remove_alias(environment_options.name)
+      cleanup_unused_versions if @delete_unreferenced_versions
+      true
     end
 
-    ##
-    # Deploys a package that has been uploaded to S3.
+    # Deletes the Lambda Object with associated versions, code, configuration, and aliases.
     #
-    # *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
+    # @param client [Aws::Lambda::Client] Client to use with SDK. Should be passed in by the API class.
+    # @param region [String] AWS Region string. Should be passed in by the API class.
+    def delete(client, region = 'AWS_REGION')
+      super
+      puts "Deleting all versions and aliases for Lambda: #{@lambda_name}"
+      lambda_details = retrieve_lambda_details
+      if lambda_details.nil?
+        puts 'No Lambda to delete.'
+      else
+        @client.delete_function(function_name: @lambda_name)
+        puts "Lambda #{@lambda_name} and all Versions & Aliases have been deleted."
+      end
+      true
+    end
+
+    def to_s
+      return @lambda_name if @lambda_name && @lambda_name.is_a?(String)
+      super
+    end
 
+    private
+
+    def retrieve_lambda_details
+      lambda_details = nil
       begin
-        @client.get_function(function_name: function_name)
-        unless vpc_subnet_ids.empty? && vpc_security_group_ids.empty?
-          vpc_configuration = {
-            subnet_ids: vpc_subnet_ids,
-            security_group_ids: vpc_security_group_ids
-          }
-        end
-        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.
-        if vpc_subnet_ids.empty? && vpc_security_group_ids.empty?
-          vpc_configuration = nil
-        else
-          vpc_configuration = { subnet_ids: vpc_subnet_ids, security_group_ids: vpc_security_group_ids }
-        end
+        lambda_details = @client.get_function(function_name: @lambda_name).configuration
+      rescue Aws::Lambda::Errors::ResourceNotFoundException, Aws::Lambda::Errors::NotFound
+        puts "Lambda #{@lambda_name} does not exist."
+      end
+      lambda_details
+    end
+
+    def create_lambda
+      puts "Creating New Lambda Function: #{@lambda_name}...."
+      puts "Runtime Engine: #{@runtime}, Timeout: #{@timeout}, Memory Size: #{@memory_size}."
 
-        # 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
+      lambda_version = @client.create_function(
+        function_name: @lambda_name, runtime: @runtime, role: @role_arn, handler: @handler,
+        code: { zip_file: @path_to_zip_file }, description: @description, timeout: @timeout, memory_size: @memory_size,
+        vpc_config: @vpc_configuration, publish: true
+      ).version
+      puts "Successfully created Lambda: #{@lambda_name}!"
+      lambda_version
+    end
 
-        puts func_config
-        func_version = func_config.version
-        raise "Error while publishing new lambda function #{function_name}" unless func_version
+    def update_lambda_config
+      puts "Updating Lambda Config for #{@lambda_name}..."
+      puts "Runtime Engine: #{@runtime}, Timeout: #{@timeout}, Memory Size: #{@memory_size}."
+      if @vpc_configuration
+        puts "With VPC Configuration: Subnets: #{@vpc_configuration[:subnet_ids]}, Security Groups: \
+#{@vpc_configuration[:security_group_ids]}"
       end
 
-      add_api_gateway_permissions(function_name, nil)
+      @client.update_function_configuration(
+        function_name: @lambda_name, role: @role_arn, handler: @handler, description: @description, timeout: @timeout,
+        memory_size: @memory_size, vpc_config: @vpc_configuration, runtime: @runtime
+      )
 
-      # return the version of the new code, not the config.
-      func_version
+      puts "Successfully updated Lambda configuration for #{@lambda_name}"
     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
-      a = if !func_alias
-            @client.create_alias(
-              function_name: function_name, name: alias_name, function_version: func_version,
-              description: 'created by an automated script'
-            ).data
+    def update_lambda_code
+      puts "Updating Lambda Code for #{@lambda_name}...."
+
+      response = @client.update_function_code(
+        function_name: @lambda_name,
+        zip_file: File.open(@path_to_zip_file, 'rb').read,
+        publish: true
+      )
+
+      puts "Successully updated Lambda #{@lambda_name} code to version: #{response.version}"
+      response.version
+    end
+
+    def create_alias(func_version, alias_name, alias_description)
+      if alias_exist?(alias_name)
+        @client.update_alias(
+          function_name: @lambda_name, name: alias_name, function_version: func_version,
+          description: alias_description || 'Alias managed by LambdaWrap'
+        )
+      else
+        @client.create_alias(
+          function_name: @lambda_name, name: alias_name, function_version: func_version,
+          description: alias_description || 'Alias managed by LambdaWrap'
+        )
+      end
+      puts "Created Alias: #{alias_name} for Lambda: #{@lambda_name} v#{func_version}."
+    end
+
+    def remove_alias(alias_name)
+      puts "Deleting Alias: #{alias_name} for #{@lambda_name}"
+      @client.delete_alias(function_name: @lambda_name, name: alias_name)
+    end
+
+    def cleanup_unused_versions
+      puts "Cleaning up unused function versions for #{@lambda_name}."
+      function_versions_to_be_deleted = retrieve_all_function_versions -
+                                        retrieve_function_versions_used_in_aliases
+
+      return if function_versions_to_be_deleted.empty?
+
+      function_versions_to_be_deleted.each do |version|
+        puts "Deleting function version: #{version}."
+        @client.delete_function(function_name: @lambda_name, qualifier: version)
+      end
+
+      puts "Cleaned up #{function_versions_to_be_deleted.length} unused versions."
+    end
+
+    def retrieve_all_function_versions
+      function_versions = []
+      response = nil
+      loop do
+        response =
+          if !response || response.next_marker.nil? || response.next_marker.empty?
+            @client.list_versions_by_function(function_name: @lambda_name)
           else
-            @client.update_alias(
-              function_name: function_name, name: alias_name, function_version: func_version,
-              description: 'updated by an automated script'
-            ).data
+            @client.list_versions_by_function(function_name: @lambda_name, marker: response.next_marker)
           end
-      puts a
+        function_versions.concat(response.versions.map(&:version))
+        if response.next_marker.nil? || response.next_marker.empty?
+          return function_versions.reject { |v| v == '$LATEST' }
+        end
+      end
+    end
 
-      add_api_gateway_permissions(function_name, alias_name)
+    def retrieve_all_aliases
+      aliases = []
+      response = nil
+      loop do
+        response = invoke_client_method_with_optional_marker(response, :list_aliases)
+        aliases.concat(response.aliases)
+        return aliases if response.aliases.empty? || response.next_marker.nil? || response.next_marker.empty?
+      end
     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)
+    def retrieve_function_versions_used_in_aliases
+      function_versions_with_aliases = Set.new []
+      function_versions_with_aliases.merge(retrieve_all_aliases.map(&:function_version)).to_a
     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
+    def alias_exist?(alias_name)
+      retrieve_all_aliases.detect { |a| a.name == alias_name }
     end
 
-    private :add_api_gateway_permissions
+    def invoke_client_method_with_optional_marker(response, method_symbol)
+      if !response || response.next_marker.nil? || response.next_marker.empty?
+        @client.send(method_symbol, function_name: @lambda_name)
+      else
+        @client.send(method_symbol, function_name: @lambda_name, marker: response.next_marker)
+      end
+    end
   end
 end

data/lib/lambda_wrap/version.rb

@@ -1,3 +1,4 @@
 module LambdaWrap
-  VERSION = '0.27.0'.freeze
+  # @!visibility private
+  VERSION = '1.0.0'.freeze
 end

data/lib/lambda_wrap.rb

@@ -1,5 +1,15 @@
-# :nodoc:
-Dir["#{File.expand_path(File.dirname(__FILE__))}/**/*.rb"].each { |f| require f }
+require 'lambda_wrap/version'
+
+require 'aws-sdk'
+require 'yaml'
+require 'active_support/core_ext/hash'
+
+require 'lambda_wrap/aws_service'
+require 'lambda_wrap/lambda_manager'
+require 'lambda_wrap/dynamo_db_manager'
+require 'lambda_wrap/api_gateway_manager'
+require 'lambda_wrap/environment'
+require 'lambda_wrap/api_manager'
 
 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.27.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Markus Thurner
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2017-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -27,19 +27,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
-  name: rubyzip
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '4'
 description: |-
   This gem wraps the AWS SDK to simplify deployment of AWS \
                         Lambda functions backed by API Gateway and DynamoDB.
@@ -51,11 +51,12 @@ extra_rdoc_files: []
 files:
 - lib/lambda_wrap.rb
 - lib/lambda_wrap/api_gateway_manager.rb
+- lib/lambda_wrap/api_manager.rb
+- lib/lambda_wrap/aws_service.rb
 - lib/lambda_wrap/dynamo_db_manager.rb
+- lib/lambda_wrap/environment.rb
 - lib/lambda_wrap/lambda_manager.rb
-- lib/lambda_wrap/s3_bucket_manager.rb
 - lib/lambda_wrap/version.rb
-- lib/lambda_wrap/zip_file_generator.rb
 homepage: https://github.com/Cimpress-MCP/LambdaWrap
 licenses:
 - Apache-2.0
@@ -68,7 +69,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/lambda_wrap/s3_bucket_manager.rb

@@ -1,32 +0,0 @@
-require 'aws-sdk'
-
-module LambdaWrap
-  ##
-  # The S3BucketManager would have functions to help add policies, CORS etc to S3 bucket.
-  class S3BucketManager
-    #
-    # The constructor creates an instance of s3 bucket
-    # * 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
-      @s3bucket = Aws::S3::Client.new
-    end
-
-    ##
-    # Adds policy to the bucket
-    #
-    # *Arguments*
-    # [s3_bucket_name]	S3 bucket name.
-    # [policy]	Policy to be added to the bucket
-    def setup_policy(s3_bucket_name, policy)
-      # Validate the parameters
-      raise 'S3 bucket is not provided' unless s3_bucket_name
-      raise 'Policy json is not provided' unless policy
-
-      @s3bucket.put_bucket_policy(bucket: s3_bucket_name,
-                                  policy: policy.to_json)
-      puts "Created/Updated policy: #{policy} in S3 bucket #{s3_bucket_name}"
-    end
-  end
-end