rstyx 0.1.0 → 0.2.0

data/lib/rstyx/client.rb

@@ -24,9 +24,10 @@
 # Copyright:: Copyright (c) 2005 Rafael R. Sevilla
 # License:: GNU Lesser General Public License
 #
-# $Id: client.rb,v 1.5 2005/09/30 08:07:46 dido Exp $
+# $Id: client.rb,v 1.10 2005/11/01 13:02:18 dido Exp $
 #
 
+require 'English'
 require 'socket'
 require 'thread'
 require 'timeout'
@@ -67,17 +68,23 @@ module RStyx
         end
         return(val)
       end
+
     end
 
     ##
     # An abstract class for Styx connections. DO NOT INSTANTIATE THIS
     # CLASS DIRECTLY!
     #
+    # A +Connection+ subclass instance acts in the same way as the
+    # +File+ class would under Ruby, and many of the class methods for
+    # File are implemented as instance methods for Connection, and are
+    # relevant to the Styx filesystem the Connection is connected to.
+    # There are a few differences: for instance, new is not equivalent
+    # to open, for obvious reasons.
+    #
     class Connection
       attr_reader :msize, :version, :rootfid, :user
 
-      TIMEOUT = 60
-
       ##
       # Create a new Styx connection.  If a block is passed, yield the
       # new connection to the block and do a disconnect when the block
@@ -288,35 +295,154 @@ module RStyx
       #
       # +path+:: the path to the Styx file to be opened
       # +mode+:: the mode to open the file (which can be r, w, r+, or e)
+      # +perm+:: the (optional) permissions bit mask.  This is only
+      #          relevant if the open creates a file.
+      # +rfid+:: the root fid.  If this is nil, use the root fid we got
+      #          when we connected.
+      #
+      # All parameters are optional.  If no path is specified, it defaults
+      # to reading the root directory on the Styx server.
       #
-      # FIXME: This doesn't deal with the case where MAXWELEM is reached yet.
+      # FIXME: This doesn't deal with the case where MAXWELEM is reached
+      #        yet.
+      # TODO: Allow the caller to make use of the Styx file access mode
+      #       values (OREAD, OWRITE, ORDWR, OEXEC, OTRUNC, ORCLOSE).
       #
-      def open(path, mode='r')
+      def open(path="", mode='r', perm=0644, rfid=nil)
         # get a new fid for the file
         fid = get_free_fid
-        # Walk the fid to the given file
+
+        if rfid.nil?
+          rfid = @rootfid
+        end
+
+        #
+        # The mode string is the standard Ruby mode string, viz.
+        # "r" - read-only, start at beginning of file
+        # "r+" - read/write, start at beginning of file
+        # "w" - write only, truncate existing file or create it if it
+        #       doesn't exist.
+        # "w+" - read/write, truncate existing file or create it if it
+        #        doesn't exist
+        # "a" - write only, starts at end of file if it exists otherwise
+        #       creates a new file for writing.
+        # "a+" - read/write, starts at end of file if it exists, otherwise
+        #        creates a new file for writing.
+        #
+        # There is also a mode specific to RStyx, not a standard mode
+        # for Ruby:
+        #
+        # "e" - execute the file
+        #
+        # The "b" suffix on DOS/Windows is not recognized as valid.
+        #
+        read = true
+        write = false
+        create = false
+        truncate = false
+        append = false
+        mval = Message::Topen::OREAD
+        case mode
+        when "r"
+          # all default above
+        when "r+"
+          write = true
+          mval = Message::Topen::ORDWR
+        when "w"
+          read = false
+          write = true
+          create = true
+          truncate = true
+          mval = Message::Topen::OWRITE
+        when "w+"
+          read = true
+          write = true
+          create = true
+          truncate = true
+          mval = Message::Topen::ORDWR
+        when "a"
+          read = false
+          write = true
+          create = true
+          append = true
+          mval = Message::Topen::OWRITE
+        when "a+"
+          read = true
+          write = true
+          create = true
+          append = true
+          mval = Message::Topen::ORDWR
+        when "e"
+          read = true
+          write = true
+          mval = Message::Topen::OEXEC
+        else
+          raise StyxException.new("Invalid mode string '#{mode}'")
+        end
+
+        if truncate
+          mval |= Message::Topen::OTRUNC
+        end
+
+        iclass = StyxIO
         begin
