engineyard-serverside 1.3.7 → 1.4.0

data/lib/engineyard-serverside/server.rb

@@ -2,92 +2,95 @@ require 'open-uri'
 require 'engineyard-serverside/logged_output'
 
 module EY
-  class Server < Struct.new(:hostname, :roles, :name, :user)
-    include LoggedOutput
+  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}'"
+        end
+      end
 
-    class DuplicateHostname < StandardError
-      def initialize(hostname)
-        super "There is already an EY::Server with hostname '#{hostname}'"
+      def initialize(*fields)
+        super
+        self.roles = self.roles.map { |r| r.to_sym } if self.roles
       end
-    end
 
-    def initialize(*fields)
-      super
-      self.roles = self.roles.map { |r| r.to_sym } if self.roles
-    end
+      attr_writer :default_task
 
-    attr_writer :default_task
+      def self.from_roles(*want_roles)
+        want_roles = want_roles.flatten.compact.map{|r| r.to_sym}
+        return all if !want_roles || want_roles.include?(:all) || want_roles.empty?
 
-    def self.from_roles(*want_roles)
-      want_roles = want_roles.flatten.compact.map{|r| r.to_sym}
-      return all if !want_roles || want_roles.include?(:all) || want_roles.empty?
+        all.select do |s|
+          !(s.roles & want_roles).empty?
+        end
+      end
 
-      all.select do |s|
-        !(s.roles & want_roles).empty?
+      def role
+        roles.first
       end
-    end
 
-    def role
-      roles.first
-    end
+      def self.load_all_from_array(server_hashes)
+        server_hashes.each do |instance_hash|
+          add(instance_hash)
+        end
+      end
 
-    def self.load_all_from_array(server_hashes)
-      server_hashes.each do |instance_hash|
-        add(instance_hash)
+      def self.all
+        @all
       end
-    end
 
-    def self.all
-      @all
-    end
+      def self.by_hostname(hostname)
+        all.find{|s| s.hostname == hostname}
+      end
 
-    def self.by_hostname(hostname)
-      all.find{|s| s.hostname == hostname}
-    end
+      def self.add(server_hash)
+        hostname = server_hash[:hostname]
+        if by_hostname(hostname)
+          raise DuplicateHostname.new(hostname)
+        end
+        server = new(hostname, server_hash[:roles], server_hash[:name], server_hash[:user])
+        @all << server
+        server
+      end
 
-    def self.add(server_hash)
-      hostname = server_hash[:hostname]
-      if by_hostname(hostname)
-        raise DuplicateHostname.new(hostname)
+      def self.current
+        all.find {|s| s.local? }
       end
-      server = new(hostname, server_hash[:roles], server_hash[:name], server_hash[:user])
-      @all << server
-      server
-    end
 
-    def self.current
-      all.find {|s| s.local? }
-    end
+      def self.reset
+        @all = []
+      end
+      reset
 
-    def self.reset
-      @all = []
-    end
-    reset
+      def roles=(roles)
+        super(roles.map{|r| r.to_sym})
+      end
 
-    def roles=(roles)
-      super(roles.map{|r| r.to_sym})
-    end
+      def local?
+        hostname == 'localhost'
+      end
 
-    def local?
-      hostname == 'localhost'
-    end
+      def sync_directory(directory)
+        return if local?
+        run "mkdir -p #{directory}"
+        logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{directory}/ #{user}@#{hostname}:#{directory}|)
+      end
 
-    def sync_directory(directory)
-      return if local?
-      run "mkdir -p #{directory}"
-      logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{directory}/ #{user}@#{hostname}:#{directory}|)
-    end
+      def run(command)
+        if local?
+          logged_system(command)
+        else
+          logged_system(ssh_command + " " + Escape.shell_command(["#{user}@#{hostname}", command]))
+        end
+      end
 
-    def run(command)
-      if local?
-        logged_system(command)
-      else
-        logged_system(ssh_command + " " + Escape.shell_command(["#{user}@#{hostname}", command]))
+      def ssh_command
+        "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no"
       end
-    end
 
-    def ssh_command
-      "ssh -i #{ENV['HOME']}/.ssh/internal -o StrictHostKeyChecking=no -o PasswordAuthentication=no"
     end
   end
 end

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

@@ -1,138 +1,140 @@
 require 'engineyard-serverside/logged_output'
 
 module EY
