travis_dpl_test 2.0.3.beta.4.ror

data/lib/dpl/providers/codedeploy.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+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
+      register :codedeploy
+
+      status :stable
+
+      full_name 'AWS Code Deploy'
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      gem 'aws-sdk-codedeploy', '~> 1.0'
+      gem 'aws-sdk-s3', '~> 1'
+
+      env :aws, :codedeploy
+      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', 'Bundle type of the revision'
+      opt '--key KEY', 'S3 bucket key of the revision'
+      opt '--description DESCR', 'Description of the revision', interpolate: true
+      opt '--endpoint ENDPOINT', 'S3 endpoint url'
+
+      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'
+
+      vars :build_number
+
+      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:,
+          application_name: application,
+          description:
+        )
+      end
+
+      def create_deployment
+        deployment = code_deploy.create_deployment(
+          revision:,
+          application_name: application,
+          deployment_group_name: deployment_group,
+          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)
+        case status
+        when 'Succeeded'
+          info :finished_deploy, status
+        else
+          error :finished_deploy, status
+        end
+      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:,
+            bundle_type:,
+            version: revision_version_info[:version_id],
+            e_tag: revision_version_info[:etag],
+            key:
+          )
+        }
+      end
+
+      def revision_version_info
+        s3.head_object(bucket:, key:)
+      rescue Aws::Errors::ServiceError => e
+        error e.message
+      end
+
+      def github_revision
+        {
+          revision_type: 'GitHub',
+          git_hub_location: {
+            commit_id:,
+            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)$/ && ::Regexp.last_match(1) || error(:unknown_bundle_type)
+      end
+
+      def description
+        interpolate(super || msg(:description), vars:)
+      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:, credentials:, endpoint:)
+      end
+
+      def credentials
+        Aws::Credentials.new(access_key_id, secret_access_key)
+      end
+    end
+  end
+end

data/lib/dpl/providers/convox.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class Convox < Provider
+      register :convox
+
+      status :dev
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      gem 'json'
+
+      env :convox
+
+      # needs descriptions
+      opt '--host HOST', default: 'console.convox.com'
+      opt '--app APP', required: true
+      opt '--rack RACK', required: true
+      opt '--password PASS', required: true
+      opt '--install_url URL', default: 'https://convox.com/cli/linux/convox'
+      opt '--update_cli'
+      opt '--create'
+      opt '--promote', default: true
+      opt '--env_names VARS', type: :array, sep: ','
+      opt '--env VARS', type: :array
+      opt '--env_file FILE'
+      opt '--description STR'
+      opt '--generation NUM', type: :int, default: '2'
+      opt '--prepare CMDS', 'Run commands with convox cli available just before deployment', type: :array
+
+      # if app and rack are exported to the env, do they need to be passed to these commands?
+      cmds login: 'convox version --rack %{rack}',
+           validate: 'convox apps info --rack %{rack} --app %{app}',
+           create: 'convox apps create %{app} --generation %{generation} --rack %{rack} --wait',
+           update: 'convox update',
+           set_env: 'convox env set %{env} --rack %{rack} --app %{app} --replace',
+           build: 'convox build --rack %{rack} --app %{app} --id --description %{escaped_description}',
+           deploy: 'convox deploy --rack %{rack} --app %{app} --wait --id --description %{escaped_description}'
+
+      msgs create: 'Application %{app} does not exist on rack %{rack}. Creating it ...',
+           missing: 'Application %{app} does not exist on rack %{rack}.',
+           env_file: 'The given env_file does not exist.',
+           deploy: 'Building and promoting application ...',
+           build: 'Building application ...'
+
+      errs login: 'Login failed.'
+
+      def install
+        script :install
+        shell :update if update_cli?
+        export
+      end
+
+      def login
+        shell :login
+      end
+
+      def validate
+        shell :validate, assert: false and return
+        error :missing unless create?
+        shell :create
+      end
+
+      def prepare
+        Array(super).each do |cmd|
+          cmd.casecmp('restart').zero? ? restart : run_cmd(cmd)
+        end
+      end
+
+      def deploy
+        shell :set_env, echo: false unless env.empty?
+        shell promote? ? :deploy : :build, echo: false
+      end
+
+      def env_names
+        env = super || []
+        env = env.map { |str| "#{str}=#{ENV[str]}" }
+        env_file.concat(env)
+      end
+
+      def env
+        env = env_names.concat(super || [])
+        env.map { |str| escape(str) }.join(' ')
+      end
+
+      def env_file
+        return [] unless env_file?
+
+        error :env_file unless file?(super)
+        lines = read(super).split("\n").map(&:strip)
+        lines.reject(&:empty?)
+      end
+
+      def description
+        if description?
+          super
+        else
+          JSON.dump(
+            repo_slug:,
+            git_commit_sha: git_sha,
+            git_commit_message: git_commit_msg,
+            git_commit_author: git_author_name,
+            git_tag:,
+            branch: git_branch,
+            travis_build_id: ENV['TRAVIS_BUILD_ID'],
+            travis_build_number: ENV['TRAVIS_BUILD_NUMBER'],
+            pull_request: ENV['TRAVIS_PULL_REQUEST']
+          )
+        end
+      end
+
+      def export
+        env_vars.each { |key, value| ENV[key.to_s] = value.to_s }
+      end
+
+      def env_vars
+        {
+          CONVOX_HOST: host,
+          CONVOX_PASSWORD: password,
+          CONVOX_APP: app,
+          CONVOX_RACK: rack,
+          CONVOX_CLI: 'convox'
+        }
+      end
+    end
+  end
+end

