sneakin-capistrano 2.5.5

data/lib/capistrano/configuration/namespaces.rb

@@ -0,0 +1,197 @@
+require 'capistrano/task_definition'
+
+module Capistrano
+  class Configuration
+    module Namespaces
+      DEFAULT_TASK = :default
+
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :initialize_without_namespaces, :initialize
+        base.send :alias_method, :initialize, :initialize_with_namespaces
+      end
+
+      # The name of this namespace. Defaults to +nil+ for the top-level
+      # namespace.
+      attr_reader :name
+
+      # The parent namespace of this namespace. Returns +nil+ for the top-level
+      # namespace.
+      attr_reader :parent
+
+      # The hash of tasks defined for this namespace.
+      attr_reader :tasks
+
+      # The hash of namespaces defined for this namespace.
+      attr_reader :namespaces
+
+      def initialize_with_namespaces(*args) #:nodoc:
+        @name = @parent = nil
+        initialize_without_namespaces(*args)
+        @tasks = {}
+        @namespaces = {}
+      end
+      private :initialize_with_namespaces
+
+      # Returns the top-level namespace (the one with no parent).
+      def top
+        return parent.top if parent
+        return self
+      end
+
+      # Returns the fully-qualified name of this namespace, or nil if the
+      # namespace is at the top-level.
+      def fully_qualified_name
+        return nil if name.nil?
+        [parent.fully_qualified_name, name].compact.join(":")
+      end
+
+      # Describe the next task to be defined. The given text will be attached to
+      # the next task that is defined and used as its description.
+      def desc(text)
+        @next_description = text
+      end
+
+      # Returns the value set by the last, pending "desc" call. If +reset+ is
+      # not false, the value will be reset immediately afterwards.
+      def next_description(reset=false)
+        @next_description
+      ensure
+        @next_description = nil if reset
+      end
+
+      # Open a namespace in which to define new tasks. If the namespace was
+      # defined previously, it will be reopened, otherwise a new namespace
+      # will be created for the given name.
+      def namespace(name, &block)
+        name = name.to_sym
+        raise ArgumentError, "expected a block" unless block_given?
+
+        namespace_already_defined = namespaces.key?(name)
+        if all_methods.any? { |m| m.to_sym == name } && !namespace_already_defined
+          thing = tasks.key?(name) ? "task" : "method"
+          raise ArgumentError, "defining a namespace named `#{name}' would shadow an existing #{thing} with that name"
+        end
+
+        namespaces[name] ||= Namespace.new(name, self)
+        namespaces[name].instance_eval(&block)
+
+        # make sure any open description gets terminated
+        namespaces[name].desc(nil)
+
+        if !namespace_already_defined
+          metaclass = class << self; self; end
+          metaclass.send(:define_method, name) { namespaces[name] }
+        end
+      end
+
+      # Describe a new task. If a description is active (see #desc), it is added
+      # to the options under the <tt>:desc</tt> key. The new task is added to
+      # the namespace.
+      def task(name, options={}, &block)
+        name = name.to_sym
+        raise ArgumentError, "expected a block" unless block_given?
+
+        task_already_defined = tasks.key?(name)
+        if all_methods.any? { |m| m.to_sym == name } && !task_already_defined
+          thing = namespaces.key?(name) ? "namespace" : "method"
+          raise ArgumentError, "defining a task named `#{name}' would shadow an existing #{thing} with that name"
+        end
+
+        tasks[name] = TaskDefinition.new(name, self, {:desc => next_description(:reset)}.merge(options), &block)
+
+        if !task_already_defined
+          metaclass = class << self; self; end
+          metaclass.send(:define_method, name) { execute_task(tasks[name]) }
+        end
+      end
+
+      # Find the task with the given name, where name is the fully-qualified
+      # name of the task. This will search into the namespaces and return
+      # the referenced task, or nil if no such task can be found. If the name
+      # refers to a namespace, the task in that namespace named "default"
+      # will be returned instead, if one exists.
+      def find_task(name)
+        parts = name.to_s.split(/:/)
+        tail = parts.pop.to_sym
+
+        ns = self
+        until parts.empty?
+          next_part = parts.shift
+          ns = next_part.empty? ? nil : ns.namespaces[next_part.to_sym]
+          return nil if ns.nil?
+        end
+
+        if ns.namespaces.key?(tail)
+          ns = ns.namespaces[tail]
+          tail = DEFAULT_TASK
+        end
+
+        ns.tasks[tail]
+      end
+
+      # Given a task name, this will search the current namespace, and all
+      # parent namespaces, looking for a task that matches the name, exactly.
+      # It returns the task, if found, or nil, if not.
+      def search_task(name)
+        name = name.to_sym
+        ns = self
+
+        until ns.nil?
+          return ns.tasks[name] if ns.tasks.key?(name)
+          ns = ns.parent
+        end
+
+        return nil
+      end
+
+      # Returns the default task for this namespace. This will be +nil+ if
+      # the namespace is at the top-level, and will otherwise return the
+      # task named "default". If no such task exists, +nil+ will be returned.
+      def default_task
+        return nil if parent.nil?
+        return tasks[DEFAULT_TASK]
+      end
+  
+      # Returns the tasks in this namespace as an array of TaskDefinition
+      # objects. If a non-false parameter is given, all tasks in all
+      # namespaces under this namespace will be returned as well.
+      def task_list(all=false)
+        list = tasks.values
+        namespaces.each { |name,space| list.concat(space.task_list(:all)) } if all
+        list
+      end
+
+      private
+
+        def all_methods
+          public_methods.concat(protected_methods).concat(private_methods)
+        end
+
+        class Namespace
+          def initialize(name, parent)
+            @parent = parent
+            @name = name
+          end
+
+          def role(*args)
+            raise NotImplementedError, "roles cannot be defined in a namespace"
+          end
+
+          def respond_to?(sym, include_priv=false)
+            super || parent.respond_to?(sym, include_priv)
+          end
+
+          def method_missing(sym, *args, &block)
+            if parent.respond_to?(sym)
+              parent.send(sym, *args, &block)
+            else
+              super
+            end
+          end
+
+          include Capistrano::Configuration::Namespaces
+          undef :desc, :next_description
+        end
+    end
+  end
+end

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/configuration.rb

