engineyard-serverside 1.6.5 → 1.7.0.pre2

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

@@ -0,0 +1,71 @@
+module EY
+  module Serverside
+    class Shell
+      class Formatter
+        def initialize(stdout, stderr, start_time, verbose)
+          @stdout, @stderr = stdout, stderr
+          @start = start_time.to_i
+          @verbose = verbose
+        end
+
+        def call(severity, time, _, message)
+          msg = build_message(severity, timestamp(time), message)
+          put_to_io(severity, msg)
+          msg
+        end
+
+        def build_message(severity, stamp, message)
+          if %w[WARN ERROR FATAL].include?(severity)
+            prepend("#{stamp}!> ", "#{message}")
+          elsif severity == "INFO"
+            prepend(stamp, message)
+          else
+            prepend(' ' * stamp.size, message)
+          end
+        end
+
+        def prepend(pre, str)
+          str.gsub(/^/, pre).sub(/\n?\z/m,"\n")
+        end
+
+        def put_to_io(severity, msg)
+          case severity
+          when "DEBUG"
+            if @verbose
+              @stdout << msg
+            end
+          when "INFO"
+            # Need to differentiate info messages more when we're running in verbose mode
+            @stdout << (@verbose && msg.index('~>') ? "\n#{thor_shell.set_color(msg, :white, true)}" : msg)
+            @stdout.flush
+          when "WARN"
+            @stderr << "\n" << thor_shell.set_color(msg, :yellow, true)
+            @stderr.flush
+          when "ERROR"
+            @stderr << "\n" << thor_shell.set_color(msg, :red, true)
+            @stderr.flush
+          else
+            @stderr << msg
+            @stderr.flush
+          end
+        end
+
+        def timestamp(datetime)
+          diff = datetime.to_i - @start
+          diff = 0 if diff < 0
+          div, mod = diff.divmod(60)
+          if div.zero?
+            "+    %02ds  " % mod
+          else
+            "+%2dm %02ds  " % [div,mod]
+          end
+        end
+
+        def thor_shell
+          thor_shell ||= Thor::Shell::Color.new
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,29 @@
+module EY
+  module Serverside
+    class Shell
+      # Compatibility with old LoggedOutput where the module was included into the class.
+      module Helpers
+        def verbose?
+          shell.verbose?
+        end
+
+        def warning(*a)
+          shell.warning(*a)
+        end
+
+        def info(*a)
+          shell.info(*a)
+        end
+
+        def debug(*a)
+          shell.debug(*a)
+        end
+
+        def logged_system(*a)
+          shell.logged_system(*a)
+        end
+      end
+    end
+  end
+end
+

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

@@ -1,82 +1,48 @@
-require 'engineyard-serverside/logged_output'
-
 module EY
   module Serverside
     module Strategies
       class Git
-        module Helpers
-          def update_repository_cache
-            unless strategy.fetch && strategy.checkout
-              abort "*** [Error] Git could not checkout (#{strategy.to_checkout}) ***"
-            end
-          end
-
-          def create_revision_file_command
-            strategy.create_revision_file_command(c.release_path)
-          end
-
-          def short_log_message(revision)
-            strategy.short_log_message(revision)
-          end
+        attr_reader :shell, :opts
 
-          def strategy
-            # Ensure the git ssh config is up to date with the current app.
-            ENV['GIT_SSH'] = ssh_executable
-            klass = Module.nesting[1]
-            # Use [] to access attributes instead of calling methods so
-            # that we get nils instead of NoMethodError.
-            #
-            # Rollback doesn't know about the repository location (nor
-            # should it need to), but it would like to use #short_log_message.
-            klass.new(
-              :repository_cache => c[:repository_cache],
-              :app => c[:app],
-              :repo => c[:repo],
-              :ref => c[:branch]
-            )
-          end
+        def initialize(shell, opts)
+          @shell = shell
+          @opts = opts
         end
 
