HeSYINUvSBZfxqA-capistrano 2.5.21

data/lib/capistrano/configuration/callbacks.rb

@@ -0,0 +1,148 @@
+require 'capistrano/callback'
+
+module Capistrano
+  class Configuration
+    module Callbacks
+      def self.included(base) #:nodoc:
+        %w(initialize invoke_task_directly).each do |method|
+          base.send :alias_method, "#{method}_without_callbacks", method
+          base.send :alias_method, method, "#{method}_with_callbacks"
+        end
+      end
+
+      # The hash of callbacks that have been registered for this configuration
+      attr_reader :callbacks
+
+      def initialize_with_callbacks(*args) #:nodoc:
+        initialize_without_callbacks(*args)
+        @callbacks = {}
+      end
+
+      def invoke_task_directly_with_callbacks(task) #:nodoc:
+        before = find_hook(task, :before)
+        execute_task(before) if before
+
+        trigger :before, task
+
+        result = invoke_task_directly_without_callbacks(task)
+
+        trigger :after, task
+
+        after = find_hook(task, :after)
+        execute_task(after) if after
+
+        return result
+      end
+
+      # Defines a callback to be invoked before the given task. You must
+      # specify the fully-qualified task name, both for the primary task, and
+      # for the task(s) to be executed before. Alternatively, you can pass a
+      # block to be executed before the given task.
+      #
+      #   before "deploy:update_code", :record_difference
+      #   before :deploy, "custom:log_deploy"
+      #   before :deploy, :this, "then:this", "and:then:this"
+      #   before :some_task do
+      #     puts "an anonymous hook!"
+      #   end
+      #
+      # This just provides a convenient interface to the more general #on method.
+      def before(task_name, *args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args << options.merge(:only => task_name)
+        on :before, *args, &block
+      end
+
+      # Defines a callback to be invoked after the given task. You must
+      # specify the fully-qualified task name, both for the primary task, and
+      # for the task(s) to be executed after. Alternatively, you can pass a
+      # block to be executed after the given task.
+      #
+      #   after "deploy:update_code", :log_difference
+      #   after :deploy, "custom:announce"
+      #   after :deploy, :this, "then:this", "and:then:this"
+      #   after :some_task do
+      #     puts "an anonymous hook!"
+      #   end
+      #
+      # This just provides a convenient interface to the more general #on method.
+      def after(task_name, *args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args << options.merge(:only => task_name)
+        on :after, *args, &block
+      end
+
+      # Defines one or more callbacks to be invoked in response to some event.
+      # Capistrano currently understands the following events:
+      #
+      # * :before, triggered before a task is invoked
+      # * :after, triggered after a task is invoked
+      # * :start, triggered before a top-level task is invoked via the command-line
+      # * :finish, triggered when a top-level task completes
+      # * :load, triggered after all recipes have loaded
+      # * :exit, triggered after all tasks have completed
+      #
+      # Specify the (fully-qualified) task names that you want invoked in
+      # response to the event. Alternatively, you can specify a block to invoke
+      # when the event is triggered. You can also pass a hash of options as the
+      # last parameter, which may include either of two keys:
+      #
+      # * :only, should specify an array of task names. Restricts this callback
+      #   so that it will only fire when the event applies to those tasks.
+      # * :except, should specify an array of task names. Restricts this callback
+      #   so that it will never fire when the event applies to those tasks.
+      #
+      # Usage:
+      #
+      #  on :before, "some:hook", "another:hook", :only => "deploy:update"
+      #  on :after, "some:hook", :except => "deploy:symlink"
+      #  on :before, "global:hook"
+      #  on :after, :only => :deploy do
+      #    puts "after deploy here"
+      #  end
+      def on(event, *args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        callbacks[event] ||= []
+
+        if args.empty? && block.nil?
+          raise ArgumentError, "please specify either a task name or a block to invoke"
+        elsif args.any? && block
+          raise ArgumentError, "please specify only a task name or a block, but not both"
+        elsif block
+          callbacks[event] << ProcCallback.new(block, options)
+        else
+          args.each do |name|
+            callbacks[event] << TaskCallback.new(self, name, options)
+          end
+        end
+      end
+
+      # Trigger the named event for the named task. All associated callbacks
+      # will be fired, in the order they were defined.
+      def trigger(event, task=nil)
+        pending = Array(callbacks[event]).select { |c| c.applies_to?(task) }
+        if pending.any?
+          msg = "triggering #{event} callbacks"
+          msg << " for `#{task.fully_qualified_name}'" if task
+          logger.trace(msg)
+          pending.each { |callback| callback.call }
+        end
+      end
+
+      private
+
+        # Looks for before_foo or after_foo tasks. This method of extending tasks
+        # is now discouraged (though not formally deprecated). You should use the
+        # before and after methods to declare hooks for such callbacks.
+        def find_hook(task, hook)
+          if task == task.namespace.default_task
+            result = task.namespace.search_task("#{hook}_#{task.namespace.name}")
+            return result if result
+          end
+
+          task.namespace.search_task("#{hook}_#{task.name}")
+        end
+
+    end
+  end
+end

data/lib/capistrano/configuration/connections.rb

@@ -0,0 +1,204 @@
+require 'enumerator'
+require 'net/ssh/gateway'
+require 'capistrano/ssh'
+require 'capistrano/errors'
+
+module Capistrano
+  class Configuration
+    module Connections
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :initialize_without_connections, :initialize
+        base.send :alias_method, :initialize, :initialize_with_connections
+      end
+
+      class DefaultConnectionFactory #:nodoc:
+        def initialize(options)
+          @options = options
+        end
+
+        def connect_to(server)
+          SSH.connect(server, @options)
+        end
+      end
+
+      class GatewayConnectionFactory #:nodoc:
+        def initialize(gateway, options)
+          @options = options
+          @options[:logger].debug "Creating gateway using #{[*gateway].join(', ')}" if @options[:logger]
+          Thread.abort_on_exception = true
+          @gateways = [*gateway].collect { |g| ServerDefinition.new(g) }
+          tunnel = SSH.connection_strategy(@gateways[0], @options) do |host, user, connect_options|
+            Net::SSH::Gateway.new(host, user, connect_options)
+          end
+          @gateway = (@gateways[1..-1]).inject(tunnel) do |tunnel, destination|
+            @options[:logger].debug "Creating tunnel to #{destination}" if @options[:logger]
+            local_host = ServerDefinition.new("127.0.0.1", :user => destination.user, :port => tunnel.open(destination.host, (destination.port || 22)))
+            SSH.connection_strategy(local_host, @options) do |host, user, connect_options|
+              Net::SSH::Gateway.new(host, user, connect_options)
+            end
+          end
+        end
+        
+        def connect_to(server)
+          @options[:logger].debug "establishing connection to `#{server}' via gateway" if @options[:logger]
+          local_host = ServerDefinition.new("127.0.0.1", :user => server.user, :port => @gateway.open(server.host, server.port || 22))
+          session = SSH.connect(local_host, @options)
+          session.xserver = server
+          session
+        end
+      end
+
+      # A hash of the SSH sessions that are currently open and available.
+      # Because sessions are constructed lazily, this will only contain
+      # connections to those servers that have been the targets of one or more
+      # executed tasks. Stored on a per-thread basis to improve thread-safety.
+      def sessions
+        Thread.current[:sessions] ||= {}
+      end
+
+      def initialize_with_connections(*args) #:nodoc:
+        initialize_without_connections(*args)
+        Thread.current[:sessions] = {}
+        Thread.current[:failed_sessions] = []
+      end
+
+      # Indicate that the given server could not be connected to.
+      def failed!(server)
+        Thread.current[:failed_sessions] << server
+      end
+
+      # Query whether previous connection attempts to the given server have
+      # failed.
+      def has_failed?(server)
+        Thread.current[:failed_sessions].include?(server)
+      end
+
+      # Used to force connections to be made to the current task's servers.
+      # Connections are normally made lazily in Capistrano--you can use this
+      # to force them open before performing some operation that might be
+      # time-sensitive.
+      def connect!(options={})
+        execute_on_servers(options) { }
+      end
+
+      # Returns the object responsible for establishing new SSH connections.
+      # The factory will respond to #connect_to, which can be used to
+      # establish connections to servers defined via ServerDefinition objects.
+      def connection_factory
+        @connection_factory ||= begin
+          if exists?(:gateway)
+            logger.debug "establishing connection to gateway `#{fetch(:gateway)}'"
+            GatewayConnectionFactory.new(fetch(:gateway), self)
+          else
+            DefaultConnectionFactory.new(self)
+          end
+        end
+      end
+
+      # Ensures that there are active sessions for each server in the list.
+      def establish_connections_to(servers)
+        failed_servers = []
+
+        # force the connection factory to be instantiated synchronously,
+        # otherwise we wind up with multiple gateway instances, because
+        # each connection is done in parallel.
+        connection_factory
+
+        threads = Array(servers).map { |server| establish_connection_to(server, failed_servers) }
+        threads.each { |t| t.join }
+
+        if failed_servers.any?
+          errors = failed_servers.map { |h| "#{h[:server]} (#{h[:error].class}: #{h[:error].message})" }
+          error = ConnectionError.new("connection failed for: #{errors.join(', ')}")
+          error.hosts = failed_servers.map { |h| h[:server] }
+          raise error
+        end
+      end
+
+      # Destroys sessions for each server in the list.
+      def teardown_connections_to(servers)
+        servers.each do |server|
+          sessions[server].close
+          sessions.delete(server)
+        end
+      end
+
+      # Determines the set of servers within the current task's scope and
+      # establishes connections to them, and then yields that list of
+      # servers.
+      def execute_on_servers(options={})
+        raise ArgumentError, "expected a block" unless block_given?
+
+        if task = current_task
+          servers = find_servers_for_task(task, options)
+
+          if servers.empty?
+            if ENV['HOSTFILTER']
+              logger.info "skipping `#{task.fully_qualified_name}' because no servers matched"
+              return
+            else
+              raise Capistrano::NoMatchingServersError, "`#{task.fully_qualified_name}' is only run for servers matching #{task.options.inspect}, but no servers matched"
+            end
+          end
+
+          if task.continue_on_error?
+            servers.delete_if { |s| has_failed?(s) }
+            return if servers.empty?
+          end
+        else
+          servers = find_servers(options)
+          raise Capistrano::NoMatchingServersError, "no servers found to match #{options.inspect}" if servers.empty?
+        end
+
+        servers = [servers.first] if options[:once]
+        logger.trace "servers: #{servers.map { |s| s.host }.inspect}"
+
+        max_hosts = (options[:max_hosts] || (task && task.max_hosts) || servers.size).to_i
+        is_subset = max_hosts < servers.size
+
+        # establish connections to those servers in groups of max_hosts, as necessary
+        servers.each_slice(max_hosts) do |servers_slice|
+          begin
+            establish_connections_to(servers_slice)
+          rescue ConnectionError => error
+            raise error unless task && task.continue_on_error?
+            error.hosts.each do |h|
+              servers_slice.delete(h)
+              failed!(h)
+            end
+          end
+
+          begin
+            yield servers_slice
+          rescue RemoteError => error
+            raise error unless task && task.continue_on_error?
+            error.hosts.each { |h| failed!(h) }
+          end
+
+          # if dealing with a subset (e.g., :max_hosts is less than the
+          # number of servers available) teardown the subset of connections
+          # that were just made, so that we can make room for the next subset.
+          teardown_connections_to(servers_slice) if is_subset
+        end
+      end
+
+      private
+
+        # We establish the connection by creating a thread in a new method--this
+        # prevents problems with the thread's scope seeing the wrong 'server'
+        # variable if the thread just happens to take too long to start up.
+        def establish_connection_to(server, failures=nil)
+          current_thread = Thread.current
+          Thread.new { safely_establish_connection_to(server, current_thread, failures) }
+        end
+
+        def safely_establish_connection_to(server, thread, failures=nil)
+          thread[:sessions] ||= {}
+          thread[:sessions][server] ||= connection_factory.connect_to(server)
+        rescue Exception => err
+          raise unless failures
+          failures << { :server => server, :error => err }
+        end
+    end
+  end
+end

data/lib/capistrano/configuration/execution.rb

@@ -0,0 +1,143 @@
+require 'capistrano/errors'
+
+module Capistrano
+  class Configuration
+    module Execution
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :initialize_without_execution, :initialize
+        base.send :alias_method, :initialize, :initialize_with_execution
+      end
+
+      # A struct for representing a single instance of an invoked task.
+      TaskCallFrame = Struct.new(:task, :rollback)
+
+      def initialize_with_execution(*args) #:nodoc:
+        initialize_without_execution(*args)
+      end
+      private :initialize_with_execution
+
+      # Returns true if there is a transaction currently active.
+      def transaction?
+        !rollback_requests.nil?
+      end
+
+      # The call stack of the tasks. The currently executing task may inspect
+      # this to see who its caller was. The current task is always the last
+      # element of this stack.
+      def task_call_frames
+        Thread.current[:task_call_frames] ||= []
+      end
+      
+      
+      # The stack of tasks that have registered rollback handlers within the
+      # current transaction. If this is nil, then there is no transaction
+      # that is currently active.
+      def rollback_requests
+        Thread.current[:rollback_requests]
+      end
+
+      def rollback_requests=(rollback_requests)
+        Thread.current[:rollback_requests] = rollback_requests
+      end
+
+      # Invoke a set of tasks in a transaction. If any task fails (raises an
+      # exception), all tasks executed within the transaction are inspected to
+      # see if they have an associated on_rollback hook, and if so, that hook
+      # is called.
+      def transaction
+        raise ArgumentError, "expected a block" unless block_given?
+        raise ScriptError, "transaction must be called from within a task" if task_call_frames.empty?
+
+        return yield if transaction?
+
+        logger.info "transaction: start"
+        begin
+          self.rollback_requests = []
+          yield
+          logger.info "transaction: commit"
+        rescue Object => e
+          rollback!
+          raise
+        ensure
+          self.rollback_requests = nil if Thread.main == Thread.current
+        end
+      end
+
+      # Specifies an on_rollback hook for the currently executing task. If this
+      # or any subsequent task then fails, and a transaction is active, this
+      # hook will be executed.
+      def on_rollback(&block)
+        if transaction?
+          # don't note a new rollback request if one has already been set
+          rollback_requests << task_call_frames.last unless task_call_frames.last.rollback
+          task_call_frames.last.rollback = block
+        end
+      end
+
+      # Returns the TaskDefinition object for the currently executing task.
+      # It returns nil if there is no task being executed.
+      def current_task
+        return nil if task_call_frames.empty?
+        task_call_frames.last.task
+      end
+
+      # Executes the task with the given name, without invoking any associated
+      # callbacks.
+      def execute_task(task)
+        logger.debug "executing `#{task.fully_qualified_name}'"
+        push_task_call_frame(task)
+        invoke_task_directly(task)
+      ensure
+        pop_task_call_frame
+      end
+
+      # Attempts to locate the task at the given fully-qualified path, and
+      # execute it. If no such task exists, a Capistrano::NoSuchTaskError will
+      # be raised.
+      def find_and_execute_task(path, hooks={})
+        task = find_task(path) or raise NoSuchTaskError, "the task `#{path}' does not exist"
+
+        trigger(hooks[:before], task) if hooks[:before]
+        result = execute_task(task)
+        trigger(hooks[:after], task) if hooks[:after]
+
+        result
+      end
+
+    protected
+
+      def rollback!
+        return if Thread.current[:rollback_requests].nil?
+        Thread.current[:rolled_back] = true
+   
+        # throw the task back on the stack so that roles are properly
+        # interpreted in the scope of the task in question.
+        rollback_requests.reverse.each do |frame|
+          begin
+            push_task_call_frame(frame.task)
+            logger.important "rolling back", frame.task.fully_qualified_name
+            frame.rollback.call
+          rescue Object => e
+            logger.info "exception while rolling back: #{e.class}, #{e.message}", frame.task.fully_qualified_name
+          ensure
+            pop_task_call_frame
+          end
+        end
+      end
+
+      def push_task_call_frame(task)
+        frame = TaskCallFrame.new(task)
+        task_call_frames.push frame
+      end
+
+      def pop_task_call_frame
+        task_call_frames.pop
+      end
+
+      # Invokes the task's body directly, without setting up the call frame.
+      def invoke_task_directly(task)
+        task.namespace.instance_eval(&task.body)
+      end
+    end
+  end
+end