net-ssh 1.1.4 → 2.0.0

data/lib/net/ssh/service/process/popen3.rb

@@ -1,178 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-require 'net/ssh/errors'
-
-module Net
-  module SSH
-    module Service
-      module Process
-      
-        # A delegate class for managing popen3 requests for remote processes.
-        class POpen3Manager
-
-          # Create a new POpen3Manager instance on the given connection.
-          def initialize( connection, log )
-            @connection = connection
-            @log = log
-          end
-
-          # Invokes the given command synchronously on the current connection.
-          # (This means that parallel commands and operations cannot be
-          # executed when this method is used.) This will return +nil+ if the
-          # method could not be executed. If the command is successfully
-          # invoked, and a block is given, the block is then invoked with the
-          # input, output, and error streams of the command as parameters, and
-          # the channel is closed as soon as the block terminates. If a block
-          # is not given, the input, output, and error channels are returned
-          # and the process *might* not terminate until the session itself
-          # terminates.
-          def popen3( command )
-            @connection.open_channel( "session" ) do |chan|
-
-              chan.on_success do |ch|
-                input  = SSHStdinPipe.new( ch )
-                output = SSHStdoutPipe.new( ch )
-                error  = SSHStderrPipe.new( ch )
-
-                if block_given?
-                  yield input, output, error
-                  chan.close
-                else
-                  return [ input, output, error ]
-                end
-              end
-
-              chan.on_failure do |ch|
-                chan.close
-              end
-
-              chan.exec command, true
-            end
-
-            @connection.loop
-            return nil
-          end
-
-          # A specialized class for use by the Net::SSH "popen3" service.
-          # An instance of this class represents a means of writing data to an
-          # SSH channel. This class should never be instantiated directly; use
-          # the popen3 method instead.
-          class SSHStdinPipe
-          
-            # The channel used by this pipe.
-            attr_reader :channel
-
-            # Create a new +stdin+ pipe on the given channel.
-            def initialize( channel )
-              @channel = channel
-            end
-
-            # Write the given data as channel data to the underlying channel.
-            def write( data )
-              @channel.send_data data
-              @channel.connection.process true
-            end
-
-            # Write the given data as channel data to the underlying channel,
-            # appending a newline character (if one isn't already appended).
-            def puts( data )
-              write data.chomp + "\n"
-            end
-
-          end
-
-          # An abstract class representing a writable stream on a channel. This
-          # is subclassed by SSHStdoutPipe and SSHStderrPipe.
-          class SSHOutputPipe
-            
-            # The channel used by this pipe.
-            attr_reader :channel
-            
-            # Create a new output pipe on the given channel.
-            def initialize( channel )
-              @channel = channel
-              @data = ""
-            end
-
-            # Returns true if there are any bytes available on this pipe. This
-            # will do a non-blocking read on the connection to determine if
-            # there
-            def data_available?
-              if @data.length == 0
-                connection = @channel.connection
-                connection.process while connection.reader_ready?
-              end
-              @data.length > 0
-            end
-
-            # Read all available bytes from the pipe. If there are no available
-            # bytes, then this will block until data becomes available.
-            def read
-              if @data.length < 1
-                @channel.connection.process while @data.length < 1
-              end
-
-              data, @data = @data, ""
-              return data
-            end
-
-          end
-
-          # A specialization of SSHOutputPipe that represents specifically the 
-          # +stdout+ stream of a process. It should only be used by popen3.
-          class SSHStdoutPipe < SSHOutputPipe
-
-            # Create a new +stdout+ stream on the given channel. Only one such
-            # pipe should ever be associated with a channel.
-            def initialize( channel )
-              super( channel )
-              channel.on_data(&method(:do_data))
-            end
-
-            # Invoked when data is recieved from the channel. It simply
-            # accumulates all data until a +read+ is invoked.
-            def do_data( channel, data )
-              @data << data
-            end
-
-          end
-
-          # A specialization of SSHOutputPipe that represents specifically the
-          # +stderr+ stream of a process. It should only be used by popen3.
-          class SSHStderrPipe < SSHOutputPipe
-
-            # Create a new +stderr+ stream on the given channel. Only one such
-            # pipe should ever be associated with a channel.
-            def initialize( channel )
-              super( channel )
-              channel.on_extended_data(&method(:do_data))
-            end
-
-            # Invoked when data is recieved from the channel. It simply
-            # accumulates all data until a +read+ is invoked.
-            def do_data( channel, type, data )
-              @data << data if type == 1
-            end
-
-          end
-
-        end
-
-      end # module Process
-    end # module Service
-  end # module SSH
-end # module Net

