dpl-lambda 1.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ca31356644301a0e6cac4f7a8368e7d534ecf55
+  data.tar.gz: 8f10f9abd9d4f670a0349105bf8c2f079382d275
+SHA512:
+  metadata.gz: dd57f55db2c061b649796fb1101a522f9b1539042c5b60f7be845d9508447a4530d54ea6b05c869849b2e9c3a349334243b4c203f115e0fcbd20670351c53248
+  data.tar.gz: 6ae409607b321e1f0349abe6bc47bc6c42b5e38f2ee98c614e4abf0b7f27a557a04e8159d1a4baedbd58a2df8081504fd4bcdeca832bf3ced314f8ba6663da96

data/dpl-lambda.gemspec

@@ -0,0 +1,3 @@
+require './gemspec_helper'
+
+gemspec_for 'lambda', [['aws-sdk', '~> 2.0'], ['rubyzip']]

data/lib/dpl/provider/lambda.rb

@@ -0,0 +1,235 @@
+require 'json'
+require 'tempfile'
+require 'fileutils'
+require 'aws-sdk'
+require 'zip'
+
+module DPL
+  class Provider
+    class Lambda < Provider
+      def lambda
+        @lambda ||= ::Aws::Lambda::Client.new(lambda_options)
+      end
+
+      def lambda_options
+        {
+            region:      options[:region] || 'us-east-1',
+            credentials: ::Aws::Credentials.new(option(:access_key_id), option(:secret_access_key))
+        }
+      end
+
+      def push_app
+
+        # The original LambdaPreview client supported create/update in one call
+        # To keep compatibility we try to fetch the function and then decide
+        # whether to update the code or create a new function
+
+        function_name = options[:name] || option(:function_name)
+
+        begin
+          response = lambda.get_function({function_name: function_name})
+
+          log "Function #{function_name} already exists, updating."
+
+          # Options defined at
+          #   https://docs.aws.amazon.com/sdkforruby/api/Aws/Lambda/Client.html#update_function_configuration-instance_method
+          response = lambda.update_function_configuration({
+	                      function_name:        function_name,
+	                      description:          options[:description]    || default_description,
+	                      timeout:              options[:timeout]        || default_timeout,
+	                      memory_size:          options[:memory_size]    || default_memory_size,
+	                      role:                 option(:role),
+	                      handler:              handler,
+	                      runtime:              options[:runtime]        || default_runtime,
+	                      vpc_config:           vpc_config,
+	                      environment:          environment_variables,
+	                      dead_letter_config:   dead_letter_arn,
+	                      kms_key_arn:          options[:kms_key_arn] || default_kms_key_arn,
+	                      tracing_config:       tracing_mode
+	                    })
+
+          log "Updated configuration of function: #{response.function_name}."
+
+          if function_tags
+            log "Add tags to function #{response.function_name}."
+            response = lambda.tag_resource({
+						              resource: response.function_arn,
+						              tags: function_tags
+						            })
+          end
+
+          # Options defined at
+          #   https://docs.aws.amazon.com/sdkforruby/api/Aws/Lambda/Client.html#update_function_code-instance_method
+          response = lambda.update_function_code({
+                                                   function_name:  options[:name] || option(:function_name),
+                                                   zip_file:       function_zip,
+                                                   publish:        publish
+                                               })
+
+          log "Updated code of function: #{response.function_name}."
+        rescue ::Aws::Lambda::Errors::ResourceNotFoundException
+          log "Function #{function_name} does not exist, creating."
+          # Options defined at
+          #   https://docs.aws.amazon.com/lambda/latest/dg/API_CreateFunction.html
+          response = lambda.create_function({
+		                    function_name:        options[:name]           || option(:function_name),
+		                    description:          options[:description]    || default_description,
+		                    timeout:              options[:timeout]        || default_timeout,
+		                    memory_size:          options[:memory_size]    || default_memory_size,
+		                    role:                 option(:role),
+		                    handler:              handler,
+		                    code: {
+		                     zip_file:           function_zip,
+		                    },
+		                    runtime:              options[:runtime]        || default_runtime,
+		                    publish:              publish,
+		                    vpc_config:           vpc_config,
+		                    environment:          environment_variables,
+		                    dead_letter_config:   dead_letter_arn,
+		                    kms_key_arn:          options[:kms_key_arn] || default_kms_key_arn,
+		                    tracing_config:       tracing_mode,
+		                    tags:                 function_tags
+		                  })
+
+          log "Created lambda: #{response.function_name}."
+        end
+      rescue ::Aws::Lambda::Errors::ServiceException => exception
+        error(exception.message)
+      rescue ::Aws::Lambda::Errors::InvalidParameterValueException => exception
+        error(exception.message)
+      rescue ::Aws::Lambda::Errors::ResourceNotFoundException => exception
+        error(exception.message)
+      end
+
+      def handler
+        module_name = options[:module_name] || default_module_name
+        handler_name = option(:handler_name)
+
+        "#{module_name}.#{handler_name}"
+      end
+
+      def function_zip
+        target_zip_path = File.absolute_path(options[:zip] || Dir.pwd)
+        dest_file_path = output_file_path
+
+        if File.directory?(target_zip_path)
+          zip_directory(dest_file_path, target_zip_path)
+        elsif File.file?(target_zip_path)
+          zip_file(dest_file_path, target_zip_path)
+        else
+          error('Invalid zip option. If set, must be path to directory, js file, or a zip file.')
+        end
+
+        File.new(dest_file_path)
+      end
+
+      def zip_file(dest_file_path, target_file_path)
+        if File.extname(target_file_path) == '.zip'
+          # Just copy it to the destination right away, since it is already a zip.
+          FileUtils.cp(target_file_path, dest_file_path)
+          dest_file_path
+        else
+          # Zip up the file.
+          src_directory_path = File.dirname(target_file_path)
+          files = [ target_file_path ]
+
+          create_zip(dest_file_path, src_directory_path, files)
+        end
+      end
+
+      def zip_directory(dest_file_path, target_directory_path)
+        files = Dir[File.join(target_directory_path, '**', '**')]
+        create_zip(dest_file_path, target_directory_path, files)
+      end
+
+      def create_zip(dest_file_path, src_directory_path, files)
+        Zip::File.open(dest_file_path, Zip::File::CREATE) do |zipfile|
+          files.each do |file|
+            zipfile.add(file.sub(src_directory_path + File::SEPARATOR, ''), file)
+          end
+        end
+
+        dest_file_path
+      end
+
+      def needs_key?
+        false
+      end
+
+      def check_auth
+        log "Using Access Key: #{option(:access_key_id)[-4..-1].rjust(20, '*')}"
+      end
+
+      def output_file_path
+        @output_file_path ||= '/tmp/' + random_chars(8) + '-lambda.zip'
+      end
+
+      def vpc_config
+        options[:subnet_ids] && options[:security_group_ids] ? { :subnet_ids => Array(options[:subnet_ids]), :security_group_ids => Array(options[:security_group_ids]) } : nil
+      end
+
+      def environment_variables
+        options[:environment_variables] ? { :variables => split_string_array_to_hash(options[:environment_variables]) } : nil
+      end
+
+      def dead_letter_arn
+        options[:dead_letter_arn] ? { :target_arn => options[:dead_letter_arn]} : nil
+      end
+
+      def tracing_mode
+        options[:tracing_mode] ? { :mode => options[:tracing_mode]} : nil
+      end
+
+      def default_kms_key_arn
+        nil
+      end
+
+      def function_tags
+        options[:function_tags] ? split_string_array_to_hash(options[:function_tags]) : nil
+      end
+
+      def default_runtime
+        'nodejs'
+      end
+
+      def default_timeout
+        3 # seconds
+      end
+
+      def default_description
+        "Deploy build #{context.env['TRAVIS_BUILD_NUMBER']} to AWS Lambda via Travis CI"
+      end
+
+      def default_memory_size
+        128
+      end
+
+      def default_module_name
+        'index'
+      end
+
+      def publish
+        !!options[:publish]
+      end
+
+      def split_string_array_to_hash(arr, delimiter="=")
+        variables = {}
+        Array(arr).map do |val|
+          keyval = val.split(delimiter)
+          variables[keyval[0]] = keyval[1]
+        end
+        variables
+      end
+
+      def random_chars(count=8)
+        (36**(count-1) + rand(36**count - 36**(count-1))).to_s(36)
+      end
+
+      def cleanup
+      end
+
+      def uncleanup
+      end
+    end
+  end
+end

