mbailey-capistrano 2.5.5

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

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

data/lib/capistrano/recipes/compat.rb

@@ -0,0 +1,32 @@
+# A collection of compatibility scripts, to ease the transition between
+# Capistrano 1.x and Capistrano 2.x.
+
+# Depends on the deployment system
+load 'deploy'
+
+map = { "diff_from_last_deploy"  => "deploy:pending:diff",
+        "update"                 => "deploy:update",
+        "update_code"            => "deploy:update_code",
+        "symlink"                => "deploy:symlink",
+        "restart"                => "deploy:restart",
+        "rollback"               => "deploy:rollback",
+        "cleanup"                => "deploy:cleanup",
+        "disable_web"            => "deploy:web:disable",
+        "enable_web"             => "deploy:web:enable",
+        "cold_deploy"            => "deploy:cold",
+        "deploy_with_migrations" => "deploy:migrations" }
+
+map.each do |old, new|
+  desc "DEPRECATED: See #{new}."
+  eval "task(#{old.inspect}) do
+    warn \"[DEPRECATED] `#{old}' is deprecated. Use `#{new}' instead.\"
+    find_and_execute_task(#{new.inspect})
+  end"
+end
+
+desc "DEPRECATED: See deploy:start."
+task :spinner do
+  warn "[DEPRECATED] `spinner' is deprecated. Use `deploy:start' instead."
+  set :runner, fetch(:spinner_user, "app")
+  deploy.start
+end

data/lib/capistrano/recipes/deploy/dependencies.rb

@@ -0,0 +1,44 @@
+require 'capistrano/recipes/deploy/local_dependency'
+require 'capistrano/recipes/deploy/remote_dependency'
+
+module Capistrano
+  module Deploy
+    class Dependencies
+      include Enumerable
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        @dependencies = []
+        yield self if block_given?
+      end
+
+      def check
+        yield self
+        self
+      end
+  
+      def remote
+        dep = RemoteDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def local
+        dep = LocalDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def each
+        @dependencies.each { |d| yield d }
+        self
+      end
+
+      def pass?
+        all? { |d| d.pass? }
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/local_dependency.rb

@@ -0,0 +1,54 @@
+module Capistrano
+  module Deploy
+    class LocalDependency
+      attr_reader :configuration
+      attr_reader :message
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+      end
+
+      def command(command)
+        @message ||= "`#{command}' could not be found in the path on the local host"
+        @success = find_in_path(command)
+        self
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+    private
+
+      # Searches the path, looking for the given utility. If an executable
+      # file is found that matches the parameter, this returns true.
+      def find_in_path(utility)
+        path = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+        suffixes = self.class.on_windows? ? self.class.windows_executable_extensions : [""]
+
+        path.each do |dir|
+          suffixes.each do |sfx|
+            file = File.join(dir, utility + sfx)
+            return true if File.executable?(file)
+          end
+        end
+
+        false
+      end
+
+      def self.on_windows?
+        RUBY_PLATFORM =~ /mswin|mingw/
+      end
+
+      def self.windows_executable_extensions
+        %w(.exe .bat .com .cmd)
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/remote_dependency.rb

@@ -0,0 +1,105 @@
+require 'capistrano/errors'
+
+module Capistrano
+  module Deploy
+    class RemoteDependency
+      attr_reader :configuration
+      attr_reader :hosts
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+        @hosts = nil
+      end
+
+      def directory(path, options={})
+        @message ||= "`#{path}' is not a directory"
+        try("test -d #{path}", options)
+        self
+      end
+
+      def file(path, options={})
+        @message ||= "`#{path}' is not a file"
+        try("test -f #{path}", options)
+        self
+      end
+
+      def writable(path, options={})
+        @message ||= "`#{path}' is not writable"
+        try("test -w #{path}", options)
+        self
+      end
+
+      def command(command, options={})
+        @message ||= "`#{command}' could not be found in the path"
+        try("which #{command}", options)
+        self
+      end
+
+      def gem(name, version, options={})
+        @message ||= "gem `#{name}' #{version} could not be found"
+        gem_cmd = configuration.fetch(:gem_command, "gem")
+        try("#{gem_cmd} specification --version '#{version}' #{name} 2>&1 | awk 'BEGIN { s = 0 } /^name:/ { s = 1; exit }; END { if(s == 0) exit 1 }'", options)
+        self
+      end
+
+      def match(command, expect, options={})
+        expect = Regexp.new(Regexp.escape(expect.to_s)) unless expect.is_a?(Regexp)
+
+        output_per_server = {} 
+        try("#{command} ", options) do |ch, stream, out| 
+          output_per_server[ch[:server]] ||= '' 
+          output_per_server[ch[:server]] += out 
+        end 
+
+        # It is possible for some of these commands to return a status != 0
+        # (for example, rake --version exits with a 1). For this check we
+        # just care if the output matches, so we reset the success flag.
+        @success = true
+
+        errored_hosts = [] 
+        output_per_server.each_pair do |server, output| 
+          next if output =~ expect
+          errored_hosts << server 
+        end 
+
+        if errored_hosts.any?
+          @hosts = errored_hosts.join(', ')
+          output = output_per_server[errored_hosts.first]
+          @message = "the output #{output.inspect} from #{command.inspect} did not match #{expect.inspect}"
+          @success = false
+        end 
+
+        self 
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+      def message
+        s = @message.dup
+        s << " (#{@hosts})" if @hosts
+        s
+      end
+
+    private
+
+      def try(command, options)
+        return unless @success # short-circuit evaluation
+        configuration.invoke_command(command, options) do |ch,stream,out|
+          warn "#{ch[:server]}: #{out}" if stream == :err
+          yield ch, stream, out if block_given?
+        end
+      rescue Capistrano::CommandError => e
+        @success = false
+        @hosts = e.hosts.join(', ')
+      end
+    end
+  end
+end