-          twalk = Message::Twalk.new(@rootfid, fid, path)
+          twalk = Message::Twalk.new(rfid, fid, path)
           rwalk = send_message(twalk)
           # if the rwalk has some other length than the number of path
           # elements in the original twalk, we have failed.
           if rwalk.qids.length != twalk.path_elements.length
             raise StyxException.new(sprintf("%s: no such file or directory", twalk.path_elements[rwalk.qids.length]))
           end
-          # TODO: if the file is a directory?
-          # Convert the mode string into a mode number
-          mval = case mode
-                 when 'r': Message::Topen::OREAD
-                 when 'w': Message::Topen::OWRITE
-                 when 'r+': Message::Topen::ORDWR
-                 when 'e': Message::Topen::OEXEC
-                 end
+          open_msg = Message::Topen.new(fid, mval)
+          # Determine if the file is actually a directory.  Such a file
+          # would have its Qid.qtype high bit set to 1.  In this case,
+          # mode can only be 'r', and instead of a StyxIO, a StyxDir
+          # instance is created instead.
+          #
+          # If the number of path elements involved is zero, assume a
+          # directory, as the root fid is always one.
+          #
+          if twalk.path_elements.length == 0 ||
+              rwalk.qids[twalk.path_elements.length-1].qtype & 0x80 != 0
+            iclass = StyxDir
+          end
+
+        rescue StyxException => se
+          # If the walk generated an error, see if the create flag
+          # was true.  If so, the error may be ignored, and the
+          # open_msgclass set to Message::Tcreate.  Otherwise, return
+          # the fid and reraise the exception.
+          if create
+            # Walk to the directory of the file to be made, if possible
+            begin
+              rwalk = send_message(Message::Twalk.new(rfid, fid,
+                                                      File.dirname(path)))
+            rescue StyxException => se
+              return_fid(fid)
+              raise se            # reraise the exception
+            end
+            open_msg = Message::Tcreate.new(fid, File.basename(path),
+                                            mval, perm)
+          else
+            return_fid(fid)
+            raise se            # reraise the exception
+          end
+        end
+
+        begin
           # Create, open, and return a StyxIO object
-          ropen = send_message(Message::Topen.new(fid, mval))
-          fp = StyxIO.new(self, path, fid, ropen.iounit, mode)
+          ropen = send_message(open_msg)
+          fp = iclass.new(self, path, fid, ropen.iounit, mode)
+
+          # if we're supposed to append, seek to the end of the file
+          if append
+            rstat = send_message(Message::Tstat.new(fid))
+            fp.seek(rstat.stat.length, :seek_set)
+          end
+
           if block_given?
             begin
-              yield fp
+            yield fp
             ensure
               fp.close
             end
@@ -325,7 +451,68 @@ module RStyx
           end
         rescue StyxException => se
           return_fid(fid)
-          raise se              # reraise the exception
+          raise se            # reraise the exception
+        end
+      end
+
+      ##
+      # Delete the files specified.  Unlike File.delete, this method
+      # should also work properly on directories
+      #
+      def delete(*files)
+        files.each do |file|
+          fid = get_free_fid
+          # walk to the file to be deleted
+          begin
+            rwalk = send_message(Message::Twalk.new(@rootfid, fid, file))
+          rescue StyxException => se
+            return_fid(fid)
+            raise se
+          end
+
+          begin
+            rremove = send_message(Message::Tremove.new(fid))
+            return_fid(fid)
+          rescue StyxException => se
+            # because the Twalk succeeded, we need to clunk the fid
+            begin
+              rclunk = send_message(Message::Tclunk.new(fid))
+            rescue StyxException => se
+              return_fid(fid)
+            end
+            raise se
+          end
+        end
+      end
+
+      alias rmdir delete
+      alias unlink delete
+
+      ##
+      # Create a new directory named by +dirname+, with permissions
+      # specified by an optional parameter +perm+.
+      #
+      def mkdir(dirname, perm=0755)
+        begin
+          fid = get_free_fid
+          perm |= Message::Tcreate::DMDIR
+          rwalk = send_message(Message::Twalk.new(@rootfid, fid,
+                                                  File.dirname(dirname)))
+        rescue StyxException => se
+          return_fid(fid)
+          raise se
+        end
+
+        begin
+          rcreate = send_message(Message::Tcreate.new(fid,
+                                                      File.basename(dirname),
+                                                      Message::Topen::OREAD,
+                                                      perm))
+        rescue StyxException => se
+          return_fid(fid)
+          raise se
+        ensure
+          rclunk = send_message(Message::Tclunk.new(fid))
         end
       end
 
