depengine 0.0.31 → 3.0.0

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/protocol/06/attributes.rb

@@ -1,107 +0,0 @@
-require 'net/sftp/protocol/04/attributes'
-
-module Net; module SFTP; module Protocol; module V06
-
-  # A class representing the attributes of a file or directory on the server.
-  # It may be used to specify new attributes, or to query existing attributes.
-  # This particular class is specific to versions 6 and higher of the SFTP
-  # protocol.
-  #
-  # To specify new attributes, just pass a hash as the argument to the
-  # constructor. The following keys are supported:
-  #
-  # * :type:: the type of the item (integer, one of the T_ constants)
-  # * :size:: the size of the item (integer)
-  # * :allocation_size:: the actual number of bytes that the item uses on disk (integer)
-  # * :uid:: the user-id that owns the file (integer)
-  # * :gid:: the group-id that owns the file (integer)
-  # * :owner:: the name of the user that owns the file (string)
-  # * :group:: the name of the group that owns the file (string)
-  # * :permissions:: the permissions on the file (integer, e.g. 0755)
-  # * :atime:: the access time of the file (integer, seconds since epoch)
-  # * :atime_nseconds:: the nanosecond component of atime (integer)
-  # * :createtime:: the time at which the file was created (integer, seconds since epoch)
-  # * :createtime_nseconds:: the nanosecond component of createtime (integer)
-  # * :mtime:: the modification time of the file (integer, seconds since epoch)
-  # * :mtime_nseconds:: the nanosecond component of mtime (integer)
-  # * :ctime:: the time that the file's attributes were last changed (integer)
-  # * :ctime_nseconds:: the nanosecond component of ctime (integer)
-  # * :acl:: an array of ACL entries for the item
-  # * :attrib_bits:: other attributes of the file or directory (as a bit field) (integer)
-  # * :attrib_bits_valid:: a mask describing which bits in attrib_bits are valid (integer)
-  # * :text_hint:: whether the file may or may not contain textual data (integer)
-  # * :mime_type:: the mime type of the file (string)
-  # * :link_count:: the hard link count of the file (integer)
-  # * :untranslated_name:: the value of the filename before filename translation was attempted (string)
-  # * :extended:: a hash of name/value pairs identifying extended info
-  #
-  # Likewise, when the server sends an Attributes object, all of the
-  # above attributes are exposed as methods (though not all will be set with
-  # non-nil values from the server).
-  class Attributes < V04::Attributes
-    F_BITS              = 0x00000200
-    F_ALLOCATION_SIZE   = 0x00000400
-    F_TEXT_HINT         = 0x00000800
-    F_MIME_TYPE         = 0x00001000
-    F_LINK_COUNT        = 0x00002000
-    F_UNTRANSLATED_NAME = 0x00004000
-    F_CTIME             = 0x00008000
-
-    # The array of elements that describe this structure, in order. Used when
-    # parsing and serializing attribute objects.
-    def self.elements #:nodoc:
-      @elements ||= [
-        [:type,                :byte,    0],
-        [:size,                :int64,   F_SIZE],
-        [:allocation_size,     :int64,   F_ALLOCATION_SIZE],
-        [:owner,               :string,  F_OWNERGROUP],
-        [:group,               :string,  F_OWNERGROUP],
-        [:permissions,         :long,    F_PERMISSIONS],
-        [:atime,               :int64,   F_ACCESSTIME],
-        [:atime_nseconds,      :long,    F_ACCESSTIME | F_SUBSECOND_TIMES],
-        [:createtime,          :int64,   F_CREATETIME],
-        [:createtime_nseconds, :long,    F_CREATETIME | F_SUBSECOND_TIMES],
-        [:mtime,               :int64,   F_MODIFYTIME],
-        [:mtime_nseconds,      :long,    F_MODIFYTIME | F_SUBSECOND_TIMES],
-        [:ctime,               :int64,   F_CTIME],
-        [:ctime_nseconds,      :long,    F_CTIME | F_SUBSECOND_TIMES],
-        [:acl,                 :special, F_ACL],
-        [:attrib_bits,         :long,    F_BITS],
-        [:attrib_bits_valid,   :long,    F_BITS],
-        [:text_hint,           :byte,    F_TEXT_HINT],
-        [:mime_type,           :string,  F_MIME_TYPE],
-        [:link_count,          :long,    F_LINK_COUNT],
-        [:untranslated_name,   :string,  F_UNTRANSLATED_NAME],
-        [:extended,            :special, F_EXTENDED]
-      ]
-    end
-
-    # The size on-disk of the file
-    attr_accessor :allocation_size
-
-    # The time at which the file's attributes were last changed
-    attr_accessor :ctime
-
-    # The nanosecond component of #ctime
-    attr_accessor :ctime_nseconds
-
-    # Other attributes of this file or directory (as a bit field)
-    attr_accessor :attrib_bits
-
-    # A bit mask describing which bits in #attrib_bits are valid
-    attr_accessor :attrib_bits_valid
-
-    # Describes whether the file may or may not contain textual data
-    attr_accessor :text_hint
-
-    # The mime-type of the file
-    attr_accessor :mime_type
-
-    # The hard link count for the file
-    attr_accessor :link_count
-
-    # The value of the file name before filename translation was attempted
-    attr_accessor :untranslated_name
-  end
-
-end; end; end; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/protocol/06/base.rb

