dpl-elastic_beanstalk 1.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22594965f777aa365113a4cb769c2876a34c6d71
+  data.tar.gz: 5e3149066cc30b974f1480b51b5eeb7673d79473
+SHA512:
+  metadata.gz: f8aa3e16185e01849c5a385ecd4161f09f8d39bee447d569cfbd8f1e44f75717668fb8d244f0bcd0f547fee233f8e2e2cb7c8688d27db29bc96cf7118821e30e
+  data.tar.gz: 2ee266003d72e0e8ce560d29ed8364083359e01251df4872ab57bb179f503aedb250e90e42799fd512d998ecb6c4938ae9d2eb3b9ced8a2aa6563d62ff2e6aa5

data/dpl-elastic_beanstalk.gemspec

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

data/lib/dpl/provider/elastic_beanstalk.rb

@@ -0,0 +1,194 @@
+require 'time'
+require 'aws-sdk'
+require 'zip'
+
+module DPL
+  class Provider
+    class ElasticBeanstalk < Provider
+      experimental 'AWS Elastic Beanstalk'
+
+      DEFAULT_REGION = 'us-east-1'
+
+      def needs_key?
+        false
+      end
+
+      def access_key_id
+        options[:access_key_id] || context.env['AWS_ACCESS_KEY_ID'] || raise(Error, "missing access_key_id")
+      end
+
+      def secret_access_key
+        options[:secret_access_key] || context.env['AWS_SECRET_ACCESS_KEY'] || raise(Error, "missing secret_access_key")
+      end
+
+      def check_auth
+        options = {
+          :region      => region,
+          :credentials => Aws::Credentials.new(access_key_id, secret_access_key)
+        }
+        Aws.config.update(options)
+      end
+
+      def check_app
+      end
+
+      def only_create_app_version
+        options[:only_create_app_version]
+      end
+
+      def push_app
+        @start_time = Time.now
+        create_bucket unless bucket_exists?
+
+        if options[:zip_file]
+          zip_file = File.expand_path(options[:zip_file])
+        else
+          zip_file = create_zip
+        end
+
+        s3_object = upload(archive_name, zip_file)
+        sleep 5 #s3 eventual consistency
+        version = create_app_version(s3_object)
+        if !only_create_app_version
+          update_app(version)
+          wait_until_deployed if options[:wait_until_deployed]
+        end
+      end
+
+      private
+
+      def app_name
+        option(:app)
+      end
+
+      def env_name
+        options[:env] || context.env['ELASTIC_BEANSTALK_ENV'] || raise(Error, "missing env")
+      end
+
+      def version_label
+        context.env['ELASTIC_BEANSTALK_LABEL'] || "travis-#{sha}-#{Time.now.to_i}"
+      end
+
+      def version_description
+        context.env['ELASTIC_BEANSTALK_DESCRIPTION'] || commit_msg
+      end
+
+      def archive_name
+        "#{version_label}.zip"
+      end
+
+      def region
+        options[:region] || DEFAULT_REGION
+      end
+
+      def bucket_name
+        option(:bucket_name)
+      end
+
+      def bucket_path
+        @bucket_path ||= options[:bucket_path] ? option(:bucket_path).gsub(/\/*$/,'/') : nil
+      end
+
+      def s3
+        @s3 ||= Aws::S3::Resource.new
+      end
+
+      def eb
+        @eb ||= Aws::ElasticBeanstalk::Client.new
+      end
+
+      def bucket_exists?
+        s3.bucket(bucket_name).exists?
+      end
+
+      def create_bucket
+        s3.bucket(bucket_name).create
+      end
+
+      def files_to_pack
+        `git ls-files -z`.split("\x0")
+      end
+
+      def create_zip
+        directory = Dir.pwd
+        zipfile_name = File.join(directory, archive_name)
+
+        Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
+          files_to_pack.each do |file|
+            relative_archive_path = File.join(directory, '/')
+            zipfile.add(file.sub(relative_archive_path, ''), file)
+          end
+        end
+        zipfile_name
+      end
+
+      def upload(key, file)
+        options = {
+          :body => Pathname.new(file).open
+        }
+        bucket = s3.bucket(bucket_name)
+        obj = bucket_path ? bucket.object("#{bucket_path}#{key}") : bucket.object(key)
+        obj.put(options)
+        obj
+      end
+
+      def create_app_version(s3_object)
+        # Elastic Beanstalk doesn't support descriptions longer than 200 characters
+        description = version_description[0, 200]
+        options = {
+          :application_name  => app_name,
+          :version_label     => version_label,
+          :description       => description,
+          :source_bundle     => {
+            :s3_bucket => bucket_name,
+            :s3_key    => s3_object.key
+          },
+          :auto_create_application => false
+        }
+        eb.create_application_version(options)
+      end
+
+      # Wait until EB environment update finishes
+      def wait_until_deployed
+        errorEvents = 0 # errors counter, should remain 0 for successful deployment
+        events = []
+
+        loop do
+          environment = eb.describe_environments({
+            :application_name  => app_name,
+            :environment_names => [env_name]
+          })[:environments].first
+
+          eb.describe_events({
+            :environment_name  => env_name,
+            :start_time        => @start_time.utc.iso8601,
+          })[:events].reverse.each do |event|
+            message = "#{event[:event_date]} [#{event[:severity]}] #{event[:message]}"
+            unless events.include?(message)
+              events.push(message)
+              if event[:severity] == "ERROR"
+                errorEvents += 1
+                warn(message)
+              else
+                log(message)
+              end
+            end
+          end
+
+          break if environment[:status] == "Ready"
+          sleep 5
+        end
+
+        if errorEvents > 0 then error("Deployment failed.") end
+      end
+
+      def update_app(version)
+        options = {
+          :environment_name  => env_name,
+          :version_label     => version[:application_version][:version_label]
+        }
+        eb.update_environment(options)
+      end
+    end
+  end
+end

data/spec/provider/elastic_beanstalk_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+require 'aws-sdk'
+require 'dpl/provider'
+require 'dpl/provider/elastic_beanstalk'
+
+describe DPL::Provider::ElasticBeanstalk do
+
+  let(:access_key_id) { 'qwertyuiopasdfghjklz' }
+  let(:secret_access_key) { 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz' }
+  let(:region) { 'us-west-2' }
+  let(:app) { 'example-app' }
+  let(:env) { 'live' }
+  let(:bucket_name) { "travis-elasticbeanstalk-test-builds-#{region}" }
+  let(:bucket_path) { "some/app"}
+  let(:only_create_app_version) { nil }
+  let(:wait_until_deployed) { nil }
+
+  let(:bucket_mock) do
+    dbl = double("bucket mock", write: nil)
+    allow(dbl).to receive(:objects).and_return(double("Hash", :[] => dbl))
+    dbl
+  end
+
+  let(:s3_mock) do
+    hash_dbl = double("Hash", :[] => bucket_mock, :map => [])
+    double("Aws::S3", bucket: hash_dbl, config: hash_dbl)
+  end
+
+  let(:io_double) do
+    double('IO', open: Object.new)
+  end
+
+  let(:s3_obj_double) do
+    double("Aws::S3::Object", put: Object.new)
+  end
+
+  subject :provider do
+    described_class.new(
+      DummyContext.new, :access_key_id => access_key_id, :secret_access_key => secret_access_key,
+      :region => region, :app => app, :env => env, :bucket_name => bucket_name, :bucket_path => bucket_path,
+      :only_create_app_version => only_create_app_version,
+      :wait_until_deployed => wait_until_deployed
+    )
+  end
+
+  subject :provider_without_bucket_path do
+    described_class.new(
+      DummyContext.new, :access_key_id => access_key_id, :secret_access_key => secret_access_key,
+      :region => region, :app => app, :env => env, :bucket_name => bucket_name
+    )
+  end
+
+  describe "#check_auth" do
+    example do
+      expect(Aws.config).to receive(:update)
+      provider.check_auth
+    end
+  end
+
+  describe "#push_app" do
+
+    let(:app_version) { Object.new }
+
+    before :each do
+      allow(io_double).to receive(:open)
+      allow(s3_obj_double).to receive(:put).with(anything).and_return(Object.new)
+      allow(s3_mock).to receive(:bucket).with(bucket_name).and_return(bucket_mock)
+      expect(Pathname).to receive(:new).and_return(io_double)
+    end
+
+    example 'bucket exists already' do
+      allow(s3_mock).to receive(:bucket).with(bucket_name).and_return(bucket_mock)
+      allow(bucket_mock).to receive(:exists?).and_return(true)
+      allow(bucket_mock).to receive(:object).with("some/app/file.zip").and_return(s3_obj_double)
+
+      expect(provider).to receive(:s3).and_return(s3_mock).twice
+      expect(provider).not_to receive(:create_bucket)
+      expect(provider).to receive(:create_zip).and_return('/path/to/file.zip')
+      expect(provider).to receive(:archive_name).and_return('file.zip')
+      expect(provider).to receive(:upload).with('file.zip', '/path/to/file.zip').and_call_original
+      expect(provider).to receive(:sleep).with(5)
+      expect(provider).to receive(:create_app_version).with(s3_obj_double).and_return(app_version)
+      expect(provider).to receive(:update_app).with(app_version)
+
+      provider.push_app
+    end
+
+    example 'bucket doesnt exist yet' do
+      allow(s3_mock).to receive(:bucket).with(bucket_name).and_return(bucket_mock)
+      allow(bucket_mock).to receive(:exists?).and_return(false)
+      allow(bucket_mock).to receive(:object).with("some/app/file.zip").and_return(s3_obj_double)
+
+      expect(provider).to receive(:s3).and_return(s3_mock).twice
+      expect(provider).to receive(:create_bucket)
+      expect(provider).to receive(:create_zip).and_return('/path/to/file.zip')
+      expect(provider).to receive(:archive_name).and_return('file.zip')
+      expect(provider).to receive(:upload).with('file.zip', '/path/to/file.zip').and_call_original
+      expect(provider).to receive(:sleep).with(5)
+      expect(provider).to receive(:create_app_version).with(s3_obj_double).and_return(app_version)
+      expect(provider).to receive(:update_app).with(app_version)
+
+      provider.push_app
+    end
+
+    context 'only creates app version' do
+      let(:only_create_app_version) { true }
+
+      example 'verify the app is not updated' do
+        allow(s3_mock).to receive(:bucket).with(bucket_name).and_return(bucket_mock)
+        allow(bucket_mock).to receive(:exists?).and_return(false)
+        allow(bucket_mock).to receive(:create)
+        allow(bucket_mock).to receive(:object).with("some/app/file.zip").and_return(s3_obj_double)
+
+        expect(provider).to receive(:s3).and_return(s3_mock).at_least(3).times
+        expect(provider).to receive(:create_zip).and_return('/path/to/file.zip')
+        expect(provider).to receive(:archive_name).and_return('file.zip')
+        expect(provider).to receive(:upload).with('file.zip', '/path/to/file.zip').and_call_original
+        expect(provider).to receive(:sleep).with(5)
+        expect(provider).to receive(:create_app_version).with(s3_obj_double).and_return(app_version)
+        expect(provider).not_to receive(:update_app).with(app_version)
+
+        provider.push_app
+      end
+    end
+
+    context 'When the bucket_path option is not set' do
+      example 'Does not prepend bucket_path to the s3 bucket' do
+        allow(s3_mock).to receive(:bucket).with(bucket_name).and_return(bucket_mock)
+        allow(bucket_mock).to receive(:object).with("file.zip").and_return(s3_obj_double)
+        allow(bucket_mock).to receive(:exists?).and_return(false)
+        allow(bucket_mock).to receive(:create)
+
+        expect(provider_without_bucket_path).to receive(:s3).and_return(s3_mock).at_least(3).times
+        expect(provider_without_bucket_path).to receive(:create_zip).and_return('/path/to/file.zip')
+        expect(provider_without_bucket_path).to receive(:archive_name).and_return('file.zip')
+        expect(provider_without_bucket_path).to receive(:bucket_path).and_return(nil)
+        expect(provider_without_bucket_path).to receive(:upload).with('file.zip', '/path/to/file.zip').and_call_original
+        expect(provider_without_bucket_path).to receive(:sleep).with(5)
+        expect(provider_without_bucket_path).to receive(:create_app_version).with(s3_obj_double).and_return(app_version)
+        expect(provider_without_bucket_path).to receive(:update_app).with(app_version)
+
+        provider_without_bucket_path.push_app
+      end
+    end
+
+    context 'When wait_until_deployed option is set' do
+      let(:wait_until_deployed) { true }
+
+      example 'Waits until deployment completes' do
+        allow(bucket_mock).to receive(:exists?).and_return(false)
+        allow(bucket_mock).to receive(:create)
+        allow(bucket_mock).to receive(:object).with("some/app/file.zip").and_return(s3_obj_double)
+
+        expect(provider).to receive(:s3).and_return(s3_mock).at_least(3).times
+        expect(provider).to receive(:create_zip).and_return('/path/to/file.zip')
+        expect(provider).to receive(:archive_name).and_return('file.zip')
+        expect(provider).to receive(:upload).with('file.zip', '/path/to/file.zip').and_call_original
+        expect(provider).to receive(:sleep).with(5)
+        expect(provider).to receive(:create_app_version).with(s3_obj_double).and_return(app_version)
+        expect(provider).to receive(:update_app).with(app_version)
+        expect(provider).to receive(:wait_until_deployed)
+
+        provider.push_app
+      end
+    end
+
+    context "when zip_file option is given" do
+      before :each do
+        allow(bucket_mock).to receive(:object).with("some/app/file.zip").and_return(s3_obj_double)
+        allow(bucket_mock).to receive(:exists?).and_return(false)
+        allow(bucket_mock).to receive(:create)
+        expect(provider).to receive(:s3).and_return(s3_mock).at_least(3).times
+        expect(provider).to receive(:archive_name).and_return('file.zip')
+        expect(provider).to receive(:sleep).with(5)
+        expect(provider).to receive(:create_app_version).with(s3_obj_double).and_return(app_version)
+        expect(provider).to receive(:update_app).with(app_version)
+      end
+
+      example 'zip_file is an absolute path' do
+        provider.options.update(:zip_file => '/absolute/path/to/file.zip')
+        expect(provider).to receive(:upload).with('file.zip', '/absolute/path/to/file.zip').and_call_original
+
+        provider.push_app
+      end
+
+      example 'zip_file is an relative path' do
+        provider.options.update(:zip_file => 'relative/path/to/file.zip')
+        expect(provider).to receive(:upload).with('file.zip', File.join(Dir.pwd, 'relative/path/to/file.zip')).and_call_original
+
+        provider.push_app
+      end
+
+      example 'zip_file is a path with ~/' do
+        provider.options.update(:zip_file => '~/file.zip')
+        expect(provider).to receive(:upload).with('file.zip', File.join(ENV['HOME'], 'file.zip')).and_call_original
+
+        provider.push_app
+      end
+
+      example 'zip_file is has no path' do
+        provider.options.update(:zip_file => 'file.zip')
+        expect(provider).to receive(:upload).with('file.zip', File.join(Dir.pwd, 'file.zip')).and_call_original
+
+        provider.push_app
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: dpl-elastic_beanstalk
+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-elastic_beanstalk.gemspec
+- lib/dpl/provider/elastic_beanstalk.rb
+- spec/provider/elastic_beanstalk_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/elastic_beanstalk_spec.rb