@@ -361,13 +548,85 @@ module RStyx
     end
 
     ##
-    # A file or directory on a Styx server.  This should probably not
-    # be instantiated directly, but only by the use of Connection#open.
+    # Internally used class for buffers
+    class Buffer
+      attr_reader :bufsize
+
+      def initialize(bufsize)
+        @bufsize = bufsize    # maximum size of the buffer
+        @data = ""            # data in the buffer
+      end
+
+      ##
+      # Returns true if the buffer is empty
+      #
+      def empty?
+        return(@data.length == 0)
+      end
+
+      ##
+      # Returns true if the buffer is full
+      def full?
+        return(@data.length == @bufsize)
+      end
+
+      ##
+      # How much data is needed to fill the buffer?
+      #
+      def slack
+        return(@bufsize - @data.length)
+      end
+
+      ##
+      # Empty the buffer.  Return all the data in the buffer
+      #
+      def empty
+        retval = @data
+        @data = ""
+        return(retval)
+      end
+
+      ##
+      # Consume data from the buffer.  Returns a string of at most +size+
+      # length from the buffer.
+      #
+      def consume(size)
+        retval = @data[0..(size-1)]
+        @data = @data[size..@data.length]
+        if @data == nil      # if the buffer goes empty
+          @data = ""
+        end
+        return(retval)
+      end
+
+      ##
+      # Write data to the buffer.  Returns the data that was not actually
+      # written to the buffer (the excess) if the buffer is full.
+      def fill(data)
+        if data.length > slack
+          excess = data[slack..(data.length)]
+          data = data[0..(slack-1)]
+        end
+        @data << data
+        return(excess)
+      end
+
+    end
+
+    ##
+    # A file on a Styx server.  This should probably not be instantiated
+    # directly, but only by the use of Connection#open.
     #
     # TODO: This should later become a true subclass of IO.
     #
     class StyxIO
-      attr_reader :name, :mode, :closed, :offset
+      attr_reader :name, :mode, :closed, :offset, :iounit, :fid
+      attr_accessor :sync
+
+      # Whether or not to buffer writes.  Unlike regular IO objects,
+      # StyxIO has this true by default.
+      attr_accessor :sync
+      include Enumerable
 
       def initialize(conn, name, fid, iounit, mode="r")
         @conn = conn
@@ -377,25 +636,25 @@ module RStyx
         @fid = fid
         @iounit = iounit        # maximum payload of a Twrite or Rread message
         @offset = 0             # file offset
-      end
+        @sync = true
 
-      ##
-      # closes the file.  Once this has been done, no more read or write
-      # operations should be possible.
-      #
-      def close
-        flush                     # flush any bytes buffered (later)
-        rclunk = @conn.send_message(Message::Tclunk.new(@fid))
-        # FIXME: abort all outstanding messages with flushes
+        @buffer = Buffer.new(iounit) # the read buffer
+        @boffset = 0   # the offset of the last buffered read or write
+        @lastop = :none         # the last operation performed
+        @sync = false           # Buffer or not buffer writes
       end
 
       ##
-      # Read at most +size+ bytes from the current file position.
+      # Read at most +size+ bytes from +offset+
       # If the size argument is negative or omitted, read until EOF.
+      # This is an unbuffered read!  This function should probably
+      # not be used directly.
       #
       # +size+:: number of bytes to read from the file
+      # +offset+:: the offset to read from.
+      # return:: the data followed by the new offset
       #
-      def read(size=-1)
+      def sysread_int(size=-1, offset=0)
         contents = ""
         bytes_to_read = size
         loop do
@@ -406,27 +665,31 @@ module RStyx
           else
             n = bytes_to_read
           end
-          rread = @conn.send_message(Message::Tread.new(@fid, @offset, n))
+          rread = @conn.send_message(Message::Tread.new(@fid, offset, n))
           if rread.data.length == 0
             break                 # EOF
           end