@@ -1,63 +0,0 @@
-require 'net/sftp/protocol/05/base'
-require 'net/sftp/protocol/06/attributes'
-
-module Net; module SFTP; module Protocol; module V06
-
-  # Wraps the low-level SFTP calls for version 6 of the SFTP protocol.
-  #
-  # None of these protocol methods block--all of them return immediately,
-  # requiring the SSH event loop to be run while the server response is
-  # pending.
-  #
-  # You will almost certainly never need to use this driver directly. Please
-  # see Net::SFTP::Session for the recommended interface.
-  class Base < V05::Base
-
-    # Returns the protocol version implemented by this driver. (6, in this
-    # case)
-    def version
-      6
-    end
-
-    # Sends a FXP_LINK packet to the server to request that a link be created
-    # at +new_link_path+, pointing to +existing_path+. If +symlink+ is true, a
-    # symbolic link will be created; otherwise a hard link will be created.
-    def link(new_link_path, existing_path, symlink)
-      send_request(FXP_LINK, :string, new_link_path, :string, existing_path, :bool, symlink)
-    end
-
-    # Provided for backwards compatibility; v6 of the SFTP protocol removes the
-    # older FXP_SYMLINK packet type, so this method simply calls the #link
-    # method.
-    def symlink(path, target)
-      link(path, target, true)
-    end
-
-    # Sends a FXP_BLOCK packet to the server to request that a byte-range lock
-    # be obtained on the given +handle+, for the given byte +offset+ and
-    # +length+. The +mask+ parameter is a bitfield indicating what kind of
-    # lock to acquire, and must be a combination of one or more of the
-    # Net::SFTP::Constants::LockTypes constants.
-    def block(handle, offset, length, mask)
-      send_request(FXP_BLOCK, :string, handle, :int64, offset, :int64, length, :long, mask)
-    end
-
-    # Sends a FXP_UNBLOCK packet to the server to request that a previously
-    # acquired byte-range lock be released on the given +handle+, for the
-    # given byte +offset+ and +length+. The +handle+, +offset+, and +length+
-    # must all exactly match the parameters that were given when the lock was
-    # originally acquired (see #block).
-    def unblock(handle, offset, length)
-      send_request(FXP_UNBLOCK, :string, handle, :int64, offset, :int64, length)
-    end
-
-    protected
-
-      # Returns the Attributes class used by this version of the protocol
-      # (Net::SFTP::Protocol::V06::Attributes, in this case)
-      def attribute_factory
-        V06::Attributes
-      end
-  end
-
-end; end; end; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/protocol/base.rb

@@ -1,50 +0,0 @@
-require 'net/ssh/loggable'
-require 'net/sftp/constants'
-
-module Net; module SFTP; module Protocol
-
-  # The abstract superclass of the specific implementations for each supported
-  # SFTP protocol version. It implements general packet parsing logic, and
-  # provides a way for subclasses to send requests.
-  class Base
-    include Net::SSH::Loggable
-    include Net::SFTP::Constants
-    include Net::SFTP::Constants::PacketTypes
-
-    # The SFTP session object that acts as client to this protocol instance
-    attr_reader :session
-
-    # Create a new instance of a protocol driver, servicing the given session.
-    def initialize(session)
-      @session = session
-      self.logger = session.logger
-      @request_id_counter = -1
-    end
-
-    # Attept to parse the given packet. If the packet is of an unsupported
-    # type, an exception will be raised. Returns the parsed data as a hash
-    # (the keys in the hash are packet-type specific).
-    def parse(packet)
-      case packet.type
-      when FXP_STATUS then parse_status_packet(packet)
-      when FXP_HANDLE then parse_handle_packet(packet)
-      when FXP_DATA   then parse_data_packet(packet)
-      when FXP_NAME   then parse_name_packet(packet)
-      when FXP_ATTRS  then parse_attrs_packet(packet)
-      else raise NotImplementedError, "unknown packet type: #{packet.type}"
-      end
-    end
-
-    private
-
-      # Send a new packet of the given type, and with the given data arguments.
-      # A new request identifier will be allocated to this request, and will
-      # be returned.
-      def send_request(type, *args)
-        @request_id_counter += 1
-        session.send_packet(type, :long, @request_id_counter, *args)
-        return @request_id_counter
-      end
-  end
-
-end; end; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/request.rb

@@ -1,91 +0,0 @@
-require 'net/sftp/constants'
-require 'net/sftp/response'
-
-module Net; module SFTP
-
-  # Encapsulates a single active SFTP request. This is instantiated
-  # automatically by the Net::SFTP::Session class when an operation is
-  # executed.
-  #
-  #   request = sftp.open("/path/to/file")
-  #   puts request.pending? #-> true
-  #   request.wait
-  #   puts request.pending? #-> false
-  #   result = request.response
-  class Request
-    include Constants::PacketTypes
-
-    # The Net::SFTP session object that is servicing this request
-    attr_reader :session
-
-    # The SFTP packet identifier for this request
-    attr_reader :id
-
-    # The type of this request (e.g., :open, :symlink, etc.)
-    attr_reader :type
-
-    # The callback (if any) associated with this request. When the response
-    # is recieved for this request, the callback will be invoked.
-    attr_reader :callback
-
-    # The hash of properties associated with this request. Properties allow
-    # programmers to associate arbitrary data with a request, making state
-    # machines richer.
-    attr_reader :properties
-
-    # The response that was received for this request (see Net::SFTP::Response)
-    attr_reader :response
-
-    # Instantiate a new Request object, serviced by the given +session+, and
-    # being of the given +type+. The +id+ is the packet identifier for this
-    # request.
-    def initialize(session, type, id, &callback) #:nodoc:
-      @session, @id, @type, @callback = session, id, type, callback
-      @response = nil
-      @properties = {}
-    end
-
-    # Returns the value of property with the given +key+. If +key+ is not a
-    # symbol, it will be converted to a symbol before lookup.
-    def [](key)
-      properties[key.to_sym]
-    end
-
-    # Sets the value of the property with name +key+ to +value+. If +key+ is
-    # not a symbol, it will be converted to a symbol before lookup.
-    def []=(key, value)
-      properties[key.to_sym] = value
-    end
-
-    # Returns +true+ if the request is still waiting for a response from the
-    # server, and +false+ otherwise. The SSH event loop must be run in order
-    # for a request to be processed; see #wait.
-    def pending?
-      session.pending_requests.key?(id)
-    end
-
-    # Waits (blocks) until the server responds to this packet. If prior
-    # SFTP packets were also pending, they will be processed as well (since
-    # SFTP packets are processed in the order in which they are received by
-    # the server). Returns the request object itself.
-    def wait
-      session.loop { pending? }
-      self
-    end
-
-    public # but not "published". Internal use only
-
-      # When the server responds to this request, the packet is passed to
-      # this method, which parses the packet and builds a Net::SFTP::Response
-      # object to encapsulate it. If a #callback has been provided for this
-      # request, the callback is invoked with the new response object.
-      def respond_to(packet) #:nodoc:
-        data = session.protocol.parse(packet)
-        data[:type] = packet.type
-        @response = Response.new(self, data)
-
-        callback.call(@response) if callback
-      end
-  end
-
-end; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/response.rb

