dpl 1.8.48.travis.2486.5 → 1.9.0

data/lib/dpl/provider/gae.rb

@@ -1,97 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,236 +0,0 @@
-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