engineyard-serverside 2.0.4 → 2.0.5.pre

data/lib/engineyard-serverside.rb

@@ -16,6 +16,7 @@ require 'escape'
 require 'json'
 
 require 'engineyard-serverside/version'
+require 'engineyard-serverside/about'
 require 'engineyard-serverside/strategies/git'
 require 'engineyard-serverside/task'
 require 'engineyard-serverside/server'
@@ -25,8 +26,8 @@ require 'engineyard-serverside/lockfile_parser'
 require 'engineyard-serverside/cli'
 require 'engineyard-serverside/configuration'
 require 'engineyard-serverside/deprecation'
-require 'engineyard-serverside/future'
 require 'engineyard-serverside/shell'
+require 'engineyard-serverside/propagator'
 
 
 module EY

data/lib/engineyard-serverside/about.rb

@@ -0,0 +1,37 @@
+
+module EY
+  module Serverside
+    module About
+      extend self
+
+      def gem_name
+        "engineyard-serverside"
+      end
+
+      def version
+        EY::Serverside::VERSION
+      end
+
+      def name_with_version
+        "#{gem_name} #{version}"
+      end
+
+      def gem_filename
+        "#{gem_name}-#{version}.gem"
+      end
+
+      def gem_file
+        File.join(Gem.dir, 'cache', gem_filename)
+      end
+
+      def gem_binary
+        File.join(Gem.default_bindir, 'gem')
+      end
+
+      def binary
+        File.expand_path("../../../bin/#{gem_name}", __FILE__)
+      end
+
+    end
+  end
+end

data/lib/engineyard-serverside/cli.rb

@@ -136,57 +136,10 @@ module EY
 
       private
 
-      # Put the same engineyard-serverside on all the servers (Used to be public but is unused as an actual CLI command now)
-      def propagate(servers, config, shell)
-        gem_filename    = "engineyard-serverside-#{EY::Serverside::VERSION}.gem"
-        local_gem_file  = File.join(Gem.dir, 'cache', gem_filename)
-        remote_gem_file = File.join(Dir.tmpdir, gem_filename)
-        gem_binary      = File.join(Gem.default_bindir, 'gem')
-
-        servers = servers.remote
-
-        return if servers.empty?
-
-        shell.status "Propagating engineyard-serverside #{EY::Serverside::VERSION} to #{servers.size} server#{servers.size == 1 ? '' : 's' }."
-
-        commands = servers.map do |server|
-          shell.debug "Building propagate commands for #{server.hostname}"
-
-          egrep_escaped_version = EY::Serverside::VERSION.gsub(/\./, '\.')
-          # the [,)] is to stop us from looking for e.g. 0.5.1, seeing
-          # 0.5.11, and mistakenly thinking 0.5.1 is there
-          has_gem_cmd = "#{gem_binary} list engineyard-serverside | grep \"engineyard-serverside\" | egrep -q '#{egrep_escaped_version}[,)]'"
-
-          proc do
-            exists = shell.logged_system(server.command_on_server('sh -l -c', has_gem_cmd))
-            if exists.success?
-              exists # Future expects logged system result object
-            else # doesn't have this exact version
-              shell.status "Installing engineyard-serverside on #{server.hostname}"
-
-              shell.logged_system(Escape.shell_command([
-                'scp', '-i', config.paths.internal_key.to_s,
-                "-o", "StrictHostKeyChecking=no",
-                local_gem_file,
-               "#{config.user}@#{server.hostname}:#{remote_gem_file}",
-              ]))
-              install_gem_cmd = "#{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'"
-              shell.logged_system(server.command_on_server('sudo sh -l -c', install_gem_cmd))
-            end
-          end
-        end
-
-        futures = EY::Serverside::Future.call(commands)
-        unless EY::Serverside::Future.success?(futures)
-          failures = futures.select {|f| f.error? }.map {|f| f.inspect}.join("\n")
-          raise EY::Serverside::RemoteFailure.new(failures)
-        end
-      end
-
       def init_and_propagate(*args)
         config, shell = init(*args)
         servers = load_servers(config)
-        propagate(servers, config, shell)
+        Propagator.call(servers, config, shell)
         [servers, config, shell]
       end
 
@@ -196,7 +149,7 @@ module EY
           :verbose  => config.verbose,
           :log_path => File.join(ENV['HOME'], "#{config.app}-#{action}.log")
         )
