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

data/lib/dpl/providers/heroku/api.rb

@@ -0,0 +1,119 @@
+module Dpl
+  module Providers
+    class Heroku
+      class Api < Heroku
+        status :alpha
+
+        full_name 'Heroku API'
+
+        description sq(<<-str)
+          tbd
+        str
+
+        opt '--api_key KEY', 'Heroku API key', required: true, secret: true
+        opt '--version VERSION', internal: true # used in triggering a build, not sure this should be exposed?
+
+        msgs pack:    'Creating application archive',
+             upload:  'Uploading application archive',
+             build:   'Triggering Heroku build (deployment)',
+             pending: 'Heroku build still pending',
+             failed:  'Heroku build failed'
+
+        cmds pack:    'tar -zcf %{escaped_archive_file} --exclude .git .',
+             upload:  'curl %{curl_opts} %{escaped_put_url} -X PUT -H "Content-Type:" -H "Accept: application/vnd.heroku+json; version=3" -H "User-Agent: %{user_agent}" --data-binary @%{escaped_archive_file}',
+             log:     'curl %{curl_opts} %{escaped_output_stream_url} -H "Accept: application/vnd.heroku+json; version=3" -H "User-Agent: %{user_agent}"'
+
+        attr_reader :data
+
+        def deploy
+          pack
+          upload
+          build
+          log
+          verify
+        end
+
+        private
+
+          def pack
+            shell :pack
+          end
+
+          def upload
+            shell :upload
+          end
+
+          def build
+            info :build
+            res = http.post("/apps/#{app}/builds") do |req|
+              req.headers['Content-Type'] = 'application/json'
+              req.body = JSON.dump(source_blob: { url: get_url, version: version })
+            end
+            handle_error(res) unless res.success?
+            @data = symbolize(JSON.parse(res.body))
+          end
+
+          def log
+            shell :log
+          end
+
+          def verify
+            loop do
+              case build_status
+              when 'pending'
+                info :pending
+                sleep 5
+              when 'succeeded'
+                break
+              else
+                error :failed
+              end
+            end
+          end
+
+          def build_status
+            res = http.get("/apps/#{app}/builds/#{build_id}")
+            JSON.parse(res.body)['status']
+          end
+
+          def archive_file
+            expand("~/.dpl.#{app}.tgz")
+          end
+
+          def get_url
+            source['get_url']
+          end
+
+          def put_url
+            source['put_url']
+          end
+
+          def source
+            # this says the endpoint /sources is deprecated: https://devcenter.heroku.com/articles/platform-api-reference#source
+            # this says to use /apps/example-app/sources: https://devcenter.heroku.com/articles/build-and-release-using-the-api#sources-endpoint
+            @source ||= begin
+              res = http.post('/sources')
+              handle_error(res) unless res.success?
+              JSON.parse(res.body)['source_blob']
+            end
+          end
+
+          def build_id
+            data[:id]
+          end
+
+          def output_stream_url
+            data[:output_stream_url]
+          end
+
+          def version
+            super || git_sha
+          end
+
+          def curl_opts
+            tty? ? '' : '-sS'
+          end
+      end
+    end
+  end
+end

data/lib/dpl/providers/heroku/git.rb

@@ -0,0 +1,50 @@
+module Dpl
+  module Providers
+    class Heroku
+      class Git < Heroku
+        status :alpha
+
+        full_name 'Heroku Git'
+
+        description sq(<<-str)
+          tbd
+        str
+
+        required :api_key, [:username, :password]
+
+        opt '--api_key KEY',   'Heroku API key', secret: true
+        opt '--username USER', 'Heroku username', alias: :user
+        opt '--password PASS', 'Heroku password', secret: true
+        opt '--git URL'
+
+        needs :git, :git_http_user_agent
+
+        cmds fetch: 'git fetch origin $TRAVIS_BRANCH --unshallow',
+             push:  'git push %{remote} HEAD:refs/heads/master -f'
+
+        def prepare
+          write_netrc if write_netrc?
+        end
+
+        def deploy
+          shell :fetch, assert: false
+          shell :push
+        end
+
+        private
+
+          def remote
+            git || "https://git.heroku.com/#{app}.git"
+          end
+
+          def write_netrc?
+            remote.start_with?('https://')
+          end
+
+          def write_netrc
+            super('git.heroku.com', email, api_key || password)
+          end
+      end
+    end
+  end
+end

data/lib/dpl/providers/lambda.rb