-        include LoggedOutput
-
-        attr_reader :opts
-
-        def initialize(opts)
-          @opts = opts
+        def update_repository_cache
+          unless fetch && checkout
+            abort "*** [Error] Git could not checkout (#{to_checkout}) ***"
+          end
         end
 
         def usable_repository?
-          File.directory?(opts[:repository_cache]) && `#{git} remote -v | grep origin`[opts[:repo]]
+          File.directory?(repository_cache) && `#{git} remote -v | grep origin`[remote_uri]
         end
 
         def fetch
           if usable_repository?
-            logged_system("#{git} fetch -q origin 2>&1")
+            run("#{git} fetch -q origin 2>&1")
           else
-            FileUtils.rm_rf(opts[:repository_cache])
-            logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
+            FileUtils.rm_rf(repository_cache)
+            run("git clone -q #{remote_uri} #{repository_cache} 2>&1")
           end
         end
 
         def checkout
-          info "~> Deploying revision #{short_log_message(to_checkout)}"
-          in_git_work_tree do
-            (logged_system("git checkout -q '#{to_checkout}'") ||
-              logged_system("git reset -q --hard '#{to_checkout}'")) &&
-              logged_system("git submodule sync") &&
-              logged_system("git submodule update --init") &&
-              logged_system("git clean -dfq")
+          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 submodule sync") &&
+              run("git submodule update --init") &&
+              run("git clean -dfq")
           end
         end
 
         def to_checkout
           return @to_checkout if @opts_ref == opts[:ref]
           @opts_ref = opts[:ref]
-          @to_checkout = if branch?(opts[:ref])
-            "origin/#{opts[:ref]}"
-          else
-            opts[:ref]
-          end
+          @to_checkout = branch?(@opts_ref) ? "origin/#{@opts_ref}" : @opts_ref
         end
 
         def create_revision_file_command(dir)
@@ -88,24 +54,28 @@ module EY
         end
 
       private
-        def in_git_work_tree
-          Dir.chdir(git_work_tree) { yield }
+        def run(cmd)
+          shell.logged_system(cmd).success?
         end
 
-        def git_work_tree
+        def in_repository_cache
+          Dir.chdir(repository_cache) { yield }
+        end
+
+        def remote_uri
+          opts[:repo]
+        end
+
+        def repository_cache
           opts[:repository_cache]
         end
 
         def git
-          "git --git-dir #{git_work_tree}/.git --work-tree #{git_work_tree}"
+          "git --git-dir #{repository_cache}/.git --work-tree #{repository_cache}"
         end
 
         def branch?(ref)
-          remote_branches = `#{git} branch -r`
-          remote_branches.each_line do |line|
-            return true if line.include?("origin/#{ref}")
-          end
-          false
+          system("#{git} show-branch origin/#{ref} > /dev/null 2>&1")
         end
       end
     end

data/lib/engineyard-serverside/task.rb

@@ -1,12 +1,14 @@
+require 'engineyard-serverside/shell/helpers'
+
 module EY
   module Serverside
     class Task
-
-      attr_reader :config
+      attr_reader :config, :shell
       alias :c :config
 
-      def initialize(conf)
+      def initialize(conf, shell = nil)
         @config = conf
+        @shell = shell
         @roles = :all
       end
 
@@ -18,7 +20,7 @@ module EY
         end
 
         if deploy_file
-          puts "~> Loading deployment task overrides from #{deploy_file}"
+          shell.status "Loading deployment task overrides from #{deploy_file}"
           instance_eval(File.read(deploy_file))
           true
         else
@@ -26,6 +28,25 @@ module EY
         end
       end
 
+      def load_ey_yml
+        ey_yml = ["config/ey.yml", "ey.yml"].map do |short_file|
+          File.join(c.repository_cache, short_file)
+        end.detect do |file|
+          File.exist?(file)
+        end
+
+        if ey_yml
+          shell.status "Loading deploy configuration in #{ey_yml}"
+          data = YAML.load_file(ey_yml)
+          config.load_ey_yml_data(data, shell)
+        else
+          false
+        end
+      rescue Exception
+        shell.error "Error loading YAML in #{ey_yml}"
+        raise
+      end
+
       def roles(*task_roles)
         raise "Roles must be passed a block" unless block_given?
 