-  module Strategies
-    class Git
-      module Helpers
+  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 update_repository_cache
-          unless strategy.fetch && strategy.checkout
-            abort "*** [Error] Git could not checkout (#{strategy.to_checkout}) ***"
+          def create_revision_file_command
+            strategy.create_revision_file_command(c.release_path)
           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
 
-        def short_log_message(revision)
-          strategy.short_log_message(revision)
+          def strategy
+            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
         end
 
-        def strategy
-          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
-      end
+        include LoggedOutput
 
-      include LoggedOutput
+        attr_reader :opts
 
-      attr_reader :opts
+        def initialize(opts)
+          @opts = opts
+          set_up_git_ssh(@opts[:app])
+        end
 
-      def initialize(opts)
-        @opts = opts
-        set_up_git_ssh(@opts[:app])
-      end
+        def usable_repository?
+          File.directory?(opts[:repository_cache]) && `#{git} remote -v | grep origin`[opts[:repo]]
+        end
 
-      def usable_repository?
-        File.directory?(opts[:repository_cache]) && `#{git} remote -v | grep origin`[opts[:repo]]
-      end
+        def fetch
+          if usable_repository?
+            logged_system("#{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")
+          end
+        end
 
-      def fetch
-        if usable_repository?
-          logged_system("#{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")
+        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")
+          end
         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")
+        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
         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]