data/lib/net/ssh/service/process/services.rb

@@ -1,66 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-module Net
-  module SSH
-    module Service
-      module Process
-
-        # Register all services pertaining to the management of remote
-        # processes.
-        def register_services( container )
-
-          # All process management services are registered in their own
-          # namespace.
-          container.namespace_define :process do |ns|
-
-            # The :open_manager service returns a proc object that can be used
-            # to create new OpenManager instances for a given command.
-            ns.open_manager do |c,p|
-              require 'net/ssh/service/process/open'
-              connection = c[:connection][:driver]
-              log = c[:log_for, p]
-              lambda { |cmd| OpenManager.new( connection, log, cmd ) }
-            end
-
-            # The :popen3_manager service returns a new POpen3Manager instance
-            # for managing the execution of commands with a popen3-type
-            # interface.
-            ns.popen3_manager do |c,p|
-              require 'net/ssh/service/process/popen3'
-              connection = c[:connection][:driver]
-              log = c[:log_for, p]
-              POpen3Manager.new( connection, log )
-            end
-
-            # The :driver controls access to all remote process management
-            # services.
-            ns.driver do |c,p|
-              require 'net/ssh/service/process/driver'
-              Driver.new( c[:connection][:driver],
-                          c[:log_for, p],
-                          :open => c[:open_manager],
-                          :popen3 => c[:popen3_manager] )
-            end
-
-          end
-        end
-        module_function :register_services
-
-      end
-    end
-  end
-end

data/lib/net/ssh/service/services.rb

@@ -1,60 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-require 'net/ssh'
-
-module Net
-  module SSH
-    module Service
-
-      # Register all standard SSH services.
-      def register_services( container )
-
-        # Define the hash that will be used to record the registered services.
-        # If the hash already exists, don't redefine it.
-        unless container.knows_key?( :services )
-          container.define.services { Hash.new }
-        end
-
-        # Register the services in their own namespace.
-        container.namespace_define :service do |ns|
-          ns.require "net/ssh/service/forward/services", "#{self}::Forward"
-          ns.require "net/ssh/service/process/services", "#{self}::Process"
-          ns.require "net/ssh/service/shell/services", "#{self}::Shell"
-          ns.require "net/ssh/service/agentforward/services", "#{self}::AgentForward"
-        end
-
-        # Add the services to the services hash.
-        container.services[ :forward ] = container.service.forward.driver
-        container.services[ :process ] = container.service.process.driver
-        container.services[ :shell ] = container.service.shell.driver
-        container.services[ :agentforward ] = container.service.agentforward.driver
-
-        # Register the external services and add them to the collection of
-        # known services.
-        EXTERNAL_SERVICES.each do |name, block|
-          container.service.register( name,
-            :model => :singleton_deferred,
-            &block )
-          container.services[ name ] = container.service[ name ]
-        end
-
-      end
-      module_function :register_services
-
-    end
-  end
-end

data/lib/net/ssh/service/shell/driver.rb

@@ -1,86 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-module Net
-  module SSH
-    module Service
-      module Shell
-
-        # The service driver for the Shell service. It manages the creation of
-        # new Shell::Shell and Shell::SyncShell subservices.
-        #
-        # Usage:
-        #
-        #   Net::SSH.start( host ) do |session|
-        #     shell = session.shell.open
-        #
-        #     shell.cd "/home/foo"
-        #     shell.mkdir "-p some/long/dir"
-        #     shell.cd "some/long/dir"
-        #     shell.touch "foo.txt"
-        #     shell.exit
-        #
-        #     session.loop
-        #   end
-        #
-        # Or:
-        #
-        #   Net::SSH.start( host ) do |session|
-        #     shell = session.shell.sync
-        #
-        #     shell.cd "/home/foo"
-        #
-        #     out = shell.test "-e some/file.txt"
-        #     if out.status == 0
-        #       out = shell.cat "some/file.txt"
-        #       puts out.stdout
-        #     else
-        #       puts "no such file 'some/file.txt'"
-        #     end
-        #
-        #   end
-        class Driver
-
-          # Create a new driver with the given logger and shell and
-          # sync factories.
-          def initialize( log, shell_factory, sync_factory )
-            @log = log
-            @shell_factory = shell_factory
-            @sync_factory = sync_factory
-          end
-
-          # Open a new shell, using the Shell::Shell subservice and
-          # the given options.
-          def open( options={} )
-            pty_opts = options[:pty]
-
-            @shell_factory.call( pty_opts )
-          end
-          
-          # Open a new shell, using the Shell::SyncShell subservice and
-          # the given options.
-          def sync( options={} )
-            pty_opts = options[:pty]
-
-            @sync_factory.call( pty_opts )
-          end
-          
-        end
-
-      end # Shell
-    end # Service
-  end # SSH
-end # Net