-        shell.debug "Initializing engineyard-serverside #{EY::Serverside::VERSION}."
+        shell.debug "Initializing #{About.name_with_version}."
         [config, shell]
       end
 

data/lib/engineyard-serverside/configuration.rb

@@ -62,6 +62,7 @@ module EY
       def_option :branch,            'master'
       def_option :bundle_without,    'test development'
       def_option :current_roles,     []
+      def_option :current_name,      nil
       def_option :asset_roles,       [:app_master, :app, :solo]
       def_option :copy_exclude,      []
       def_option(:user)              { ENV['USER'] }

data/lib/engineyard-serverside/deploy.rb

@@ -153,12 +153,10 @@ To fix this problem, commit your Gemfile.lock to your repository and redeploy.
       # task
       def push_code
         shell.status "Pushing code to all servers"
-        commands = servers.remote.map do |server|
+        servers.remote.run_on_each do |server|
           cmd = server.sync_directory_command(paths.repository_cache)
-          proc { shell.logged_system(cmd) }
+          shell.logged_system(cmd)
         end
-        futures = EY::Serverside::Future.call(commands)
-        EY::Serverside::Future.success?(futures)
       end
 
       # task
@@ -415,7 +413,7 @@ WRAP
       end
 
       def base_callback_command_for(what)
-        cmd =  [serverside_bin, 'hook', what.to_s]
+        cmd =  [About.binary, 'hook', what.to_s]
         cmd << '--app'              << config.app
         cmd << '--environment-name' << config.environment_name
         cmd << '--account-name'     << config.account_name
@@ -426,8 +424,7 @@ WRAP
       end
 
       def serverside_bin
-        basedir = File.expand_path('../../..', __FILE__)
-        File.join(basedir, 'bin', 'engineyard-serverside')
+        About.binary
       end
 
       def puts_deploy_failure
@@ -497,7 +494,7 @@ WRAP
           clean_bundle_on_system_version_change
 
           bundler_version, install_switches = bundler_config
-          sudo "#{clean_environment} && #{serverside_bin} install_bundler #{bundler_version}"
+          sudo "#{clean_environment} && #{About.binary} install_bundler #{bundler_version}"
           run  "#{clean_environment} && cd #{paths.active_release} && ruby -S bundle _#{bundler_version}_ install #{install_switches}"
 
           write_system_version

data/lib/engineyard-serverside/propagator.rb