+        def create_revision_file_command(dir)
+          %Q{#{git} show --pretty=format:"%H" | head -1 > "#{dir}/REVISION"}
         end
-      end
 
-      def create_revision_file_command(dir)
-        %Q{#{git} show --pretty=format:"%H" | head -1 > "#{dir}/REVISION"}
-      end
+        def short_log_message(rev)
+          `#{git} log --pretty=oneline --abbrev-commit '#{rev}^..#{rev}'`.strip
+        end
 
-      def short_log_message(rev)
-        `#{git} log --pretty=oneline --abbrev-commit '#{rev}^..#{rev}'`.strip
-      end
+      private
+        def in_git_work_tree
+          Dir.chdir(git_work_tree) { yield }
+        end
 
-    private
-      def in_git_work_tree
-        Dir.chdir(git_work_tree) { yield }
-      end
+        def git_work_tree
+          opts[:repository_cache]
+        end
 
-      def git_work_tree
-        opts[:repository_cache]
-      end
+        def git
+          "git --git-dir #{git_work_tree}/.git --work-tree #{git_work_tree}"
+        end
 
-      def git
-        "git --git-dir #{git_work_tree}/.git --work-tree #{git_work_tree}"
-      end
+        def branch?(ref)
+          `#{git} branch -r`.map { |x| x.strip }.include?("origin/#{ref}")
+        end
 
-      def branch?(ref)
-        `#{git} branch -r`.map { |x| x.strip }.include?("origin/#{ref}")
-      end
+        def set_up_git_ssh(app)
+          # hold references to the tempfiles so they don't get finalized
+          # unexpectedly; tempfile finalization unlinks the files
+          @git_ssh = Tempfile.open("git-ssh")
+          @config = Tempfile.open("git-ssh-config")
+
+          @config.write "StrictHostKeyChecking no\n"
+          @config.write "CheckHostIP no\n"
+          @config.write "PasswordAuthentication no\n"
+          @config.write "LogLevel DEBUG\n"
+          @config.write "IdentityFile ~/.ssh/#{app}-deploy-key\n"
+          @config.chmod(0600)
+          @config.close
+
+          @git_ssh.write "#!/bin/sh\n"
+          @git_ssh.write "unset SSH_AUTH_SOCK\n"
+          @git_ssh.write "ssh -F \"#{@config.path}\" $*\n"
+          @git_ssh.chmod(0700)
+          # NB: this file _must_ be closed before git looks at it.
+          #
+          # Linux won't let you execve a file that's open for writing,
+          # so if this file stays open, then git will complain about
+          # being unable to exec it and will exit with a message like
+          #
+          # fatal: exec /tmp/git-ssh20100417-21417-d040rm-0 failed.
+          @git_ssh.close
 
-      def set_up_git_ssh(app)
-        # hold references to the tempfiles so they don't get finalized
-        # unexpectedly; tempfile finalization unlinks the files
-        @git_ssh = Tempfile.open("git-ssh")
-        @config = Tempfile.open("git-ssh-config")
-
-        @config.write "StrictHostKeyChecking no\n"
-        @config.write "CheckHostIP no\n"
-        @config.write "PasswordAuthentication no\n"
-        @config.write "LogLevel DEBUG\n"
-        @config.write "IdentityFile ~/.ssh/#{app}-deploy-key\n"
-        @config.chmod(0600)
-        @config.close
-
-        @git_ssh.write "#!/bin/sh\n"
-        @git_ssh.write "unset SSH_AUTH_SOCK\n"
-        @git_ssh.write "ssh -F \"#{@config.path}\" $*\n"
-        @git_ssh.chmod(0700)
-        # NB: this file _must_ be closed before git looks at it.
-        #
-        # Linux won't let you execve a file that's open for writing,
-        # so if this file stays open, then git will complain about
-        # being unable to exec it and will exit with a message like
-        #
-        # fatal: exec /tmp/git-ssh20100417-21417-d040rm-0 failed.
-        @git_ssh.close
-
-        ENV['GIT_SSH'] = @git_ssh.path
-      end
+          ENV['GIT_SSH'] = @git_ssh.path
+        end
 
+      end
     end
   end
 end

data/lib/engineyard-serverside/task.rb

@@ -1,62 +1,65 @@
 module EY
-  class Task
-    include Dataflow
+  module Serverside
+    class Task
+      include Dataflow
 
-    attr_reader :config
-    alias :c :config
+      attr_reader :config
+      alias :c :config
 
-    def initialize(conf)
-      @config = conf
-      @roles = :all
-    end
-
-    def require_custom_tasks
-      deploy_file = ["config/eydeploy.rb", "eydeploy.rb"].map do |short_file|
-        File.join(c.repository_cache, short_file)
-      end.detect do |file|
-        File.exist?(file)
+      def initialize(conf)
+        @config = conf
+        @roles = :all
       end
 
-      if deploy_file
-        puts "~> Loading deployment task overrides from #{deploy_file}"
-        instance_eval(File.read(deploy_file))
-        true
-      else
-        false
+      def require_custom_tasks
+        deploy_file = ["config/eydeploy.rb", "eydeploy.rb"].map do |short_file|
+          File.join(c.repository_cache, short_file)
+        end.detect do |file|
+          File.exist?(file)
+        end
+
+        if deploy_file
+          puts "~> Loading deployment task overrides from #{deploy_file}"
+          instance_eval(File.read(deploy_file))
+          true
+        else
+          false
+        end
       end
-    end
 
-    def roles(*task_roles)
-      raise "Roles must be passed a block" unless block_given?
+      def roles(*task_roles)
+        raise "Roles must be passed a block" unless block_given?
 
-      begin
-        @roles = task_roles
-        yield
-      ensure
-        @roles = :all
+        begin
+          @roles = task_roles
+          yield
+        ensure
+          @roles = :all
+        end
       end
-    end
 
-    def run(cmd, &blk)
-      run_on_roles(cmd, &blk)
-    end
+      def run(cmd, &blk)
+        run_on_roles(cmd, &blk)
+      end
 
-    def sudo(cmd, &blk)
-      run_on_roles(cmd, %w[sudo sh -l -c], &blk)
-    end
+      def sudo(cmd, &blk)
+        run_on_roles(cmd, %w[sudo sh -l -c], &blk)
+      end
 
-    private
+      private
 
-    def run_on_roles(cmd, wrapper=%w[sh -l -c])
-      results = EY::Server.from_roles(@roles).map do |server|
-        to_run = block_given? ? yield(server, cmd.dup) : cmd
-        need_later { server.run(Escape.shell_command(wrapper + [to_run])) }
+      def run_on_roles(cmd, wrapper=%w[sh -l -c])
+        results = EY::Serverside::Server.from_roles(@roles).map do |server|
+          to_run = block_given? ? yield(server, cmd.dup) : cmd
+          need_later { server.run(Escape.shell_command(wrapper + [to_run])) }
+        end
+        barrier *results
+        # MRI's truthiness check is an internal C thing that does not call
+        # any methods... so Dataflow cannot proxy it & we must "x == true"
+        # Rubinius, wherefore art thou!?
+        results.all?{|x| x == true } || raise(EY::Serverside::RemoteFailure.new(cmd))
       end
-      barrier *results
-      # MRI's truthiness check is an internal C thing that does not call
-      # any methods... so Dataflow cannot proxy it & we must "x == true"
-      # Rubinius, wherefore art thou!?
-      results.all?{|x| x == true } || raise(EY::RemoteFailure.new(cmd))
+
     end
   end
 end