redcar 0.3.7.1 → 0.3.8

data/plugins/project/vendor/net-sftp/lib/net/sftp/protocol/01/name.rb

@@ -0,0 +1,43 @@
+module Net; module SFTP; module Protocol; module V01
+
+  # Represents a single named item on the remote server. This includes the
+  # name, attributes about the item, and the "longname", which is intended
+  # for use when displaying directory data, and has no specified format.
+  class Name
+    # The name of the item on the remote server.
+    attr_reader :name
+
+    # The display-ready name of the item, possibly with other attributes.
+    attr_reader :longname
+
+    # The Attributes object describing this item.
+    attr_reader :attributes
+
+    # Create a new Name object with the given name, longname, and attributes.
+    def initialize(name, longname, attributes)
+      @name, @longname, @attributes = name, longname, attributes
+    end
+
+    # Returns +true+ if the item appears to be a directory. It does this by
+    # examining the attributes. If there is insufficient information in the
+    # attributes, this will return nil, rather than a boolean.
+    def directory?
+      attributes.directory?
+    end
+
+    # Returns +true+ if the item appears to be a symlink. It does this by
+    # examining the attributes. If there is insufficient information in the
+    # attributes, this will return nil, rather than a boolean.
+    def symlink?
+      attributes.symlink?
+    end
+
+    # Returns +true+ if the item appears to be a regular file. It does this by
+    # examining the attributes. If there is insufficient information in the
+    # attributes, this will return nil, rather than a boolean.
+    def file?
+      attributes.file?
+    end
+  end
+
+end; end; end; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/protocol/02/base.rb

@@ -0,0 +1,31 @@
+require 'net/sftp/protocol/01/base'
+
+module Net; module SFTP; module Protocol; module V02
+
+  # Wraps the low-level SFTP calls for version 2 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 < V01::Base
+
+    # Returns the protocol version implemented by this driver. (2, in this
+    # case)
+    def version
+      2
+    end
+
+    # Sends a FXP_RENAME packet to the server to request that the file or
+    # directory with the given +name+ (must be a full path) be changed to
+    # +new_name+ (which must also be a path). The +flags+ parameter is
+    # ignored in this version of the protocol.
+    def rename(name, new_name, flags=nil)
+      send_request(FXP_RENAME, :string, name, :string, new_name)
+    end
+
+  end
+
+end; end; end; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/protocol/03/base.rb

@@ -0,0 +1,35 @@
+require 'net/sftp/protocol/02/base'
+
+module Net; module SFTP; module Protocol; module V03
+
+  # Wraps the low-level SFTP calls for version 3 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 < V02::Base
+
+    # Returns the protocol version implemented by this driver. (3, in this
+    # case)
+    def version
+      3
+    end
+
+    # Sends a FXP_READLINK packet to the server to request that the target of
+    # the given symlink on the remote host (+path+) be returned.
+    def readlink(path)
+      send_request(FXP_READLINK, :string, path)
+    end
+
+    # Sends a FXP_SYMLINK packet to the server to request that a symlink at the
+    # given +path+ be created, pointing at +target+..
+    def symlink(path, target)
+      send_request(FXP_SYMLINK, :string, path, :string, target)
+    end
+
+  end
+
+end; end; end; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/protocol/04/attributes.rb

