capistrano-edge 2.5.6

data/lib/capistrano/configuration/roles.rb

@@ -0,0 +1,73 @@
+require 'capistrano/server_definition'
+require 'capistrano/role'
+
+module Capistrano
+  class Configuration
+    module Roles
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :initialize_without_roles, :initialize
+        base.send :alias_method, :initialize, :initialize_with_roles
+      end
+
+      # The hash of roles defined for this configuration. Each entry in the
+      # hash points to an array of server definitions that belong in that
+      # role.
+      attr_reader :roles
+
+      def initialize_with_roles(*args) #:nodoc:
+        initialize_without_roles(*args)
+        @roles = Hash.new { |h,k| h[k] = Role.new }
+      end
+
+      # Define a new role and its associated servers. You must specify at least
+      # one host for each role. Also, you can specify additional information
+      # (in the form of a Hash) which can be used to more uniquely specify the
+      # subset of servers specified by this specific role definition.
+      #
+      # Usage:
+      #
+      #   role :db,  "db1.example.com", "db2.example.com"
+      #   role :db,  "master.example.com", :primary => true
+      #   role :app, "app1.example.com", "app2.example.com"
+      #
+      # You can also encode the username and port number for each host in the
+      # server string, if needed:
+      #
+      #   role :web,  "www@web1.example.com"
+      #   role :file, "files.example.com:4144"
+      #   role :db,   "admin@db3.example.com:1234"
+      #
+      # Lastly, username and port number may be passed as options, if that is
+      # preferred; note that the options apply to all servers defined in
+      # that call to "role":
+      #
+      #   role :web, "web2", "web3", :user => "www", :port => 2345
+      def role(which, *args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        which = which.to_sym
+
+        # The roles Hash is defined so that unrecognized keys always auto-initialize
+        # to a new Role instance (see the assignment in the initialize_with_roles method,
+        # above). However, we explicitly assign here so that role declarations will
+        # vivify the role object even if there are no server arguments. (Otherwise,
+        # role(:app) won't actually instantiate a Role object for :app.)
+        roles[which] ||= Role.new
+
+        roles[which].push(block, options) if block_given?
+        args.each { |host| roles[which] << ServerDefinition.new(host, options) }
+      end
+
+      # An alternative way to associate servers with roles. If you have a server
+      # that participates in multiple roles, this can be a DRYer way to describe
+      # the relationships. Pass the host definition as the first parameter, and
+      # the roles as the remaining parameters:
+      #
+      #   server "master.example.com", :web, :app
+      def server(host, *roles)
+        options = roles.last.is_a?(Hash) ? roles.pop : {}
+        raise ArgumentError, "you must associate a server with at least one role" if roles.empty?
+        roles.each { |name| role(name, host, options) }
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/servers.rb

@@ -0,0 +1,85 @@
+module Capistrano
+  class Configuration
+    module Servers
+      # Identifies all servers that the given task should be executed on.
+      # The options hash accepts the same arguments as #find_servers, and any
+      # preexisting options there will take precedence over the options in
+      # the task.
+      def find_servers_for_task(task, options={})
+        find_servers(task.options.merge(options))
+      end
+
+      # Attempts to find all defined servers that match the given criteria.
+      # The options hash may include a :hosts option (which should specify
+      # an array of host names or ServerDefinition instances), a :roles
+      # option (specifying an array of roles), an :only option (specifying
+      # a hash of key/value pairs that any matching server must match), and
+      # an :exception option (like :only, but the inverse).
+      #
+      # Additionally, if the HOSTS environment variable is set, it will take
+      # precedence over any other options. Similarly, the ROLES environment
+      # variable will take precedence over other options. If both HOSTS and
+      # ROLES are given, HOSTS wins.
+      #
+      # Yet additionally, if the HOSTFILTER environment variable is set, it
+      # will limit the result to hosts found in that (comma-separated) list.
+      #
+      # Usage:
+      #
+      #   # return all known servers
+      #   servers = find_servers
+      #
+      #   # find all servers in the app role that are not exempted from
+      #   # deployment
+      #   servers = find_servers :roles => :app,
+      #                :except => { :no_release => true }
+      #
+      #   # returns the given hosts, translated to ServerDefinition objects
+      #   servers = find_servers :hosts => "jamis@example.host.com"
+      def find_servers(options={})
+        hosts  = server_list_from(ENV['HOSTS'] || options[:hosts])
+        
+        if hosts.any?
+          filter_server_list(hosts.uniq)
+        else
+          roles  = role_list_from(ENV['ROLES'] || options[:roles] || self.roles.keys)
+          only   = options[:only] || {}
+          except = options[:except] || {}
+          
+          servers = roles.inject([]) { |list, role| list.concat(self.roles[role]) }
+          servers = servers.select { |server| only.all? { |key,value| server.options[key] == value } }
+          servers = servers.reject { |server| except.any? { |key,value| server.options[key] == value } }
+          filter_server_list(servers.uniq)
+        end
+      end
+
+    protected
+
+      def filter_server_list(servers)
+        return servers unless ENV['HOSTFILTER']
+        filters = ENV['HOSTFILTER'].split(/,/)
+        servers.select { |server| filters.include?(server.host) }
+      end
+
+      def server_list_from(hosts)
+        hosts = hosts.split(/,/) if String === hosts
+        hosts = build_list(hosts)
+        hosts.map { |s| String === s ? ServerDefinition.new(s.strip) : s }
+      end
+
+      def role_list_from(roles)
+        roles = roles.split(/,/) if String === roles
+        roles = build_list(roles)
+        roles.map do |role|
+          role = String === role ? role.strip.to_sym : role
+          raise ArgumentError, "unknown role `#{role}'" unless self.roles.key?(role)
+          role
+        end
+      end
+
+      def build_list(list)
+        Array(list).map { |item| item.respond_to?(:call) ? item.call : item }.flatten
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/variables.rb

@@ -0,0 +1,127 @@
+require 'thread'
+
+module Capistrano
+  class Configuration
+    module Variables
+      def self.included(base) #:nodoc:
+        %w(initialize respond_to? method_missing).each do |m|
+          base_name = m[/^\w+/]
+          punct     = m[/\W+$/]
+          base.send :alias_method, "#{base_name}_without_variables#{punct}", m
+          base.send :alias_method, m, "#{base_name}_with_variables#{punct}"
+        end
+      end
+
+      # The hash of variables that have been defined in this configuration
+      # instance.
+      attr_reader :variables
+
+      # Set a variable to the given value.
+      def set(variable, *args, &block)
+        if variable.to_s !~ /^[_a-z]/
+          raise ArgumentError, "invalid variable `#{variable}' (variables must begin with an underscore, or a lower-case letter)"
+        end
+
+        if !block_given? && args.empty? || block_given? && !args.empty?
+          raise ArgumentError, "you must specify exactly one of either a value or a block"
+        end
+
+        if args.length > 1
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
+        end
+
+        value = args.empty? ? block : args.first
+        sym = variable.to_sym
+        protect(sym) { @variables[sym] = value }
+      end
+
+      alias :[]= :set
+
+      # Removes any trace of the given variable.
+      def unset(variable)
+        sym = variable.to_sym
+        protect(sym) do
+          @original_procs.delete(sym)
+          @variables.delete(sym)
+        end
+      end
+
+      # Returns true if the variable has been defined, and false otherwise.
+      def exists?(variable)
+        @variables.key?(variable.to_sym)
+      end
+
+      # If the variable was originally a proc value, it will be reset to it's
+      # original proc value. Otherwise, this method does nothing. It returns
+      # true if the variable was actually reset.
+      def reset!(variable)
+        sym = variable.to_sym
+        protect(sym) do
+          if @original_procs.key?(sym)
+            @variables[sym] = @original_procs.delete(sym)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # Access a named variable. If the value of the variable responds_to? :call,
+      # #call will be invoked (without parameters) and the return value cached
+      # and returned.
+      def fetch(variable, *args)
+        if !args.empty? && block_given?
+          raise ArgumentError, "you must specify either a default value or a block, but not both"
+        end
+
+        sym = variable.to_sym
+        protect(sym) do
+          if !@variables.key?(sym)
+            return args.first unless args.empty?
+            return yield(variable) if block_given?
+            raise IndexError, "`#{variable}' not found"
+          end
+
+          if @variables[sym].respond_to?(:call)
+            @original_procs[sym] = @variables[sym]
+            @variables[sym] = @variables[sym].call
+          end
+        end
+
+        @variables[sym]
+      end
+
+      def [](variable)
+        fetch(variable, nil)
+      end
+
+      def initialize_with_variables(*args) #:nodoc:
+        initialize_without_variables(*args)
+        @variables = {}
+        @original_procs = {}
+        @variable_locks = Hash.new { |h,k| h[k] = Mutex.new }
+
+        set :ssh_options, {}
+        set :logger, logger
+      end
+      private :initialize_with_variables
+
+      def protect(variable)
+        @variable_locks[variable.to_sym].synchronize { yield }
+      end
+      private :protect
+
+      def respond_to_with_variables?(sym, include_priv=false) #:nodoc:
+        @variables.has_key?(sym) || respond_to_without_variables?(sym, include_priv)
+      end
+
+      def method_missing_with_variables(sym, *args, &block) #:nodoc:
+        if args.length == 0 && block.nil? && @variables.has_key?(sym)
+          self[sym]
+        else
+          method_missing_without_variables(sym, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/errors.rb

@@ -0,0 +1,15 @@
+module Capistrano
+  class Error < RuntimeError; end
+
+  class CaptureError < Error; end
+  class NoSuchTaskError < Error; end
+  class NoMatchingServersError < Error; end
+  
+  class RemoteError < Error
+    attr_accessor :hosts
+  end
+
+  class ConnectionError < RemoteError; end
+  class TransferError < RemoteError; end
+  class CommandError < RemoteError; end
+end

data/lib/capistrano/extensions.rb

@@ -0,0 +1,57 @@
+module Capistrano
+  class ExtensionProxy #:nodoc:
+    def initialize(config, mod)
+      @config = config
+      extend(mod)
+    end
+
+    def method_missing(sym, *args, &block)
+      @config.send(sym, *args, &block)
+    end
+  end
+
+  # Holds the set of registered plugins, keyed by name (where the name is a
+  # symbol).
+  EXTENSIONS = {}
+
+  # Register the given module as a plugin with the given name. It will henceforth
+  # be available via a proxy object on Configuration instances, accessible by
+  # a method with the given name.
+  def self.plugin(name, mod)
+    name = name.to_sym
+    return false if EXTENSIONS.has_key?(name)
+
+    methods = Capistrano::Configuration.public_instance_methods +
+      Capistrano::Configuration.protected_instance_methods +
+      Capistrano::Configuration.private_instance_methods
+
+    if methods.any? { |m| m.to_sym == name }
+      raise Capistrano::Error, "registering a plugin named `#{name}' would shadow a method on Capistrano::Configuration with the same name"
+    end
+
+    Capistrano::Configuration.class_eval <<-STR, __FILE__, __LINE__+1
+      def #{name}
+        @__#{name}_proxy ||= Capistrano::ExtensionProxy.new(self, Capistrano::EXTENSIONS[#{name.inspect}])
+      end
+    STR
+
+    EXTENSIONS[name] = mod
+    return true
+  end
+
+  # Unregister the plugin with the given name.
+  def self.remove_plugin(name)
+    name = name.to_sym
+    if EXTENSIONS.delete(name)
+      Capistrano::Configuration.send(:remove_method, name)
+      return true
+    end
+
+    return false
+  end
+
+  def self.configuration(*args) #:nodoc:
+    warn "[DEPRECATION] Capistrano.configuration is deprecated. Use Capistrano::Configuration.instance instead"
+    Capistrano::Configuration.instance(*args)
+  end
+end

data/lib/capistrano/logger.rb

@@ -0,0 +1,59 @@
+module Capistrano
+  class Logger #:nodoc:
+    attr_accessor :level
+    attr_reader   :device
+
+    IMPORTANT = 0
+    INFO      = 1
+    DEBUG     = 2
+    TRACE     = 3
+    
+    MAX_LEVEL = 3
+
+    def initialize(options={})
+      output = options[:output] || $stderr
+      if output.respond_to?(:puts)
+        @device = output
+      else
+        @device = File.open(output.to_str, "a")
+        @needs_close = true
+      end
+
+      @options = options
+      @level = 0
+    end
+
+    def close
+      device.close if @needs_close
+    end
+
+    def log(level, message, line_prefix=nil)
+      if level <= self.level
+        indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
+        (RUBY_VERSION >= "1.9" ? message.lines : message).each do |line|
+          if line_prefix
+            device.puts "#{indent} [#{line_prefix}] #{line.strip}\n"
+          else
+            device.puts "#{indent} #{line.strip}\n"
+          end
+        end
+      end
+    end
+
+    def important(message, line_prefix=nil)
+      log(IMPORTANT, message, line_prefix)
+    end
+
+    def info(message, line_prefix=nil)
+      log(INFO, message, line_prefix)
+    end
+
+    def debug(message, line_prefix=nil)
+      log(DEBUG, message, line_prefix)
+    end
+
+    def trace(message, line_prefix=nil)
+      log(TRACE, message, line_prefix)
+    end
+  end
+end

data/lib/capistrano/processable.rb

@@ -0,0 +1,53 @@
+module Capistrano
+  module Processable
+    module SessionAssociation
+      def self.on(exception, session)
+        unless exception.respond_to?(:session)
+          exception.extend(self)
+          exception.session = session
+        end
+
+        return exception
+      end
+
+      attr_accessor :session
+    end
+
+    def process_iteration(wait=nil, &block)
+      ensure_each_session { |session| session.preprocess }
+
+      return false if block && !block.call(self)
+
+      readers = sessions.map { |session| session.listeners.keys }.flatten.reject { |io| io.closed? }
+      writers = readers.select { |io| io.respond_to?(:pending_write?) && io.pending_write? }
+
+      if readers.any? || writers.any?
+        readers, writers, = IO.select(readers, writers, nil, wait)
+      end
+
+      if readers
+        ensure_each_session do |session|
+          ios = session.listeners.keys
+          session.postprocess(ios & readers, ios & writers)
+        end
+      end
+
+      true
+    end
+
+    def ensure_each_session
+      errors = []
+
+      sessions.each do |session|
+        begin
+          yield session
+        rescue Exception => error
+          errors << SessionAssociation.on(error, session)
+        end
+      end
+
+      raise errors.first if errors.any?
+      sessions
+    end
+  end
+end