dpl-thib 1.10.5

data/lib/dpl/cli.rb

@@ -0,0 +1,66 @@
+require 'dpl/error'
+require 'dpl/provider'
+
+module DPL
+  class CLI
+    def self.run(*args)
+      new(args).run
+    end
+
+    OPTION_PATTERN = /\A--([a-z][a-z_\-]*)(?:=(.+))?\z/
+    attr_accessor :options, :fold_count
+
+    def initialize(*args)
+      options = {}
+      args.flatten.each do |arg|
+        next options.update(arg) if arg.is_a? Hash
+        die("invalid option %p" % arg) unless match = OPTION_PATTERN.match(arg)
+        key = match[1].tr('-', '_').to_sym
+        if options.include? key
+          options[key] = Array(options[key]) << match[2]
+        else
+          options[key] = match[2] || true
+        end
+      end
+
+      self.fold_count = 0
+      self.options    = default_options.merge(options)
+    end
+
+    def run
+      provider = Provider.new(self, options)
+      provider.deploy
+    rescue Error => error
+      options[:debug] ? raise(error) : die(error.message)
+    end
+
+    def fold(message)
+      self.fold_count += 1
+      print "travis_fold:start:dpl.#{fold_count}\r" if options[:fold]
+      puts "\e[33m#{message}\e[0m"
+      yield
+    ensure
+      print "\ntravis_fold:end:dpl.#{fold_count}\r" if options[:fold]
+    end
+
+    def default_options
+      {
+        :app      => File.basename(Dir.pwd),
+        :key_name => %x[hostname].strip
+      }
+    end
+
+    def shell(command)
+      system(command)
+    end
+
+    def die(message)
+      $stderr.puts(message)
+      exit 1
+    end
+
+    def env
+      ENV
+    end
+  end
+end

data/lib/dpl/error.rb

@@ -0,0 +1,3 @@
+module DPL
+  Error = Class.new(StandardError)
+end

data/lib/dpl/provider.rb

