minmb-capistrano 2.15.4

data/lib/capistrano/recipes/deploy/strategy/export.rb

@@ -0,0 +1,20 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # Implements the deployment strategy which does an SCM export on each
+      # target host.
+      class Export < Remote
+        protected
+
+          # Returns the SCM's export command for the revision to deploy.
+          def command
+            @command ||= source.export(revision, configuration[:release_path])
+          end
+      end
+
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/strategy/remote.rb

@@ -0,0 +1,52 @@
+require 'capistrano/recipes/deploy/strategy/base'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # An abstract superclass, which forms the base for all deployment
+      # strategies which work by grabbing the code from the repository directly
+      # from remote host. This includes deploying by checkout (the default),
+      # and deploying by export.
+      class Remote < Base
+        # Executes the SCM command for this strategy and writes the REVISION
+        # mark file to each host.
+        def deploy!
+          scm_run "#{command} && #{mark}"
+        end
+
+        def check!
+          super.check do |d|
+            d.remote.command(source.command)
+          end
+        end
+
+        protected
+
+          # Runs the given command, filtering output back through the
+          # #handle_data filter of the SCM implementation.
+          def scm_run(command)
+            run(command) do |ch,stream,text|
+              ch[:state] ||= { :channel => ch }
+              output = source.handle_data(ch[:state], stream, text)
+              ch.send_data(output) if output
+            end
+          end
+
+          # An abstract method which must be overridden in subclasses, to
+          # return the actual SCM command(s) which must be executed on each
+          # target host in order to perform the deployment.
+          def command
+            raise NotImplementedError, "`command' is not implemented by #{self.class.name}"
+          end
+
+          # Returns the command which will write the identifier of the
+          # revision being deployed to the REVISION file on each host.
+          def mark
+            "(echo #{revision} > #{configuration[:release_path]}/REVISION)"
+          end
+      end
+
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/strategy/remote_cache.rb

@@ -0,0 +1,57 @@
+require 'capistrano/recipes/deploy/strategy/remote'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # Implements the deployment strategy that keeps a cached checkout of
+      # the source code on each remote server. Each deploy simply updates the
+      # cached checkout, and then does a copy from the cached copy to the
+      # final deployment location.
+      class RemoteCache < Remote
+        # Executes the SCM command for this strategy and writes the REVISION
+        # mark file to each host.
+        def deploy!
+          update_repository_cache
+          copy_repository_cache
+        end
+
+        def check!
+          super.check do |d|
+            d.remote.command("rsync") unless copy_exclude.empty?
+            d.remote.writable(shared_path)
+          end
+        end
+
+        private
+
+          def repository_cache
+            File.join(shared_path, configuration[:repository_cache] || "cached-copy")
+          end
+
+          def update_repository_cache
+            logger.trace "updating the cached checkout on all servers"
+            command = "if [ -d #{repository_cache} ]; then " +
+              "#{source.sync(revision, repository_cache)}; " +
+              "else #{source.checkout(revision, repository_cache)}; fi"
+            scm_run(command)
+          end
+
+          def copy_repository_cache
+            logger.trace "copying the cached version to #{configuration[:release_path]}"
+            if copy_exclude.empty?
+              run "cp -RPp #{repository_cache} #{configuration[:release_path]} && #{mark}"
+            else
+              exclusions = copy_exclude.map { |e| "--exclude=\"#{e}\"" }.join(' ')
+              run "rsync -lrpt #{exclusions} #{repository_cache}/ #{configuration[:release_path]} && #{mark}"
+            end
+          end
+
+          def copy_exclude
+            @copy_exclude ||= Array(configuration.fetch(:copy_exclude, []))
+          end
+      end
+
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/strategy/unshared_remote_cache.rb

@@ -0,0 +1,21 @@
+require 'capistrano/recipes/deploy/strategy/remote_cache'
+
+module Capistrano
+  module Deploy
+    module Strategy
+      class UnsharedRemoteCache < RemoteCache
+        def check!
+          super.check do |d|
+            d.remote.writable(repository_cache)
+          end
+        end
+
+        private
+
+        def repository_cache
+          configuration[:repository_cache]
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/standard.rb