data/lib/net/ssh/service/shell/services.rb

@@ -1,54 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-module Net
-  module SSH
-    module Service
-      module Shell
-
-        def register_services( container )
-
-          container.namespace_define :shell do |ns|
-
-            ns.shell do |c,p|
-              require 'net/ssh/service/shell/shell'
-              connection = c[:connection][:driver]
-              log = c[:log_for, p]
-              lambda { |pty| Shell.new( connection, log, pty ) }
-            end
-
-            ns.sync do |c,p|
-              require 'net/ssh/service/shell/sync'
-              connection = c[:connection][:driver]
-              log = c[:log_for, p]
-              shell = c[:shell]
-              lambda { |pty| SyncShell.new( shell, log, pty ) }
-            end
-
-            ns.driver do |c,p|
-              require 'net/ssh/service/shell/driver'
-              Driver.new( c[:log_for, p], c[:shell], c[:sync] )
-            end
-
-          end
-
-        end
-        module_function :register_services
-
-      end
-    end
-  end
-end

data/lib/net/ssh/service/shell/shell.rb

@@ -1,222 +0,0 @@
-#--
-# =============================================================================
-# Copyright (c) 2004,2005 Jamis Buck (jamis@37signals.com)
-# All rights reserved.
-#
-# This source file is distributed as part of the Net::SSH Secure Shell Client
-# library for Ruby. This file (and the library as a whole) may be used only as
-# allowed by either the BSD license, or the Ruby license (or, by association
-# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
-# distribution for the texts of these licenses.
-# -----------------------------------------------------------------------------
-# net-ssh website : http://net-ssh.rubyforge.org
-# project website: http://rubyforge.org/projects/net-ssh
-# =============================================================================
-#++
-
-require 'stringio'
-require 'net/ssh/errors'
-
-module Net
-  module SSH
-    module Service
-      module Shell
-
-        class OpenFailed < Net::SSH::Exception; end
-
-        # A service class for interacting with a user's shell on a remote
-        # machine. The shell may be interacted with either with or without a
-        # pty.
-        class Shell
-
-          # Create a new shell over the given connection. The +pty_opts+
-          # parameter must be either a Hash of the allowed values for the
-          # Net::SSH::Connection::Channel#request_pty method, or a boolean
-          # value (indicating whether a pty should be allocated or not). This
-          # will block until the shell is open and ready to receive input.
-          def initialize( connection, log, pty_opts )
-            @connection = connection
-            @log = log
-
-            @pty_opts = pty_opts
-
-            @stdout = ""
-            @stderr = ""
-
-            @state = :opening
-            @connection.open_channel( "session", &method( :on_confirm ) )
-
-            @connection.loop { @state != :open && @state != :closed }
-            raise "could not open shell" if @state != :open
-          end
-
-          # Returns +true+ if the shell is open.
-          def open?
-            @state == :open
-          end
-
-          # Return the stdout output (if any) that the shell has generated
-          # since the last time this method was invoked.
-          def stdout
-            string, @stdout = @stdout, ""
-            string
-          end
-
-          # Returns +true+ if there is any data from the shell on stdout,
-          # consuming input on the connection in a non-blocking manner to make
-          # sure that any available data is considered.
-          def stdout?
-            exists = @stdout.length > 0
-            unless exists
-              consume_connection
-              exists = @stdout.length > 0
-            end
-            exists
-          end
-
-          # Return the stderr output (if any) that the shell has generated
-          # since the last time this method was invoked.
-          def stderr
-            string, @stderr = @stderr, ""
-            string
-          end
-
-          # Returns +true+ if there is any data from the shell on stderr,
-          # consuming input on the connection in a non-blocking manner to make
-          # sure that any available data is considered.
-          def stderr?
-            exists = @stderr.length > 0
-            unless exists
-              consume_connection
-              exists = @stderr.length > 0
-            end
-            exists
-          end
-
-          # Sends the given data to the shell on the shell's stdin stream.
-          def send_data( data )
-            raise "channel not open" unless @state == :open
-            @channel.send_data data
-          end
-
-          # Sends the given data to the shell on the stream indicated by the
-          # +type+ parameter.
-          def send_extended_data( type, data )
-            raise "channel not open" unless @state == :open
-            @channel.send_extended_data type, data
-          end
-
-          # Reinterprets method invocations as requests to send data to the
-          # shell. The method name and the arguments are concatenated together
-          # with spaces and a newline appended. The resulting string is sent
-          # to the shell via #send_data.
-          def method_missing( sym, *args )
-            cmd = sym.to_s
-            cmd << " " << args.join( " " ) unless args.empty?
-            send_data cmd + "\n"
-          end
-
-          undef_method :exit
-
-          private
-
-            # Consumes all available input on the connection.
-            def consume_connection
-              return unless @channel
-              connection = @channel.connection
-              connection.process while connection.reader_ready?
-            end
-
-            # Invoked when the channel has been confirmed.
-            def on_confirm( channel )
-              @channel = channel
-
-              @channel.on_confirm_failed( &method( :on_confirm_failed ) )
-              @channel.on_close( &method( :on_close ) )
-              @channel.on_data( &method( :on_data ) )
-              @channel.on_eof( &method( :on_eof ) )
-              @channel.on_extended_data( &method( :on_extended_data ) )
-              @channel.on_request( &method( :on_request ) )
-              @channel.on_failure( &method( :on_failure ) )
-              @channel.on_success( &method( :on_success ) )
-
-              @pty_opts ? request_pty : request_shell
-            end
-
-            # Request a pty from the server for this channel, using the
-            # parameters given when the service was started.
-            def request_pty
-              @state = :pty
-              pty_opts = { :want_reply=>true }
-              pty_opts = @pty_opts.merge( pty_opts ) if @pty_opts.is_a?( Hash )
-              @channel.request_pty pty_opts
-            end
-
-            # Request that the user's shell be started on this channel. All
-            # subsequent input to the channel is interpreted as input to the
-            # shell.
-            def request_shell
-              @state = :shell
-              @channel.send_request "shell", nil, true
-            end
-
-            # Called when the channel could not be opened for some reason.
-            def on_confirm_failed( channel, reason, description, *args )
-              raise OpenFailed, "#{reason} (#{description})"
-            end
-
-            # Invoked when the channel closes. Changes the shell's state to
-            # closed.
-            def on_close( channel )
-              @state = :closed
-            end
-
-            # Invoked when data is received over the channel. It is written
-            # to the stdout stream.
-            def on_data( channel, data )
-              @stdout << data if @state == :open
-            end
-
-            # Invoked when the channel receives an eof notification. (Not
-            # currently used.)
-            def on_eof( channel )
-            end
-
-            # Invoked when extended data (stderr) is recieved. If type == 1,
-            # this data is written to the stderr stream; otherwise, it is
-            # ignored.
-            def on_extended_data( channel, type, data )
-              @stderr << data if @state == :open && type == 1
-            end
-
-            # Invoked when a request is received over the channel. (Not
-            # currently used.)
-            def on_request( channel, request, want_reply, data )
-            end
-
-            # Invoked when a request fails. Currently, this is only used in
-            # response to the pty or shell request, and will close the shell
-            # in reponse.
-            def on_failure( channel )
-              if @state == :pty || @state == :shell
-                @state = :closed
-              end
-            end
-
-            # Invoked when a request succeeds. Currently used only to manage
-            # the state machine and make sure that the shell gets opened after
-            # a successful pty request.
-            def on_success( channel )
-              if @state == :pty
-                request_shell
-              elsif @state == :shell
-                @state = :open
-              end
-            end
-
-        end
-
-      end # Shell
-    end # Service
-  end # SSH
-end # Net