@@ -0,0 +1,75 @@
+require 'engineyard-serverside/about'
+
+module EY
+  module Serverside
+    # Put the same engineyard-serverside on all the servers
+    class Propagator
+      def self.call(*args)
+        new(*args).call
+      end
+
+      attr_reader :config, :shell
+
+      def initialize(servers, config, shell, options={})
+        @remote_servers = servers.remote
+        @config, @shell = config, shell
+      end
+
+      # servers that need to have the gem installed
+      def servers
+        @servers ||= find_servers_missing_gem
+      end
+
+      # Find the servers that need the gem, then install the gem on them
+      def call
+        servers.any? && propagate
+      end
+
+      def remote_gem_file
+        File.join(Dir.tmpdir, About.gem_filename)
+      end
+
+      def gem_binary
+        File.join(Gem.default_bindir, 'gem')
+      end
+
+      # the [,)] is to stop us from looking for e.g. 0.5.1, seeing
+      # 0.5.11, and mistakenly thinking 0.5.1 is there
+      def check_command
+        %{#{gem_binary} list #{About.gem_name} | grep "#{About.gem_name}" | egrep -q "#{About.version.gsub(/\./, '\.')}[,)]"}
+      end
+
+      def scp_command(server)
+        Escape.shell_command([
+          'scp',
+          '-i', config.paths.internal_key.to_s,
+          "-o", "StrictHostKeyChecking=no",
+          About.gem_file,
+         "#{server.authority}:#{remote_gem_file}",
+        ])
+      end
+
+      def install_command
+        "#{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'"
+      end
+
+      def count_servers(set)
+        "#{set.size} server#{set.size == 1 ? '' : 's'}"
+      end
+
+      def find_servers_missing_gem
+        return @remote_servers if @remote_servers.empty?
+        shell.status "Verifying #{About.name_with_version} on #{count_servers(@remote_servers)}."
+        @remote_servers.select_in_parallel do |server|
+          !shell.logged_system(server.command_on_server('sh -l -c', check_command)).success?
+        end
+      end
+
+      def propagate
+        shell.status "Propagating #{About.name_with_version} to #{count_servers(servers)}."
+        servers.run_on_each { |server| shell.logged_system(scp_command(server)) }
+        servers.run_on_each { |server| shell.logged_system(server.command_on_server('sudo sh -l -c', install_command)) }
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/server.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'tempfile'
 
 module EY
   module Serverside
@@ -7,8 +8,8 @@ module EY
         new(server_hash[:hostname], Set.new(server_hash[:roles].map{|r|r.to_sym}), server_hash[:name], server_hash[:user])
       end
 
-      def initialize(*fields)
-        super
+      def authority
+        "#{user}@#{hostname}"
       end
 
       def role

data/lib/engineyard-serverside/servers.rb

@@ -63,27 +63,41 @@ module EY
       end
 
       # Run a command on this set of servers.
-      def run(shell, cmd, &blk)
-        run_on_servers(shell, 'sh -l -c', cmd, &blk)
+      def run(shell, cmd, &block)
+        run_on_each do |server|
+          exec_cmd = server.command_on_server('sh -l -c', cmd, &block)
+          shell.logged_system(exec_cmd)
+        end
       end
 
       # Run a sudo command on this set of servers.
-      def sudo(shell, cmd, &blk)
-        run_on_servers(shell, 'sudo sh -l -c', cmd, &blk)
+      def sudo(shell, cmd, &block)
+        run_on_each do |server|
+          exec_cmd = server.command_on_server('sudo sh -l -c', cmd, &block)
+          shell.logged_system(exec_cmd)
+        end
       end
 
-      private
-
-      def run_on_servers(shell, prefix, cmd, &block)
-        commands = map do |server|
-          exec_cmd = server.command_on_server(prefix, cmd, &block)
-          proc { shell.logged_system(exec_cmd) }
-        end
+      # Makes a thread for each server and executes the block,
+      # returning an array of return values
+      def map_in_parallel(&block)
+        threads = map { |server| Thread.new { block.call(server) } }
+        threads.map { |t| t.value }
+      end
 
-        futures = EY::Serverside::Future.call(commands)
+      def select_in_parallel(&block)
+        results = map_in_parallel { |server| block.call(server) ? server : nil }.compact
+        self.class.new results
+      end
 
-        unless EY::Serverside::Future.success?(futures)
-          failures = futures.select {|f| f.error? }.map {|f| f.inspect}.join("\n")
+      # Makes a theard for each server and executes the block,
+      # Assumes that the return value of the block is a CommandResult
+      # and ensures that all the command results were successful.
+      def run_on_each(&block)
+        results = map_in_parallel(&block)
+        failures = results.reject {|result| result.success? }
+        if failures.any?
+          message = failures.map { |f| f.inspect }.join("\n")
           raise EY::Serverside::RemoteFailure.new(failures)
         end
       end

data/lib/engineyard-serverside/shell.rb

@@ -51,15 +51,15 @@ module EY
       #   $ cmd blah do \
       #   > something more
       #   > end
-      def show_command(cmd)
-        debug cmd.gsub(/^/, '   > ').sub(/>/, '$')
-      end
+      def command_show(cmd) debug   cmd.gsub(/^/,'   > ').sub(/>/, '$') end
+      def command_out(msg)  debug   msg.gsub(/^/,'     ') end
+      def command_err(msg)  unknown msg.gsub(/^/,'     ') end
 
       def logged_system(cmd)
-        show_command(cmd)
+        command_show(cmd)
         output = ""
-        outio = YieldIO.new { |msg| output << msg; debug   msg.gsub(/^/,'     ') }
-        errio = YieldIO.new { |msg| output << msg; unknown msg.gsub(/^/,'     ') }
+        outio = YieldIO.new { |msg| output << msg; command_out(msg) }
+        errio = YieldIO.new { |msg| output << msg; command_err(msg) }
         result = spawn_process(cmd, outio, errio)
         CommandResult.new(cmd, result.exitstatus, output)
       end

data/lib/engineyard-serverside/shell/command_result.rb

@@ -3,7 +3,7 @@ module EY
     class Shell
       class CommandResult < Struct.new(:command, :exitstatus, :output)
         def success?
-          exitstatus.zero?
+          exitstatus.to_i == 0
         end
 
         def inspect

data/lib/engineyard-serverside/strategies/git.rb

@@ -31,8 +31,8 @@ module EY
         def checkout
           shell.status "Deploying revision #{short_log_message(to_checkout)}"
           in_repository_cache do
-            (run("git checkout -q '#{to_checkout}'") ||
-              run("git reset -q --hard '#{to_checkout}'")) &&
+            (run("git checkout -f '#{to_checkout}'") ||
+              run("git reset --hard '#{to_checkout}'")) &&
               run("git submodule sync") &&
               run("git submodule update --init") &&
               run("git clean -dfq")
@@ -42,7 +42,12 @@ module EY
         def to_checkout
           return @to_checkout if @opts_ref == opts[:ref]
           @opts_ref = opts[:ref]
-          @to_checkout = branch?(@opts_ref) ? "origin/#{@opts_ref}" : @opts_ref
+          clean_local_branch(@opts_ref)
+          @to_checkout = remote_branch?(@opts_ref) ? "origin/#{@opts_ref}" : @opts_ref
+        end
+
+        def clean_local_branch(ref)
+          system("#{git} show-branch #{ref} > /dev/null 2>&1 && #{git} branch -D #{ref} > /dev/null 2>&1")
         end
 
         def gc_repository_cache
@@ -79,7 +84,7 @@ module EY
           "git --git-dir #{repository_cache}/.git --work-tree #{repository_cache}"
         end
 
-        def branch?(ref)
+        def remote_branch?(ref)
           system("#{git} show-branch origin/#{ref} > /dev/null 2>&1")
         end
       end

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '2.0.4'
+    VERSION = '2.0.5.pre'
   end
 end

data/spec/propagator_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe EY::Serverside::Propagator do
+  let(:config) do
+    EY::Serverside::Deploy::Configuration.new({
+      'app'       => 'app',
+      'deploy_to' => deploy_dir.to_s,
+      'user'      => ENV['USER'],
+    })
+  end
+
+  let(:servers) do
+    EY::Serverside::Servers.from_hashes(
+      [
+        {:user => config.user, :hostname => 'localhost', :roles => %w[solo]},
+        {:user => config.user, :hostname => '127.0.0.1', :roles => %w[util], :name => 'myutil'},
+      ]
+    )
+  end
+
+  let(:solo) { servers.roles(:solo).first }
+  let(:util) { servers.roles(:util).first }
+
+  let(:shell)       { mock('shell') }
+  let(:check_command)   { util.command_on_server('sh -l -c', subject.check_command) }
+  let(:scp_command)     { subject.scp_command(util) }
+  let(:install_command) { util.command_on_server('sudo sh -l -c', subject.install_command) }
+
+  subject do
+    EY::Serverside::Propagator.new(servers, config, shell)
+  end
+
+  def stub_shell_command(command, success, output="STUB OUTPUT")
+    shell.should_receive(:logged_system).once.ordered.with(command).and_return do
+      test_shell.command_show(command)
+      EY::Serverside::Shell::CommandResult.new(command, success ? 0 : 1, output)
+    end
+  end
+
+  before do
+    shell.stub(:status) do |msg|
+      test_shell.status(msg) # hax so you can see the output with VERBOSE
+    end
+  end
+
+  context "no remote servers" do
+    subject { EY::Serverside::Propagator.new(test_servers, config, shell) }
+
+    it "returns without doing anything" do
+      shell.should_not_receive(:logged_system)
+      subject.call
+    end
+  end
+
+  context "all servers have the gem" do
+    before do
+      stub_shell_command(check_command, true)
+      shell.should_not_receive(:logged_system).with(scp_command)
+      shell.should_not_receive(:logged_system).with(install_command)
+    end
+
+    it "finds no servers" do
+      subject.servers.should be_empty
+      subject.call
+    end
+  end
+
+  context "with a server missing the gem" do
+    before do
+      stub_shell_command(check_command, false)
+    end
+
+    it "finds servers that need the gem installed and installs it" do
+      stub_shell_command(scp_command, true)
+      stub_shell_command(install_command, true)
+
+      subject.servers.to_a.should == [util]
+      subject.call
+    end
+
+    it "raises if the scp fails" do
+      stub_shell_command(scp_command, false)
+      shell.should_not_receive(:logged_system).with(install_command)
+
+      lambda { subject.call }.should raise_error(EY::Serverside::RemoteFailure)
+    end
+
+    it "raises if the install fails" do
+      stub_shell_command(scp_command, true)
+      stub_shell_command(install_command, false)
+
+      lambda { subject.call }.should raise_error(EY::Serverside::RemoteFailure)
+    end
+  end
+end