@@ -37,26 +58,26 @@ module EY
         end
       end
 
-      # Returns +true+ if the command is successful,
-      # raises EY::Serverside::RemoteFailure with a list of failures
-      # otherwise.
       def run(cmd, &blk)
-        run_on_roles(cmd, &blk)
+        run_on_roles('sh -l -c', cmd, &blk)
       end
 
       def sudo(cmd, &blk)
-        run_on_roles(cmd, %w[sudo sh -l -c], &blk)
+        run_on_roles('sudo sh -l -c', cmd, &blk)
       end
 
       private
 
-      def run_on_roles(cmd, wrapper=%w[sh -l -c], &block)
+      def run_on_roles(prefix, cmd, &block)
         servers = EY::Serverside::Server.from_roles(@roles)
-        futures = EY::Serverside::Future.call(servers, block_given?) do |server, exec_block|
-          to_run = exec_block ? block.call(server, cmd.dup) : cmd
-          server.run(Escape.shell_command(wrapper + [to_run]))
+
+        commands = servers.map do |server|
+          exec_cmd = server.command_on_server(prefix, cmd, &block)
+          proc { shell.logged_system(exec_cmd) }
         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)

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '1.6.5'
+    VERSION = '1.7.0.pre2'
   end
 end

data/spec/basic_deploy_spec.rb

@@ -1,54 +1,19 @@
 require 'spec_helper'
 
-describe "Deploying an application without Bundler" do
-  before(:all) do
-    $DISABLE_GEMFILE = true # Don't generate Gemfile/Gemfile.lock
-    $DISABLE_LOCKFILE = true
-    @deploy_dir = Pathname.new(Dir.tmpdir).join("serverside-deploy-#{Time.now.to_i}-#{$$}")
-
-    # set up EY::Serverside::Server like we're on a solo
-    EY::Serverside::Server.reset
-    EY::Serverside::Server.add(:hostname => 'localhost', :roles => %w[solo])
-
-    # run a deploy
-    config = EY::Serverside::Deploy::Configuration.new({
-        "strategy"      => "IntegrationSpec",
-        "deploy_to"     => @deploy_dir.to_s,
-        "group"         => `id -gn`.strip,
-        "stack"         => 'nginx_passenger',
-        "migrate"       => nil,
-        'app'           => 'foo',
-        'framework_env' => 'staging'
-      })
-
-    @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-    @deployer = FullTestDeploy.new(config)
-    @deployer.deploy
-  end
-
-  def exist
-    be_exist
-  end
-
-  it "creates a REVISION file" do
-    @deploy_dir.join('current', 'REVISION').should exist
-  end
-
-  it "restarts the app servers" do
-    @deploy_dir.join('current', 'restart').should exist
+describe "Deploying a simple application" do
+  context "without Bundler" do
+    before(:all) do
+      deploy_test_application('not_bundled')
+    end
+
+    it "creates a REVISION file" do
+      @deploy_dir.join('current', 'REVISION').should exist
+    end
+
+    it "restarts the app servers" do
+      restart = @deploy_dir.join('current', 'restart')
+      restart.should exist
+      restart.read.chomp.should == %|LANG="en_US.UTF-8" /engineyard/bin/app_rails31 deploy|
+    end
   end
-
-  it "runs all the hooks" do
-    @deploy_dir.join('current', 'before_bundle.ran' ).should exist
-    @deploy_dir.join('current', 'after_bundle.ran'  ).should exist
-    @deploy_dir.join('current', 'before_migrate.ran').should exist
-    @deploy_dir.join('current', 'after_migrate.ran' ).should exist
-    @deploy_dir.join('current', 'before_compile_assets.ran').should exist
-    @deploy_dir.join('current', 'after_compile_assets.ran' ).should exist
-    @deploy_dir.join('current', 'before_symlink.ran').should exist
-    @deploy_dir.join('current', 'after_symlink.ran' ).should exist
-    @deploy_dir.join('current', 'before_restart.ran').should exist
-    @deploy_dir.join('current', 'after_restart.ran' ).should exist
-  end
-
 end