@@ -0,0 +1,43 @@
+require 'capistrano/logger'
+
+require 'capistrano/configuration/callbacks'
+require 'capistrano/configuration/connections'
+require 'capistrano/configuration/execution'
+require 'capistrano/configuration/loading'
+require 'capistrano/configuration/namespaces'
+require 'capistrano/configuration/roles'
+require 'capistrano/configuration/servers'
+require 'capistrano/configuration/variables'
+
+require 'capistrano/configuration/actions/file_transfer'
+require 'capistrano/configuration/actions/inspect'
+require 'capistrano/configuration/actions/invocation'
+
+module Capistrano
+  # Represents a specific Capistrano configuration. A Configuration instance
+  # may be used to load multiple recipe files, define and describe tasks,
+  # define roles, and set configuration variables.
+  class Configuration
+    # The logger instance defined for this configuration.
+    attr_accessor :debug, :logger, :dry_run
+
+    def initialize #:nodoc:
+      @debug = false
+      @dry_run = false
+      @logger = Logger.new
+    end
+
+    # make the DSL easier to read when using lazy evaluation via lambdas
+    alias defer lambda
+
+    # The includes must come at the bottom, since they may redefine methods
+    # defined in the base class.
+    include Connections, Execution, Loading, Namespaces, Roles, Servers, Variables
+
+    # Mix in the actions
+    include Actions::FileTransfer, Actions::Inspect, Actions::Invocation
+
+    # Must mix last, because it hooks into previously defined methods
+    include Callbacks
+  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