capistrano 2.15.11 → 3.0.0.pre

data/lib/capistrano/configuration/connections.rb

@@ -1,237 +0,0 @@
-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
-          Thread.abort_on_exception = true
-          @gateways = {}
-          if gateway.is_a?(Hash)
-            @options[:logger].debug "Creating multiple gateways using #{gateway.inspect}" if @options[:logger]
-            gateway.each do |gw, hosts|
-              gateway_connection = add_gateway(gw)
-              [*hosts].each do |host|
-                @gateways[:default] ||= gateway_connection
-                @gateways[host] = gateway_connection
-              end
-            end
-          else
-            @options[:logger].debug "Creating gateway using #{[*gateway].join(', ')}" if @options[:logger]
-            @gateways[:default] = add_gateway(gateway)
-          end
-        end
-
-        def add_gateway(gateway)
-          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
-          (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_for(server).open(server.host, server.port || 22))
-          session = SSH.connect(local_host, @options)
-          session.xserver = server
-          session
-        end
-
-        def gateway_for(server)
-          @gateways[server.host] || @gateways[:default]
-        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) && !fetch(:gateway).nil? && !fetch(:gateway).empty?
-            logger.debug "establishing connection to gateway `#{fetch(:gateway).inspect}'"
-            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|
-          begin
-            session = sessions.delete(server)
-            session.close if session
-          rescue IOError, Net::SSH::Disconnect
-            # the TCP connection is already dead
-          end
-        end
-      end
-
-      # Determines the set of servers within the current task's scope
-      def filter_servers(options={})
-        if task = current_task
-          servers = find_servers_for_task(task, options)
-
-          if servers.empty?
-            if ENV['HOSTFILTER'] || ENV['HOSTROLEFILTER'] || task.options.merge(options)[:on_no_matching_servers] == :continue
-              logger.info "skipping `#{task.fully_qualified_name}' because no servers matched"
-            else
-              unless dry_run
-                raise Capistrano::NoMatchingServersError, "`#{task.fully_qualified_name}' is only run for servers matching #{task.options.inspect}, but no servers matched"
-              end
-            end
-          end
-
-          if task.continue_on_error?
-            servers.delete_if { |s| has_failed?(s) }
-          end
-        else
-          servers = find_servers(options)
-          if servers.empty? && !dry_run
-            raise Capistrano::NoMatchingServersError, "no servers found to match #{options.inspect}" if options[:on_no_matching_servers] != :continue
-          end
-        end
-
-        servers = [servers.first] if options[:once]
-        [task, servers.compact]
-      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?
-
-        task, servers = filter_servers(options)
-        return if servers.empty?
-        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

@@ -1,142 +0,0 @@
-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
-        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?
-
-        # 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

data/lib/capistrano/configuration/loading.rb