data/spec/provider/lambda_spec.rb

@@ -0,0 +1,434 @@
+require 'spec_helper'
+require 'aws-sdk'
+require 'dpl/error'
+require 'dpl/provider'
+require 'dpl/provider/lambda'
+
+describe DPL::Provider::Lambda do
+
+  subject :provider do
+    described_class.new(DummyContext.new, :access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz')
+  end
+
+  describe '#lambda_options' do
+    context 'without region' do
+      example do
+        options = provider.lambda_options
+        expect(options[:region]).to eq('us-east-1')
+      end
+    end
+
+    context 'with region' do
+      example do
+        region = 'us-west-1'
+        provider.options.update(:region => region)
+        options = provider.lambda_options
+        expect(options[:region]).to eq(region)
+      end
+    end
+  end
+end
+
+describe DPL::Provider::Lambda do
+  access_key_id = 'someaccesskey'
+  secret_access_key = 'somesecretaccesskey'
+  region = 'us-east-1'
+
+  client_options = {
+    stub_responses: true,
+    region: region,
+    credentials: Aws::Credentials.new(access_key_id, secret_access_key)
+  }
+
+  subject :provider do
+    described_class.new(DummyContext.new, {
+      access_key_id: access_key_id,
+      secret_access_key: secret_access_key
+    })
+  end
+
+  before :each do
+    FileUtils.touch provider.output_file_path
+    allow(provider).to receive(:lambda_options).and_return(client_options)
+    allow(provider).to receive(:create_zip).and_return(provider.output_file_path)
+  end
+
+  describe '#lambda' do
+    example do
+      expect(Aws::Lambda::Client).to receive(:new).with(client_options).once
+      provider.lambda
+    end
+  end
+
+  describe '#push_app' do
+    lambda_options = {
+      function_name: 'test-function',
+      role: 'some-role',
+      module_name: 'index',
+      handler_name: 'handler'
+    }
+
+    example_get_function_response = {
+      code: {
+        location: 'location',
+        repository_type: 's3',
+      },
+      configuration: {
+        function_name: 'test-function'
+      }
+    }
+
+    example_response = {
+      function_name: 'test-function',
+      function_arn: 'arn:lambda:region:account-id:function:test-function',
+      role: 'some-role',
+      handler: 'index.handler'
+    }
+
+    before(:each) do
+      old_options = provider.options
+      allow(provider).to receive(:options) { old_options.merge(lambda_options) }
+    end
+
+    context 'by creating a new function' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'ResourceNotFoundException')
+        provider.lambda.stub_responses(:create_function, example_response)
+      end
+
+      example do
+        expect(provider).to receive(:log).with(/Function #{lambda_options[:function_name]} does not exist, creating\./)
+        expect(provider).to receive(:log).with(/Created lambda: #{lambda_options[:function_name]}\./)
+        provider.push_app
+      end
+    end
+
+    context 'by updating an existing function' do
+      before do
+        provider.lambda.stub_responses(:get_function, example_get_function_response)
+        provider.lambda.stub_responses(:update_function_configuration, example_response)
+        provider.lambda.stub_responses(:update_function_code, example_response)
+      end
+
+      example do
+        expect(provider).to receive(:log).with(/Function #{lambda_options[:function_name]} already exists, updating\./)
+        expect(provider).to receive(:log).with(/Updated configuration of function: #{lambda_options[:function_name]}\./)
+        expect(provider).to receive(:log).with(/Updated code of function: #{lambda_options[:function_name]}\./)
+        provider.push_app
+      end
+    end
+
+    context 'by updating an existing function with new tags' do
+      before do
+        lambda_options[:function_tags] = [ 'TAG_KEY=some-value' ]
+        provider.lambda.stub_responses(:get_function, example_get_function_response)
+        provider.lambda.stub_responses(:update_function_configuration, example_response)
+        provider.lambda.stub_responses(:tag_resource)
+        provider.lambda.stub_responses(:update_function_code, example_response)
+      end
+
+      example do
+        expect(provider).to receive(:log).with(/Function #{lambda_options[:function_name]} already exists, updating\./)
+        expect(provider).to receive(:log).with(/Updated configuration of function: #{lambda_options[:function_name]}\./)
+        expect(provider).to receive(:log).with(/Add tags to function #{lambda_options[:function_name]}\./)
+        expect(provider).to receive(:log).with(/Updated code of function: #{lambda_options[:function_name]}\./)
+        provider.push_app
+      end
+    end
+
+    context 'with a ServiceException response' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'ResourceNotFoundException')
+        provider.lambda.stub_responses(:create_function, 'ServiceException')
+      end
+
+      example do
+        expect(provider).to receive(:error).once
+        provider.push_app
+      end
+    end
+
+    context 'with a InvalidParameterValueException response' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'InvalidParameterValueException')
+      end
+
+      example do
+        expect(provider).to receive(:error).once
+        provider.push_app
+      end
+    end
+
+    context 'with a ResourceNotFoundException response' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'ResourceNotFoundException')
+        provider.lambda.stub_responses(:create_function, 'ResourceNotFoundException')
+      end
+
+      example do
+        expect(provider).to receive(:error).once
+        provider.push_app
+      end
+    end
+  end
+
+  describe "#handler" do
+    context "without a module name" do
+      module_name = 'index'
+      handler_name = 'HandlerName'
+      expected_handler = "#{module_name}.#{handler_name}"
+
+      before do
+        expect(provider.options).to receive(:[]).with(:module_name).and_return(nil)
+        expect(provider.options).to receive(:fetch).with(:handler_name).and_return(handler_name)
+      end
+
+      example do
+        expect(provider.handler).to eq(expected_handler)
+      end
+    end
+
+    context "with a module name" do
+      module_name = 'ModuleName'
+      handler_name = 'HandlerName'
+      expected_handler = "#{module_name}.#{handler_name}"
+
+      before do
+        expect(provider.options).to receive(:[]).with(:module_name).and_return(module_name)
+        expect(provider.options).to receive(:fetch).with(:handler_name).and_return(handler_name)
+      end
+
+      example do
+        expect(provider.handler).to eq(expected_handler)
+      end
+    end
+  end
+
+  describe '#function_zip' do
+    context 'when zip is not specified' do
+      path = Dir.pwd
+      output_file_path = '/some/path.zip'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(nil)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(true)
+        expect(provider).to receive(:zip_directory).with(output_file_path, path)
+        expect(File).to receive(:new).with(output_file_path)
+      end
+
+      example do
+        provider.function_zip
+      end
+    end
+
+    context 'when zip is a file path' do
+      path = '/some/file/path.zip'
+      output_file_path = '/some/path.zip'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(path)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(false)
+        expect(File).to receive(:file?).with(path).and_return(true)
+        expect(provider).to receive(:zip_file).with(output_file_path, path)
+        expect(File).to receive(:new).with(output_file_path)
+      end
+
+      example do
+        provider.function_zip
+      end
+    end
+
+    context 'when zip is a directory' do
+      path = '/some/dir/path'
+      output_file_path = '/some/path.zip'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(path)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(true)
+        expect(provider).to receive(:zip_directory).with(output_file_path, path)
+        expect(File).to receive(:new).with(output_file_path)
+      end
+
+      example do
+        provider.function_zip
+      end
+    end
+
+    context 'with an invalid zip option' do
+      path = '/some/file/path.zip'
+      output_file_path = '/some/path.zip'
+      error = 'Invalid zip option. If set, must be path to directory, js file, or a zip file.'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(path)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(false)
+        expect(File).to receive(:file?).with(path).and_return(false)
+      end
+
+      example do
+        expect { provider.function_zip }.to raise_error(DPL::Error, error)
+      end
+    end
+  end
+
+  describe '#zip_file' do
+    dest = '/some/path/to/write.zip'
+
+    context 'when zip is a file path' do
+      dir = '/some/target'
+      target = File.join(dir, 'file.js')
+
+      before do
+        expect(File).to receive(:extname).with(target).and_return('.js')
+        expect(provider).to receive(:create_zip).with(dest, dir, [ target ])
+      end
+
+      example do
+        provider.zip_file(dest, target)
+      end
+    end
+
+    context 'when zip is an existing zip file' do
+      dir = '/some/target'
+      target = File.join(dir, 'file.js')
+
+      before do
+        expect(File).to receive(:extname).with(target).and_return('.zip')
+        expect(FileUtils).to receive(:cp).with(target, dest)
+      end
+
+      example do
+        provider.zip_file(dest, target)
+      end
+    end
+  end
+
+  describe '#zip_directory' do
+    dest = '/some/path/to/write.zip'
+    target = '/some/dir'
+    glob = File.join(target, '**', '**')
+    files = %w[ 'one' 'two' ]
+
+    before do
+      expect(Dir).to receive(:[]).with(glob).and_return(files)
+      expect(provider).to receive(:create_zip).with(dest, target, files)
+    end
+
+    example do
+      provider.zip_directory(dest, target)
+    end
+  end
+
+  describe '#create_zip' do
+    dest = '/some/dest.zip'
+    src =  '/some/src/dir'
+    file_one = 'one.js'
+    file_two = 'two.js'
+    files = [
+      File.join(src, file_one),
+      File.join(src, file_two)
+    ]
+
+    before do
+      expect(provider).to receive(:create_zip).and_call_original
+      zip_file = double(Zip::File)
+      expect(Zip::File).to receive(:open).with(dest, Zip::File::CREATE).and_yield(zip_file)
+      expect(zip_file).to receive(:add).once.with(file_one, File.join(src, file_one))
+      expect(zip_file).to receive(:add).once.with(file_two, File.join(src, file_two))
+    end
+
+    example do
+      provider.create_zip(dest, src, files)
+    end
+  end
+
+  describe '#needs_key?' do
+    example do
+      expect(provider.needs_key?).to eq(false)
+    end
+  end
+
+  describe '#check_auth' do
+    example do
+      expect(provider).to receive(:log).with("Using Access Key: #{access_key_id[-4..-1].rjust(20, '*')}")
+      provider.check_auth
+    end
+  end
+
+  describe '#output_file_path' do
+    example do
+      expect(provider.output_file_path).to match(/tmp\/\w{8}\-lambda\.zip/)
+    end
+  end
+
+  describe '#default_runtime' do
+    example do
+      expect(provider.default_runtime).to eq('nodejs')
+    end
+  end
+
+  describe '#default_timeout' do
+    example do
+      expect(provider.default_timeout).to eq(3)
+    end
+  end
+
+  describe '#default_description' do
+    build_number = 2
+
+    before do
+      allow(provider.context.env).to receive(:[]).with('TRAVIS_BUILD_NUMBER').and_return(build_number)
+    end
+
+    let(:build_number) { provider.context.env['TRAVIS_BUILD_NUMBER'] }
+
+    example do
+      expect(provider.default_description).to eq(
+        "Deploy build #{build_number} to AWS Lambda via Travis CI"
+      )
+    end
+  end
+
+  describe '#default_memory_size' do
+    example do
+      expect(provider.default_memory_size).to eq(128)
+    end
+  end
+
+  describe '#publish' do
+    context 'is default turned off' do
+      example do
+        expect(provider.publish).to eq(false)
+      end
+    end
+    context 'can be turned on' do
+      before do
+        expect(provider.options).to receive(:[]).with(:publish).and_return(true)
+      end
+
+      example do
+        expect(provider.publish).to eq(true)
+      end
+    end
+  end
+
+  describe '#random_chars' do
+    context 'without specifying count' do
+      example do
+        expect(provider.random_chars.length).to eq(8)
+      end
+    end
+
+    context 'with specified count' do
+      count = 4
+      example do
+        expect(provider.random_chars(count).length).to eq(count)
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: dpl-lambda
+version: !ruby/object:Gem::Version
+  version: 1.9.0
+platform: ruby
+authors:
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dpl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tins
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: deploy tool abstraction for clients
+email: konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- dpl-lambda.gemspec
+- lib/dpl/provider/lambda.rb
+- spec/provider/lambda_spec.rb
+homepage: https://github.com/travis-ci/dpl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: deploy tool
+test_files:
+- spec/provider/lambda_spec.rb