engineyard-serverside 2.1.4 → 2.2.0.pre

data/lib/engineyard-serverside.rb

@@ -26,7 +26,6 @@ require 'engineyard-serverside/cli'
 require 'engineyard-serverside/configuration'
 require 'engineyard-serverside/deprecation'
 require 'engineyard-serverside/shell'
-require 'engineyard-serverside/propagator'
 
 
 module EY

data/lib/engineyard-serverside/cli.rb

@@ -1,5 +1,6 @@
 require 'thor'
 require 'pathname'
+require 'engineyard-serverside/about'
 require 'engineyard-serverside/deploy'
 require 'engineyard-serverside/shell'
 require 'engineyard-serverside/servers'
@@ -8,6 +9,7 @@ require 'engineyard-serverside/cli_helpers'
 module EY
   module Serverside
     class CLI < Thor
+
       extend CLIHelpers
 
       method_option :migrate,         :type     => :string,
@@ -99,15 +101,12 @@ module EY
 
           # We have to rsync the entire app dir, so we need all the permissions to be correct!
           chown_command = "find #{app_dir} -not -user #{config.user} -or -not -group #{config.group} -exec chown #{config.user}:#{config.group} {} +"
-          shell.logged_system "sudo sh -l -c '#{chown_command}'"
-
-          servers.each do |server|
-            shell.logged_system server.sync_directory_command(app_dir)
-            # we're just about to recreate this, so it has to be gone
-            # first. otherwise, non-idempotent deploy hooks could screw
-            # things up, and since we don't control deploy hooks, we must
-            # assume the worst.
-            shell.logged_system server.command_on_server('sh -l -c', "rm -rf #{current_app_dir}")
+          shell.logged_system("sudo sh -l -c '#{chown_command}'", servers.detect {|s| s.local?})
+
+          servers.run_for_each! do |server|
+            sync  = server.sync_directory_command(app_dir)
+            clean = server.command_on_server('sh -l -c', "rm -rf #{current_app_dir}")
+            "(#{sync}) && (#{clean})"
           end
 
           # deploy local-ref to other instances into /data/$app/local-current
@@ -130,8 +129,8 @@ module EY
 
       def init_and_propagate(*args)
         init(*args) do |config, shell|
-          servers = load_servers(config)
-          Propagator.call(servers, config, shell)
+          servers = load_servers(config, shell)
+          propagate(servers, shell)
           yield servers, config, shell
         end
       end
@@ -154,8 +153,28 @@ module EY
         end
       end
 