@@ -1,76 +0,0 @@
-require 'net/sftp/constants'
-
-module Net; module SFTP
-
-  # Encapsulates a response from the remote server, to a specific client
-  # request. Response objects are passed as parameters to callbacks when you
-  # are performing asynchronous operations; when you call Net::SFTP::Request#wait,
-  # you can get the corresponding response object via Net::SFTP::Request#response.
-  #
-  #   sftp.open("/path/to/file") do |response|
-  #     p response.ok?
-  #     p response[:handle]
-  #   end
-  #
-  #   sftp.loop
-  class Response
-    include Net::SFTP::Constants::StatusCodes
-
-    # The request object that this object is in response to
-    attr_reader :request
-
-    # A hash of request-specific data, such as a file handle or attribute information
-    attr_reader :data
-
-    # The numeric code, one of the FX_* constants
-    attr_reader :code
-
-    # The textual message for this response (possibly blank)
-    attr_reader :message
-
-    # Create a new Response object for the given Net::SFTP::Request instance,
-    # and with the given data. If there is no :code key in the data, the
-    # code is assumed to be FX_OK.
-    def initialize(request, data={}) #:nodoc:
-      @request, @data = request, data
-      @code, @message = data[:code] || FX_OK, data[:message]
-    end
-
-    # Retrieve the data item with the given +key+. The key is converted to a
-    # symbol before being used to lookup the value.
-    def [](key)
-      data[key.to_sym]
-    end
-
-    # Returns a textual description of this response, including the status
-    # code and name.
-    def to_s
-      if message && !message.empty? && message.downcase != MAP[code]
-        "#{message} (#{MAP[code]}, #{code})"
-      else
-        "#{MAP[code]} (#{code})"
-      end
-    end
-
-    alias :to_str :to_s
-
-    # Returns +true+ if the status code is FX_OK; +false+ otherwise.
-    def ok?
-      code == FX_OK
-    end
-
-    # Returns +true+ if the status code is FX_EOF; +false+ otherwise.
-    def eof?
-      code == FX_EOF
-    end
-
-    #--
-    MAP = constants.inject({}) do |memo, name|
-      next memo unless name =~ /^FX_(.*)/
-      memo[const_get(name)] = $1.downcase.tr("_", " ")
-      memo
-    end
-    #++
-  end
-
-end; end

data/etc/isolate/jruby-1.8/gems/net-sftp-2.0.4/lib/net/sftp/session.rb