@@ -0,0 +1,37 @@
+desc <<-DESC
+  Invoke a single command on the remote servers. This is useful for performing \
+  one-off commands that may not require a full task to be written for them. \
+  Simply specify the command to execute via the COMMAND environment variable. \
+  To execute the command only on certain roles, specify the ROLES environment \
+  variable as a comma-delimited list of role names. Alternatively, you can \
+  specify the HOSTS environment variable as a comma-delimited list of hostnames \
+  to execute the task on those hosts, explicitly. Lastly, if you want to \
+  execute the command via sudo, specify a non-empty value for the SUDO \
+  environment variable.
+
+  Sample usage:
+
+    $ cap COMMAND=uptime HOSTS=foo.capistano.test invoke
+    $ cap ROLES=app,web SUDO=1 COMMAND="tail -f /var/log/messages" invoke
+DESC
+task :invoke do
+  command = ENV["COMMAND"] || ""
+  abort "Please specify a command to execute on the remote servers (via the COMMAND environment variable)" if command.empty?
+  method = ENV["SUDO"] ? :sudo : :run
+  invoke_command(command, :via => method)
+end
+
+desc <<-DESC
+  Begin an interactive Capistrano session. This gives you an interactive \
+  terminal from which to execute tasks and commands on all of your servers. \
+  (This is still an experimental feature, and is subject to change without \
+  notice!)
+
+  Sample usage:
+
+    $ cap shell
+DESC
+task :shell do
+  require 'capistrano/shell'
+  Capistrano::Shell.run(self)
+end

data/lib/capistrano/recipes/templates/maintenance.rhtml

