dpl 1.10.17.travis.6637.6 → 2.0.0.alpha.1

data/lib/dpl/providers/codedeploy.rb

@@ -0,0 +1,179 @@
+module Dpl
+  module Providers
+    # split this up to CodeDeploy::Github and CodeDeploy::S3 using the
+    # revision_type, in order to make opts more strict
+    class Codedeploy < Provider
+      status :alpha
+
+      full_name 'AWS Code Deploy'
+
+      description sq(<<-str)
+        tbd
+      str
+
+      gem 'aws-sdk-codedeploy', '~> 1.0'
+      gem 'aws-sdk-s3', '~> 1.0'
+
+      env :aws
+      config '~/.aws/credentials', '~/.aws/config', prefix: 'aws'
+
+      opt '--access_key_id ID', 'AWS access key', required: true, secret: true
+      opt '--secret_access_key KEY', 'AWS secret access key', required: true, secret: true
+      opt '--application NAME', 'CodeDeploy application name', required: true
+      opt '--deployment_group GROUP', 'CodeDeploy deployment group name'
+      opt '--revision_type TYPE', 'CodeDeploy revision type', enum: %w(s3 github), downcase: true
+      opt '--commit_id SHA', 'Commit ID in case of GitHub'
+      opt '--repository NAME', 'Repository name in case of GitHub'
+      opt '--bucket NAME', 'S3 bucket in case of S3'
+      opt '--region REGION', 'AWS availability zone', default: 'us-east-1'
+      opt '--file_exists_behavior STR', 'How to handle files that already exist in a deployment target location', enum: %w(disallow overwrite retain), default: 'disallow'
+      opt '--wait_until_deployed', 'Wait until the deployment has finished'
+      opt '--bundle_type TYPE'
+      opt '--endpoint ENDPOINT'
+      opt '--key KEY'
+      opt '--description DESCR'
+
+      msgs login:                 'Using Access Key: %{access_key_id}',
+           deploy_triggered:      'Deployment triggered: %s',
+           register_revision:     'Registering app revision with version=%s, etag=%s',
+           waiting_for_deploy:    'Waiting for the deployment to finish ',
+           finished_deploy:       'done: %s.',
+           description:           'Deploy build %{build_number} via Travis CI',
+           missing_bucket:        'Missing required bucket for S3 deployment',
+           missing_key:           'Missing required key for S3 deployment',
+           unknown_revision_type: 'Unknown revision type %p',
+           unknown_bundle_type:   'Unknown bundle type'
+
+      def login
+        info :login
+      end
+
+      def deploy
+        register_revision if revision_info[:version]
+        id = create_deployment
+        info :deploy_triggered, id
+        wait_until_deployed(id) if wait_until_deployed?
+      rescue Aws::CodeDeploy::Errors::DeploymentLimitExceededException => e
+        error e.message
+      end
+
+      def register_revision
+        info :register_revision, revision_info[:version], revision_info[:e_tag]
+        code_deploy.register_application_revision(
+          revision: revision,
+          application_name: application,
+          description: description
+        )
+      end
+
+      def create_deployment
+        deployment = code_deploy.create_deployment(
+          revision: revision,
+          application_name: application,
+          deployment_group_name: deployment_group,
+          description: description,
+          file_exists_behavior: file_exists_behavior.upcase
+        )
+        deployment.deployment_id
+      end
+
+      def wait_until_deployed(id)
+        print :waiting_for_deploy
+        status = poll(id) until %w(Succeeded Failed Stopped).include?(status)
+        info :finished_deploy, status
+      end
+
+      def poll(id)
+        sleep 5
+        print '.'
+        code_deploy.get_deployment(deployment_id: id)[:deployment_info][:status]
+      end
+
+      def revision_info
+        revision[:s3_location] || {}
+      end
+
+      def revision
+        @revision ||= case revision_type
+        when 's3'     then s3_revision
+        when 'github' then github_revision
+        when nil      then bucket? ? s3_revision : github_revision
+        else error :unknown_revision_type, revision_type
+        end
+      end
+
+      def s3_revision
+        {
+          revision_type: 'S3',
+          s3_location: compact(
+            bucket: bucket,
+            bundle_type: bundle_type,
+            version: revision_version_info[:version_id],
+            e_tag: revision_version_info[:etag],
+            key: key,
+          )
+        }
+      end
+
+      def revision_version_info
+        s3.head_object(bucket: bucket, key: key)
+      rescue Aws::Errors::ServiceError => e
+        error e.message
+      end
+
+      def github_revision
+        {
+          revision_type: 'GitHub',
+          git_hub_location: {
+            commit_id:  commit_id,
+            repository: repository
+          }
+        }
+      end
+
+      def commit_id
+        super || git_sha
+      end
+
+      def repository
+        super || ENV['TRAVIS_REPO_SLUG'] || File.basename(Dir.pwd)
+      end
+
+      def bucket
+        super || error(:missing_bucket)
+      end
+
+      def key
+        super || error(:missing_key)
+      end
+
+      def bundle_type
+        super || key =~ /\.(tar|tgz|zip)$/ && $1 || error(:unknown_bundle_type)
+      end
+
+      def description
+        super || interpolate(msg(:description))
+      end
+
+      def build_number
+        ENV['TRAVIS_BUILD_NUMBER']
+      end
+
+      def code_deploy
+        @code_deploy ||= Aws::CodeDeploy::Client.new(client_options)
+      end
+
+      def s3
+        @s3 ||= Aws::S3::Client.new(client_options)
+      end
+
+      def client_options
+        compact(region: region, credentials: credentials, endpoint: endpoint)
+      end
+
+      def credentials
+        Aws::Credentials.new(access_key_id, secret_access_key)
+      end
+    end
+  end
+end

