dpl-connect 1.8.43

data/lib/dpl/provider/deis.rb

@@ -0,0 +1,119 @@
+module DPL
+  class Provider
+    class Deis < Provider
+
+      def install_deploy_dependencies
+        install_url = determine_install_url
+        context.shell "curl -sSL #{install_url} | bash -x -s #{option(:cli_version)}"
+      end
+
+      #Default to installing the default v1 client. Otherwise determine if this is a v2 client
+      def determine_install_url
+        return "https://raw.githubusercontent.com/teamhephy/workflow-cli/master/install-v2.sh"
+      end
+
+      def needs_key?
+        true
+      end
+
+      def check_auth
+        unless context.shell "./deis login #{option(:controller)}" \
+                      " --username=#{option(:username)}" \
+                      " --password=#{option(:password)}"
+          error 'Login failed.'
+        end
+      end
+
+      def check_app
+        unless context.shell "./deis apps:info --app=#{option(:app)}"
+          error 'Application could not be verified.'
+        end
+      end
+
+      def setup_key(file)
+        unless context.shell "./deis keys:add #{file}"
+          error 'Adding keys failed.'
+        end
+      end
+
+      def setup_git_ssh(path, key_path)
+        key_path = File.expand_path(key_path)
+        path     = File.expand_path(path)
+
+        File.open(path, 'w') do |file|
+          file.write "#!/bin/sh\n"
+          file.write "exec ssh #{verbose_flag} -o StrictHostKeychecking=no -o CheckHostIP=no -o UserKnownHostsFile=/dev/null -i #{key_path} \"$@\"\n"
+        end
+
+        chmod(0740, path)
+        context.env['GIT_SSH'] = path
+
+        wait_for_git_access
+      end
+
+      def wait_for_git_access()
+        retry_count=0
+        max_retries=30
+
+        #Get the deis git remote host and port
+        remote_uri=repository_url.split("ssh://")[1].split("/")[0]
+        remote_host, remote_port = remote_uri.split(":")
+        puts "Git remote is #{remote_host} at port #{remote_port}"
+
+        #Try and connect to the github remote via ssh.
+        while retry_count < max_retries
+          puts "Waiting for ssh key to propagate..."
+          if context.shell "#{context.env['GIT_SSH']} #{remote_host} -p #{remote_port}  2>&1 | grep -c 'PTY allocation request failed' > /dev/null"
+            puts "SSH connection established."
+            break
+          end
+          retry_count += 1
+          sleep(1)
+        end
+      end
+
+      def remove_key
+        unless context.shell "./deis keys:remove #{option(:key_name)}"
+          error 'Removing keys failed.'
+        end
+      end
+
+      def repository_url
+        "ssh://git@#{builder_hostname}:2222/#{option(:app)}.git"
+      end
+
+      def builder_hostname
+        host_tokens = controller_host.split(".")
+        host_tokens[0] = [host_tokens[0], "builder"].join("-")
+        host_tokens.join(".")
+      end
+
+      def controller_host
+        option(:controller).gsub(/https?:\/\//, "").split(":")[0]
+      end
+
+      def push_app
+        unless context.shell "bash -c 'git push #{verbose_flag} #{repository_url} HEAD:refs/heads/master -f 2>&1 | tr -dc \"[:alnum:][:space:][:punct:]\" | sed -E \"s/remote: (\\[1G)+//\" | sed \"s/\\[K$//\"; exit ${PIPESTATUS[0]}'"
+          error 'Deploying application failed.'
+        end
+      end
+
+      def run(command)
+        unless context.shell "./deis run -a #{option(:app)} -- #{command}"
+          error 'Running command failed.'
+        end
+      end
+
+      def cleanup
+        return if options[:skip_cleanup]
+        context.shell "mv deis ~/deis"
+        super
+        context.shell "mv ~/deis deis"
+      end
+
+      def verbose_flag
+        '-v' if options[:verbose]
+      end
+    end
+  end
+end

data/lib/dpl/provider/divshot.rb

@@ -0,0 +1,23 @@
+module DPL
+  class Provider
+    class Divshot < Provider
+      npm_g 'divshot-cli', 'divshot'
+
+      def check_auth
+        raise Error, "must supply an api key" unless option(:api_key)
+      end
+
+      def check_app
+        error "missing divshot.json" unless File.exist? "divshot.json"
+      end
+
+      def needs_key?
+        false
+      end
+
+      def push_app
+        context.shell "divshot push #{options[:environment] || "production"} --token=#{option(:api_key)}"
+      end
+    end
+  end
+end

data/lib/dpl/provider/elastic_beanstalk.rb

@@ -0,0 +1,195 @@
+require 'time'
+
+module DPL
+  class Provider
+    class ElasticBeanstalk < Provider
+      experimental 'AWS Elastic Beanstalk'
+
+      requires 'aws-sdk', version: '~> 2.0'
+      requires 'rubyzip', :load => 'zip'
+
+      DEFAULT_REGION = 'us-east-1'
+
+      def needs_key?
+        false
+      end
+
+      def access_key_id
+        options[:access_key_id] || context.env['AWS_ACCESS_KEY_ID'] || raise(Error, "missing access_key_id")
+      end
+
+      def secret_access_key
+        options[:secret_access_key] || context.env['AWS_SECRET_ACCESS_KEY'] || raise(Error, "missing secret_access_key")
+      end
+
+      def check_auth
+        options = {
+          :region      => region,
+          :credentials => Aws::Credentials.new(access_key_id, secret_access_key)
+        }
+        Aws.config.update(options)
+      end
+
+      def check_app
+      end
+
+      def only_create_app_version
+        options[:only_create_app_version]
+      end
+
+      def push_app
+        @start_time = Time.now
+        create_bucket unless bucket_exists?
+
+        if options[:zip_file]
+          zip_file = File.expand_path(options[:zip_file])
+        else
+          zip_file = create_zip
+        end
+
+        s3_object = upload(archive_name, zip_file)
+        sleep 5 #s3 eventual consistency
+        version = create_app_version(s3_object)
+        if !only_create_app_version
+          update_app(version)
+          wait_until_deployed if options[:wait_until_deployed]
+        end
+      end
+
+      private
+
+      def app_name
+        option(:app)
+      end
+
+      def env_name
+        options[:env] || context.env['ELASTIC_BEANSTALK_ENV'] || raise(Error, "missing env")
+      end
+
+      def version_label
+        context.env['ELASTIC_BEANSTALK_LABEL'] || "travis-#{sha}-#{Time.now.to_i}"
+      end
+
+      def version_description
+        context.env['ELASTIC_BEANSTALK_DESCRIPTION'] || commit_msg
+      end
+
+      def archive_name
+        "#{version_label}.zip"
+      end
+
+      def region
+        options[:region] || DEFAULT_REGION
+      end
+
+      def bucket_name
+        option(:bucket_name)
+      end
+
+      def bucket_path
+        @bucket_path ||= options[:bucket_path] ? option(:bucket_path).gsub(/\/*$/,'/') : nil
+      end
+
+      def s3
+        @s3 ||= Aws::S3::Resource.new
+      end
+
+      def eb
+        @eb ||= Aws::ElasticBeanstalk::Client.new
+      end
+
+      def bucket_exists?
+        s3.bucket(bucket_name).exists?
+      end
+
+      def create_bucket
+        s3.bucket(bucket_name).create
+      end
+
+      def files_to_pack
+        `git ls-files -z`.split("\x0")
+      end
+
+      def create_zip
+        directory = Dir.pwd
+        zipfile_name = File.join(directory, archive_name)
+
+        Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
+          files_to_pack.each do |file|
+            relative_archive_path = File.join(directory, '/')
+            zipfile.add(file.sub(relative_archive_path, ''), file)
+          end
+        end
+        zipfile_name
+      end
+
+      def upload(key, file)
+        options = {
+          :body => Pathname.new(file).open
+        }
+        bucket = s3.bucket(bucket_name)
+        obj = bucket_path ? bucket.object("#{bucket_path}#{key}") : bucket.object(key)
+        obj.put(options)
+        obj
+      end
+
+      def create_app_version(s3_object)
+        # Elastic Beanstalk doesn't support descriptions longer than 200 characters
+        description = version_description[0, 200]
+        options = {
+          :application_name  => app_name,
+          :version_label     => version_label,
+          :description       => description,
+          :source_bundle     => {
+            :s3_bucket => bucket_name,
+            :s3_key    => s3_object.key
+          },
+          :auto_create_application => false
+        }
+        eb.create_application_version(options)
+      end
+
+      # Wait until EB environment update finishes
+      def wait_until_deployed
+        errorEvents = 0 # errors counter, should remain 0 for successful deployment
+        events = []
+
+        loop do
+          environment = eb.describe_environments({
+            :application_name  => app_name,
+            :environment_names => [env_name]
+          })[:environments].first
+
+          eb.describe_events({
+            :environment_name  => env_name,
+            :start_time        => @start_time.utc.iso8601,
+          })[:events].reverse.each do |event|
+            message = "#{event[:event_date]} [#{event[:severity]}] #{event[:message]}"
+            unless events.include?(message)
+              events.push(message)
+              if event[:severity] == "ERROR"
+                errorEvents += 1
+                warn(message)
+              else
+                log(message)
+              end
+            end
+          end
+
+          break if environment[:status] == "Ready"
+          sleep 5
+        end
+
+        if errorEvents > 0 then error("Deployment failed.") end
+      end
+
+      def update_app(version)
+        options = {
+          :environment_name  => env_name,
+          :version_label     => version[:application_version][:version_label]
+        }
+        eb.update_environment(options)
+      end
+    end
+  end
+end

data/lib/dpl/provider/engine_yard.rb

@@ -0,0 +1,90 @@
+require 'time'
+
+module DPL
+  class Provider
+    class EngineYard < Provider
+      requires 'engineyard-cloud-client'
+
+      def token
+        options[:api_key] ||= if options[:email] and options[:password]
+          EY::CloudClient.authenticate(options[:email], options[:password])
+        else
+          option(:api_key) # will raise
+        end
+      end
+
+      def api
+        @api ||= EY::CloudClient.new(:token => token)
+      end
+
+      def check_auth
+        log "authenticated as %s" % api.current_user.email
+      end
+
+      def check_app
+        remotes = `git remote -v`.scan(/\t[^\s]+\s/).map { |c| c.strip }.uniq
+        @current_sha = `git rev-parse HEAD`.chomp
+        resolver = api.resolve_app_environments(
+          :app_name => options[:app],
+          :account_name => options[:account],
+          :environment_name => options[:environment],
+          :remotes => remotes)
+        resolver.one_match { @app_env = resolver.matches.first }
+        resolver.no_matches { error resolver.errors.join("\n").inspect }
+        resolver.many_matches do |matches|
+          message = "Multiple matches possible, please be more specific:\n\n"
+          matches.each do |appenv|
+            message << "environment: '#{appenv.environment.name}' account: '#{appenv.environment.account.name}'\n"
+          end
+          error message
+        end
+        @app_env
+      end
+
+      def needs_key?
+        false
+      end
+
+      def cleanup
+      end
+
+      def uncleanup
+      end
+
+      def push_app
+        deploy_opts = {:ref => @current_sha}
+        if command = options[:migrate]
+          if command === true || command === "true"
+            error("\"true\" doesn't look like a migration command, try --migrate=\"rake db:migrate\"")
+          end
+          deploy_opts[:migrate] = true
+          deploy_opts[:migration_command] = command
+        end
+        print "deploying "
+        deployment = EY::CloudClient::Deployment.deploy(api, @app_env, deploy_opts)
+        result = poll_for_result(deployment)
+        unless result.successful
+          error "Deployment failed (see logs on Engine Yard)"
+        end
+      end
+
+      def poll_for_result(deployment)
+        until deployment.finished?
+          sleep 5
+          #TODO: configurable timeout?
+          print "."
+          deployment = EY::CloudClient::Deployment.get(api, deployment.app_environment, deployment.id)
+        end
+        puts "DONE: https://cloud.engineyard.com/apps/#{deployment.app.id}/environments/#{deployment.environment.id}/deployments/#{deployment.id}/pretty"
+        deployment
+      end
+
+      def deploy
+        super
+      rescue EY::CloudClient::Error => e
+        error(e.message)
+      end
+
+    end
+  end
+end

data/lib/dpl/provider/firebase.rb

@@ -0,0 +1,27 @@
+module DPL
+  class Provider
+    class Firebase < Provider
+      npm_g 'firebase-tools@^3.0', 'firebase'
+
+      def check_auth
+        raise Error, "must supply token option or FIREBASE_TOKEN environment variable" if !options[:token] && !context.env['FIREBASE_TOKEN']
+      end
+
+      def check_app
+        error "missing firebase.json" unless File.exist? "firebase.json"
+      end
+
+      def needs_key?
+        false
+      end
+
+      def push_app
+        command = "firebase deploy --non-interactive"
+        command << " --project #{options[:project]}" if options[:project]
+        command << " --message '#{options[:message]}'" if options[:message]
+        command << " --token '#{options[:token]}'" if options[:token]
+        context.shell command
+      end
+    end
+  end
+end