@@ -0,0 +1,53 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
+  <title>System down for maintenance</title>
+
+  <style type="text/css">
+    div.outer {
+      position: absolute;
+      left: 50%;
+      top: 50%;
+      width: 500px;
+      height: 300px;
+      margin-left: -260px; 
+      margin-top: -150px;
+    }
+
+    .DialogBody {
+      margin: 0;
+      padding: 10px;
+      text-align: left;
+      border: 1px solid #ccc;
+      border-right: 1px solid #999;
+      border-bottom: 1px solid #999;
+      background-color: #fff;
+    }
+
+    body { background-color: #fff; }
+  </style>
+</head>
+
+<body>
+
+  <div class="outer">
+     <div class="DialogBody" style="text-align: center;">
+       <div style="text-align: center; width: 200px; margin: 0 auto;">
+         <p style="color: red; font-size: 16px; line-height: 20px;">
+           The system is down for <%= reason ? reason : "maintenance" %>
+           as of <%= Time.now.strftime("%H:%M %Z") %>.
+         </p>
+         <p style="color: #666;">
+           It'll be back <%= deadline ? deadline : "shortly" %>.
+         </p>
+       </div>
+     </div>
+  </div>
+
+</body>
+</html>

data/lib/capistrano/role.rb

@@ -0,0 +1,102 @@
+module Capistrano
+  class Role
+    include Enumerable
+
+    def initialize(*list)
+      @static_servers = []
+      @dynamic_servers = []
+      push(*list)
+    end
+
+    def each(&block)
+      servers.each &block
+    end
+
+    def push(*list)
+      options = list.last.is_a?(Hash) ? list.pop : {}
+      list.each do |item|
+        if item.respond_to?(:call)
+          @dynamic_servers << DynamicServerList.new(item, options)
+        else
+          @static_servers << self.class.wrap_server(item, options)
+        end
+      end
+    end
+    alias_method :<<, :push
+
+    def servers
+      @static_servers + dynamic_servers
+    end
+    alias_method :to_ary, :servers
+
+    def empty?
+      servers.empty?
+    end
+
+    def clear
+      @dynamic_servers.clear
+      @static_servers.clear
+    end
+
+    def include?(server)
+      servers.include?(server)
+    end
+
+    protected
+
+    # This is the combination of a block, a hash of options, and a cached value.
+    class DynamicServerList
+      def initialize (block, options)
+        @block = block
+        @options = options
+        @cached = []
+        @is_cached = false
+      end
+
+      # Convert to a list of ServerDefinitions
+      def to_ary
+        unless @is_cached
+          @cached = Role::wrap_list(@block.call(@options), @options)
+          @is_cached = true
+        end
+        @cached
+      end
+
+      # Clear the cached value
+      def reset!
+        @cached.clear
+        @is_cached = false
+      end
+    end
+
+    # Attribute reader for the cached results of executing the blocks in turn
+    def dynamic_servers
+      @dynamic_servers.inject([]) { |list, item| list.concat item }
+    end
+
+    # Wraps a string in a ServerDefinition, if it isn't already.
+    # This and wrap_list should probably go in ServerDefinition in some form.
+    def self.wrap_server (item, options)
+      item.is_a?(ServerDefinition) ? item : ServerDefinition.new(item, options)
+    end
+
+    # Turns a list, or something resembling a list, into a properly-formatted
+    # ServerDefinition list. Keep an eye on this one -- it's entirely too
+    # magical for its own good. In particular, if ServerDefinition ever inherits
+    # from Array, this will break.
+    def self.wrap_list (*list)
+      options = list.last.is_a?(Hash) ? list.pop : {}
+      if list.length == 1
+        if list.first.nil?
+          return []
+        elsif list.first.is_a?(Array)
+          list = list.first
+        end
+      end
+      options.merge! list.pop if list.last.is_a?(Hash)
+      list.map do |item|
+        self.wrap_server item, options
+      end
+    end
+  end
+end

data/lib/capistrano/server_definition.rb

@@ -0,0 +1,56 @@
+module Capistrano
+  class ServerDefinition
+    include Comparable
+
+    attr_reader :host
+    attr_reader :user
+    attr_reader :port
+    attr_reader :options
+
+    # The default user name to use when a user name is not explicitly provided
+    def self.default_user
+      ENV['USER'] || ENV['USERNAME'] || "not-specified"
+    end
+
+    def initialize(string, options={})
+      @user, @host, @port = string.match(/^(?:([^;,:=]+)@|)(.*?)(?::(\d+)|)$/)[1,3]
+
+      @options = options.dup
+      user_opt, port_opt = @options.delete(:user), @options.delete(:port)
+
+      @user ||= user_opt
+      @port ||= port_opt
+
+      @port = @port.to_i if @port
+    end
+
+    def <=>(server)
+      [host, port, user] <=> [server.host, server.port, server.user]
+    end
+
+    # Redefined, so that Array#uniq will work to remove duplicate server
+    # definitions, based solely on their host names.
+    def eql?(server)
+      host == server.host &&
+        user == server.user &&
+        port == server.port
+    end
+
+    alias :== :eql?
+
+    # Redefined, so that Array#uniq will work to remove duplicate server
+    # definitions, based on their connection information.
+    def hash
+      @hash ||= [host, user, port].hash
+    end
+
+    def to_s
+      @to_s ||= begin
+        s = host
+        s = "#{user}@#{s}" if user
+        s = "#{s}:#{port}" if port && port != 22
+        s
+      end
+    end
+  end
+end

data/lib/capistrano/shell.rb

@@ -0,0 +1,265 @@
+require 'thread'
+require 'capistrano/processable'
+
+module Capistrano
+  # The Capistrano::Shell class is the guts of the "shell" task. It implements
+  # an interactive REPL interface that users can employ to execute tasks and
+  # commands. It makes for a GREAT way to monitor systems, and perform quick
+  # maintenance on one or more machines.
+  class Shell
+    include Processable
+
+    # A Readline replacement for platforms where readline is either
+    # unavailable, or has not been installed.
+    class ReadlineFallback #:nodoc:
+      HISTORY = []
+
+      def self.readline(prompt)
+        STDOUT.print(prompt)
+        STDOUT.flush
+        STDIN.gets
+      end
+    end
+
+    # The configuration instance employed by this shell
+    attr_reader :configuration
+
+    # Instantiate a new shell and begin executing it immediately.
+    def self.run(config)
+      new(config).run!
+    end
+
+    # Instantiate a new shell
+    def initialize(config)
+      @configuration = config
+    end
+
+    # Start the shell running. This method will block until the shell
+    # terminates.
+    def run!
+      setup
+
+      puts <<-INTRO
+====================================================================
+Welcome to the interactive Capistrano shell! This is an experimental
+feature, and is liable to change in future releases. Type 'help' for
+a summary of how to use the shell.
+--------------------------------------------------------------------
+INTRO
+
+      loop do
+        break if !read_and_execute
+      end
+
+      @bgthread.kill
+    end
+
+    def read_and_execute
+      command = read_line
+
+      case command
+        when "?", "help" then help
+        when "quit", "exit" then
+          puts "exiting"
+          return false
+        when /^set -(\w)\s*(\S+)/
+          set_option($1, $2)
+        when /^set :(.*)\s+(.*)/
+          configuration.set($1.to_sym, $2)
+          puts "updated :#{$1} to #{$2}"
+        when /^(?:(with|on)\s*(\S+))?\s*(\S.*)?/i
+          process_command($1, $2, $3)
+        else
+          raise "eh?"
+      end
+
+      return true
+    end
+
+    private
+
+      # Present the prompt and read a single line from the console. It also
+      # detects ^D and returns "exit" in that case. Adds the input to the
+      # history, unless the input is empty. Loops repeatedly until a non-empty
+      # line is input.
+      def read_line
+        loop do
+          command = reader.readline("cap> ")
+
+          if command.nil?
+            command = "exit"
+            puts(command)
+          else
+            command.strip!
+          end
+
+          unless command.empty?
+            reader::HISTORY << command
+            return command
+          end
+        end
+      end
+
+      # Display a verbose help message.
+      def help
+        puts <<-HELP
+--- HELP! ---------------------------------------------------
+"Get me out of this thing. I just want to quit."
+-> Easy enough. Just type "exit", or "quit". Or press ctrl-D.
+
+"I want to execute a command on all servers."
+-> Just type the command, and press enter. It will be passed,
+   verbatim, to all defined servers.
+
+"What if I only want it to execute on a subset of them?"
+-> No problem, just specify the list of servers, separated by
+   commas, before the command, with the `on' keyword:
+
+   cap> on app1.foo.com,app2.foo.com echo ping
+
+"Nice, but can I specify the servers by role?"
+-> You sure can. Just use the `with' keyword, followed by the
+   comma-delimited list of role names:
+
+   cap> with app,db echo ping
+
+"Can I execute a Capistrano task from within this shell?"
+-> Yup. Just prefix the task with an exclamation mark:
+
+   cap> !deploy
+HELP
+      end
+
+      # Determine which servers the given task requires a connection to, and
+      # establish connections to them if necessary. Return the list of
+      # servers (names).
+      def connect(task)
+        servers = configuration.find_servers_for_task(task)
+        needing_connections = servers - configuration.sessions.keys
+        unless needing_connections.empty?
+          puts "[establishing connection(s) to #{needing_connections.join(', ')}]"
+          configuration.establish_connections_to(needing_connections)
+        end
+        servers
+      end
+
+      # Execute the given command. If the command is prefixed by an exclamation
+      # mark, it is assumed to refer to another capistrano task, which will
+      # be invoked. Otherwise, it is executed as a command on all associated
+      # servers.
+      def exec(command)
+        @mutex.synchronize do
+          if command[0] == ?!
+            exec_tasks(command[1..-1].split)
+          else
+            servers = connect(configuration.current_task)
+            exec_command(command, servers)
+          end
+        end
+      ensure
+        STDOUT.flush
+      end
+
+      # Given an array of task names, invoke them in sequence.
+      def exec_tasks(list)
+        list.each do |task_name|
+          task = configuration.find_task(task_name)
+          raise Capistrano::NoSuchTaskError, "no such task `#{task_name}'" unless task
+          connect(task)
+          configuration.execute_task(task)
+        end
+      rescue Capistrano::NoMatchingServersError, Capistrano::NoSuchTaskError => error
+        warn "error: #{error.message}"
+      end
+
+      # Execute a command on the given list of servers.
+      def exec_command(command, servers)
+        command = command.gsub(/^(\s*)sudo\b|([|;&])\s*sudo\b/, "\\0 -p '#{configuration.sudo_prompt}'")
+        processor = configuration.sudo_behavior_callback(Configuration.default_io_proc)
+        sessions = servers.map { |server| configuration.sessions[server] }
+        options = configuration.add_default_command_options({})
+        cmd = Command.new(command, sessions, options.merge(:logger => configuration.logger), &processor)
+        previous = trap("INT") { cmd.stop! }
+        cmd.process!
+      rescue Capistrano::Error => error
+        warn "error: #{error.message}"
+      ensure
+        trap("INT", previous)
+      end
+
+      # Return the object that will be used to query input from the console.
+      # The returned object will quack (more or less) like Readline.
+      def reader
+        @reader ||= begin
+          require 'readline'
+          Readline
+        rescue LoadError
+          ReadlineFallback
+        end
+      end
+
+      # Prepare every little thing for the shell. Starts the background
+      # thread and generally gets things ready for the REPL.
+      def setup
+        configuration.logger.level = Capistrano::Logger::INFO
+        wait_for = 0.1
+
+        @mutex = Mutex.new
+        @bgthread = Thread.new do
+          loop do
+            ret = @mutex.synchronize { process_iteration(wait_for) }
+            sleep wait_for if !ret
+          end
+        end
+      end
+
+      # Set the given option to +value+.
+      def set_option(opt, value)
+        case opt
+          when "v" then
+            puts "setting log verbosity to #{value.to_i}"
+            configuration.logger.level = value.to_i
+          when "o" then
+            case value
+            when "vi" then
+              puts "using vi edit mode"
+              reader.vi_editing_mode
+            when "emacs" then
+              puts "using emacs edit mode"
+              reader.emacs_editing_mode
+            else
+              puts "unknown -o option #{value.inspect}"
+            end
+          else
+            puts "unknown setting #{opt.inspect}"
+        end
+      end
+
+      # Process a command. Interprets the scope_type (must be nil, "with", or
+      # "on") and the command. If no command is given, then the scope is made
+      # effective for all subsequent commands. If the scope value is "all",
+      # then the scope is unrestricted.
+      def process_command(scope_type, scope_value, command)
+        env_var = case scope_type
+            when "with" then "ROLES"
+            when "on"   then "HOSTS"
+          end
+
+        old_var, ENV[env_var] = ENV[env_var], (scope_value == "all" ? nil : scope_value) if env_var
+        if command
+          begin
+            exec(command)
+          ensure
+            ENV[env_var] = old_var if env_var
+          end
+        else
+          puts "scoping #{scope_type} #{scope_value}"
+        end
+      end
+
+      # All open sessions, needed to satisfy the Command::Processable include
+      def sessions
+        configuration.sessions.values
+      end
+    end
+end