@@ -1,951 +0,0 @@
-require 'net/ssh'
-require 'net/sftp/constants'
-require 'net/sftp/errors'
-require 'net/sftp/protocol'
-require 'net/sftp/request'
-require 'net/sftp/operations/dir'
-require 'net/sftp/operations/upload'
-require 'net/sftp/operations/download'
-require 'net/sftp/operations/file_factory'
-
-module Net; module SFTP
-
-  # The Session class encapsulates a single SFTP channel on a Net::SSH
-  # connection. Instances of this class are what most applications will
-  # interact with most, as it provides access to both low-level (mkdir,
-  # rename, remove, symlink, etc.) and high-level (upload, download, etc.)
-  # SFTP operations.
-  #
-  # Although Session makes it easy to do SFTP operations serially, you can
-  # also set up multiple operations to be done in parallel, too, without
-  # needing to resort to threading. You merely need to fire off the requests,
-  # and then run the event loop until all of the requests have completed:
-  #
-  #   handle1 = sftp.open!("/path/to/file1")
-  #   handle2 = sftp.open!("/path/to/file2")
-  #
-  #   r1 = sftp.read(handle1, 0, 1024)
-  #   r2 = sftp.read(handle2, 0, 1024)
-  #   sftp.loop { [r1, r2].any? { |r| r.pending? } }
-  #
-  #   puts "chunk #1: #{r1.response[:data]}"
-  #   puts "chunk #2: #{r2.response[:data]}"
-  #
-  # By passing blocks to the operations, you can set up powerful state
-  # machines, to fire off subsequent operations. In fact, the Net::SFTP::Operations::Upload
-  # and Net::SFTP::Operations::Download classes set up such state machines, so that
-  # multiple uploads and/or downloads can be running simultaneously.
-  #
-  # The convention with the names of the operations is as follows: if the method
-  # name ends with an exclamation mark, like #read!, it will be synchronous
-  # (e.g., it will block until the server responds). Methods without an
-  # exclamation mark (e.g. #read) are asynchronous, and return before the
-  # server has responded. You will need to make sure the SSH event loop is
-  # run in order to process these requests. (See #loop.)
-  class Session
-    include Net::SSH::Loggable
-    include Net::SFTP::Constants::PacketTypes
-
-    # The highest protocol version supported by the Net::SFTP library.
-    HIGHEST_PROTOCOL_VERSION_SUPPORTED = 6
-
-    # A reference to the Net::SSH session object that powers this SFTP session.
-    attr_reader :session
-
-    # The Net::SSH::Connection::Channel object that the SFTP session is being
-    # processed by.
-    attr_reader :channel
-
-    # The state of the SFTP connection. It will be :opening, :subsystem, :init,
-    # :open, or :closed.
-    attr_reader :state
-
-    # The protocol instance being used by this SFTP session. Useful for
-    # querying the protocol version in effect.
-    attr_reader :protocol
-
-    # The hash of pending requests. Any requests that have been sent and which
-    # the server has not yet responded to will be represented here.
-    attr_reader :pending_requests
-
-    # Creates a new Net::SFTP instance atop the given Net::SSH connection.
-    # This will return immediately, before the SFTP connection has been properly
-    # initialized. Once the connection is ready, the given block will be called.
-    # If you want to block until the connection has been initialized, try this:
-    #
-    #   sftp = Net::SFTP::Session.new(ssh)
-    #   sftp.loop { sftp.opening? }
-    def initialize(session, &block)
-      @session    = session
-      @input      = Net::SSH::Buffer.new
-      self.logger = session.logger
-      @state      = :closed
-
-      connect(&block)
-    end
-
-    public # high-level SFTP operations
-
-      # Initiates an upload from +local+ to +remote+, asynchronously. This
-      # method will return a new Net::SFTP::Operations::Upload instance, and requires
-      # the event loop to be run in order for the upload to progress. See
-      # Net::SFTP::Operations::Upload for a full discussion of how this method can be
-      # used.
-      #
-      #   uploader = sftp.upload("/local/path", "/remote/path")
-      #   uploader.wait
-      def upload(local, remote, options={}, &block)
-        Operations::Upload.new(self, local, remote, options, &block)
-      end
-
-      # Identical to #upload, but blocks until the upload is complete.
-      def upload!(local, remote, options={}, &block)
-        upload(local, remote, options, &block).wait
-      end
-
-      # Initiates a download from +remote+ to +local+, asynchronously. This
-      # method will return a new Net::SFTP::Operations::Download instance, and requires
-      # that the event loop be run in order for the download to progress. See
-      # Net::SFTP::Operations::Download for a full discussion of hos this method can be
-      # used.
-      #
-      #   download = sftp.download("/remote/path", "/local/path")
-      #   download.wait
-      def download(remote, local, options={}, &block)
-        Operations::Download.new(self, local, remote, options, &block)
-      end
-
-      # Identical to #download, but blocks until the download is complete.
-      # If +local+ is omitted, downloads the file to an in-memory buffer
-      # and returns the result as a string; otherwise, returns the
-      # Net::SFTP::Operations::Download instance.
-      def download!(remote, local=nil, options={}, &block)
-        destination = local || StringIO.new
-        result = download(remote, destination, options, &block).wait
-        local ? result : destination.string
-      end
-
-      # Returns an Net::SFTP::Operations::FileFactory instance, which can be used to
-      # mimic synchronous, IO-like file operations on a remote file via
-      # SFTP.
-      #
-      #   sftp.file.open("/path/to/file") do |file|
-      #     while line = file.gets
-      #       puts line
-      #     end
-      #   end
-      #
-      # See Net::SFTP::Operations::FileFactory and Net::SFTP::Operations::File for more details.
-      def file
-        @file ||= Operations::FileFactory.new(self)
-      end
-
-      # Returns a Net::SFTP::Operations::Dir instance, which can be used to
-      # conveniently iterate over and search directories on the remote server.
-      #
-      #  sftp.dir.glob("/base/path", "*/**/*.rb") do |entry|
-      #    p entry.name
-      #  end
-      #
-      # See Net::SFTP::Operations::Dir for a more detailed discussion of how
-      # to use this.
-      def dir
-        @dir ||= Operations::Dir.new(self)
-      end
-
-    public # low-level SFTP operations
-
-      # :call-seq:
-      #   open(path, flags="r", options={}) -> request
-      #   open(path, flags="r", options={}) { |response| ... } -> request
-      #
-      # Opens a file on the remote server. The +flags+ parameter determines
-      # how the flag is open, and accepts the same format as IO#open (e.g.,
-      # either a string like "r" or "w", or a combination of the IO constants).
-      # The +options+ parameter is a hash of attributes to be associated
-      # with the file, and varies greatly depending on the SFTP protocol
-      # version in use, but some (like :permissions) are always available.
-      #
-      # Returns immediately with a Request object. If a block is given, it will
-      # be invoked when the server responds, with a Response object as the only
-      # parameter. The :handle property of the response is the handle of the
-      # opened file, and may be passed to other methods (like #close, #read,
-      # #write, and so forth).
-      #
-      #   sftp.open("/path/to/file") do |response|
-      #     raise "fail!" unless response.ok?
-      #     sftp.close(response[:handle])
-      #   end
-      #   sftp.loop
-      def open(path, flags="r", options={}, &callback)
-        request :open, path, flags, options, &callback
-      end
-
-      # Identical to #open, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the handle of the newly opened file.
-      #
-      #   handle = sftp.open!("/path/to/file")
-      def open!(path, flags="r", options={}, &callback)
-        wait_for(open(path, flags, options, &callback), :handle)
-      end
-
-      # :call-seq:
-      #   close(handle) -> request
-      #   close(handle) { |response| ... } -> request
-      #
-      # Closes an open handle, whether obtained via #open, or #opendir. Returns
-      # immediately with a Request object. If a block is given, it will be
-      # invoked when the server responds.
-      #
-      #   sftp.open("/path/to/file") do |response|
-      #     raise "fail!" unless response.ok?
-      #     sftp.close(response[:handle])
-      #   end
-      #   sftp.loop
-      def close(handle, &callback)
-        request :close, handle, &callback
-      end
-
-      # Identical to #close, but blocks until the server responds. It will
-      # raise a StatusException if the request was unsuccessful. Otherwise,
-      # it returns the Response object for this request.
-      #
-      #   sftp.close!(handle)
-      def close!(handle, &callback)
-        wait_for(close(handle, &callback))
-      end
-
-      # :call-seq:
-      #   read(handle, offset, length) -> request
-      #   read(handle, offset, length) { |response| ... } -> request
-      #
-      # Requests that +length+ bytes, starting at +offset+ bytes from the
-      # beginning of the file, be read from the file identified by
-      # +handle+. (The +handle+ should be a value obtained via the #open
-      # method.)  Returns immediately with a Request object. If a block is
-      # given, it will be invoked when the server responds.
-      #
-      # The :data property of the response will contain the requested data,
-      # assuming the call was successful.
-      #
-      #   request = sftp.read(handle, 0, 1024) do |response|
-      #     if response.eof?
-      #       puts "end of file reached before reading any data"
-      #     elsif !response.ok?
-      #       puts "error (#{response})"
-      #     else
-      #       print(response[:data])
-      #     end
-      #   end
-      #   request.wait
-      #
-      # To read an entire file will usually require multiple calls to #read,
-      # unless you know in advance how large the file is.
-      def read(handle, offset, length, &callback)
-        request :read, handle, offset, length, &callback
-      end
-
-      # Identical to #read, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. If the end of the file
-      # was reached, +nil+ will be returned. Otherwise, it returns the data that
-      # was read, as a String.
-      #
-      #   data = sftp.read!(handle, 0, 1024)
-      def read!(handle, offset, length, &callback)
-        wait_for(read(handle, offset, length, &callback), :data)
-      end
-
-      # :call-seq:
-      #   write(handle, offset, data) -> request
-      #   write(handle, offset, data) { |response| ... } -> request
-      #
-      # Requests that +data+ be written to the file identified by +handle+,
-      # starting at +offset+ bytes from the start of the file. The file must
-      # have been opened for writing via #open. Returns immediately with a
-      # Request object. If a block is given, it will be invoked when the
-      # server responds.
-      #
-      #   request = sftp.write(handle, 0, "hello, world!\n")
-      #   request.wait
-      def write(handle, offset, data, &callback)
-        request :write, handle, offset, data, &callback
-      end
-
-      # Identical to #write, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful, or the end of the file
-      # was reached. Otherwise, it returns the Response object for this request.
-      #
-      #   sftp.write!(handle, 0, "hello, world!\n")
-      def write!(handle, offset, data, &callback)
-        wait_for(write(handle, offset, data, &callback))
-      end
-
-      # :call-seq:
-      #   lstat(path, flags=nil) -> request
-      #   lstat(path, flags=nil) { |response| ... } -> request
-      #
-      # This method is identical to the #stat method, with the exception that
-      # it will not follow symbolic links (thus allowing you to stat the
-      # link itself, rather than what it refers to). The +flags+ parameter
-      # is not used in SFTP protocol versions prior to 4, and will be ignored
-      # in those versions of the protocol that do not use it. For those that
-      # do, however, you may provide hints as to which file proprties you wish
-      # to query (e.g., if all you want is permissions, you could pass the
-      # Net::SFTP::Protocol::V04::Attributes::F_PERMISSIONS flag as the value
-      # for the +flags+ parameter).
-      #
-      # The method returns immediately with a Request object. If a block is given,
-      # it will be invoked when the server responds. The :attrs property of
-      # the response will contain an Attributes instance appropriate for the
-      # the protocol version (see Protocol::V01::Attributes, Protocol::V04::Attributes,
-      # and Protocol::V06::Attributes).
-      #
-      #   request = sftp.lstat("/path/to/file") do |response|
-      #     raise "fail!" unless response.ok?
-      #     puts "permissions: %04o" % response[:attrs].permissions
-      #   end
-      #   request.wait
-      def lstat(path, flags=nil, &callback)
-        request :lstat, path, flags, &callback
-      end
-
-      # Identical to the #lstat method, but blocks until the server responds.
-      # It will raise a StatusException if the request was unsuccessful.
-      # Otherwise, it will return the attribute object describing the path.
-      #
-      #   puts sftp.lstat!("/path/to/file").permissions
-      def lstat!(path, flags=nil, &callback)
-        wait_for(lstat(path, flags, &callback), :attrs)
-      end
-
-      # The fstat method is identical to the #stat and #lstat methods, with
-      # the exception that it takes a +handle+ as the first parameter, such
-      # as would be obtained via the #open or #opendir methods. (See the #lstat
-      # method for full documentation).
-      def fstat(handle, flags=nil, &callback)
-        request :fstat, handle, flags, &callback
-      end
-
-      # Identical to the #fstat method, but blocks until the server responds.
-      # It will raise a StatusException if the request was unsuccessful.
-      # Otherwise, it will return the attribute object describing the path.
-      #
-      #   puts sftp.fstat!(handle).permissions
-      def fstat!(handle, flags=nil, &callback)
-        wait_for(fstat(handle, flags, &callback), :attrs)
-      end
-
-      # :call-seq:
-      #    setstat(path, attrs) -> request
-      #    setstat(path, attrs) { |response| ... } -> request
-      #
-      # This method may be used to set file metadata (such as permissions, or
-      # user/group information) on a remote file. The exact metadata that may
-      # be tweaked is dependent on the SFTP protocol version in use, but in
-      # general you may set at least the permissions, user, and group. (See
-      # Protocol::V01::Attributes, Protocol::V04::Attributes, and Protocol::V06::Attributes
-      # for the full lists of attributes that may be set for the different
-      # protocols.)
-      #
-      # The +attrs+ parameter is a hash, where the keys are symbols identifying
-      # the attributes to set.
-      #
-      # The method returns immediately with a Request object. If a block is given,
-      # it will be invoked when the server responds.
-      #
-      #   request = sftp.setstat("/path/to/file", :permissions => 0644)
-      #   request.wait
-      #   puts "success: #{request.response.ok?}"
-      def setstat(path, attrs, &callback)
-        request :setstat, path, attrs, &callback
-      end
-
-      # Identical to the #setstat method, but blocks until the server responds.
-      # It will raise a StatusException if the request was unsuccessful.
-      # Otherwise, it will return the Response object for the request.
-      #
-      #   sftp.setstat!("/path/to/file", :permissions => 0644)
-      def setstat!(path, attrs, &callback)
-        wait_for(setstat(path, attrs, &callback))
-      end
-
-      # The fsetstat method is identical to the #setstat method, with the
-      # exception that it takes a +handle+ as the first parameter, such as
-      # would be obtained via the #open or #opendir methods. (See the
-      # #setstat method for full documentation.)
-      def fsetstat(handle, attrs, &callback)
-        request :fsetstat, handle, attrs, &callback
-      end
-
-      # Identical to the #fsetstat method, but blocks until the server responds.
-      # It will raise a StatusException if the request was unsuccessful.
-      # Otherwise, it will return the Response object for the request.
-      #
-      #   sftp.fsetstat!(handle, :permissions => 0644)
-      def fsetstat!(handle, attrs, &callback)
-        wait_for(fsetstat(handle, attrs, &callback))
-      end
-
-      # :call-seq:
-      #   opendir(path) -> request
-      #   opendir(path) { |response| ... } -> request
-      #
-      # Attempts to open a directory on the remote host for reading. Once the
-      # handle is obtained, directory entries may be retrieved using the
-      # #readdir method. The method returns immediately with a Request object.
-      # If a block is given, it will be invoked when the server responds.
-      #
-      #   sftp.opendir("/path/to/directory") do |response|
-      #     raise "fail!" unless response.ok?
-      #     sftp.close(response[:handle])
-      #   end
-      #   sftp.loop
-      def opendir(path, &callback)
-        request :opendir, path, &callback
-      end
-
-      # Identical to #opendir, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return a handle to the given path.
-      #
-      #   handle = sftp.opendir!("/path/to/directory")
-      def opendir!(path, &callback)
-        wait_for(opendir(path, &callback), :handle)
-      end
-
-      # :call-seq:
-      #   readdir(handle) -> request
-      #   raeddir(handle) { |response| ... } -> request
-      #
-      # Reads a set of entries from the given directory handle (which must
-      # have been obtained via #opendir). If the response is EOF, then there
-      # are no more entries in the directory. Otherwise, the entries will be
-      # in the :names property of the response:
-      #
-      #   loop do
-      #     request = sftp.readdir(handle).wait
-      #     break if request.response.eof?
-      #     raise "fail!" unless request.response.ok?
-      #     request.response[:names].each do |entry|
-      #        puts entry.name
-      #     end
-      #   end
-      #
-      # See also Protocol::V01::Name and Protocol::V04::Name for the specific
-      # properties of each individual entry (which vary based on the SFTP
-      # protocol version in use).
-      def readdir(handle, &callback)
-        request :readdir, handle, &callback
-      end
-
-      # Identical to #readdir, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return nil if there were no more names to read, or an array of name
-      # entries.
-      #
-      #   while (entries = sftp.readdir!(handle)) do
-      #     entries.each { |entry| puts(entry.name) }
-      #   end
-      def readdir!(handle, &callback)
-        wait_for(readdir(handle, &callback), :names)
-      end
-
-      # :call-seq:
-      #   remove(filename) -> request
-      #   remove(filename) { |response| ... } -> request
-      #
-      # Attempts to remove the given file from the remote file system. Returns
-      # immediately with a Request object. If a block is given, the block will
-      # be invoked when the server responds, and will be passed a Response
-      # object.
-      #
-      #   sftp.remove("/path/to/file").wait
-      def remove(filename, &callback)
-        request :remove, filename, &callback
-      end
-
-      # Identical to #remove, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      #
-      #   sftp.remove!("/path/to/file")
-      def remove!(filename, &callback)
-        wait_for(remove(filename, &callback))
-      end
-
-      # :call-seq:
-      #   mkdir(path, attrs={}) -> request
-      #   mkdir(path, attrs={}) { |response| ... } -> request
-      #
-      # Creates the named directory on the remote server. If an attribute hash
-      # is given, it must map to the set of attributes supported by the version
-      # of the SFTP protocol in use. (See Protocol::V01::Attributes,
-      # Protocol::V04::Attributes, and Protocol::V06::Attributes.)
-      #
-      #   sftp.mkdir("/path/to/directory", :permissions => 0550).wait
-      def mkdir(path, attrs={}, &callback)
-        request :mkdir, path, attrs, &callback
-      end
-
-      # Identical to #mkdir, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      #
-      #   sftp.mkdir!("/path/to/directory", :permissions => 0550)
-      def mkdir!(path, attrs={}, &callback)
-        wait_for(mkdir(path, attrs, &callback))
-      end
-
-      # :call-seq:
-      #   rmdir(path) -> request
-      #   rmdir(path) { |response| ... } -> request
-      #
-      # Removes the named directory on the remote server. The directory must
-      # be empty before it can be removed.
-      #
-      #   sftp.rmdir("/path/to/directory").wait
-      def rmdir(path, &callback)
-        request :rmdir, path, &callback
-      end
-
-      # Identical to #rmdir, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      #
-      #   sftp.rmdir!("/path/to/directory")
-      def rmdir!(path, &callback)
-        wait_for(rmdir(path, &callback))
-      end
-
-      # :call-seq:
-      #   realpath(path) -> request
-      #   realpath(path) { |response| ... } -> request
-      #
-      # Tries to canonicalize the given path, turning any given path into an
-      # absolute path. This is primarily useful for converting a path with
-      # ".." or "." segments into an identical path without those segments.
-      # The answer will be in the response's :names attribute, as a
-      # one-element array.
-      #
-      #   request = sftp.realpath("/path/../to/../directory").wait
-      #   puts request[:names].first.name
-      def realpath(path, &callback)
-        request :realpath, path, &callback
-      end
-
-      # Identical to #realpath, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return a name object identifying the path.
-      #
-      #   puts(sftp.realpath!("/path/../to/../directory"))
-      def realpath!(path, &callback)
-        wait_for(realpath(path, &callback), :names).first
-      end
-
-      # Identical to the #lstat method, except that it follows symlinks
-      # (e.g., if you give it the path to a symlink, it will stat the target
-      # of the symlink rather than the symlink itself). See the #lstat method
-      # for full documentation.
-      def stat(path, flags=nil, &callback)
-        request :stat, path, flags, &callback
-      end
-
-      # Identical to #stat, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return an attribute object for the named path.
-      #
-      #   attrs = sftp.stat!("/path/to/file")
-      def stat!(path, flags=nil, &callback)
-        wait_for(stat(path, flags, &callback), :attrs)
-      end
-
-      # :call-seq:
-      #   rename(name, new_name, flags=nil) -> request
-      #   rename(name, new_name, flags=nil) { |response| ... } -> request
-      #
-      # Renames the given file. This operation is only available in SFTP
-      # protocol versions two and higher. The +flags+ parameter is ignored
-      # in versions prior to 5. In versions 5 and higher, the +flags+
-      # parameter can be used to specify how the rename should be performed
-      # (atomically, etc.).
-      #
-      # The following flags are defined in protocol version 5:
-      #
-      # * 0x0001 - overwrite an existing file if the new name specifies a file
-      #   that already exists.
-      # * 0x0002 - perform the rewrite atomically.
-      # * 0x0004 - allow the server to perform the rename as it prefers.
-      def rename(name, new_name, flags=nil, &callback)
-        request :rename, name, new_name, flags, &callback
-      end
-
-      # Identical to #rename, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      #
-      #   sftp.rename!("/path/to/old", "/path/to/new")
-      def rename!(name, new_name, flags=nil, &callback)
-        wait_for(rename(name, new_name, flags, &callback))
-      end
-
-      # :call-seq:
-      #   readlink(path) -> request
-      #   readlink(path) { |response| ... } -> request
-      #
-      # Queries the server for the target of the specified symbolic link.
-      # This operation is only available in protocol versions 3 and higher.
-      # The response to this request will include a names property, a one-element
-      # array naming the target of the symlink.
-      #
-      #   request = sftp.readlink("/path/to/symlink").wait
-      #   puts request.response[:names].first.name
-      def readlink(path, &callback)
-        request :readlink, path, &callback
-      end
-
-      # Identical to #readlink, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Name object for the path that the symlink targets.
-      #
-      #   item = sftp.readlink!("/path/to/symlink")
-      def readlink!(path, &callback)
-        wait_for(readlink(path, &callback), :names).first
-      end
-
-      # :call-seq:
-      #   symlink(path, target) -> request
-      #   symlink(path, target) { |response| ... } -> request
-      #
-      # Attempts to create a symlink to +path+ at +target+. This operation
-      # is only available in protocol versions 3, 4, and 5, but the Net::SFTP
-      # library mimics the symlink behavior in protocol version 6 using the
-      # #link method, so it is safe to use this method in protocol version 6.
-      #
-      #   sftp.symlink("/path/to/file", "/path/to/symlink").wait
-      def symlink(path, target, &callback)
-        request :symlink, path, target, &callback
-      end
-
-      # Identical to #symlink, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      #
-      #   sftp.symlink!("/path/to/file", "/path/to/symlink")
-      def symlink!(path, target, &callback)
-        wait_for(symlink(path, target, &callback))
-      end
-
-      # :call-seq:
-      #   link(new_link_path, existing_path, symlink=true) -> request
-      #   link(new_link_path, existing_path, symlink=true) { |response| ... } -> request
-      #
-      # Attempts to create a link, either hard or symbolic. This operation is
-      # only available in SFTP protocol versions 6 and higher. If the +symlink+
-      # paramter is true, a symbolic link will be created, otherwise a hard
-      # link will be created. The link will be named +new_link_path+, and will
-      # point to the path +existing_path+.
-      #
-      #   sftp.link("/path/to/symlink", "/path/to/file", true).wait
-      #
-      # Note that #link is only available for SFTP protocol 6 and higher. You
-      # can use #symlink for protocols 3 and higher.
-      def link(new_link_path, existing_path, symlink=true, &callback)
-        request :link, new_link_path, existing_path, symlink, &callback
-      end
-
-      # Identical to #link, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      #
-      #   sftp.link!("/path/to/symlink", "/path/to/file", true)
-      def link!(new_link_path, existing_path, symlink=true, &callback)
-        wait_for(link(new_link_path, existing_path, symlink, &callback))
-      end
-
-      # :call-seq:
-      #   block(handle, offset, length, mask) -> request
-      #   block(handle, offset, length, mask) { |response| ... } -> request
-      #
-      # Creates a byte-range lock on the file specified by the given +handle+.
-      # This operation is only available in SFTP protocol versions 6 and
-      # higher. The lock may be either mandatory or advisory.
-      #
-      # The +handle+ parameter is a file handle, as obtained by the #open method.
-      #
-      # The +offset+ and +length+ parameters describe the location and size of
-      # the byte range.
-      #
-      # The +mask+ describes how the lock should be defined, and consists of
-      # some combination of the following bit masks:
-      #
-      # * 0x0040 - Read lock. The byte range may not be accessed for reading
-      #   by via any other handle, though it may be written to.
-      # * 0x0080 - Write lock. The byte range may not be written to via any
-      #   other handle, though it may be read from.
-      # * 0x0100 - Delete lock. No other handle may delete this file.
-      # * 0x0200 - Advisory lock. The server need not honor the lock instruction.
-      #
-      # Once created, the lock may be removed via the #unblock method.
-      def block(handle, offset, length, mask, &callback)
-        request :block, handle, offset, length, mask, &callback
-      end
-
-      # Identical to #block, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      def block!(handle, offset, length, mask, &callback)
-        wait_for(block(handle, offset, length, mask, &callback))
-      end
-
-      # :call-seq:
-      #   unblock(handle, offset, length) -> request
-      #   unblock(handle, offset, length) { |response| ... } -> request
-      #
-      # Removes a previously created byte-range lock. This operation is only
-      # available in protocol versions 6 and higher. The +offset+ and +length+
-      # parameters must exactly match those that were given to #block when the
-      # lock was acquired.
-      def unblock(handle, offset, length, &callback)
-        request :unblock, handle, offset, length, &callback
-      end
-
-      # Identical to #unblock, but blocks until the server responds. It will raise
-      # a StatusException if the request was unsuccessful. Otherwise, it will
-      # return the Response object for the request.
-      def unblock!(handle, offset, length, &callback)
-        wait_for(unblock(handle, offset, length, &callback))
-      end
-
-    public # miscellaneous methods
-
-      # Closes the SFTP connection, but not the SSH connection. Blocks until the
-      # session has terminated. Once the session has terminated, further operations
-      # on this object will result in errors. You can reopen the SFTP session
-      # via the #connect method.
-      def close_channel
-        return unless open?
-        channel.close
-        loop { !closed? }
-      end
-
-      # Returns true if the connection has been initialized.
-      def open?
-        state == :open
-      end
-
-      # Returns true if the connection has been closed.
-      def closed?
-        state == :closed
-      end
-
-      # Returns true if the connection is in the process of being initialized
-      # (e.g., it is not closed, but is not yet fully open).
-      def opening?
-        !(open? || closed?)
-      end
-
-      # Attempts to establish an SFTP connection over the SSH session given when
-      # this object was instantiated. If the object is already open, this will
-      # simply execute the given block (if any), passing the SFTP session itself
-      # as argument. If the session is currently being opened, this will add
-      # the given block to the list of callbacks, to be executed when the session
-      # is fully open.
-      #
-      # This method does not block, and will return immediately. If you pass a
-      # block to it, that block will be invoked when the connection has been
-      # fully established. Thus, you can do something like this:
-      #
-      #   sftp.connect do
-      #     puts "open!"
-      #   end
-      #
-      # If you just want to block until the connection is ready, see the #connect!
-      # method.
-      def connect(&block)
-        case state
-        when :open
-          block.call(self) if block
-        when :closed
-          @state = :opening
-          @channel = session.open_channel(&method(:when_channel_confirmed))
-          @packet_length = nil
-          @protocol = nil
-          @on_ready = Array(block)
-        else # opening
-          @on_ready << block if block
-        end
-
-        self
-      end
-
-      # Same as the #connect method, but blocks until the SFTP connection has
-      # been fully initialized.
-      def connect!(&block)
-        connect(&block)
-        loop { opening? }
-        self
-      end
-
-      alias :loop_forever :loop
-
-      # Runs the SSH event loop while the given block returns true. This lets
-      # you set up a state machine and then "fire it off". If you do not specify
-      # a block, the event loop will run for as long as there are any pending
-      # SFTP requests. This makes it easy to do thing like this:
-      #
-      #   sftp.remove("/path/to/file")
-      #   sftp.loop
-      def loop(&block)
-        block ||= Proc.new { pending_requests.any? }
-        session.loop(&block)
-      end
-
-      # Formats, constructs, and sends an SFTP packet of the given type and with
-      # the given data. This does not block, but merely enqueues the packet for
-      # sending and returns.
-      #
-      # You should probably use the operation methods, rather than building and
-      # sending the packet directly. (See #open, #close, etc.)
-      def send_packet(type, *args)
-        data = Net::SSH::Buffer.from(*args)
-        msg = Net::SSH::Buffer.from(:long, data.length+1, :byte, type, :raw, data)
-        channel.send_data(msg.to_s)
-      end
-
-    private
-
-      #--
-      # "ruby -w" hates private attributes, so we have to do this longhand
-      #++
-
-      # The input buffer used to accumulate packet data
-      def input; @input; end
-
-      # Create and enqueue a new SFTP request of the given type, with the
-      # given arguments. Returns a new Request instance that encapsulates the
-      # request.
-      def request(type, *args, &callback)
-        request = Request.new(self, type, protocol.send(type, *args), &callback)
-        info { "sending #{type} packet (#{request.id})" }
-        pending_requests[request.id] = request
-      end
-
-      # Waits for the given request to complete. If the response is
-      # EOF, nil is returned. If the response was not successful
-      # (e.g., !response.ok?), a StatusException will be raised.
-      # If +property+ is given, the corresponding property from the response
-      # will be returned; otherwise, the response object itself will be
-      # returned.
-      def wait_for(request, property=nil)
-        request.wait
-        if request.response.eof?
-          nil
-        elsif !request.response.ok?
-          raise StatusException.new(request.response)
-        elsif property
-          request.response[property.to_sym]
-        else
-          request.response
-        end
-      end
-
-      # Called when the SSH channel is confirmed as "open" by the server.
-      # This is one of the states of the SFTP state machine, and is followed
-      # by the #when_subsystem_started state.
-      def when_channel_confirmed(channel)
-        debug { "requesting sftp subsystem" }
-        @state = :subsystem
-        channel.subsystem("sftp", &method(:when_subsystem_started))
-      end
-
-      # Called when the SSH server confirms that the SFTP subsystem was
-      # successfully started. This sets up the appropriate callbacks on the
-      # SSH channel and then starts the SFTP protocol version negotiation
-      # process.
-      def when_subsystem_started(channel, success)
-        raise Net::SFTP::Exception, "could not start SFTP subsystem" unless success
-
-        debug { "sftp subsystem successfully started" }
-        @state = :init
-
-        channel.on_data { |c,data| input.append(data) }
-        channel.on_extended_data { |c,t,data| debug { data } }
-
-        channel.on_close(&method(:when_channel_closed))
-        channel.on_process(&method(:when_channel_polled))
-
-        send_packet(FXP_INIT, :long, HIGHEST_PROTOCOL_VERSION_SUPPORTED)
-      end
-
-      # Called when the SSH server closes the underlying channel.
-      def when_channel_closed(channel)
-        debug { "sftp channel closed" }
-        @channel = nil
-        @state = :closed
-      end
-
-      # Called whenever Net::SSH polls the SFTP channel for pending activity.
-      # This basically checks the input buffer to see if enough input has been
-      # accumulated to handle. If there has, the packet is parsed and
-      # dispatched, according to its type (see #do_version and #dispatch_request).
-      def when_channel_polled(channel)
-        while input.length > 0
-          if @packet_length.nil?
-            # make sure we've read enough data to tell how long the packet is
-            return unless input.length >= 4
-            @packet_length = input.read_long
-          end
-
-          return unless input.length >= @packet_length
-          packet = Net::SFTP::Packet.new(input.read(@packet_length))
-          input.consume!
-          @packet_length = nil
-
-          debug { "received sftp packet #{packet.type} len #{packet.length}" }
-
-          if packet.type == FXP_VERSION
-            do_version(packet)
-          else
-            dispatch_request(packet)
-          end
-        end
-      end
-
-      # Called to handle FXP_VERSION packets. This performs the SFTP protocol
-      # version negotiation, instantiating the appropriate Protocol instance
-      # and invoking the callback given to #connect, if any.
-      def do_version(packet)
-        debug { "negotiating sftp protocol version, mine is #{HIGHEST_PROTOCOL_VERSION_SUPPORTED}" }
-
-        server_version = packet.read_long
-        debug { "server reports sftp version #{server_version}" }
-
-        negotiated_version = [server_version, HIGHEST_PROTOCOL_VERSION_SUPPORTED].min
-        info { "negotiated version is #{negotiated_version}" }
-
-        extensions = {}
-        until packet.eof?
-          name = packet.read_string
-          data = packet.read_string
-          extensions[name] = data
-        end
-
-        @protocol = Protocol.load(self, negotiated_version)
-        @pending_requests = {}
-
-        @state = :open
-        @on_ready.each { |callback| callback.call(self) }
-        @on_ready = nil
-      end
-
-      # Parses the packet, finds the associated Request instance, and tells
-      # the Request instance to respond to the packet (see Request#respond_to).
-      def dispatch_request(packet)
-        id = packet.read_long
-        request = pending_requests.delete(id) or raise Net::SFTP::Exception, "no such request `#{id}'"
-        request.respond_to(packet)
-      end
-  end
-
-end; end