engineyard-serverside 1.6.0.pre5 → 1.6.3

data/lib/engineyard-serverside/deploy_hook.rb

@@ -1,51 +1,40 @@
-require 'engineyard-serverside/shell/helpers'
-
 module EY
   module Serverside
     class DeployHook < Task
+      def initialize(options)
+        super(EY::Serverside::Deploy::Configuration.new(options))
+      end
+
       def callback_context
-        @context ||= CallbackContext.new(config, shell)
+        @context ||= CallbackContext.new(config)
       end
 
       def run(hook)
         hook_path = "#{c.release_path}/deploy/#{hook}.rb"
         if File.exist?(hook_path)
           Dir.chdir(c.release_path) do
-            shell.status "Running deploy hook: deploy/#{hook}.rb"
+            puts "~> running deploy hook: deploy/#{hook}.rb"
             if desc = syntax_error(hook_path)
               hook_name = File.basename(hook_path)
               abort "*** [Error] Invalid Ruby syntax in hook: #{hook_name} ***\n*** #{desc.chomp} ***"
             else
-              eval_hook(IO.read(hook_path))
+              callback_context.instance_eval(IO.read(hook_path))
             end
           end
         end
       end
 
-      def eval_hook(code)
-        callback_context.instance_eval(code)
-      end
-
       def syntax_error(file)
         output = `ruby -c #{file} 2>&1`
         output unless output =~ /Syntax OK/
       end
 
       class CallbackContext
-        include EY::Serverside::Shell::Helpers
-
-        attr_reader :shell
-
-        def initialize(config, shell)
+        def initialize(config)
           @configuration = config
-          @shell = shell
           @node = node
         end
 
-        def config
-          @configuration
-        end
-
         def method_missing(meth, *args, &blk)
           if @configuration.respond_to?(meth)
             @configuration.send(meth, *args, &blk)
@@ -59,11 +48,19 @@ module EY
         end
 
         def run(cmd)
-          shell.logged_system(Escape.shell_command(["sh", "-l", "-c", cmd]))
+          system(Escape.shell_command(["sh", "-l", "-c", cmd]))
         end
 
         def sudo(cmd)
-          shell.logged_system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd]))
+          system(Escape.shell_command(["sudo", "sh", "-l", "-c", cmd]))
+        end
+
+        def info(*args)
+          $stderr.puts *args
+        end
+
+        def debug(*args)
+          $stdout.puts *args
         end
 
         # convenience functions for running on certain instance types

data/lib/engineyard-serverside/deprecation.rb

@@ -1,18 +1,26 @@
-require 'engineyard-serverside/shell/helpers'
-
 module EY
   module Serverside
     def self.deprecation_warning(msg)
       $stderr.puts "DEPRECATION WARNING: #{msg}"
     end
+  end
 
-    def self.const_missing(const)
-      if const == :LoggedOutput
-        EY::Serverside.deprecation_warning("EY::Serverside::LoggedOutput has been deprecated. Use EY::Serverside::Shell::Helpers instead.")
-        EY::Serverside::Shell::Helpers
-      else
-        super
-      end
+  def self.const_missing(const)
+    if EY::Serverside.const_defined?(const)
+      EY::Serverside.deprecation_warning("EY::#{const} has been deprecated. use EY::Serverside::#{const} instead")
+      EY::Serverside.class_eval(const.to_s)
+    else
+      super
     end
   end
+
+  def self.node
+    EY::Serverside.deprecation_warning("EY.node has been deprecated. use EY::Serverside.node instead")
+    EY::Serverside.node
+  end
+
+  def self.dna_json
+    EY::Serverside.deprecation_warning("EY.dna_json has been deprecated. use EY::Serverside.dna_json instead")
+    EY::Serverside.dna_json
+  end
 end

data/lib/engineyard-serverside/lockfile_parser.rb