data/lib/dpl/providers/datica.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class Datica < Provider
+      register :datica
+
+      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 if git_dirty? && !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
+      ].freeze
+
+      def vars
+        @vars ||= ENV.values_at(*VARS).compact
+      end
+    end
+  end
+end

data/lib/dpl/providers/ecr.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Dpl
+  module Providers
+    class Ecr < Provider
+      status :alpha
+
+      full_name 'AWS ECR'
+
+      description sq(<<-STR)
+        tbd
+      STR
+
+      gem 'aws-sdk-ecr', '~> 1.0'
+      # gem 'docker-api', '~> 1.34'
+      gem 'json'
+
+      env :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 '--account_id ID', 'AWS Account ID', note: 'Required if the repository is owned by a different account than the IAM user'
+      opt '--source SOURCE', 'Image to push', note: 'can be the id or the name and optional tag (e.g. mysql:5.6)', required: true
+      opt '--target TARGET', 'Comma separated list of partial repository names to push to', eg: 'image-one:tag,image-two', required: true
+      opt '--region REGION', 'Comma separated list of regions to push to', default: 'us-east-1'
+
+      msgs login: 'Using Access Key: %{access_key_id}',
+           auth_region: 'Authenticated with %{url}',
+           deploy: 'Pushing image %{source} to regions %{regions} as %{targets}',
+           image_pushed: 'Pushed image %{source} to region %{region} as %{target}'
+
+      cmds login: 'docker login -u %{user} -p %{pass} %{url}',
+           tag: 'docker tag %{source} %{url}/%{repo}:%{tag}',
+           push: 'docker push %{url}/%{repo}'
+
+      errs unknown_image: 'Image %{source} not found in the local Docker repository'
+
+      attr_reader :endpoints
+
+      def login
+        info :login
+        auth_regions
+      end
+
+      def validate
+        # TODO: validate the image exists locally
+      end
+
+      def deploy
+        info :deploy, regions: regions.join(', '), targets: targets.join(', ')
+        regions.product(targets).each do |region, target|
+          push(region, target)
+        end
+      end
+
+      private
+
+      def push(region, target)
+        url, repo, tag = endpoints[region], *target.split(':')
+        shell :tag, url:, repo:, tag: tag || 'latest'
+        shell(:push, url:, repo:)
+        info :image_pushed, region:, target:
+      end
+
+      def auth_regions
+        @endpoints = regions.map { |region| [region, auth_region(region)] }.to_h
+      end
+
+      def auth_region(region)
+        token = auth_token(region)
+        user, pass = parse_auth(token.authorization_token)
+        url = token.proxy_endpoint
+        shell :login, user:, pass:, url:, echo: false, silent: true
+        info(:auth_region, url:)
+        strip_protocol(url)
+      end
+
+      def auth_token(region)
+        ecr(region).get_authorization_token(registry_ids).authorization_data[0]
+      end
+
+      def registry_ids
+        account_id? ? { registry_ids: [account_id] } : {}
+      end
+
+      def regions
+        # not sure how this was meant to be normalized when being a YAML list
+        region.split(',')
+      end
+
+      def targets
+        # not sure how this was meant to be normalized when being a YAML list
+        target.split(',')
+      end
+
+      def creds
+        @creds ||= only(opts, :access_key_id, :secret_access_key)
+      end
+
+      def ecr(region)
+        Aws::ECR::Client.new(region:, **creds)
+      end
+
+      def parse_auth(str)
+        user, pass = Base64.decode64(str).split(':')
+        [user, pass.chomp]
+      end
+
+      def strip_protocol(url)
+        url.sub(%r{^https?://}, '')
+      end
+
+      def progress(events)
+        events.split("\r\n").each do |event|
+          event = JSON.parse(event)
+          if e = event['error']
+            error e
+          elsif %w[Preparing Pushing].include?(event['status'])
+            nil
+          elsif event['id']
+            info "#{event['status']} [#{event['id']}]"
+          elsif event['status']
+            info event['status']
+          end
+        end
+      end
+    end
+  end
+end