data/spec/bundler_deploy_spec.rb

@@ -6,41 +6,9 @@ describe "Deploying an application that uses Bundler" do
     @version_pattern = Regexp.quote(@bundler_version)
   end
 
-  def deploy_test_application
-    @deploy_dir = File.join(Dir.tmpdir, "serverside-deploy-#{Time.now.to_i}-#{$$}")
-
-    # set up EY::Serverside::Server like we're on a solo
-    EY::Serverside::Server.reset
-    EY::Serverside::Server.add(:hostname => 'localhost', :roles => %w[solo])
-
-    # run a deploy
-    config = EY::Serverside::Deploy::Configuration.new({
-      "strategy"       => "IntegrationSpec",
-      "deploy_to"      => @deploy_dir,
-      "group"          => `id -gn`.strip,
-      "stack"          => 'nginx_passenger',
-      "migrate"        => "ruby -e 'puts ENV[\"PATH\"]' > #{@deploy_dir}/path-when-migrating",
-      'app'            => 'foo',
-      'framework_env'  => 'staging',
-      'bundle_without' => 'release test',
-    })
-
-    # pretend there is a shared bundled_gems directory
-    FileUtils.mkdir_p(File.join(@deploy_dir, 'shared', 'bundled_gems'))
-    %w(RUBY_VERSION SYSTEM_VERSION).each do |name|
-      File.open(File.join(@deploy_dir, 'shared', 'bundled_gems', name), "w") { |f| f.write("old\n") }
-    end
-
-    @binpath = File.expand_path(File.join(File.dirname(__FILE__), '..', 'bin', 'engineyard-serverside'))
-    @deployer = FullTestDeploy.new(config)
-    @deployer.deploy
-  end
-
   context "with a Gemfile.lock" do
     before(:all) do
-      $DISABLE_GEMFILE = false
-      $DISABLE_LOCKFILE = false
-      deploy_test_application
+      deploy_test_application('ey_yml')
     end
 
     it "runs the right bundler command" do
@@ -69,12 +37,6 @@ describe "Deploying an application that uses Bundler" do
       File.read(File.join(@deploy_dir, 'path-when-migrating')).should include('ey_bundler_binstubs')
     end
 
-    it "runs 'bundle install' with custom --without options" do
-      bundle_install_cmd = @deployer.commands.grep(/bundle _\S+_ install/).first
-      bundle_install_cmd.should_not be_nil
-      bundle_install_cmd.should include("--without release test")
-    end
-
     it "creates a ruby version file" do
       File.exist?(File.join(@deploy_dir, 'shared', 'bundled_gems', 'RUBY_VERSION')).should be_true
     end
@@ -90,13 +52,10 @@ describe "Deploying an application that uses Bundler" do
 
   context "without a Gemfile.lock" do
     before(:all) do
-      $DISABLE_GEMFILE = false
-      $DISABLE_LOCKFILE = true
-      deploy_test_application
+      deploy_test_application('no_gemfile_lock')
     end
 
     it "installs the proper Bundler version" do
-      @bundler_version.should == "1.0.21" # Something should break when the default changes.
       install_bundler_command_ran = @deployer.commands.detect{ |command| command.index("install_bundler") }
       install_bundler_command_ran.should_not be_nil
       install_bundler_command_ran.should include("#{@binpath} install_bundler #{@bundler_version}")
@@ -116,7 +75,7 @@ describe "Deploying an application that uses Bundler" do
       File.exist?(File.join(@deploy_dir, 'shared', 'bundled_gems', 'SYSTEM_VERSION')).should be_true
     end
 
-    it "Sets GIT_SSH environment variable" do
+    it "sets GIT_SSH environment variable" do
       install_cmd = @deployer.commands.grep(/GIT_SSH/).first
       install_cmd.should match(/export GIT_SSH.*install_bundler/)
     end