dpl-connect 1.8.43

data/lib/dpl/provider/gae.rb

@@ -0,0 +1,97 @@
+module DPL
+  class Provider
+    class GAE < Provider
+      experimental 'Google App Engine'
+
+      BASE='https://dl.google.com/dl/cloudsdk/channels/rapid/'
+      NAME='google-cloud-sdk'
+      EXT='.tar.gz'
+      INSTALL='~'
+      BOOTSTRAP="#{INSTALL}/#{NAME}/bin/bootstrapping/install.py"
+      GCLOUD="#{INSTALL}/#{NAME}/bin/gcloud"
+
+      def with_python_2_7(cmd)
+        cmd.gsub!(/'/, "'\\\\''")
+        context.shell("bash -c 'source #{context.env['HOME']}/virtualenv/python2.7/bin/activate; #{cmd}'")
+      end
+
+      def install_deploy_dependencies
+        if File.exists? GCLOUD
+          return
+        end
+
+        $stderr.puts 'Python 2.7 Version'
+
+        unless with_python_2_7("python -c 'import sys; print(sys.version)'")
+          error 'Could not use python2.7'
+        end
+
+        $stderr.puts 'Downloading Google Cloud SDK ...'
+
+        unless context.shell("curl -L #{BASE + NAME + EXT} | gzip -d | tar -x -C #{INSTALL}")
+          error 'Could not download Google Cloud SDK.'
+        end
+
+        $stderr.puts 'Bootstrapping Google Cloud SDK ...'
+
+        unless with_python_2_7("#{BOOTSTRAP} --usage-reporting=false --command-completion=false --path-update=false")
+          error 'Could not bootstrap Google Cloud SDK.'
+        end
+      end
+
+      def needs_key?
+        false
+      end
+
+      def check_auth
+        unless with_python_2_7("#{GCLOUD} -q auth activate-service-account --key-file #{keyfile}")
+          error 'Authentication failed.'
+        end
+      end
+
+      def keyfile
+        options[:keyfile] || context.env['GOOGLECLOUDKEYFILE'] || 'service-account.json'
+      end
+
+      def project
+        options[:project] || context.env['GOOGLECLOUDPROJECT'] || context.env['CLOUDSDK_CORE_PROJECT'] || File.dirname(context.env['TRAVIS_REPO_SLUG'] || '')
+      end
+
+      def version
+        options[:version]
+      end
+
+      def config
+        options[:config] || 'app.yaml'
+      end
+
+      def no_promote
+        options[:no_promote]
+      end
+
+      def verbosity
+        options[:verbosity] || 'warning'
+      end
+
+      def no_stop_previous_version
+        options[:no_stop_previous_version]
+      end
+
+      def push_app
+        command = GCLOUD
+        command << ' --quiet'
+        command << " --verbosity \"#{verbosity}\""
+        command << " --project \"#{project}\""
+        command << " app deploy \"#{config}\""
+        command << " --version \"#{version}\"" unless version.to_s.empty?
+        command << " --#{no_promote ? 'no-' : ''}promote"
+        command << ' --no-stop-previous-version' unless no_stop_previous_version.to_s.empty?
+        unless with_python_2_7(command)
+          log 'Deployment failed.'
+          context.shell('find $HOME/.config/gcloud/logs -type f -print -exec cat {} \;')
+          error ''
+        end
+      end
+    end
+  end
+end

data/lib/dpl/provider/gcs.rb

@@ -0,0 +1,59 @@
+require 'kconv'
+
+module DPL
+  class Provider
+    class GCS < Provider
+      requires 'gstore'
+      requires 'mime-types', version: '~> 2.0'
+
+      def needs_key?
+        false
+      end
+
+      def client
+        @client ||= GStore::Client.new(
+          :access_key => option(:access_key_id),
+          :secret_key => option(:secret_access_key)
+        )
+      end
+
+      def check_auth
+        log "Logging in with Access Key: #{option(:access_key_id)[-4..-1].rjust(20, '*')}"
+      end
+
+      def upload_path(filename)
+        [options[:upload_dir], filename].compact.join("/")
+      end
+
+      def push_app
+        glob_args = ["**/*"]
+        glob_args << File::FNM_DOTMATCH if options[:dot_match]
+        Dir.chdir(options.fetch(:local_dir, Dir.pwd)) do
+          Dir.glob(*glob_args) do |filename|
+            next if File.directory?(filename)
+            content_type = MIME::Types.type_for(filename).first.to_s
+            opts                  = { :"Content-Type" => content_type }.merge(encoding_option_for(filename))
+            opts["Cache-Control"] = options[:cache_control] if options[:cache_control]
+            opts["x-goog-acl"]    = options[:acl] if options[:acl]
+
+            client.put_object(
+              option(:bucket),
+              upload_path(filename),
+              { :data => File.read(filename), :headers => opts }
+            )
+          end
+        end
+      end
+
+      private
+      def encoding_option_for(path)
+        if detect_encoding? && encoding_for(path)
+          {"Content-Encoding" => encoding_for(path)}
+        else
+          {}
+        end
+      end
+
+    end
+  end
+end

data/lib/dpl/provider/hackage.rb

@@ -0,0 +1,29 @@
+module DPL
+  class Provider
+    class Hackage < Provider
+      apt_get 'cabal', 'cabal-install'
+
+      def check_auth
+        unless option(:username) and option(:password)
+          raise Error, "must supply username and password"
+        end
+      end
+
+      def check_app
+        context.shell "cabal check" or raise Error, "cabal check failed"
+      end
+
+      def needs_key?
+        false
+      end
+
+      def push_app
+        context.shell "cabal sdist" or raise Error, "cabal sdist failed"
+        Dir.glob("dist/*.tar.gz") do |tar|
+          context.shell "cabal upload --username=#{option(:username)} --password=#{option(:password)} #{tar}"
+        end
+      end
+    end
+  end
+end
+

data/lib/dpl/provider/heroku.rb

@@ -0,0 +1,18 @@
+module DPL
+  class Provider
+    module Heroku
+      autoload :API,          'dpl/provider/heroku/api'
+      autoload :Generic,      'dpl/provider/heroku/generic'
+      autoload :Git,          'dpl/provider/heroku/git'
+
+      extend self
+
+      def new(context, options)
+        strategy = options[:strategy] || 'api'
+        constant = constants.detect { |c| c.to_s.downcase == strategy.downcase.gsub(/\W/, '') }
+        raise Error, 'unknown strategy %p' % strategy unless constant and constant != Generic
+        const_get(constant).new(context, options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+require 'json'
+require 'shellwords'
+require 'logger'
+
+module DPL
+  class Provider
+    module Heroku
+      class API < Generic
+        attr_reader :build_id
+        requires 'faraday'
+        requires 'rendezvous'
+
+        def push_app
+          pack_archive
+          upload_archive
+          trigger_build
+          verify_build
+        end
+
+        def archive_file
+          Shellwords.escape("#{context.env['HOME']}/.dpl.#{option(:app)}.tgz")
+        end
+
+        def pack_archive
+          log "creating application archive"
+          context.shell "tar -zcf #{archive_file} --exclude .git ."
+        end
+
+        def upload_archive
+          log "uploading application archive"
+          context.shell "curl #{Shellwords.escape(put_url)} -X PUT -H 'Content-Type:' -H 'Accept: application/vnd.heroku+json; version=3' --data-binary @#{archive_file}"
+        end
+
+        def trigger_build
+          log "triggering new deployment"
+          response = faraday.post("/apps/#{option(:app)}/builds") do |req|
+            req.headers['Content-Type'] = 'application/json'
+            req.body = {
+              "source_blob" => {
+                "url" => get_url,
+                "version" => version
+              }
+              }.to_json
+          end
+
+          if response.success?
+            @build_id  = JSON.parse(response.body)['id']
+            output_stream_url = JSON.parse(response.body)['output_stream_url']
+            context.shell "curl #{Shellwords.escape(output_stream_url)} -H 'Accept: application/vnd.heroku+json; version=3'"
+          else
+            handle_error_response(response)
+          end
+        end
+
+        def verify_build
+          loop do
+            response = faraday.get("/apps/#{option(:app)}/builds/#{build_id}/result")
+            exit_code = JSON.parse(response.body)['exit_code']
+            if exit_code.nil?
+              log "heroku build still pending"
+              sleep 5
+              next
+            elsif exit_code == 0
+              break
+            else
+              error "deploy failed, build exited with code #{exit_code}"
+            end
+          end
+        end
+
+        def get_url
+          source_blob.fetch("get_url")
+        end
+
+        def put_url
+          source_blob.fetch("put_url")
+        end
+
+        def source_blob
+          return @source_blob if @source_blob
+
+          response = faraday.post('/sources')
+
+          if response.success?
+            @source_blob = JSON.parse(response.body)["source_blob"]
+          else
+            handle_error_response(response)
+          end
+        end
+
+        def version
+          @version ||= options[:version] || context.env['TRAVIS_COMMIT'] || `git rev-parse HEAD`.strip
+        end
+
+      end
+    end
+  end
+end

data/lib/dpl/provider/heroku/generic.rb

@@ -0,0 +1,94 @@
+require 'json'
+
+module DPL
+  class Provider
+    module Heroku
+      class Generic < Provider
+        requires 'rendezvous'
+        requires 'faraday'
+
+        attr_reader :app, :user
+
+        def needs_key?
+          false
+        end
+
+        def faraday
+          return @conn if @conn
+          headers = { "Accept" => "application/vnd.heroku+json; version=3" }
+
+          if options[:user] and options[:password]
+            # no-op
+          else
+            headers.merge!({ "Authorization" => "Bearer #{option(:api_key)}" })
+          end
+
+          @conn = Faraday.new( url: 'https://api.heroku.com', headers: headers ) do |faraday|
+            if options[:user] and options[:password]
+              faraday.basic_auth(options[:user], options[:password])
+            end
+            if log_level = options[:log_level]
+              logger = Logger.new($stderr)
+              logger.level = Logger.const_get(log_level.upcase)
+
+              faraday.response :logger, logger do | logger |
+                logger.filter(/(.*Authorization: ).*/,'\1[REDACTED]')
+              end
+            end
+            faraday.adapter Faraday.default_adapter
+          end
+        end
+
+        def check_auth
+          response = faraday.get('/account')
+
+          if response.success?
+            email = JSON.parse(response.body)["email"]
+            @user = email
+            log "authentication succeeded"
+          else
+            handle_error_response(response)
+          end
+        end
+
+        def handle_error_response(response)
+          error_response = JSON.parse(response.body)
+          error "API request failed.\nMessage: #{error_response["message"]}\nReference: #{error_response["url"]}"
+        end
+
+        def check_app
+          log "checking for app #{option(:app)}"
+          response = faraday.get("/apps/#{option(:app)}")
+          if response.success?
+            @app = JSON.parse(response.body)
+            log "found app #{@app["name"]}"
+          else
+            handle_error_response(response)
+          end
+        end
+
+        def restart
+          response = faraday.delete "/apps/#{option(:app)}/dynos" do |req|
+            req.headers['Content-Type'] = 'application/json'
+          end
+          unless response.success?
+            handle_error_response(response)
+          end
+        end
+
+        def run(command)
+          response = faraday.post "/apps/#{option(:app)}/dynos" do |req|
+            req.headers['Content-Type'] = 'application/json'
+            req.body = {"command" => command, "attach" => true}.to_json
+          end
+          if response.success?
+            rendezvous_url = JSON.parse(response.body)["attach_url"]
+            Rendezvous.start(url: rendezvous_url)
+          else
+            handle_error_response(response)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module DPL
+  class Provider
+    module Heroku
+      class Git < Generic
+        requires 'netrc'
+
+        def git_url
+          "https://git.heroku.com/#{option(:app)}.git"
+        end
+
+        def push_app
+          git_remote = options[:git] || git_url
+          write_netrc if git_remote.start_with?("https://")
+          log "$ git fetch origin $TRAVIS_BRANCH --unshallow"
+          context.shell "git fetch origin $TRAVIS_BRANCH --unshallow"
+          log "$ git push #{git_remote} HEAD:refs/heads/master -f"
+          context.shell "git push #{git_remote} HEAD:refs/heads/master -f"
+        end
+
+        def write_netrc
+          n = Netrc.read
+          n['git.heroku.com'] = [user, option(:api_key)]
+          n.save
+        end
+      end
+    end
+  end
+end

data/lib/dpl/provider/lambda.rb

@@ -0,0 +1,236 @@
+require 'json'
+require 'tempfile'
+require 'fileutils'
+
+module DPL
+  class Provider
+    class Lambda < Provider
+      requires 'aws-sdk', version: '~> 2.0'
+      requires 'rubyzip', load: 'zip'
+
+      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