@@ -0,0 +1,308 @@
+require 'dpl/error'
+require 'dpl/version'
+require 'fileutils'
+
+module DPL
+  class Provider
+    include FileUtils
+
+    # map of DPL provider class name constants to their corresponding
+    # file names. There is no simple rule to map them automatically
+    # (camel-cases, snake-cases, call-caps, etc.), so we need an explicit
+    # map.
+    GEM_NAME_OF = {
+      'Anynines'            => 'anynines',
+      'Appfog'              => 'appfog',
+      'Atlas'               => 'atlas',
+      'AzureWebApps'        => 'azure_webapps',
+      'Bintray'             => 'bintray',
+      'BitBalloon'          => 'bitballoon',
+      'BluemixCloudFoundry' => 'bluemix_cloud_foundry',
+      'Boxfuse'             => 'boxfuse',
+      'Catalyze'            => 'catalyze',
+      'ChefSupermarket'     => 'chef_supermarket',
+      'Cloud66'             => 'cloud66',
+      'CloudFiles'          => 'cloud_files',
+      'CloudFoundry'        => 'cloud_foundry',
+      'CodeDeploy'          => 'code_deploy',
+      'Cargo'               => 'cargo',
+      'Deis'                => 'deis',
+      'ElasticBeanstalk'    => 'elastic_beanstalk',
+      'EngineYard'          => 'engine_yard',
+      'Firebase'            => 'firebase',
+      'GAE'                 => 'gae',
+      'GCS'                 => 'gcs',
+      'Hackage'             => 'hackage',
+      'Hephy'               => 'hephy',
+      'Heroku'              => 'heroku',
+      'Lambda'              => 'lambda',
+      'Launchpad'           => 'launchpad',
+      'Nodejitsu'           => 'nodejitsu',
+      'NPM'                 => 'npm',
+      'Openshift'           => 'openshift',
+      'OpsWorks'            => 'ops_works',
+      'Packagecloud'        => 'packagecloud',
+      'Pages'               => 'pages',
+      'PuppetForge'         => 'puppet_forge',
+      'PyPI'                => 'pypi',
+      'Releases'            => 'releases',
+      'RubyGems'            => 'rubygems',
+      'S3'                  => 's3',
+      'Scalingo'            => 'scalingo',
+      'Script'              => 'script',
+      'Snap'                => 'snap',
+      'Surge'               => 'surge',
+      'TestFairy'           => 'testfairy',
+      'Transifex'           => 'transifex',
+    }
+
+    def self.new(context, options)
+      return super if self < Provider
+
+      # when requiring the file corresponding to the provider name
+      # given in the options, the general strategy is to normalize
+      # the option to lower-case alphanumeric, then
+      # use that key to find the file name using the GEM_NAME_OF map.
+
+      context.fold("Installing deploy dependencies") do
+        begin
+          opt_lower = super.option(:provider).to_s.downcase
+          opt = opt_lower.gsub(/[^a-z0-9]/, '')
+          class_name = class_of(opt)
+          raise Error, "could not find provider %p" % opt unless class_name
+          require "dpl/provider/#{GEM_NAME_OF[class_name]}"
+          provider = const_get(class_name).new(context, options)
+        rescue NameError, LoadError => e
+          if /uninitialized constant DPL::Provider::(?<provider_wanted>\S+)/ =~ e.message
+            provider_gem_name = GEM_NAME_OF[provider_wanted]
+          elsif %r(cannot load such file -- dpl/provider/(?<provider_file_name>\S+)) =~ e.message
+            provider_gem_name = GEM_NAME_OF[class_name]
+          else
+            # don't know what to do with this error
+            raise e
+          end
+          install_cmd = "gem install dpl-#{provider_gem_name || opt} -v #{ENV['DPL_VERSION'] || DPL::VERSION}"
+
+          if File.exist?(local_gem = File.join(Dir.pwd, "dpl-#{GEM_NAME_OF[provider_gem_name] || opt_lower}-#{ENV['DPL_VERSION'] || DPL::VERSION}.gem"))
+            install_cmd = "gem install #{local_gem}"
+          end
+
+          context.shell(install_cmd)
+          Gem.clear_paths
+
+          require "dpl/provider/#{GEM_NAME_OF[class_name]}"
+          provider = const_get(class_name).new(context, options)
+        rescue DPL::Error
+          if opt_lower
+            provider = const_get(opt.capitalize).new(context, options)
+          else
+            raise Error, 'missing provider'
+          end
+        end
+
+        if options[:no_deploy]
+          def provider.deploy; end
+        else
+          provider.install_deploy_dependencies if provider.respond_to? :install_deploy_dependencies
+        end
+
+        provider
+      end
+    end
+
+    def self.experimental(name)
+      puts "", "!!! #{name} support is experimental !!!", ""
+    end
+
+    def self.deprecated(*lines)
+      puts ''
+      lines.each do |line|
+        puts "\e[31;1m#{line}\e[0m"
+      end
+      puts ''
+    end
+
+    def self.context
+      self
+    end
+
+    def self.shell(command, options = {})
+      system(command)
+    end
+
+    def self.apt_get(name, command = name)
+      context.shell("sudo apt-get -qq install #{name}", retry: true) if `which #{command}`.chop.empty?
+    end
+
+    def self.pip(name, command = name, version = nil)
+      if version
+        puts "pip install --user #{name}==#{version}"
+        context.shell("pip uninstall --user -y #{name}") unless `which #{command}`.chop.empty?
+        context.shell("pip install --user #{name}==#{version}", retry: true)
+      else
+        puts "pip install --user #{name}"
+        context.shell("pip install --user #{name}", retry: true) if `which #{command}`.chop.empty?
+      end
+      context.shell("export PATH=$PATH:$HOME/.local/bin")
+    end
+
+    def self.npm_g(name, command = name)
+      context.shell("npm install -g #{name}", retry: true) if `which #{command}`.chop.empty?
+    end
+
+    def self.class_of(filename)
+      GEM_NAME_OF.keys.detect { |p| p.to_s.downcase == filename }
+    end
+
+    attr_reader :context, :options
+
+    def initialize(context, options)
+      @context, @options = context, options
+      context.env['GIT_HTTP_USER_AGENT'] = user_agent(git: `git --version`[/[\d\.]+/])
+    end
+
+    def user_agent(*strings)
+      strings.unshift "dpl/#{DPL::VERSION}"
+      strings.unshift "travis/0.1.0" if context.env['TRAVIS']
+      strings = strings.flat_map { |e| Hash === e ? e.map { |k,v| "#{k}/#{v}" } : e }
+      strings.join(" ").gsub(/\s+/, " ").strip
+    end
+
+    def option(name, *alternatives)
+      options.fetch(name) do
+        alternatives.any? ? option(*alternatives) : raise(Error, "missing #{name}")
+      end
+    end
+
+    def deploy
+      setup_git_credentials
+      rm_rf ".dpl"
+      mkdir_p ".dpl"
+
+      context.fold("Preparing deploy") do
+        check_auth
+        check_app
+
+        if needs_key?
+          create_key(".dpl/id_rsa")
+          setup_key(".dpl/id_rsa.pub")
+          setup_git_ssh(".dpl/git-ssh", ".dpl/id_rsa")
+        end
+
+        cleanup
+      end
+
+      context.fold("Deploying application") { push_app }
+
+      Array(options[:run]).each do |command|
+        if command == 'restart'
+          context.fold("Restarting application") { restart }
+        else
+          context.fold("Running %p" % command) { run(command) }
+        end
+      end
+    ensure
+      if needs_key?
+        remove_key rescue nil
+      end
+      uncleanup
+    end
+
+    def sha
+      @sha ||= context.env['TRAVIS_COMMIT'] || `git rev-parse HEAD`.strip
+    end
+
+    def commit_msg
+      @commit_msg ||= %x{git log #{sha} -n 1 --pretty=%B}.strip
+    end
+
+    def cleanup
+      return if options[:skip_cleanup]
+      context.shell "mv .dpl ~/dpl"
+      log "Cleaning up git repository with `git stash --all`. " \
+        "If you need build artifacts for deployment, set `deploy.skip_cleanup: true`. " \
+        "See https://docs.travis-ci.com/user/deployment#Uploading-Files-and-skip_cleanup."
+      context.shell "git stash --all"
+      context.shell "mv ~/dpl .dpl"
+    end
+
+    def uncleanup
+      return if options[:skip_cleanup]
+      context.shell "git stash pop"
+    end
+
+    def needs_key?
+      true
+    end
+
+    def check_app
+    end
+
+    def create_key(file)
+      context.shell "ssh-keygen -t rsa -N \"\" -C #{option(:key_name)} -f #{file}"
+    end
+
+    def setup_git_credentials
+      context.shell "git config user.email >/dev/null 2>/dev/null || git config user.email `whoami`@localhost"
+      context.shell "git config user.name >/dev/null 2>/dev/null || git config user.name `whoami`@localhost"
+    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 -o StrictHostKeychecking=no -o CheckHostIP=no -o UserKnownHostsFile=/dev/null -i #{key_path} -- \"$@\"\n"
+      end
+
+      chmod(0740, path)
+      context.env['GIT_SSH'] = path
+    end
+
+    def detect_encoding?
+      options[:detect_encoding]
+    end
+
+    def default_text_charset?
+      options[:default_text_charset]
+    end
+
+    def default_text_charset
+      options[:default_text_charset].downcase
+    end
+
+    def install_deploy_dependencies
+    end
+
+    def encoding_for(path)
+      file_cmd_output = `file '#{path}'`
+      case file_cmd_output
+      when /gzip compressed/
+        'gzip'
+      when /compress'd/
+        'compress'
+      when /text/
+        'text'
+      when /data/
+        # Shrugs?
+      end
+    end
+
+    def log(message)
+      $stderr.puts(message)
+    end
+
+    def warn(message)
+      log "\e[31;1m#{message}\e[0m"
+    end
+
+    def run(command)
+      error "running commands not supported"
+    end
+
+    def error(message)
+      raise Error, message
+    end
+  end
+end

data/lib/dpl/version.rb

@@ -0,0 +1,3 @@
+module DPL
+  VERSION = '1.10.5'
+end

data/notes/engine_yard.md

@@ -0,0 +1 @@
+EY has a a special deploy app. Get in touch with Kevin Holler if we don't hear back from them.

data/notes/heroku.md

@@ -0,0 +1,3 @@
+Heroku might send out emails for new deploy keys (doesn't do it for me, but for some others).
+
+Alternative is Anvil, but it's not perfect, as it duplicates a lot of Heroku logic internally (and failed for me in one case).

data/spec/cli_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'dpl/cli'
+
+describe DPL::CLI do
+  describe "#options" do
+    example { expect(described_class.new.options[:app])                           .to eq(File.basename(Dir.pwd)) }
+    example { expect(described_class.new(:app => 'foo')            .options[:app]).to eq('foo')                  }
+    example { expect(described_class.new("--app=foo")              .options[:app]).to eq('foo')                  }
+    example { expect(described_class.new("--app")                  .options[:app]).to eq(true)                   }
+    example { expect(described_class.new("--app=foo", "--app=bar") .options[:app]).to eq(['foo', 'bar'])         }
+
+    example "error handling" do
+      expect($stderr).to receive(:puts).with('invalid option "app"')
+      expect { described_class.new("app") }.to raise_error(SystemExit)
+    end
+  end
+
+  describe "#run" do
+    example "triggers deploy" do
+      provider = double('provider')
+      expect(DPL::Provider).to receive(:new).and_return(provider)
+      expect(provider).to receive(:deploy)
+
+      described_class.run("--provider=foo")
+    end
+
+    example "error handling" do
+      expect($stderr).to receive(:puts).with('missing provider')
+      expect { described_class.run }.to raise_error(SystemExit)
+    end
+
+    example "error handling in debug mode" do
+      expect { described_class.run("--debug") }.to raise_error(DPL::Error, 'missing provider')
+    end
+  end
+end

data/spec/provider_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+require 'dpl/provider'
+
+describe DPL::Provider do
+  let(:example_provider) { Class.new(described_class)}
+  let(:context) { DummyContext.new }
+  subject(:provider) { example_provider.new(context, :app => 'example', :key_name => 'foo', :run => ["foo", "bar"]) }
+
+  before { stub_const "DPL::Provider::Example", example_provider }
+
+  describe "#new" do
+    example { expect(described_class.new(context, :provider => "example")) .to be_an(example_provider) }
+    example { expect(described_class.new(context, :provider => "Example")) .to be_an(example_provider) }
+    example { expect(described_class.new(context, :provider => "exa_mple")).to be_an(example_provider) }
+    example { expect(described_class.new(context, :provider => "exa-mple")).to be_an(example_provider) }
+    example { expect(described_class.new(context, :provider => "scri_pt")).to be_an(DPL::Provider::Script) }
+    example { expect(described_class.new(context, :provider => "scri _pt")).to be_an(DPL::Provider::Script) }
+    example { expect(described_class.new(context, :provider => "cloudfoundry")).to be_an(DPL::Provider::CloudFoundry) }
+    example "install deployment dependencies" do
+      expect_any_instance_of(described_class).to receive(:respond_to?).with(:install_deploy_dependencies).and_return(true)
+      expect_any_instance_of(described_class).to receive(:install_deploy_dependencies)
+      described_class.new(context, :provider => "example")
+    end
+
+    it "installs correct gem when provider name does not match" do
+      expect(context).to receive(:shell).with("gem install dpl-cloud_foundry -v #{ENV['DPL_VERSION'] || DPL::VERSION}")
+      expect(described_class).to receive(:require).with("dpl/provider/cloud_foundry").and_raise LoadError.new("cannot load such file -- dpl/provider/cloud_foundry")
+      expect(described_class).to receive(:require).with("dpl/provider/cloud_foundry").and_call_original
+      described_class.new(context, :provider => 'cloudfoundry')
+    end
+
+  end
+
+  describe "#pip" do
+    example "installed" do
+      expect(example_provider).to receive(:`).with("which foo").and_return("/bin/foo\n")
+      expect(example_provider).not_to receive(:system)
+      expect(example_provider.context).to receive(:shell).with("export PATH=$PATH:$HOME/.local/bin")
+      example_provider.pip("foo")
+    end
+
+    example "missing" do
+      expect(example_provider).to receive(:`).with("which foo").and_return("")
+      expect(example_provider.context).to receive(:shell).with("pip install --user foo", retry: true)
+      expect(example_provider.context).to receive(:shell).with("export PATH=$PATH:$HOME/.local/bin")
+      example_provider.pip("foo")
+    end
+
+    example "specific version" do
+      expect(example_provider).to receive(:`).with("which foo").and_return("")
+      expect(example_provider.context).to receive(:shell).with("pip install --user foo==1.0", retry: true)
+      expect(example_provider.context).to receive(:shell).with("export PATH=$PATH:$HOME/.local/bin")
+      example_provider.pip("foo", "foo", "1.0")
+    end
+  end
+
+  describe "#deploy" do
+    before do
+      expect(provider).to receive(:check_auth)
+      expect(provider).to receive(:check_app)
+      expect(provider).to receive(:push_app)
+      expect(provider).to receive(:run).with("foo")
+      expect(provider).to receive(:run).with("bar")
+    end
+
+    example "needs key" do
+      expect(provider).to receive(:remove_key)
+      expect(provider).to receive(:create_key)
+      expect(provider).to receive(:setup_key)
+      expect(provider).to receive(:setup_git_ssh)
+      provider.deploy
+    end
+
+    example "does not need key" do
+      allow(provider).to receive_messages(:needs_key? => false)
+      provider.deploy
+    end
+  end
+
+  describe "#cleanup" do
+    example do
+      expect(provider.context).to receive(:shell).with('mv .dpl ~/dpl')
+      expect(provider.context).to receive(:shell).with('git stash --all')
+      expect(provider.context).to receive(:shell).with('mv ~/dpl .dpl')
+      provider.cleanup
+    end
+
+    example "skip cleanup" do
+      expect(provider.options).to receive(:[]).with(:skip_cleanup).and_return("true")
+      expect(provider.context).not_to receive(:shell)
+      provider.cleanup
+    end
+  end
+
+  describe "#uncleanup" do
+    example do
+      expect(provider.context).to receive(:shell).with('git stash pop')
+      provider.uncleanup
+    end
+
+    example "skip cleanup" do
+      expect(provider.options).to receive(:[]).with(:skip_cleanup).and_return("true")
+      expect(provider.context).not_to receive(:shell)
+      provider.uncleanup
+    end
+  end
+
+  describe "#create_key" do
+    example do
+      expect(provider.context).to receive(:shell).with('ssh-keygen -t rsa -N "" -C foo -f thekey')
+      provider.create_key('thekey')
+    end
+  end
+
+  describe "#setup_git_ssh" do
+    after { FileUtils.rm provider.context.env.delete('GIT_SSH') }
+
+    example do
+      provider.setup_git_ssh('foo', 'bar')
+      expect(provider.context.env['GIT_SSH']).to eq(File.expand_path('foo'))
+    end
+  end
+
+  describe "#detect_encoding?" do
+    example do
+      provider.options.update(:detect_encoding => true)
+      expect(provider.detect_encoding?).to eq(true)
+    end
+  end
+
+  describe "#encoding_for" do
+    example do
+      path = 'foo.js'
+      expect(provider).to receive(:`).at_least(1).times.with("file '#{path}'").and_return("#{path}: gzip compressed")
+      expect(provider.encoding_for(path)).to eq('gzip')
+    end
+
+    example do
+      path = 'file with a space'
+      expect(provider).to receive(:`).at_least(1).times.with("file '#{path}'").and_return("#{path}: empty")
+      expect(provider.encoding_for(path)).to be_nil
+    end
+
+    example do
+      path = 'foo.js'
+      expect(provider).to receive(:`).at_least(1).times.with("file '#{path}'").and_return("#{path}: ASCII text, with very long line")
+      expect(provider.encoding_for(path)).to eq('text')
+    end
+
+    example do
+      path = 'foo.js'
+      provider.options.update(:default_text_charset => 'UTF-8')
+      expect(provider).to receive(:`).at_least(1).times.with("file '#{path}'").and_return("#{path}: ASCII text, with very long line")
+      expect(provider.encoding_for(path)).to eq('text')
+    end
+  end
+
+  describe "#log" do
+    example do
+      expect($stderr).to receive(:puts).with("foo")
+      provider.log("foo")
+    end
+  end
+
+  describe "#shell" do
+    example do
+      expect(example_provider).to receive(:system).with("command")
+      example_provider.shell("command")
+    end
+  end
+
+  describe "#npm_g" do
+    example do
+      expect(example_provider.context).to receive(:shell).with("npm install -g foo", retry: true)
+      example_provider.npm_g("foo")
+    end
+  end
+
+  describe "#run" do
+    example do
+      expect(provider).to receive(:error).with("running commands not supported")
+      provider.run "blah"
+    end
+  end
+
+  describe "#error" do
+    example do
+      expect { provider.error("Foo") }.to raise_error("Foo")
+    end
+  end
+end