@@ -1,205 +0,0 @@
-module Capistrano
-  class Configuration
-    module Loading
-      def self.included(base) #:nodoc:
-        base.send :alias_method, :initialize_without_loading, :initialize
-        base.send :alias_method, :initialize, :initialize_with_loading
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        # Used by third-party task bundles to identify the capistrano
-        # configuration that is loading them. Its return value is not reliable
-        # in other contexts. If +require_config+ is not false, an exception
-        # will be raised if the current configuration is not set.
-        def instance(require_config=false)
-          config = Thread.current[:capistrano_configuration]
-          if require_config && config.nil?
-            raise LoadError, "Please require this file from within a Capistrano recipe"
-          end
-          config
-        end
-
-        # Used internally by Capistrano to specify the current configuration
-        # before loading a third-party task bundle.
-        def instance=(config)
-          Thread.current[:capistrano_configuration] = config
-        end
-
-        # Used internally by Capistrano to track which recipes have been loaded
-        # via require, so that they may be successfully reloaded when require
-        # is called again.
-        def recipes_per_feature
-          @recipes_per_feature ||= {}
-        end
-
-        # Used internally to determine what the current "feature" being
-        # required is. This is used to track which files load which recipes
-        # via require.
-        def current_feature
-          Thread.current[:capistrano_current_feature]
-        end
-
-        # Used internally to specify the current file being required, so that
-        # any recipes loaded by that file can be remembered. This allows
-        # recipes loaded via require to be correctly reloaded in different
-        # Configuration instances in the same Ruby instance.
-        def current_feature=(feature)
-          Thread.current[:capistrano_current_feature] = feature
-        end
-      end
-
-      # The load paths used for locating recipe files.
-      attr_reader :load_paths
-
-      def initialize_with_loading(*args) #:nodoc:
-        initialize_without_loading(*args)
-        @load_paths = [".", File.expand_path(File.join(File.dirname(__FILE__), "../recipes"))]
-        @loaded_features = []
-      end
-      private :initialize_with_loading
-
-      # Load a configuration file or string into this configuration.
-      #
-      # Usage:
-      #
-      #   load("recipe"):
-      #     Look for and load the contents of 'recipe.rb' into this
-      #     configuration.
-      #
-      #   load(:file => "recipe"):
-      #     same as above
-      #
-      #   load(:string => "set :scm, :subversion"):
-      #     Load the given string as a configuration specification.
-      #
-      #   load { ... }
-      #     Load the block in the context of the configuration.
-      def load(*args, &block)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-
-        if block
-          raise ArgumentError, "loading a block requires 0 arguments" unless options.empty? && args.empty?
-          load(:proc => block)
-
-        elsif args.any?
-          args.each { |arg| load options.merge(:file => arg) }
-
-        elsif options[:file]
-          load_from_file(options[:file], options[:name])
-
-        elsif options[:string]
-          remember_load(options) unless options[:reloading]
-          instance_eval(options[:string], options[:name] || "<eval>")
-
-        elsif options[:proc]
-          remember_load(options) unless options[:reloading]
-          instance_eval(&options[:proc])
-
-        else
-          raise ArgumentError, "don't know how to load #{options.inspect}"
-        end
-      end
-
-      # Require another file. This is identical to the standard require method,
-      # with the exception that it sets the receiver as the "current" configuration
-      # so that third-party task bundles can include themselves relative to
-      # that configuration.
-      #
-      # This is a bit more complicated than an initial review would seem to
-      # necessitate, but the use case that complicates things is this: An
-      # advanced user wants to embed capistrano, and needs to instantiate
-      # more than one capistrano configuration at a time. They also want each
-      # configuration to require a third-party capistrano extension. Using a
-      # naive require implementation, this would allow the first configuration
-      # to successfully load the third-party extension, but the require would
-      # fail for the second configuration because the extension has already
-      # been loaded.
-      #
-      # To work around this, we do a few things:
-      #
-      # 1. Each time a 'require' is invoked inside of a capistrano recipe,
-      #    we remember the arguments (see "current_feature").
-      # 2. Each time a 'load' is invoked inside of a capistrano recipe, and
-      #    "current_feature" is not nil (meaning we are inside of a pending
-      #    require) we remember the options (see "remember_load" and
-      #    "recipes_per_feature").
-      # 3. Each time a 'require' is invoked inside of a capistrano recipe,
-      #    we check to see if this particular configuration has ever seen these
-      #    arguments to require (see @loaded_features), and if not, we proceed
-      #    as if the file had never been required. If the superclass' require
-      #    returns false (meaning, potentially, that the file has already been
-      #    required), then we look in the recipes_per_feature collection and
-      #    load any remembered recipes from there.
-      #
-      # It's kind of a bear, but it works, and works transparently. Note that
-      # a simpler implementation would just muck with $", allowing files to be
-      # required multiple times, but that will cause warnings (and possibly
-      # errors) if the file to be required contains constant definitions and
-      # such, alongside (or instead of) capistrano recipe definitions.
-      def require(*args) #:nodoc:
-        # look to see if this specific configuration instance has ever seen
-        # these arguments to require before
-        if @loaded_features.include?(args)
-          return false
-        end
-
-        @loaded_features << args
-        begin
-          original_instance, self.class.instance = self.class.instance, self
-          original_feature, self.class.current_feature = self.class.current_feature, args
-
-          result = super
-          if !result # file has been required previously, load up the remembered recipes
-            list = self.class.recipes_per_feature[args] || []
-            list.each { |options| load(options.merge(:reloading => true)) }
-          end
-
-          return result
-        ensure
-          # restore the original, so that require's can be nested
-          self.class.instance = original_instance
-          self.class.current_feature = original_feature
-        end
-      end
-
-      def file_in_load_path?(file)
-        begin
-          !!find_file_in_load_path(file)
-        rescue LoadError
-          false
-        end
-      end
-
-      private
-
-        # Load a recipe from the named file. If +name+ is given, the file will
-        # be reported using that name.
-        def load_from_file(file, name=nil)
-          file = find_file_in_load_path(file) unless File.file?(file)
-          load :string => File.read(file), :name => name || file
-        end
-
-        def find_file_in_load_path(file)
-          load_paths.each do |path|
-            ["", ".rb"].each do |ext|
-              name = File.join(path, "#{file}#{ext}")
-              return name if File.file?(name)
-            end
-          end
-
-          raise LoadError, "no such file to load -- #{file}"
-        end
-
-        # If a file is being required, the options associated with loading a
-        # recipe are remembered in the recipes_per_feature archive under the
-        # name of the file currently being required.
-        def remember_load(options)
-          if self.class.current_feature
-            list = (self.class.recipes_per_feature[self.class.current_feature] ||= [])
-            list << options
-          end
-        end
-    end
-  end
-end

