capistrano-edge 2.5.6

data/lib/capistrano/recipes/ext/rails-database-migrations.rb

@@ -0,0 +1,50 @@
+namespace :deploy do
+
+  desc <<-DESC
+    Run the migrate rake task. By default, it runs this in most recently \
+    deployed version of the app. However, you can specify a different release \
+    via the migrate_target variable, which must be one of :latest (for the \
+    default behavior), or :current (for the release indicated by the \
+    `current' symlink). Strings will work for those values instead of symbols, \
+    too. You can also specify additional environment variables to pass to rake \
+    via the migrate_env variable. Finally, you can specify the full path to the \
+    rake executable by setting the rake variable. The defaults are:
+
+      set :rake,           "rake"
+      set :rails_env,      "production"
+      set :migrate_env,    ""
+      set :migrate_target, :latest
+  DESC
+  task :migrate, :roles => :db, :only => { :primary => true } do
+    rake = fetch(:rake, "rake")
+    rails_env = fetch(:rails_env, "production")
+    migrate_env = fetch(:migrate_env, "")
+    migrate_target = fetch(:migrate_target, :latest)
+
+    directory = case migrate_target.to_sym
+      when :current then current_path
+      when :latest  then current_release
+      else raise ArgumentError, "unknown migration target #{migrate_target.inspect}"
+      end
+
+    run "cd #{directory}; #{rake} RAILS_ENV=#{rails_env} #{migrate_env} db:migrate"
+  end
+
+  desc <<-DESC
+    Deploy and run pending migrations. This will work similarly to the \
+    `deploy' task, but will also run any pending migrations (via the \
+    `deploy:migrate' task) prior to updating the symlink. Note that the \
+    update in this case it is not atomic, and transactions are not used, \
+    because migrations are not guaranteed to be reversible.
+  DESC
+  task :migrations do
+    set :migrate_target, :latest
+    update_code
+    migrate
+    symlink
+    restart
+  end
+  
+end
+
+after('deploy:update_code', 'deploy:migrate')

data/lib/capistrano/recipes/ext/web-disable-enable.rb

@@ -0,0 +1,40 @@
+namespace :web do
+  desc <<-DESC
+    Present a maintenance page to visitors. Disables your application's web \
+    interface by writing a "maintenance.html" file to each web server. The \
+    servers must be configured to detect the presence of this file, and if \
+    it is present, always display it instead of performing the request.
+
+    By default, the maintenance page will just say the site is down for \
+    "maintenance", and will be back "shortly", but you can customize the \
+    page by specifying the REASON and UNTIL environment variables:
+
+      $ cap deploy:web:disable \\
+            REASON="hardware upgrade" \\
+            UNTIL="12pm Central Time"
+
+    Further customization will require that you write your own task.
+  DESC
+  task :disable, :roles => :web, :except => { :no_release => true } do
+    require 'erb'
+    on_rollback { run "rm #{shared_path}/system/maintenance.html" }
+
+    reason = ENV['REASON']
+    deadline = ENV['UNTIL']
+
+    template = File.read(File.join(File.dirname(__FILE__), "templates", "maintenance.rhtml"))
+    result = ERB.new(template).result(binding)
+
+    put result, "#{shared_path}/system/maintenance.html", :mode => 0644
+  end
+
+  desc <<-DESC
+    Makes the application web-accessible again. Removes the \
+    "maintenance.html" page generated by deploy:web:disable, which (if your \
+    web servers are configured correctly) will make your application \
+    web-accessible again.
+  DESC
+  task :enable, :roles => :web, :except => { :no_release => true } do
+    run "rm #{shared_path}/system/maintenance.html"
+  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/recipes/upgrade.rb

@@ -0,0 +1,33 @@
+# Tasks to aid the migration of an established Capistrano 1.x installation to
+# Capistrano 2.x.
+
+namespace :upgrade do
+  desc <<-DESC
+    Migrate from the revisions log to REVISION. Capistrano 1.x recorded each \
+    deployment to a revisions.log file. Capistrano 2.x is cleaner, and just \
+    puts a REVISION file in the root of the deployed revision. This task \
+    migrates from the revisions.log used in Capistrano 1.x, to the REVISION \
+    tag file used in Capistrano 2.x. It is non-destructive and may be safely \
+    run any number of times.
+  DESC
+  task :revisions, :except => { :no_release => true } do
+    revisions = capture("cat #{deploy_to}/revisions.log")
+
+    mapping = {}
+    revisions.each do |line|
+      revision, directory = line.chomp.split[-2,2]
+      mapping[directory] = revision
+    end
+
+    commands = mapping.keys.map do |directory|
+      "echo '.'; test -d #{directory} && echo '#{mapping[directory]}' > #{directory}/REVISION"
+    end
+
+    command = commands.join(";")
+
+    run "cd #{releases_path}; #{command}; true" do |ch, stream, out|
+      STDOUT.print(".")
+      STDOUT.flush
+    end
+  end
+end

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,260 @@
+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 /^(?:(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(/\bsudo\b/, "sudo -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
+
+        @mutex = Mutex.new
+        @bgthread = Thread.new do
+          loop do
+            @mutex.synchronize { process_iteration(0.1) }
+          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
+    end
+
+    # All open sessions, needed to satisfy the Command::Processable include
+    def sessions
+      configuration.sessions.values
+    end
+end