-          @offset += rread.data.length
+          offset += rread.data.length
           contents << rread.data
           if size >= 0
             bytes_to_read -= rread.data.length
           end
         end
-        return(contents)
+        return([contents, offset])
       end
 
       ##
       #
-      # Write data to the file at the current offset.  No buffering is
-      # performed (yet).
+      # Write data to the file at +offset+.  No buffering is
+      # performed.  This function should probably not be used
+      # directly.
       #
       # +str+:: data to be written
+      # +offset+:: the offset to write at
       #
-      def write(str)
+      # returns the new offset
+      #
+      def syswrite_int(str, offset)
         pos = 0
         loop do
           bytes_left = str.length - pos
@@ -437,28 +700,197 @@ module RStyx
           else
             n = bytes_left
           end
-          rwrite = @conn.send_message(Message::Twrite.new(@fid, @offset,
+          rwrite = @conn.send_message(Message::Twrite.new(@fid, offset,
                                                           str[pos..(pos+n)]))
           if rwrite.count != n
             raise StyxException.new("error writing data")
           end
           pos += n
-          @offset += n
+          offset += n
         end
+        return(offset)
+      end
 
+      public
+
+      ##
+      # closes the file.  Once this has been done, no more read or write
+      # operations should be possible.
+      #
+      def close
+        flush                     # flush any bytes buffered
+        rclunk = @conn.send_message(Message::Tclunk.new(@fid))
+        # FIXME: abort all outstanding messages with flushes
+      end
+
+      ##
+      # Read at most +size+ bytes from the current file position.
+      # If the size argument is negative or omitted, read until EOF.
+      # Returns nil if we read from the end of stream.
+      #
+      # This is a buffered read.
+      #
+      # +size+:: number of bytes to read from the file
+      #
+      def read(size=-1)
+        # flush any buffered data first, so the buffer becomes empty
+        if @lastop == :write
+          flush
+        end
+        @lastop = :read
+
+        bytes_to_read = size
+        contents = ""
+        loop do
+          if @buffer.empty?
+            # fill the buffer if the buffer goes empty
+            rdata, @boffset = sysread_int(@buffer.slack, @boffset)
+            if rdata.length == 0
+              break
+            end
+            @buffer.fill(rdata)
+          end
+
+          d = ""
+
+          if size < 0 || bytes_to_read > @buffer.bufsize
+            d = @buffer.empty
+          else
+            d = @buffer.consume(bytes_to_read)
+          end
+
+          @offset += d.length
+          contents << d
+          if size >= 0
+            bytes_to_read -= d.length
+          end
+
+          if bytes_to_read == 0
+            break
+          end
+        end
+        if (contents.length == 0)
+          return(nil)
+        end
+        return(contents)
+      end
+
+      ##
+      # Do an unbuffered read.
+      #
+      def sysread(size=-1)
+        unless @buffer.empty?
+          raise IOError.new("sysread for buffered IO")
+        end
+        data, @offset = sysread_int(size, @offset)
+        if (data.length == 0)
+          return(nil)
+        end
+        return(data)
+      end
+
+      ##
+      # Calls the given block once for each byte (0..255) in the StyxIO,
+      # passing the byte as an argument.  The Styx file must be opened
+      # for reading.
+      #
+      def each_byte
+        if !block_given?
+          raise LocalJumpError("no block given")
+        end
+
+        while (!(c=read(1)).nil?)
+          yield c[0]
+        end
+      end
+
+      ##
+      # Reads the next "line" from the Styx file; lines are separated by
+      # sep_str.  A separator of nil reads the entire contents, [and a
+      # zero length separator reads the input a paragraph at a time (two
+      # successive newlines in the input separate paragraphs) TODO: this
+      # needs to be implemented].  The Styxfile
+      # must be opened for reading.  The line read in will be returned and
+      # also assigned to $LAST_READ_LINE.  Returns nil if called at end
+      # of file.
+      #
+      def gets(sep_str=$RS)
+        line = ""
+        while (!(c=read(1)).nil?)
+          line << c
+          if c == $RS
+            break
+          end
+        end
+        if line.length == 0
+          return(nil)
+        end
+        return(line)
+      end
+
+      ##
+      # Executes the passed block for every line in styxio, where lines
+      # are separated by sep_str.  The Styx file must be opened for
+      # reading.
+      #
+      def each
+        if !block_given?
+          raise LocalJumpError("no block given")
+        end
+
+        while (!(line = gets).nil?)
+          yield line
+        end
+      end
+
+      ##
+      # A buffered write of data to the file.
+      #
+      def write(data)
+        if @lastop == :read
+          @buffer.empty         # empty the buffer
+        end
+        @lastop = :write
+
+        # If the sync flag is set, simply write the data straight
+        # to the file with no buffering at all.
+        if @sync
+          @offset = syswrite_int(data, @offset)
+          return(data.length)
+        end
+
+        # If the sync flag is not set, try to write the data to the buffer
+        # until the buffer becomes full.
+        bytes_written = data.length
+        while !data.nil?
+          if @buffer.full?
+            # flush the buffer if the buffer fills up
+            flush
+          end
+          data = @buffer.fill(data)
+        end
+        @offset += bytes_written
+        return(bytes_written)
       end
 
       ##
       # Flushes any buffered data
       #
       def flush
-        # TODO
+        if @lastop == :write
+          @boffset = syswrite_int(@buffer.empty, @boffset)
+          return(self)
+        end
       end
 
       ##
       # Move to a new seek position
       #
+      # TODO: implement :seek_end
+      #
       def seek(offset, whence=:seek_set)
+        # flush the buffers before doing the seek
+        flush
         case whence
         when :seek_set: @offset = offset
         when :seek_cur: @offset += offset
@@ -466,8 +898,17 @@ module RStyx
         when :seek_end: raise StyxException.new("Can't seek from end of file")
         else raise StyxException.new("whence must be :seek_set, :seek_cur, or :seek_end")
         end
+        @boffset = @offset
+        @buffer.empty
       end
-      
+
+      ##
+      # Seek to the start of the file
+      #
+      def rewind
+        seek(0, :seek_set)
+      end
+
       ##
       # Return the current file position
       #
@@ -485,15 +926,93 @@ module RStyx
 
     end
 
-  end                           # module Client
+    ##
+    # A directory on a Styx server.  This obtains the entries inside
+    # a directory.  This actually delegates to StyxIO.
+    #
+    class StyxDir
+      include Enumerable
 
-end                             # module RStyx
+      def initialize(conn, name, fid, iounit, mode="r")
+        @io = StyxIO.new(conn, name, fid, iounit, mode)
+        # directory entry buffer
+        @read_direntries = []
+      end
+
+      def close
+        @io.close
+      end
+
+      ##
+      # get the fid corresponding to this directory
+      #
+      def fid
+        @io.fid
+      end
+
+      ##
+      # Read the next directory entry from the dir and return the file
+      # name as a string.  Returns nil at the end of stream.
+      #
+      def read
+        # if there are directory entries left over from the previous
+        # read that have not yet been returned, return them.
+        if @read_direntries.length != 0
+          return(@read_direntries.shift.name)
+        end
+        # read iounit bytes from the directory--this must be unbuffered
+        data = @io.read(@io.iounit)
+
+        if (data.nil?)
+          return(nil)
+        end
+
+        # decode the directory entries in the iounit
+        while data.length != 0
+          delen = data[0..1].unpack("v")[0]
+          edirent = data[0..(delen + 1)]
+          data = data[(delen + 2)..(data.length)]
+          @read_direntries << Message::DirEntry.decode(edirent)
+        end
+        de = @read_direntries.shift
+        if (de.nil?)
+          return(nil)
+        end
+        return(de.name)
+      end
+
+      ##
+      # Seek to the beginning of the directory.  This is the only type of
+      # seek allowed.
+      #
+      def rewind
+        @io.rewind
+      end
+
+      ##
+      # same as StyxIO#stat
+      #
+      def stat
+        return(@io.stat)
+      end
+
+      ##
+      # Call the block once for each entry in the directory, passing the
+      # filename of each entry as a parameter to the block.
+      #
+      def each
+        if !block_given?
+          raise LocalJumpError("no block given")
+        end
+
+        self.rewind
+        while (!(de = self.read).nil?)
+          yield de
+        end
+      end
 
-if $0 == __FILE__
-  RStyx::Client::TCPConnection.new("127.0.0.1", 1234) do |c|
-    c.open("hello.txt", "r+") do |fp|
-      puts fp.stat.to_s
     end
-  end
-end
 
+  end                           # module Client
+
+end                             # module RStyx

data/lib/rstyx/messages.rb

@@ -24,7 +24,7 @@
 # Copyright:: Copyright (c) 2005 Rafael R. Sevilla
 # License:: GNU Lesser General Public License
 #
-# $Id: messages.rb,v 1.24 2005/09/30 05:35:42 dido Exp $
+# $Id: messages.rb,v 1.26 2005/11/01 11:40:26 dido Exp $
 #
 
 require 'rstyx/errors'
@@ -163,7 +163,7 @@ module RStyx
         str << Util.strpack(@gid)
         str << Util.strpack(@muid)
         @size = str.length
-        return([size].pack("v") + str)
+        return([@size].pack("v") + str)
       end
 
       ##
@@ -1340,6 +1340,7 @@ module RStyx
         @stat = stat
         @mtype = RSTAT
         @messagebody = @stat.to_bytes
+        @messagebody = [@stat.size + 2].pack("v") + @messagebody
         @length = 7 + @messagebody.length
         @body = sprintf("%s", @stat)
       end
@@ -1353,7 +1354,7 @@ module RStyx
       #
       def Rstat.decode(message)
         len = message[0..3].unpack("V")[0]
-        stat = DirEntry.decode(message[7..len])
+        stat = DirEntry.decode(message[9..len])
         return(Rstat.new(stat))
       end
 
@@ -1375,7 +1376,9 @@ module RStyx
         @fid = fid
         @stat = stat
         @mtype = TWSTAT
-        @messagebody = [@fid].pack("V") + @stat.to_bytes
+        @messagebody = @stat.to_bytes
+        @messagebody = [@fid].pack("V") +
+          [@stat.size + 2].pack("v") + @messagebody
         @length = 7 + @messagebody.length
         @body = sprintf("%s, %s", @fid, @stat)
       end
@@ -1390,7 +1393,7 @@ module RStyx
       def Twstat.decode(message)
         len = message[0..3].unpack("V")[0]
         fid = message[7..10].unpack("V")[0]
-        stat = DirEntry.decode(message[11..len])
+        stat = DirEntry.decode(message[13..len])
         return(Twstat.new(fid, stat))
       end
 

data/lib/rstyx/version.rb

@@ -20,14 +20,14 @@
 #
 # RStyx version code
 #
-# $Id: version.rb,v 1.1 2005/09/30 08:13:09 dido Exp $
+# $Id: version.rb,v 1.2 2005/11/01 13:17:27 dido Exp $
 #
 
 module RStyx
   module Version
 
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY = 0
 
     # The version of RStyx in use.

data/tests/tc_client.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/ruby
+#
+# Copyright (C) 2005 Rafael Sevilla
+# This file is part of RStyx
+#
+# RStyx is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1
+# of the License, or (at your option) any later version.
+#
+# RStyx is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with RStyx; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+# 02111-1307 USA.
+#
+# Unit tests for Styx client.
+#
+# To use these tests, redefine CONNECT_HOST and CONNECT_PORT to point to
+# a Styx server that will accept connections with no authentication and
+# will allow write access.  I'm currently using 4th Edition Inferno hosted
+# on GNU/Linux to do this
+#
+# $Id: tc_client.rb,v 1.2 2005/11/01 13:17:04 dido Exp $
+#
+require 'test/unit'
+require 'rstyx'
+
+class ClientTest < Test::Unit::TestCase
+  CONNECT_HOST = "127.0.0.1"
+  CONNECT_PORT = "1234"
+  TEST_DIRECTORY = "/rstyx_test_dir"
+  TEST_FILE = TEST_DIRECTORY + "/test.file"
+
+  def test_client
+    RStyx::Client::TCPConnection.new(CONNECT_HOST, CONNECT_PORT) do |c|
+      begin
+        # Create the directory
+        assert_nothing_raised { c.mkdir(TEST_DIRECTORY) }
+        # Try to create the directory again (this should result in an error)
+        assert_raise(RStyx::StyxException) { c.mkdir(TEST_DIRECTORY) }
+
+        # open a file in the directory for writing, and fill it with data
+        assert_nothing_raised do
+          c.open(TEST_FILE, "w") do |fp|
+            0.upto(1024) do |i|
+              fp.write(sprintf("%04x\n", i))
+            end
+          end
+        end
+
+        # Open the file for reading, and check that the data is correct
+        c.open(TEST_FILE, "r") do |fp|
+          i = 0
+          fp.each do |line|
+            assert(line == sprintf("%04x\n", i))
+            i += 1
+          end
+        end
+      ensure
+        assert_nothing_raised { c.delete(TEST_FILE) }
+        assert_raise(RStyx::StyxException) { c.delete(TEST_FILE) }
+        # Make sure the directories are deleted.
+        assert_nothing_raised { c.rmdir("/rstyx_test_dir") }
+        # Deleting the directory twice should generate an error
+        assert_raise(RStyx::StyxException) { c.rmdir(TEST_DIRECTORY) }
+      end
+    end
+  end
+end

data/tests/tc_message.rb

@@ -20,7 +20,7 @@
 #
 # Unit tests for Styx messages
 #
-# $Id: tc_message.rb,v 1.23 2005/09/28 17:56:58 dido Exp $
+# $Id: tc_message.rb,v 1.25 2005/11/01 11:44:06 dido Exp $
 #
 require 'test/unit'
 require 'rstyx/messages'
@@ -1138,10 +1138,11 @@ class MessageTest < Test::Unit::TestCase
     de.muid = "quux"
     rs = RStyx::Message::Rstat.new(de)
     bytes = rs.to_bytes(0x1234)
-    expect = "\x7d\x34\x12\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux"
+    expect = "\x7d\x34\x12\x3e\x00\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux"
     len = expect.length + 4
     packlen = [len].pack("V")
     expect = packlen + expect
+    puts ""
     assert(expect == bytes)
 
     # decode expect
@@ -1207,7 +1208,7 @@ class MessageTest < Test::Unit::TestCase
     de.muid = "quux"
     tw = RStyx::Message::Twstat.new(0x12345678, de)
     bytes = tw.to_bytes(0x1234)
-    expect = "\x7e\x34\x12\x78\x56\x34\x12\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux"
+    expect = "\x7e\x34\x12\x78\x56\x34\x12\x3e\x00\x3c\x00\x34\x12\xab\x90\x78\x56\x01\xef\xbe\xad\xde\xee\xee\xff\xc0\xce\xfa\xed\xfe\xf0\xde\xbc\x9a\xef\xbe\xad\xde\xbe\xba\xfe\xca\x10\x32\x54\x76\x98\xba\xdc\xfe\x03\x00foo\x03\x00bar\x03\x00baz\x04\x00quux"
     len = expect.length + 4
     packlen = [len].pack("V")
     expect = packlen + expect

metadata

@@ -1,13 +1,13 @@
-!ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification 
 rubygems_version: 0.8.11
 specification_version: 1
 name: rstyx
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2005-10-01 00:00:00 +08:00
+  version: 0.2.0
+date: 2005-11-01 00:00:00 +08:00
 summary: RStyx is an implementation of the Styx/9P2000 distributed filesystem protocol for Ruby.
 require_paths: 
-- lib
+  - lib
 email: dido@imperium.ph
 homepage: http://rubyforge.org/projects/rstyx
 rubyforge_project: 
@@ -18,35 +18,31 @@ bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
 authors: 
-- Rafael Sevilla
+  - Rafael Sevilla
 files: 
-- lib/rstyx
-- lib/rstyx.rb
-- lib/rstyx/messages.rb
-- lib/rstyx/client.rb
-- lib/rstyx/version.rb
-- lib/rstyx/errors.rb
-- tests/tc_message.rb
+  - lib/rstyx
+  - lib/rstyx.rb
+  - lib/rstyx/messages.rb
+  - lib/rstyx/client.rb
+  - lib/rstyx/version.rb
+  - lib/rstyx/errors.rb
+  - tests/tc_client.rb
+  - tests/tc_message.rb
 test_files: []
-
 rdoc_options: 
-- --title
-- RStyx -- Styx/9P2000 for Ruby
+  - "--title"
+  - "RStyx -- Styx/9P2000 for Ruby"
 extra_rdoc_files: []
-
 executables: []
-
 extensions: []
-
 requirements: []
-
-dependencies: []
-
+dependencies: []