@@ -0,0 +1,152 @@
+require 'net/sftp/protocol/01/attributes'
+
+module Net; module SFTP; module Protocol; module V04
+
+  # 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 4 and 5 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)
+  # * :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)
+  # * :acl:: an array of ACL entries for the item
+  # * :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 < V01::Attributes
+
+    F_ACCESSTIME        = 0x00000008
+    F_CREATETIME        = 0x00000010
+    F_MODIFYTIME        = 0x00000020
+    F_ACL               = 0x00000040
+    F_OWNERGROUP        = 0x00000080
+    F_SUBSECOND_TIMES   = 0x00000100
+    
+    # A simple struct for representing a single entry in an Access Control
+    # List. (See Net::SFTP::Constants::ACE)
+    ACL = Struct.new(:type, :flag, :mask, :who)
+
+    class <<self
+      # The list of supported elements in the attributes structure as defined
+      # by v4 of the sftp protocol.
+      def elements #:nodoc:
+        @elements ||= [
+          [:type,                :byte,    0],
+          [:size,                :int64,   V01::Attributes::F_SIZE],
+          [:owner,               :string,  F_OWNERGROUP],
+          [:group,               :string,  F_OWNERGROUP],
+          [:permissions,         :long,    V01::Attributes::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],
+          [:acl,                 :special, F_ACL],
+          [:extended,            :special, V01::Attributes::F_EXTENDED]
+        ]
+      end
+
+      private
+
+        # A helper method for parsing the ACL entry in an Attributes struct.
+        def parse_acl(buffer)
+          acl_buf = Net::SSH::Buffer.new(buffer.read_string)
+          acl = []
+          acl_buf.read_long.times do
+            acl << ACL.new(acl_buf.read_long, acl_buf.read_long, acl_buf.read_long, acl_buf.read_string)
+          end
+          acl
+        end
+    end
+
+    # The type of the item on the remote server. Must be one of the T_* constants.
+    attr_accessor :type
+
+    # The owner of the item on the remote server, as a string.
+    attr_writer   :owner
+
+    # The group of the item on the remote server, as a string.
+    attr_writer   :group
+
+    # The nanosecond component of the access time.
+    attr_accessor :atime_nseconds
+
+    # The creation time of the remote item, in seconds since the epoch.
+    attr_accessor :createtime
+
+    # The nanosecond component of the creation time.
+    attr_accessor :createtime_nseconds
+
+    # The nanosecond component of the modification time.
+    attr_accessor :mtime_nseconds
+
+    # The array of access control entries for this item.
+    attr_accessor :acl
+
+    # Create a new Attributes instance with the given attributes. The
+    # following keys are supported:
+    #
+    # * :type:: the type of the item (integer, one of the T_ constants)
+    # * :size:: the size of the item (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)
+    # * :acl:: an array of ACL entries for the item
+    # * :extended:: a hash of name/value pairs identifying extended info
+    #
+    # All of them default to +nil+ if omitted, except for +type+, which defaults
+    # to T_REGULAR.
+    def initialize(attributes={})
+      super
+      attributes[:type] ||= T_REGULAR
+    end
+
+    private
+
+      # Perform protocol-version-specific preparations for serialization.
+      def prepare_serialization!
+        # force the group/owner to be translated from uid/gid, if those keys
+        # were given on instantiation
+        owner
+        group
+      end
+
+      # Performs protocol-version-specific encoding of the access control
+      # list, if one exists.
+      def encode_acl(buffer)
+        acl_buf = Net::SSH::Buffer.from(:long, acl.length)
+        acl.each do |item|
+          acl_buf.write_long item.type, item.flag, item.mask
+          acl_buf.write_string item.who
+        end
+        buffer.write_string(acl_buf.to_s)
+      end
+
+  end
+
+end ; end ; end ; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/protocol/04/base.rb