data/lib/capistrano/configuration/log_formatters.rb

@@ -1,75 +0,0 @@
-# Add custom log formatters
-#
-# Passing a hash or a array of hashes with custom log formatters.
-#
-# Add the following to your deploy.rb or in your ~/.caprc
-#
-# == Example:
-#
-#   capistrano_log_formatters = [
-#     { :match => /command finished/,       :color => :hide,      :priority => 10, :prepend => "$$$" },
-#     { :match => /executing command/,      :color => :blue,      :priority => 10, :style => :underscore, :timestamp => true },
-#     { :match => /^transaction: commit$/,  :color => :magenta,   :priority => 10, :style => :blink },
-#     { :match => /git/,                    :color => :white,     :priority => 20, :style => :reverse }
-#   ]
-#
-#   log_formatter capistrano_log_formatters
-#
-# You can call log_formatter multiple times, with either a hash or an array of hashes.
-#
-# == Colors:
-#
-# :color can have the following values:
-#
-# * :hide  (hides the row completely)
-# * :none
-# * :black
-# * :red
-# * :green
-# * :yellow
-# * :blue
-# * :magenta
-# * :cyan
-# * :white
-#
-# == Styles:
-#
-# :style can have the following values:
-#
-# * :bright
-# * :dim
-# * :underscore
-# * :blink
-# * :reverse
-# * :hidden
-#
-#
-#  == Text alterations
-#
-# :prepend gives static text to be prepended to the output
-# :replace replaces the matched text in the output
-# :timestamp adds the current time before the output
-
-module Capistrano
-  class Configuration
-    module LogFormatters
-      def log_formatter(options)
-        if options.class == Array
-          options.each do |option|
-            Capistrano::Logger.add_formatter(option)
-          end
-        else
-          Capistrano::Logger.add_formatter(options)
-        end
-      end
-
-      def default_log_formatters(formatters)
-        default_formatters = [*formatters]
-      end
-
-      def disable_log_formatters
-        @logger.disable_formatters = true
-      end
-    end
-  end
-end