-      def load_servers(config)
-        EY::Serverside::Servers.from_hashes(assemble_instance_hashes(config))
+      def propagate(servers, shell)
+        shell.status "Verifying and propagating #{About.name_with_version} to all servers."
+
+        gem_binary = File.join(Gem.default_bindir, 'gem')
+        remote_gem_file = File.join(Dir.tmpdir, About.gem_filename)
+
+        # 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
+        check_command = %{#{gem_binary} list #{About.gem_name} | grep "#{About.gem_name}" | egrep -q "#{About.version.gsub(/\./, '\.')}[,)]"}
+        install_command = "#{gem_binary} install --no-rdoc --no-ri '#{remote_gem_file}'"
+
+        servers.remote.run_for_each! do |server|
+          check   = server.command_on_server('sh -l -c', check_command)
+          scp     = server.scp_command(About.gem_file, remote_gem_file)
+          install = server.command_on_server('sudo sh -l -c', install_command)
+
+          "(#{check}) || ((#{scp}) && (#{install}))"
+        end
+      end
+
+      def load_servers(config, shell)
+        EY::Serverside::Servers.from_hashes(assemble_instance_hashes(config), shell)
       end
 
       def assemble_instance_hashes(config)

data/lib/engineyard-serverside/configuration.rb

@@ -60,7 +60,7 @@ module EY
       def_option :precompile_assets, 'detect'
       def_option :precompile_assets_task, 'assets:precompile'
       def_option :asset_strategy,    'shifting'
-      def_option :asset_dependencies, %w[app/assets lib/assets vendor/assets Gemfile.lock config/routes.rb]
+      def_option :asset_dependencies, %w[app/assets lib/assets vendor/assets Gemfile.lock config/routes.rb config/application.rb]
       def_option :stack,             nil
       def_option :strategy,          'Git'
       def_option :branch,            'master'

data/lib/engineyard-serverside/dependency_manager/composer.rb

@@ -42,11 +42,11 @@ To fix this problem, commit your composer.lock to the repository and redeploy.
         end
 
         def composer_install
-            run "composer install --no-interaction --working-dir #{paths.active_release}"
+          run "composer install --no-interaction --working-dir #{paths.active_release}"
         end
 
         def composer_selfupdate
-            run "composer self-update"
+          run "composer self-update"
         end
 
         def composer_available?

data/lib/engineyard-serverside/deploy.rb

@@ -106,9 +106,8 @@ module EY
       # task
       def push_code
         shell.status "Pushing code to all servers"
-        servers.remote.run_on_each(shell) do |server|
-          cmd = server.sync_directory_command(paths.repository_cache)
-          shell.logged_system(cmd)
+        servers.remote.run_for_each do |server|
+          server.sync_directory_command(paths.repository_cache)
         end
       end
 
@@ -149,7 +148,7 @@ module EY
         path = paths.ssh_wrapper
         <<-SCRIPT
 mkdir -p #{path.dirname}
-[[ -x #{path} ]] || cat > #{path} <<'SSH'
+[ -x #{path} ] || cat > #{path} <<'SSH'
 #!/bin/sh
 unset SSH_AUTH_SOCK
 ssh -o CheckHostIP=no -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o LogLevel=INFO -o IdentityFile=#{paths.deploy_key} -o IdentitiesOnly=yes $*

data/lib/engineyard-serverside/maintenance.rb

@@ -68,7 +68,7 @@ module EY
       end
 
       def run(cmd)
-        @servers.roles(:app_master, :app, :solo).run(shell, cmd)
+        @servers.roles(:app_master, :app, :solo).run(cmd)
       end
 
       def paths

data/lib/engineyard-serverside/rails_assets.rb

@@ -86,10 +86,15 @@ module EY
         run_precompile_assets_task
 
         shell.warning <<-WARN
-Inferred asset compilation succeeded, but failures may be silently ignored!
+Assets were detected and precompiled for this application, but asset precompile
+failures may be silently ignored in the future without updating config/ey.yml.
 
-ACTION REQUIRED: Add precompile_assets option to ey.yml.
-  precompile_assets: true  # precompile assets when asset changes detected
+ACTION REQUIRED: Add this line to config/ey.yml to ensure assets are compiled
+every deploy and deploys are halted if there is an asset compilation failure.
+
+  precompile_assets: true  # precompile assets when assets are changed.
+
+This warning will continue to show until you update and commit config/ey.yml.
         WARN
       rescue EY::Serverside::RemoteFailure => e
         # If we are implicitly precompiling, we want to fail non-destructively

data/lib/engineyard-serverside/server.rb

@@ -42,6 +42,18 @@ module EY
         ].join(' && ')
       end
 
+      def scp_command(local_file, remote_file)
+        Escape.shell_command([
+          'scp',
+          '-i', "#{ENV['HOME']}/.ssh/internal",
+          "-o", "StrictHostKeyChecking=no",
+          "-o", "UserKnownHostsFile=#{self.class.known_hosts_file.path}",
+          "-o", "PasswordAuthentication=no",
+          local_file,
+          "#{authority}:#{remote_file}",
+        ])
+      end
+
       def command_on_server(prefix, cmd, &block)
         command = block ? block.call(self, cmd.dup) : cmd
         command = "#{prefix} #{Escape.shell_command([command])}"

data/lib/engineyard-serverside/servers.rb

@@ -1,6 +1,7 @@
 require 'engineyard-serverside/server'
 require 'forwardable'
 require 'set'
+require 'engineyard-serverside/spawner'
 
 module EY
   module Serverside
@@ -16,24 +17,25 @@ module EY
       extend Forwardable
       include Enumerable
       def_delegators :@servers, :each, :size, :empty?
-      def select(*a, &b) self.class.new @servers.select(*a,&b) end
-      def reject(*a, &b) self.class.new @servers.reject(*a,&b) end
+      def select(*a, &b) self.class.new @servers.select(*a,&b), @shell end
+      def reject(*a, &b) self.class.new @servers.reject(*a,&b), @shell end
       def to_a() @servers end
       def ==(other) other.respond_to?(:to_a) && other.to_a == to_a end
 
 
-      def self.from_hashes(server_hashes)
+      def self.from_hashes(server_hashes, shell)
         servers = server_hashes.inject({}) do |memo, server_hash|
           server = Server.from_hash(server_hash)
           raise DuplicateHostname.new(server.hostname) if memo.key?(server.hostname)
           memo[server.hostname] = server
           memo
         end
-        new(servers.values)
+        new(servers.values, shell)
       end
 
-      def initialize(servers)
+      def initialize(servers, shell)
         @servers = servers
+        @shell = shell
         @cache = {}
       end
 
@@ -62,40 +64,43 @@ module EY
         end
       end
 
+      def run_on_each(cmd, &block)
+        run_for_each do |server|
+          server.command_on_server('sh -l -c', cmd, &block)
+        end
+      end
+
       # Run a command on this set of servers.
-      def run(shell, cmd, &block)
-        run_on_each(shell) do |server|
-          exec_cmd = server.command_on_server('sh -l -c', cmd, &block)
-          shell.logged_system(exec_cmd, server)
+      def run_on_each!(cmd, &block)
+        run_for_each! do |server|
+          server.command_on_server('sh -l -c', cmd, &block)
         end
       end
+      alias run run_on_each!
 
       # Run a sudo command on this set of servers.
-      def sudo(shell, cmd, &block)
-        run_on_each(shell) do |server|
-          exec_cmd = server.command_on_server('sudo sh -l -c', cmd, &block)
-          shell.logged_system(exec_cmd, server)
+      def sudo_on_each(cmd, &block)
+        run_for_each do |server|
+          server.command_on_server('sudo sh -l -c', cmd, &block)
         end
       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 }
+      # Run a sudo command on this set of servers.
+      def sudo_on_each!(cmd, &block)
+        run_for_each! do |server|
+          server.command_on_server('sudo sh -l -c', cmd, &block)
+        end
       end
+      alias sudo sudo_on_each!
 
-      def select_in_parallel(&block)
-        results = map_in_parallel { |server| block.call(server) ? server : nil }.compact
-        self.class.new results
+      def run_for_each(&block)
+        spawner = Spawner.new
+        each { |server| spawner.add(block.call(server), @shell, server) }
+        spawner.run
       end
 
-      # 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(shell, &block)
-        results = map_in_parallel(&block)
-        failures = results.reject {|result| result.success? }
+      def run_for_each!(&block)
+        failures = run_for_each(&block).reject {|result| result.success? }
 
         if failures.any?
           commands = failures.map { |f| f.command }.uniq

data/lib/engineyard-serverside/shell.rb

@@ -1,6 +1,6 @@
 require 'logger'
 require 'pathname'
-require 'systemu'
+require 'open3'
 require 'engineyard-serverside/shell/formatter'
 require 'engineyard-serverside/shell/command_result'
 require 'engineyard-serverside/shell/yieldio'
@@ -64,21 +64,9 @@ module EY
       def command_err(msg)  unknown msg.gsub(/^/,'     ') end
 
       def logged_system(cmd, server = nil)
-        command_show(cmd)
-        output = ""
-        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, server)
+        EY::Serverside::Spawner.run(cmd, self, server)
       end
 
-      protected
-
-      # This is the meat of process spawning. It's nice to keep it separate even
-      # though it's simple because we've had to modify it frequently.
-      def spawn_process(cmd, outio, errio)
-        systemu cmd, 'stdout' => outio, 'stderr' => errio
-      end
     end
   end
 end

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

@@ -1,17 +1,13 @@
 module EY
   module Serverside
     class Shell
-      class CommandResult < Struct.new(:command, :exitstatus, :output, :server)
-        def success?
-          exitstatus.to_i == 0
-        end
+      class CommandResult < Struct.new(:command, :success, :output, :server)
+        alias success? success
 
         def inspect
           <<-EOM
-$ #{command}
+$ #{success? ? "(success)" : "(failed)"} #{command}
 #{output}
-
-($?: #{exitstatus})
           EOM
         end
       end

data/lib/engineyard-serverside/spawner.rb

@@ -0,0 +1,187 @@
+require 'open3'
+require 'engineyard-serverside/spawner'
+
+module EY
+  module Serverside
+    class Spawner
+      def self.run(cmd, shell, server = nil)
+        s = new
+        s.add(cmd, shell, server)
+        s.run.first
+      end
+
+      def initialize
+        @poll_period = 0.5
+        @children = []
+      end
+
+      def add(cmd, shell, server = nil)
+        @children << Child.new(cmd, shell, server)
+      end
+
+      def run
+        @child_by_fd = {}
+        @child_by_pid = {}
+
+        @children.each do |child|
+          pid, stdout_fd, stderr_fd = child.spawn
+          @child_by_pid[pid] = child
+          @child_by_fd[stdout_fd] = child
+          @child_by_fd[stderr_fd] = child
+        end
+
+        while @child_by_pid.any?
+          process
+          wait
+        end
+
+        @children.map { |child| child.result }
+      end
+
+      protected
+
+      def process
+        read_fds = @child_by_pid.values.map {|child| child.ios }.flatten.compact
+        ra, _, _ = IO.select(read_fds, [], [], @poll_period)
+        process_readable(ra) if ra
+      end
+
+      def process_readable(ra)
+        ra.each do |fd|
+          child = @child_by_fd[fd]
+          if !child
+            raise "Select returned unknown fd: #{fd.inspect}"
+          end
+
+          begin
+            if buf = fd.sysread(4096)
+              child.append_to_buffer(fd, buf)
+            else
+              raise "sysread() returned nil"
+            end
+          rescue SystemCallError, EOFError => e
+            @child_by_fd.delete(fd)
+            child.close(fd)
+          end
+        end
+      end
+
+      def wait
+        possible_children = true
+        just_reaped = []
+        while possible_children
+          begin
+            pid, status = Process::waitpid2(-1, Process::WNOHANG)
+            if pid.nil?
+              possible_children = false
+            else
+              child = @child_by_pid.delete(pid)
+              child.finished status
+              just_reaped << child
+            end
+          rescue Errno::ECHILD
+            possible_children = false
+          end
+        end
+        # We may have waited on a child before reading all its output. Collect those missing bits. No blocking.
+        if just_reaped.any?
+          read_fds = just_reaped.map {|child| child.ios }.flatten.compact
+          ra, _, _ = IO.select(read_fds, nil, nil, 0)
+          process_readable(ra) if ra
+        end
+      end
+
+      class Child
+        attr_reader :stdout_fd, :stderr_fd
+
+        def initialize(command, shell, server = nil)
+          @command = command
+          @shell = shell
+          @server = server
+          @output = ""
+        end
+
+        def spawn
+          @shell.command_show @command
+          #stdin, @stdout_fd, @stderr_fd, @waitthr = Open3.popen3(@cmd)
+          #stdin.close
+
+          stdin_rd, stdin_wr = IO.pipe
+          @stdout_fd, stdout_wr = IO.pipe
+          @stderr_fd, stderr_wr = IO.pipe
+
+          @pid = fork do
+            stdin_wr.close
+            @stdout_fd.close
+            @stderr_fd.close
+            STDIN.reopen(stdin_rd)
+            STDOUT.reopen(stdout_wr)
+            STDERR.reopen(stderr_wr)
+            Kernel.exec(@command)
+            raise "Exec failed!"
+          end
+
+          stdin_rd.close
+          stdin_wr.close
+          stdout_wr.close
+          stderr_wr.close
+
+          [@pid, @stdout_fd, @stderr_fd]
+        end
+
+        def ios
+          [@stdout_fd, @stderr_fd].compact
+        end
+
+        def finished(status)
+          @status = status
+        end
+
+        def result
+          if @status
+            Result.new(@command, @status.success?, @output, @server)
+          else
+            raise "No result from unfinished child process"
+          end
+        end
+
+        def close(fd)
+          case fd
+          when @stdout_fd then @stdout_fd = nil
+          when @stderr_fd then @stderr_fd = nil
+          end
+          fd.close rescue true
+        end
+
+        def append_to_buffer(fd,data)
+          case fd
+          when @stdout_fd
+            @shell.command_out data
+            @output << data
+          when @stderr_fd
+            @shell.command_err data
+            @output << data
+          end
+        end
+      end
+
+      class Result
+        attr_reader :command, :success, :output, :server
+        def initialize(command, success, output, server = nil)
+          @command = command
+          @success = success
+          @output = output
+          @server = server
+        end
+
+        alias success? success
+        def inspect
+          <<-EOM
+$ #{success? ? "(success)" : "(failed)"} #{command}
+#{output}
+          EOM
+        end
+      end
+    end
+  end
+end