data/lib/dpl/providers/datica.rb

@@ -0,0 +1,60 @@
+module Dpl
+  module Providers
+    class Datica < Provider
+      status :dev
+
+      register :datica, :catalyze
+
+      description sq(<<-str)
+        tbd
+      str
+
+      env :datica, :catalyze
+
+      opt '--target TARGET', 'The git remote repository to deploy to', required: true
+      opt '--path PATH', 'Path to files to deploy', default: '.'
+
+      needs :git
+
+      cmds checkout: 'git checkout HEAD',
+           add:      'git add %{path} --all --force',
+           commit:   'git commit -m "%{message}" --quiet',
+           push:     'git push --force %{target} HEAD:master'
+
+      msgs commit:   'Committing build files for deployment',
+           push:     'Deploying to Datica: %{target}'
+
+      def setup
+        commit unless cleanup?
+      end
+
+      def deploy
+        shell :push
+      end
+
+      private
+
+        def commit
+          info :commit
+          shell :checkout
+          shell :add
+          shell :commit
+        end
+
+        def message
+          vars.empty? ? 'Local build' : 'Build #%s (%s) of %s@%s' % vars
+        end
+
+        VARS = %w(
+          TRAVIS_BUILD_NUMBER
+          TRAVIS_COMMIT
+          TRAVIS_REPO_SLUG
+          TRAVIS_BRANCH
+        )
+
+        def vars
+          @vars ||= ENV.values_at(*VARS).compact
+        end
+    end
+  end
+end

data/lib/dpl/providers/elasticbeanstalk.rb

