dpl 1.8.48.travis.2486.5 → 1.9.0

data/lib/dpl/provider/deis.rb

@@ -1,128 +0,0 @@
-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
-         if option(:cli_version).nil?
-           return "http://deis.io/deis-cli/install.sh"
-         else
-           version_arg = Gem::Version.new(option(:cli_version).gsub(/^v?V?/,''))
-           if version_arg >= Gem::Version.new('2.0.0')
-             return "http://deis.io/deis-cli/install-v2.sh"
-           else
-             return "http://deis.io/deis-cli/install.sh"
-           end
-         end
-      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

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

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

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

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