@@ -0,0 +1,202 @@
+require 'dpl/helper/zip'
+
+module Dpl
+  module Providers
+    class Lambda < Provider
+      status :alpha
+
+      full_name 'AWS Lambda'
+
+      description sq(<<-str)
+        tbd
+      str
+
+      gem 'aws-sdk-lambda', '~> 1.0'
+      gem 'rubyzip', '~> 1.2.2', require: 'zip'
+
+      env :aws
+      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 Lambda function is running in', default: 'us-east-1'
+      opt '--function_name FUNC',     'Name of the Lambda being created or updated', required: true
+      opt '--role ROLE',              'ARN of the IAM role to assign to the Lambda function', note: 'required for creating a new function'
+      opt '--handler_name NAME',      'Function the Lambda calls to begin execution.', note: 'required for creating a new function'
+      opt '--module_name NAME',       'Name of the module that exports the handler', default: 'index', requires: :handler_name
+      opt '--description DESCR',      'Description of the Lambda being created or updated'
+      opt '--timeout SECS',           'Function execution time (in seconds) at which Lambda should terminate the function', default: 3
+      opt '--memory_size MB',         'Amount of memory in MB to allocate to this Lambda', default: 128
+      opt '--subnet_ids IDS',         'List of subnet IDs to be added to the function', type: :array, note: 'Needs the ec2:DescribeSubnets and ec2:DescribeVpcs permission for the user of the access/secret key to work'
+      opt '--security_group_ids IDS', 'List of security group IDs to be added to the function', type: :array, note: 'Needs the ec2:DescribeSecurityGroups and ec2:DescribeVpcs permission for the user of the access/secret key to work'
+      opt '--environment VARS',       'List of Environment Variables to add to the function', type: :array, format: /[\w\-]+=.+/, note: 'Can be encrypted for added security', alias: :environment_variables
+      opt '--runtime NAME',           'Lambda runtime to use', default: 'nodejs8.10', enum: %w(java8 nodejs8.10 nodejs10.x python2.7 python3.6 python3.7 dotnetcore2.1 go1.x ruby2.5)
+      opt '--dead_letter_arn ARN',    'ARN to an SNS or SQS resource used for the dead letter queue.'
+      opt '--kms_key_arn ARN',        'KMS key ARN to use to encrypt environment_variables.'
+      opt '--tracing_mode MODE',      'Tracing mode', default: 'PassThrough', enum: %w(Active PassThrough), note: 'Needs xray:PutTraceSegments xray:PutTelemetryRecords on the role'
+      opt '--layers LAYERS',          'Function layer arns', type: :array
+      opt '--function_tags TAGS',     'List of tags to add to the function', type: :array, format: /[\w\-]+=.+/, note: 'Can be encrypted for added security'
+      opt '--publish',                'Create a new version of the code instead of replacing the existing one.'
+      opt '--zip PATH',               'Path to a packaged Lambda, a directory to package, or a single file to package', default: '.'
+      opt '--dot_match',              'Include hidden .* files to the zipped archive'
+
+      msgs login:           'Using Access Key: %{access_key_id}',
+           create_function: 'Creating function %{function_name}.',
+           update_config:   'Updating existing function %{function_name}.',
+           update_tags:     'Updating tags.',
+           update_code:     'Updating code.',
+           description:     'Deploy build %{build_number} to AWS Lambda via Travis CI'
+
+      def login
+        info :login
+      end
+
+      def deploy
+        exists? ? update : create
+      rescue Aws::Errors::ServiceError => e
+        error e.message
+      end
+
+      private
+
+        def exists?
+          !!client.get_function(function_name: function_name)
+        rescue ::Aws::Lambda::Errors::ResourceNotFoundException
+          false
+        end
+
+        def create
+          info :create_function
+          config = function_config
+          config = config.merge(code: { zip_file: function_zip })
+          config = config.merge(tags: function_tags) if function_tags?
+          client.create_function(config)
+        end
+
+        def update
+          arn = update_config
+          update_tags(arn) if function_tags?
+          update_code
+        end
+
+        def update_config
+          info :update_config
+          response = client.update_function_configuration(function_config)
+          response.function_arn
+        end
+
+        def update_tags(arn)
+          info :update_tags
+          client.tag_resource(tag_resource(arn))
+        end
+
+        def update_code
+          info :update_code
+          client.update_function_code(function_code)
+        end
+
+        def function_config
+          compact(
+            function_name: function_name,
+            role: role,
+            handler: handler,
+            description: description,
+            timeout: timeout,
+            memory_size: memory_size,
+            vpc_config: vpc_config,
+            environment: environment,
+            runtime: runtime,
+            dead_letter_config: dead_letter_arn,
+            kms_key_arn: kms_key_arn,
+            tracing_config: tracing_config,
+            layers: layers
+          )
+        end
+
+        def tag_resource(arn)
+          {
+            resource: arn,
+            tags: function_tags
+          }
+        end
+
+        def function_code
+          {
+            function_name: function_name,
+            zip_file: function_zip,
+            publish: publish?
+          }
+        end
+
+        def handler
+          Handler.new(runtime, module_name, handler_name).to_s if handler_name?
+        end
+
+        def function_zip
+          Zip.new(zip, tmp_filename, opts).zip
+        end
+
+        def vpc_config
+          compact(subnet_ids: subnet_ids, security_group_ids: security_group_ids)
+        end
+
+        def environment
+          { variables: split_vars(super) } if environment?
+        end
+
+        def dead_letter_arn
+          { target_arn: super } if dead_letter_arn?
+        end
+
+        def tracing_config
+          { mode: tracing_mode } if tracing_mode?
+        end
+
+        def function_tags
+          split_vars(super) if function_tags?
+        end
+
+        def description
+          super || interpolate(msg(:description))
+        end
+
+        def client
+          @client ||= Aws::Lambda::Client.new(region: region, credentials: credentials)
+        end
+
+        def credentials
+          Aws::Credentials.new(access_key_id, secret_access_key)
+        end
+
+        def split_vars(vars)
+          vars.map { |var| var.split('=', 2) }.to_h
+        end
+
+        def tmp_filename
+          @tmp_filename ||= "#{tmp_dir}/#{repo_name}.zip"
+        end
+
+        class Handler < Struct.new(:runtime, :module_name, :handler_name)
+          SEP = {
+            default: '.',
+            java:    '::',
+            dotnet:  '::',
+            go:      ''
+          }
+
+          def to_s
+            [go? ? nil : module_name, sep, handler_name].compact.join
+          end
+
+          def sep
+            key = SEP.keys.detect { |key| runtime.start_with?(key.to_s) }
+            SEP[key || :default]
+          end
+
+          def go?
+            runtime.start_with?('go')
+          end
+        end
+    end
+  end
+end