@@ -0,0 +1,94 @@
+require 'net/sftp/protocol/03/base'
+require 'net/sftp/protocol/04/attributes'
+require 'net/sftp/protocol/04/name'
+
+module Net; module SFTP; module Protocol; module V04
+
+  # Wraps the low-level SFTP calls for version 4 of the SFTP protocol. Also
+  # implements the updated FXP_NAME packet parsing as mandated by v4 of the
+  # 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 < V03::Base
+
+    # Returns the protocol version implemented by this driver. (4, in this
+    # case)
+    def version
+      4
+    end
+
+    # As of v4 of the SFTP protocol, the "longname" member was removed from the
+    # FXP_NAME structure. This method is essentially the same as the previous
+    # implementation, but omits longname.
+    def parse_name_packet(packet)
+      names = []
+
+      packet.read_long.times do
+        filename = packet.read_string
+        attrs    = attribute_factory.from_buffer(packet)
+        names   << name_factory.new(filename, attrs)
+      end
+
+      { :names => names }
+    end
+
+    # Sends a FXP_STAT packet to the server for the given +path+, and with the
+    # given +flags+. If +flags+ is nil, it defaults to F_SIZE | F_PERMISSIONS |
+    # F_ACCESSTIME | F_CREATETIME | F_MODIFYTIME | F_ACL | F_OWNERGROUP |
+    # F_SUBSECOND_TIMES | F_EXTENDED (see Net::SFTP::Protocol::V04::Attributes
+    # for those constants).
+    def stat(path, flags=nil)
+      send_request(FXP_STAT, :string, path, :long, flags || DEFAULT_FLAGS)
+    end
+
+    # Sends a FXP_LSTAT packet to the server for the given +path+, and with the
+    # given +flags+. If +flags+ is nil, it defaults to F_SIZE | F_PERMISSIONS |
+    # F_ACCESSTIME | F_CREATETIME | F_MODIFYTIME | F_ACL | F_OWNERGROUP |
+    # F_SUBSECOND_TIMES | F_EXTENDED (see Net::SFTP::Protocol::V04::Attributes
+    # for those constants).
+    def lstat(path, flags=nil)
+      send_request(FXP_LSTAT, :string, path, :long, flags || DEFAULT_FLAGS)
+    end
+
+    # Sends a FXP_FSTAT packet to the server for the given +path+, and with the
+    # given +flags+. If +flags+ is nil, it defaults to F_SIZE | F_PERMISSIONS |
+    # F_ACCESSTIME | F_CREATETIME | F_MODIFYTIME | F_ACL | F_OWNERGROUP |
+    # F_SUBSECOND_TIMES | F_EXTENDED (see Net::SFTP::Protocol::V04::Attributes
+    # for those constants).
+    def fstat(handle, flags=nil)
+      send_request(FXP_FSTAT, :string, handle, :long, flags || DEFAULT_FLAGS)
+    end
+
+    protected
+
+      # The default flags used if the +flags+ parameter is nil for any of the
+      # #stat, #lstat, or #fstat operations.
+      DEFAULT_FLAGS = Attributes::F_SIZE |
+                      Attributes::F_PERMISSIONS |
+                      Attributes::F_ACCESSTIME |
+                      Attributes::F_CREATETIME |
+                      Attributes::F_MODIFYTIME |
+                      Attributes::F_ACL |
+                      Attributes::F_OWNERGROUP |
+                      Attributes::F_SUBSECOND_TIMES |
+                      Attributes::F_EXTENDED
+
+      # Returns the Attributes class used by this version of the protocol
+      # (Net::SFTP::Protocol::V04::Attributes, in this case)
+      def attribute_factory
+        V04::Attributes
+      end
+
+      # Returns the Name class used by this version of the protocol
+      # (Net::SFTP::Protocol::V04::Name, in this case)
+      def name_factory
+        V04::Name
+      end
+  end
+
+end; end; end; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/protocol/04/name.rb