@@ -24,7 +24,7 @@ module EY
           @contents.index(/^\s+#{type}\s\([^\)]+\)$/)
         end
 
-        any_jruby_adapter = %w[mysql postgresql].any? do |type|
+        any_jruby_adapter = %w[mysql postgresql postgres].any? do |type|
           @contents.index(/^\s+jdbc-#{type}\s\([^\)]+\)$/) || @contents.index(/^\s+activerecord-jdbc#{type}-adapter\s\([^\)]+\)$/)
         end
 

data/lib/engineyard-serverside/logged_output.rb

@@ -0,0 +1,91 @@
+require 'systemu'
+
+module EY
+  module Serverside
+    module LoggedOutput
+
+      class Tee
+        def initialize(*streams)
+          @streams = streams.flatten
+        end
+
+        def <<(output)
+          @streams.each do |s|
+            s << output
+            s.flush
+          end
+          self
+        end
+      end # Tee
+
+      @@logfile = File.join(ENV['HOME'], 'ey.log')
+      def self.logfile=(filename)
+        File.unlink filename if File.exist?(filename)  # start fresh
+        @@logfile = filename
+      end
+
+      def self.logfile
+        @@logfile
+      end
+
+      @@verbose = false
+      def self.verbose=(v)
+        @@verbose = !!v
+      end
+
+      def self.verbose?
+        @@verbose
+      end
+
+      def verbose?
+        EY::Serverside::LoggedOutput.verbose?
+      end
+
+      def warning(msg)
+        info "WARNING: #{msg}\n".gsub(/^/,'!> ')
+      end
+
+      def info(msg)
+        with_logfile do |log|
+          Tee.new($stdout, log) << ("#{with_timestamp(msg)}\n")
+        end
+      end
+
+      def debug(msg)
+        with_logfile do |log|
+          log << "#{with_timestamp(msg)}\n"
+        end
+      end
+
+      def logged_system(cmd)
+        with_logfile do |log|
+          out = verbose? ? Tee.new($stdout, log) : log
+          err = Tee.new($stderr, log)    # we always want to see errors
+
+          cmd = "sh -c #{Escape.shell_command([cmd])}"
+          puts "running #{cmd}" if ENV['DEBUG']
+          out <<  with_timestamp(":: running #{cmd}\n")
+          status = systemu cmd, 'stdout' => out, 'stderr' => err
+          puts "exit status= #{status.exitstatus}" if ENV['DEBUG']
+          status.exitstatus == 0
+        end
+      end
+
+      private
+      def with_logfile
+        File.open(logfile, 'a') {|f| yield f }
+      end
+
+      def logfile
+        EY::Serverside::LoggedOutput.logfile
+      end
+
+      def with_timestamp(msg)
+        return msg unless respond_to?(:starting_time)
+        time_passed = Time.now.to_i - starting_time.to_i
+        timestamp   = "+%2dm %02ds " % time_passed.divmod(60)
+        msg.gsub(/^/, timestamp)
+      end
+    end
+  end
+end

data/lib/engineyard-serverside/rails_asset_support.rb

@@ -9,7 +9,7 @@ module EY
           keep_existing_assets
           cmd = "cd #{c.release_path} && PATH=#{c.binstubs_path}:$PATH #{c.framework_envs} rake assets:precompile || true"
           if rails_version
-            shell.status "Precompiling assets for rails v#{rails_version}"
+            info "~> Precompiling assets for rails v#{rails_version}"
           else
             warning "Precompiling assets even though Rails was not bundled."
           end
@@ -22,24 +22,24 @@ module EY
         return unless File.readable?(app_rb_path) # Not a Rails app in the first place.
 
         if File.directory?(File.join(c.release_path, 'app', 'assets'))
-          shell.status "app/assets/ found. Attempting Rails asset pre-compilation."
+          info "~> app/assets/ found. Attempting Rails asset pre-compilation."
         else
           return false
         end
 
         if app_builds_own_assets?
-          shell.status "public/assets already exists, skipping pre-compilation."
+          info "~> public/assets already exists, skipping pre-compilation."
           return
         end
         if app_disables_assets?(app_rb_path)
-          shell.status "application.rb has disabled asset compilation. Skipping."
+          info "~> application.rb has disabled asset compilation. Skipping."
           return
         end
 # This check is very expensive, and has been deemed not worth the time.
 # Leaving this here in case someone comes up with a faster way.
 =begin
         unless app_has_asset_task?
-          shell.status "No 'assets:precompile' Rake task found. Skipping."
+          info "~> No 'assets:precompile' Rake task found. Skipping."
           return
         end
 =end

data/lib/engineyard-serverside/server.rb

@@ -1,8 +1,11 @@
 require 'open-uri'
+require 'engineyard-serverside/logged_output'
 
 module EY
   module Serverside
     class Server < Struct.new(:hostname, :roles, :name, :user)
+      include LoggedOutput
+
       class DuplicateHostname < StandardError
         def initialize(hostname)
           super "There is already an EY::Serverside::Server with hostname '#{hostname}'"
@@ -72,20 +75,20 @@ module EY
 
       def sync_directory(directory)
         return if local?
-        yield remote_command("mkdir -p #{directory}")
-        yield Escap.shell_command(%w[rsync --delete -aq -e] + [ssh_command, "#{directory}/", "#{user}@#{hostname}:#{directory}"])
+        run "mkdir -p #{directory}"
+        logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{directory}/ #{user}@#{hostname}:#{directory}|)
       end
 
       def run(command)
-        yield local? ? command : remote_command(command)
-      end
-
-      def remote_command(command)
-        ssh_command + Escape.shell_command(["#{user}@#{hostname}", command])
+        if local?
+          logged_system(command)
+        else
+          logged_system("#{ssh_command} #{user}@#{hostname} #{Escape.shell_command [command]}")
+        end
       end
 
       def ssh_command
-        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no "
+        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PasswordAuthentication=no"
       end
 
     end

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

@@ -1,3 +1,5 @@
+require 'engineyard-serverside/logged_output'
+
 module EY
   module Serverside
     module Strategies
@@ -26,7 +28,7 @@ module EY
             #
             # Rollback doesn't know about the repository location (nor
             # should it need to), but it would like to use #short_log_message.
-            klass.new(shell,
+            klass.new(
               :repository_cache => c[:repository_cache],
               :app => c[:app],
               :repo => c[:repo],
@@ -35,10 +37,11 @@ module EY
           end
         end
 
-        attr_reader :shell, :opts
+        include LoggedOutput
+
+        attr_reader :opts
 
-        def initialize(shell, opts)
-          @shell = shell
+        def initialize(opts)
           @opts = opts
         end
 
@@ -48,21 +51,21 @@ module EY
 
         def fetch
           if usable_repository?
-            shell.logged_system("#{git} fetch -q origin 2>&1")
+            logged_system("#{git} fetch -q origin 2>&1")
           else
             FileUtils.rm_rf(opts[:repository_cache])
-            shell.logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
+            logged_system("git clone -q #{opts[:repo]} #{opts[:repository_cache]} 2>&1")
           end
         end
 
         def checkout
-          shell.status "Deploying revision #{short_log_message(to_checkout)}"
+          info "~> Deploying revision #{short_log_message(to_checkout)}"
           in_git_work_tree do
-            (shell.logged_system("git checkout -q '#{to_checkout}'") ||
-              shell.logged_system("git reset -q --hard '#{to_checkout}'")) &&
-              shell.logged_system("git submodule sync") &&
-              shell.logged_system("git submodule update --init") &&
-              shell.logged_system("git clean -dfq")
+            (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")
           end
         end
 

data/lib/engineyard-serverside/task.rb

@@ -1,16 +1,12 @@
-require 'engineyard-serverside/shell/helpers'
-
 module EY
   module Serverside
     class Task
-      include EY::Serverside::Shell::Helpers
 
-      attr_reader :config, :shell
+      attr_reader :config
       alias :c :config
 
-      def initialize(conf, shell = nil)
+      def initialize(conf)
         @config = conf
-        @shell = shell
         @roles = :all
       end
 
@@ -22,7 +18,7 @@ module EY
         end
 
         if deploy_file
-          shell.status "Loading deployment task overrides from #{deploy_file}"
+          puts "~> Loading deployment task overrides from #{deploy_file}"
           instance_eval(File.read(deploy_file))
           true
         else
@@ -30,25 +26,6 @@ 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.ey_yml_data = data
-        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?
 
@@ -68,16 +45,18 @@ module EY
       end
 
       def sudo(cmd, &blk)
-        run_on_roles(cmd, %w[sudo sh -l -c], &blk)
+        sudo_cmd = "sudo sh -c #{Escape.shell_command [cmd]}"
+
+        run_on_roles(sudo_cmd, &blk)
       end
 
       private
 
-      def run_on_roles(cmd, wrapper=%w[sh -l -c], &block)
+      def run_on_roles(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])) { |cmd| shell.logged_system(cmd) }
+          server.run(to_run)
         end
 
         unless EY::Serverside::Future.success?(futures)

data/lib/engineyard-serverside/version.rb

@@ -1,5 +1,5 @@
 module EY
   module Serverside
-    VERSION = '1.6.0.pre5'
+    VERSION = '1.6.3'
   end
 end

data/lib/vendor/systemu/LICENSE

@@ -0,0 +1,3 @@
+same as Ruby's
+
+http://www.ruby-lang.org/en/LICENSE.txt