capistrano 2.1.0 → 3.0.0

data/lib/capistrano/shell.rb

@@ -1,256 +0,0 @@
-require 'thread'
-
-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
-    # 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)
-        if command[0] == ?!
-          exec_tasks(command[1..-1].split)
-        else
-          servers = connect(configuration.current_task)
-          exec_command(command, servers)
-        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] }
-        cmd = Command.new(command, sessions, :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
-              ready = configuration.sessions.values.select { |sess| sess.connection.reader_ready? }
-              if ready.empty?
-                sleep 0.1
-              else
-                @mutex.synchronize do
-                  ready.each { |session| session.connection.process(true) }
-                end
-              end
-            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
-            @mutex.synchronize { exec(command) }
-          ensure
-            ENV[env_var] = old_var if env_var
-          end
-        else
-          puts "scoping #{scope_type} #{scope_value}"
-        end
-      end
-    end
-end

data/lib/capistrano/ssh.rb

@@ -1,109 +0,0 @@
-require 'net/ssh'
-
-module Capistrano
-  unless ENV['SKIP_VERSION_CHECK']
-    require 'capistrano/version'
-    require 'net/ssh/version'
-    ssh_version = [Net::SSH::Version::MAJOR, Net::SSH::Version::MINOR, Net::SSH::Version::TINY]
-    if !Version.check(Version::SSH_REQUIRED, ssh_version)
-      raise "You have Net::SSH #{ssh_version.join(".")}, but you need at least #{Version::SSH_REQUIRED.join(".")}"
-    end
-  end
-
-  # Now, Net::SSH is kind of silly, and tries to lazy-load everything. This
-  # wreaks havoc with the parallel connection trick that Capistrano wants to
-  # use, so we're going to do something hideously ugly here and force all the
-  # files that Net::SSH uses to load RIGHT NOW, rather than lazily.
-
-  net_ssh_dependencies = %w(connection/services connection/channel connection/driver
-    service/agentforward/services service/agentforward/driver
-    service/process/driver util/prompter
-    service/forward/services service/forward/driver service/forward/local-network-handler service/forward/remote-network-handler
-    service/shell/services service/shell/driver
-    lenient-host-key-verifier
-    transport/compress/services transport/compress/zlib-compressor transport/compress/none-compressor transport/compress/zlib-decompressor transport/compress/none-decompressor
-    transport/kex/services transport/kex/dh transport/kex/dh-gex
-    transport/ossl/services
-    transport/ossl/hmac/services transport/ossl/hmac/sha1 transport/ossl/hmac/sha1-96 transport/ossl/hmac/md5 transport/ossl/hmac/md5-96 transport/ossl/hmac/none
-    transport/ossl/cipher-factory transport/ossl/hmac-factory transport/ossl/buffer-factory transport/ossl/key-factory transport/ossl/digest-factory
-    transport/identity-cipher transport/packet-stream transport/version-negotiator transport/algorithm-negotiator transport/session
-    userauth/methods/services userauth/methods/password userauth/methods/keyboard-interactive userauth/methods/publickey userauth/methods/hostbased
-    userauth/services userauth/agent userauth/userkeys userauth/driver
-    transport/services service/services
-  )
-
-  net_ssh_dependencies << "userauth/pageant" if File::ALT_SEPARATOR
-  net_ssh_dependencies.each do |path|
-    begin
-      require "net/ssh/#{path}"
-    rescue LoadError
-      # Ignore load errors from this, since some files are in the list which
-      # do not exist in different (supported) versions of Net::SSH. We know
-      # (by this point) that Net::SSH is installed, though, since we do a
-      # require 'net/ssh' at the very top of this file, and we know the
-      # installed version meets the minimum version requirements because of
-      # the version check, also at the top of this file. So, if we get a
-      # LoadError, it's simply because the file in question does not exist in
-      # the version of Net::SSH that is installed.
-      #
-      # Whew!
-    end
-  end
-
-  # A helper class for dealing with SSH connections.
-  class SSH
-    # Patch an accessor onto an SSH connection so that we can record the server
-    # definition object that defines the connection. This is useful because
-    # the gateway returns connections whose "host" is 127.0.0.1, instead of
-    # the host on the other side of the tunnel.
-    module Server #:nodoc:
-      def self.apply_to(connection, server)
-        connection.extend(Server)
-        connection.xserver = server
-        connection
-      end
-
-      attr_accessor :xserver
-    end
-
-    # The default port for SSH.
-    DEFAULT_PORT = 22
-
-    # An abstraction to make it possible to connect to the server via public key
-    # without prompting for the password. If the public key authentication fails
-    # this will fall back to password authentication.
-    #
-    # +server+ must be an instance of ServerDefinition.
-    #
-    # If a block is given, the new session is yielded to it, otherwise the new
-    # session is returned.
-    #
-    # If an :ssh_options key exists in +options+, it is passed to the Net::SSH
-    # constructor. Values in +options+ are then merged into it, and any
-    # connection information in +server+ is added last, so that +server+ info
-    # takes precedence over +options+, which takes precendence over ssh_options.
-    def self.connect(server, options={}, &block)
-      methods = [ %w(publickey hostbased), %w(password keyboard-interactive) ]
-      password_value = nil
-      
-      ssh_options = (options[:ssh_options] || {}).dup
-      ssh_options[:username] = server.user || options[:user] || ssh_options[:username]
-      ssh_options[:port]     = server.port || options[:port] || ssh_options[:port] || DEFAULT_PORT
-
-      begin
-        connection_options = ssh_options.merge(
-          :password => password_value,
-          :auth_methods => ssh_options[:auth_methods] || methods.shift
-        )
-
-        connection = Net::SSH.start(server.host, connection_options, &block)
-        Server.apply_to(connection, server)
-
-      rescue Net::SSH::AuthenticationFailed
-        raise if methods.empty? || ssh_options[:auth_methods]
-        password_value = options[:password]
-        retry
-      end
-    end
-  end
-end

data/lib/capistrano/task_definition.rb

@@ -1,69 +0,0 @@
-require 'capistrano/server_definition'
-
-module Capistrano
-  # Represents the definition of a single task.
-  class TaskDefinition
-    attr_reader :name, :namespace, :options, :body, :desc, :on_error
-
-    def initialize(name, namespace, options={}, &block)
-      @name, @namespace, @options = name, namespace, options
-      @desc = @options.delete(:desc)
-      @on_error = options.delete(:on_error)
-      @body = block or raise ArgumentError, "a task requires a block"
-      @servers = nil
-    end
-    
-    # Returns the task's fully-qualified name, including the namespace
-    def fully_qualified_name
-      @fully_qualified_name ||= begin
-        if namespace.default_task == self
-          namespace.fully_qualified_name
-        else
-          [namespace.fully_qualified_name, name].compact.join(":")
-        end
-      end
-    end
-
-    # Returns the description for this task, with newlines collapsed and
-    # whitespace stripped. Returns the empty string if there is no
-    # description for this task.
-    def description(rebuild=false)
-      @description = nil if rebuild
-      @description ||= begin
-        description = @desc || ""
-
-        indentation = description[/\A\s+/]
-        if indentation
-          reformatted_description = ""
-          description.strip.each_line do |line|
-            line = line.chomp.sub(/^#{indentation}/, "")
-            line = line.gsub(/#{indentation}\s*/, " ") if line[/^\S/]
-            reformatted_description << line << "\n"
-          end
-          description = reformatted_description
-        end
-
-        description.strip.gsub(/\r\n/, "\n")
-      end
-    end
-
-    # Returns the first sentence of the full description. If +max_length+ is
-    # given, the result will be truncated if it is longer than +max_length+,
-    # and an ellipsis appended.
-    def brief_description(max_length=nil)
-      brief = description[/^.*?\.(?=\s|$)/] || description
-
-      if max_length && brief.length > max_length
-        brief = brief[0,max_length-3] + "..."
-      end
-
-      brief
-    end
-
-    # Indicates whether the task wants to continue, even if a server has failed
-    # previously
-    def continue_on_error?
-      @on_error == :continue
-    end
-  end
-end

data/lib/capistrano/upload.rb

@@ -1,146 +0,0 @@
-require 'net/sftp'
-require 'net/sftp/operations/errors'
-require 'capistrano/errors'
-
-module Capistrano
-  unless ENV['SKIP_VERSION_CHECK']
-    require 'capistrano/version' 
-    require 'net/sftp/version'
-    sftp_version = [Net::SFTP::Version::MAJOR, Net::SFTP::Version::MINOR, Net::SFTP::Version::TINY]
-    required_version = [1,1,0]
-    if !Capistrano::Version.check(required_version, sftp_version)
-      raise "You have Net::SFTP #{sftp_version.join(".")}, but you need at least #{required_version.join(".")}. Net::SFTP will not be used."
-    end
-  end
-
-  # This class encapsulates a single file upload to be performed in parallel
-  # across multiple machines, using the SFTP protocol. Although it is intended
-  # to be used primarily from within Capistrano, it may also be used standalone
-  # if you need to simply upload a file to multiple servers.
-  #
-  # Basic Usage:
-  #
-  #   begin
-  #     uploader = Capistrano::Upload.new(sessions, "remote-file.txt",
-  #         :data => "the contents of the file to upload")
-  #     uploader.process!
-  #   rescue Capistrano::UploadError => e
-  #     warn "Could not upload the file: #{e.message}"
-  #   end
-  class Upload
-    def self.process(sessions, filename, options)
-      new(sessions, filename, options).process!
-    end
-  
-    attr_reader :sessions, :filename, :options
-    attr_reader :failed, :completed
-
-    # Creates and prepares a new Upload instance. The +sessions+ parameter
-    # must be an array of open Net::SSH sessions. The +filename+ is the name
-    # (including path) of the destination file on the remote server. The
-    # +options+ hash accepts the following keys (as symbols):
-    #
-    # * data: required. Should refer to a String containing the contents of
-    #   the file to upload.
-    # * mode: optional. The "mode" of the destination file. Defaults to 0660.
-    # * logger: optional. Should point to a Capistrano::Logger instance, if
-    #   given.
-    def initialize(sessions, filename, options)
-      raise ArgumentError, "you must specify the data to upload via the :data option" unless options[:data]
-
-      @sessions = sessions
-      @filename = filename
-      @options  = options
-
-      @completed = @failed = 0
-      @sftps = setup_sftp
-    end
-    
-    # Uploads to all specified servers in parallel. If any one of the servers
-    # fails, an exception will be raised (UploadError).
-    def process!
-      logger.debug "uploading #{filename}" if logger
-      while running?
-        @sftps.each do |sftp|
-          next if sftp.channel[:done]
-          begin
-            sftp.channel.connection.process(true)
-          rescue Net::SFTP::Operations::StatusException => error
-            logger.important "uploading failed: #{error.description}", sftp.channel[:server] if logger
-            failed!(sftp)
-          end
-        end
-        sleep 0.01 # a brief respite, to keep the CPU from going crazy
-      end
-      logger.trace "upload finished" if logger
-
-      if (failed = @sftps.select { |sftp| sftp.channel[:failed] }).any?
-        hosts = failed.map { |sftp| sftp.channel[:server] }
-        error = UploadError.new("upload of #{filename} failed on #{hosts.join(',')}")
-        error.hosts = hosts
-        raise error
-      end
-
-      self
-    end
-
-    private
-
-      def logger
-        options[:logger]
-      end
-
-      def setup_sftp
-        sessions.map do |session|
-          server = session.xserver
-          sftp = session.sftp
-          sftp.connect unless sftp.state == :open
-
-          sftp.channel[:server] = server
-          sftp.channel[:done] = false
-          sftp.channel[:failed] = false
-
-          real_filename = filename.gsub(/\$CAPISTRANO:HOST\$/, server.host)
-          sftp.open(real_filename, IO::WRONLY | IO::CREAT | IO::TRUNC, options[:mode] || 0664) do |status, handle|
-            break unless check_status(sftp, "open #{real_filename}", server, status)
-            
-            logger.info "uploading data to #{server}:#{real_filename}" if logger
-            sftp.write(handle, options[:data] || "") do |status|
-              break unless check_status(sftp, "write to #{server}:#{real_filename}", server, status)
-              sftp.close_handle(handle) do
-                logger.debug "done uploading data to #{server}:#{real_filename}" if logger
-                completed!(sftp)
-              end
-            end
-          end
-          
-          sftp
-        end
-      end
-      
-      def check_status(sftp, action, server, status)
-        return true if status.code == Net::SFTP::Session::FX_OK
-
-        logger.error "could not #{action} on #{server} (#{status.message})" if logger
-        failed!(sftp)
-
-        return false
-      end
-
-      def running?
-        completed < @sftps.length
-      end
-
-      def failed!(sftp)
-        completed!(sftp)
-        @failed += 1
-        sftp.channel[:failed] = true
-      end
-
-      def completed!(sftp)
-        @completed += 1
-        sftp.channel[:done] = true
-      end
-  end
-
-end