@@ -0,0 +1,195 @@
+module Dpl
+  module Providers
+    class Elasticbeanstalk < Provider
+      status :alpha
+
+      full_name 'AWS Elastic Beanstalk'
+
+      description sq(<<-str)
+        tbd
+      str
+
+      gem 'aws-sdk-elasticbeanstalk', '~> 1.0'
+      gem 'aws-sdk-s3', '~> 1.0'
+      gem 'rubyzip', '~> 1.2.2', require: 'zip'
+      gem 'pathspec', '~> 0.2.1', require: 'pathspec'
+
+      env :aws, :elastic_beanstalk
+      config '~/.aws/credentials', '~/.aws/config', prefix: 'aws'
+
+      opt '--access_key_id ID', 'AWS Access Key ID', required: true, secret: true
+      opt '--secret_access_key KEY', 'AWS Secret Key', required: true, secret: true
+      opt '--region REGION', 'AWS Region the Elastic Beanstalk app is running in', default: 'us-east-1'
+      opt '--app NAME', 'Elastic Beanstalk application name', default: :repo_name
+      opt '--env NAME', 'Elastic Beanstalk environment name which will be updated', required: true
+      opt '--bucket NAME', 'Bucket name to upload app to', required: true, alias: :bucket_name
+      opt '--bucket_path PATH', 'Location within Bucket to upload app to'
+      opt '--description DESC', 'Description for the application version'
+      opt '--label LABEL', 'Label for the application version'
+      opt '--zip_file PATH', 'The zip file that you want to deploy'
+      opt '--only_create_app_version', 'Only create the app version, do not actually deploy it'
+      opt '--wait_until_deployed', 'Wait until the deployment has finished'
+      opt '--debug', internal: true
+
+      msgs login:   'Using Access Key: %{access_key_id}',
+           zip_add: 'Adding %s'
+
+      msgs clean_description: 'Removed non-printable characters from the version description'
+
+      attr_reader :started, :object, :version
+
+      def login
+        info :login
+      end
+
+      def setup
+        info :login
+        Aws.config.update(credentials: credentials, region: region)
+      end
+
+      def deploy
+        @started = Time.now
+        bucket.create unless bucket.exists?
+        create_zip unless zip_exists?
+        upload
+        create_version
+        update_app unless only_create_app_version?
+      end
+
+      def zip_file
+        zip_file? ? expand(super) : archive_name
+      end
+
+      def archive_name
+        "#{label}.zip"
+      end
+
+      def label
+        @label ||= super || "travis-#{git_sha}-#{Time.now.to_i}"
+      end
+
+      def description
+        super || git_commit_msg
+      end
+
+      def bucket_path
+        bucket_path? ? "#{super.gsub(/\/*$/, '')}/#{archive_name}" : archive_name
+      end
+
+      def cwd
+        @cwd ||= "#{Dir.pwd}/"
+      end
+
+      def zip_exists?
+        File.exists?(zip_file)
+      end
+
+      def create_zip
+        ::Zip::File.open(zip_file, ::Zip::File::CREATE) do |zip|
+          files.each do |path|
+            debug :zip_add, path
+            zip.add(path.sub(cwd, ''), path)
+          end
+        end
+      end
+
+      def upload
+        @object = bucket.object(bucket_path)
+        object.put(body: File.open(zip_file))
+        sleep 5 # s3 eventual consistency
+      end
+
+      def create_version
+        @version = eb.create_application_version(
+          application_name: app,
+          version_label: label,
+          description: clean(description[0, 200]),
+          source_bundle: {
+            s3_bucket: bucket.name,
+            s3_key: object.key
+          },
+          auto_create_application: false
+        )
+      end
+
+      def update_app
+        eb.update_environment(
+          environment_name: env,
+          version_label: version[:application_version][:version_label]
+        )
+        wait_until_deployed if wait_until_deployed?
+      end
+
+      def wait_until_deployed
+        msgs = []
+        1.upto(20) { return if check_deployment(msgs) }
+        error 'Too many failures'
+      end
+
+      def check_deployment(msgs)
+        sleep 5
+        events.each do |event|
+          msg = "#{event.event_date} [#{event.severity}] #{event.message}"
+          error "Deployment failed: #{msg}" if event.severity == 'ERROR'
+          info msg unless msgs.include?(msg)
+          msgs << msg
+        end
+        environment[:status] == 'Ready'
+      rescue Aws::Errors::ServiceError => e
+        info "Caught #{e}: #{e.message}. Retrying ..."
+      end
+
+      def files
+        files = Dir.glob('**/*', File::FNM_DOTMATCH)
+        files = filter(files, '.ebignore') if file?('.ebignore')
+        files
+      end
+
+      def filter(files, spec)
+        spec = PathSpec.from_filename(spec)
+        files.reject { |file| spec.match(file) }
+      end
+
+      def events
+        args = { environment_name: env, start_time: started.utc.iso8601 }
+        eb.describe_events(args)[:events].reverse
+      end
+
+      def environment
+        args = { application_name: app, environment_names: [env] }
+        eb.describe_environments(args)[:environments].first
+      end
+
+      def credentials
+        Aws::Credentials.new(access_key_id, secret_access_key)
+      end
+
+      def s3
+        @s3 ||= Aws::S3::Resource.new
+      end
+
+      def bucket
+        @bucket ||= s3.bucket(super)
+      end
+
+      def eb
+        @eb ||= Aws::ElasticBeanstalk::Client.new(retry_limit: 10)
+      end
+
+      # We do not actually know what characters are valid on AWS EB's side,
+      # see: https://github.com/aws/aws-sdk-ruby/issues/1502
+      #
+      # Reference: https://www.w3.org/TR/xml/#charsets
+      NON_PRINTABLE_CHARS = "\u0009\u000A\u000D\u0020-\uD7FF\uE000-\uFFFD\u10000-\u10FFFF"
+
+      def clean(str)
+        str.gsub!(/[^#{NON_PRINTABLE_CHARS}]/, '') && info(:clean_description)
+        str
+      end
+
+      def debug(*args)
+        info *args if debug?
+      end
+    end
+  end
+end

data/lib/dpl/providers/engineyard.rb

@@ -0,0 +1,107 @@
+module Dpl
+  module Providers
+    class Engineyard < Provider
+      status :alpha
+
+      description sq(<<-str)
+        tbd
+      str
+
+      gem 'ey-core', '~> 3.5'
+
+      required :api_key, [:email, :password]
+
+      opt '--api_key KEY',   'Engine Yard API key', secret: true
+      opt '--email EMAIL',   'Engine Yard account email'
+      opt '--password PASS', 'Engine Yard password', secret: true
+      opt '--app APP',       'Engine Yard application name', default: :repo_name
+      opt '--env ENV',       'Engine Yard application environment', alias: :environment
+      opt '--migrate CMD',   'Engine Yard migration commands'
+      opt '--account NAME',  'Engine Yard account name'
+
+      msgs deploy:           'Deploying ...',
+           login:            'Authenticating via email and password ...',
+           write_rc:         'Authenticating via api token ...',
+           authenticated:    'Authenticated as %{name}',
+           invalid_migrate:  'Invalid migration command, try --migrate="rake db:migrate"',
+           envs:             'Checking environment ...',
+           no_env:           'No matching environment found',
+           too_many_envs:    'Multiple environments match, please be more specific: %s',
+           env_entry:        'environment=%s account=%s'
+
+      cmds login:  "ey-core login << str\n%{email}\n%{password}\nstr",
+           whoami: 'ey-core whoami',
+           envs:   'ey-core environments',
+           deploy: 'ey-core deploy %{deploy_opts}'
+
+      def login
+        api_key? ? write_rc : authenticate
+        info :authenticated, name: whoami
+      end
+
+      def validate
+        error :invalid_migrate if invalid_migrate?
+        env
+      end
+
+      def deploy
+        shell :deploy
+      end
+
+      private
+
+        def authenticate
+          shell :login, echo: false, capture: true
+        end
+
+        def whoami
+          shell(:whoami, echo: false, capture: true) =~ /email\s*:\s*"(.+)"/ && $1
+        end
+
+        def write_rc
+          info :write_rc
+          write_file '~/.ey-core', "https://api.engineyard.com/: #{api_key}"
+        end
+
+        def invalid_migrate?
+          migrate.is_a?(TrueClass) || migrate == 'true'
+        end
+
+        def deploy_opts
+          opts = [%(--ref="#{git_sha}" --environment="#{env}")]
+          opts << opts_for(%i(app account))
+          opts << migrate_opt
+          opts.join(' ')
+        end
+
+        def migrate_opt
+          migrate? ? opts_for(%i(migrate)) : '--no-migrate'
+        end
+
+        def env
+          @env ||= super || detect_env(envs)
+        end
+
+        def detect_env(envs)
+          case envs.size
+          when 1 then envs.first[:name]
+          when 0 then error :no_env
+          else too_many_envs(envs)
+          end
+        end
+
+        def envs
+          lines = shell(:envs, echo: false, capture: true).split("\n")[2..-1] || []
+          envs = lines.map { |line| line.split('|')[1..-1].map(&:strip) }
+          envs = envs.map { |pair| %i(name account).zip(pair).to_h }
+          envs.select { |env| env[:name] == opts[:env] } if env?
+          envs
+        end
+
+        def too_many_envs(envs)
+          envs = envs.map { |env| msg(:env_entry) % env.values_at(:name, :account) }
+          error msg(:too_many_envs) % envs.join(', ')
+        end
+    end
+  end
+end