@@ -0,0 +1,67 @@
+module Net; module SFTP; module Protocol; module V04
+
+  # Represents a single named item on the remote server. This includes the
+  # name, and attributes about the item, and the "longname".
+  #
+  # For backwards compatibility with the format and interface of the Name
+  # structure from previous protocol versions, this also exposes a #longname
+  # method, which returns a string that can be used to display this item in
+  # a directory listing.
+  class Name
+    # The name of the item on the remote server.
+    attr_reader :name
+
+    # Attributes instance describing this item.
+    attr_reader :attributes
+
+    # Create a new Name object with the given name and attributes.
+    def initialize(name, attributes)
+      @name, @attributes = name, attributes
+    end
+
+    # Returns +true+ if the item is a directory.
+    def directory?
+      attributes.directory?
+    end
+
+    # Returns +true+ if the item is a symlink.
+    def symlink?
+      attributes.symlink?
+    end
+
+    # Returns +true+ if the item is a regular file.
+    def file?
+      attributes.file?
+    end
+
+    # Returns a string representing this file, in a format similar to that
+    # used by the unix "ls" utility.
+    def longname
+      @longname ||= begin
+        longname = if directory?
+          "d"
+        elsif symlink?
+          "l"
+        else
+          "-"
+        end
+
+        longname << (attributes.permissions & 0400 != 0 ? "r" : "-")
+        longname << (attributes.permissions & 0200 != 0 ? "w" : "-")
+        longname << (attributes.permissions & 0100 != 0 ? "x" : "-")
+        longname << (attributes.permissions & 0040 != 0 ? "r" : "-")
+        longname << (attributes.permissions & 0020 != 0 ? "w" : "-")
+        longname << (attributes.permissions & 0010 != 0 ? "x" : "-")
+        longname << (attributes.permissions & 0004 != 0 ? "r" : "-")
+        longname << (attributes.permissions & 0002 != 0 ? "w" : "-")
+        longname << (attributes.permissions & 0001 != 0 ? "x" : "-")
+
+        longname << (" %-8s %-8s %8d " % [attributes.owner, attributes.group, attributes.size])
+
+        longname << Time.at(attributes.mtime).strftime("%b %e %H:%M ")
+        longname << name
+      end
+    end
+  end
+
+end; end; end; end

data/plugins/project/vendor/net-sftp/lib/net/sftp/protocol/05/base.rb

@@ -0,0 +1,66 @@
+require 'net/sftp/protocol/04/base'
+
+module Net; module SFTP; module Protocol; module V05
+
+  # Wraps the low-level SFTP calls for version 5 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 < V04::Base
+    # Returns the protocol version implemented by this driver. (5, in this
+    # case)
+    def version
+      5
+    end
+
+    # Sends a FXP_RENAME packet to the server to request that the file or
+    # directory with the given +name+ (must be a full path) be changed to
+    # +new_name+ (which must also be a path). The +flags+ parameter must be
+    # either +nil+ or 0 (the default), or some combination of the
+    # Net::SFTP::Constants::RenameFlags constants.
+    def rename(name, new_name, flags=nil)
+      send_request(FXP_RENAME, :string, name, :string, new_name, :long, flags || 0)
+    end
+
+    # Sends a FXP_OPEN packet to the server and returns the packet identifier.
+    # The +flags+ parameter is either an integer (in which case it must be
+    # a combination of the IO constants) or a string (in which case it must
+    # be one of the mode strings that IO::open accepts). The +options+
+    # parameter is a hash that is used to construct a new Attribute object,
+    # to pass as part of the FXP_OPEN request.
+    def open(path, flags, options)
+      flags = normalize_open_flags(flags)
+
+      sftp_flags, desired_access = if flags & (IO::WRONLY | IO::RDWR) != 0
+          open = if flags & (IO::CREAT | IO::EXCL) == (IO::CREAT | IO::EXCL)
+            FV5::CREATE_NEW
+          elsif flags & (IO::CREAT | IO::TRUNC) == (IO::CREAT | IO::TRUNC)
+            FV5::CREATE_TRUNCATE
+          elsif flags & IO::CREAT == IO::CREAT
+            FV5::OPEN_OR_CREATE
+          else
+            FV5::OPEN_EXISTING
+          end
+          access = ACE::Mask::WRITE_DATA | ACE::Mask::WRITE_ATTRIBUTES
+          access |= ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES if (flags & IO::RDWR) == IO::RDWR
+          if flags & IO::APPEND == IO::APPEND
+            open |= FV5::APPEND_DATA
+            access |= ACE::Mask::APPEND_DATA
+          end
+          [open, access]
+        else
+          [FV5::OPEN_EXISTING, ACE::Mask::READ_DATA | ACE::Mask::READ_ATTRIBUTES]
+        end
+
+      attributes = attribute_factory.new(options)
+
+      send_request(FXP_OPEN, :string, path, :long, desired_access, :long, sftp_flags, :raw, attributes.to_s)
+    end
+
+  end
+
+end; end; end; end