data/lib/dpl/providers/launchpad.rb

@@ -0,0 +1,74 @@
+module Dpl
+  module Providers
+    class Launchpad < Provider
+      status :alpha
+
+      description sq(<<-str)
+        tbd
+      str
+
+      opt '--slug SLUG', 'Launchpad project slug', format: /^~[^\/]+\/[^\/]+\/[^\/]+$/, example: '~user-name/project-name/branch-name'
+      opt '--oauth_token TOKEN', 'Launchpad OAuth token', secret: true
+      opt '--oauth_token_secret SECRET', 'Launchpad OAuth token secret', secret: true
+
+      msgs invalid_credentials: 'Invalid credentials (%s)',
+           unknown_error:       'Error: %s (%s)'
+
+      def deploy
+        handle_response(post)
+      end
+
+      private
+
+        def post
+          req = Net::HTTP::Post.new(path)
+          req['Authorization'] = authorization
+          req.set_form_data(data)
+          http.request(req)
+        end
+
+        def handle_response(res)
+          error :invalid_credentials, res.code if res.code == '401'
+          error :unknown_error, res.body, res.code unless res.kind_of?(Net::HTTPSuccess)
+        end
+
+        def http
+          http = Net::HTTP.new('api.launchpad.net', 443)
+          http.use_ssl = true
+          http
+        end
+
+        def path
+          "/1.0/#{slug}/+code-import"
+        end
+
+        def data
+          { 'ws.op' => 'requestImport' }
+        end
+
+        def authorization
+          squish(<<-auth)
+            OAuth oauth_consumer_key="Travis%20Deploy",
+            oauth_nonce="#{nonce}",
+            oauth_signature="%26#{oauth_token_secret}",
+            oauth_signature_method="PLAINTEXT",
+            oauth_timestamp="#{now}",
+            oauth_token="#{oauth_token}",
+            oauth_version="1.0"
+          auth
+        end
+
+        def nonce
+          rand(36 ** 32).to_s(36)
+        end
+
+        def now
+          Time::now().to_i
+        end
+
+        def squish(str)
+          str.strip.gsub(/\s+/, ' ')
+        end
+    end
+  end
+end