rstyx 0.1.0

data/lib/rstyx/client.rb

@@ -0,0 +1,499 @@
+#!/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.
+#
+# Styx Client
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# 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 $
+#
+
+require 'socket'
+require 'thread'
+require 'timeout'
+require 'rstyx/errors'
+require 'rstyx/messages'
+
+module RStyx
+
+  module Client
+
+    ##
+    # Utility functions
+    #
+    class Util
+      ##
+      # Gets the next unused tag or fid.
+      #
+      # +limit+:: [Fixnum] maximum value
+      # +func+:: [Proc] predicate that determines if tag or fid i is in use
+      # +thing+:: [String] what we're trying to get
+      # return:: an unused value
+      #
+      def Util.get_first_unused(limit, func, thing)
+        found = false
+        val = nil
+        0.upto(limit-1) do |i|
+          if func.call(i)
+            i += 1
+          else
+            val = i
+            break
+          end
+        end
+
+        if val.nil?
+          # this should probably be impossible
+          raise StyxException.new(sprintf("No more free %s!", thing))
+        end
+        return(val)
+      end
+    end
+
+    ##
+    # An abstract class for Styx connections. DO NOT INSTANTIATE THIS
+    # CLASS DIRECTLY!
+    #
+    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
+      # finishes.
+      #
+      # +user+:: [String] the user to connect as
+      #
+      def initialize(user="")
+        @lock = Mutex.new       # used to synchronize threads
+        @condvar = ConditionVariable.new
+        @rmessages = Hash.new   # filled with rmessages that have arrived
+        @usedfids = Array.new   # list of fids currently in use
+        @pendingclunks = Hash.new # outstanding Tclunk messages (tags and fids)
+        @conn = self.startconn  # get the connection
+
+        # start message receiving thread
+        @receiver = Thread.new { receive_messages }
+
+        tv = Message::Tversion.new
+        rver = send_message(tv)
+        @msize = rver.msize
+        @version = rver.version
+        @rootfid = get_free_fid # the fid representing the serv. root
+        rattach = send_message(Message::Tattach.new(@rootfid, user))
+        @user = user
+
+        if block_given?
+          begin
+            yield self
+          ensure
+            self.disconnect
+          end
+        else
+          return(self)
+        end
+      end
+
+      protected
+
+      ##
+      # This method should be overridden by subclasses, and should return
+      # a subclass of IO (e.g. a TCPSocket) on which the read and write
+      # methods can be used.
+      #
+      def startconn
+        return(nil)             # Override me!
+      end
+
+      ##
+      # Thread that listens for incoming messages on the socket.
+      #
+      # FIXME: Frankly, I think this is quite ugly...
+      #
+      def receive_messages
+        buffer = ""
+        data = nil
+        done = false
+        loop do
+          begin
+            data = @conn.read(1)
+          rescue Exception => e
+            done = true
+            raise StyxException.new("error reading from socket: #{e.message}")
+          end
+
+          # There may be more than one message (or a partial message)
+          buffer << data
+          if buffer.length >= 4
+            length = buffer[0..3].unpack("V")[0]
+            if buffer.length >= length
+              message = buffer[0..(length-1)]
+              buffer = buffer[length..(buffer.length)]
+              styxmsg = Message::StyxMessage.decode(message)
+
+              # let everyone know there's a new message available
+              @lock.synchronize do
+                @rmessages[styxmsg.tag] = styxmsg
+                @condvar.signal
+              end
+            end
+          end
+        end
+      end
+
+      ##
+      # Get a new tag for use in new messages.
+      #
+      def get_free_tag
+        return(Util.get_first_unused(0xffff,
+                                     lambda {|i| @rmessages.has_key?(i) },
+                                     "tags"))
+      end
+
+      ##
+      # Send a message and return immediately, returning the message's tag
+      #
+      # +message+:: [StyxMessage] the message to be sent
+      # return:: [Fixnum] the tag number used
+      #
+      def send_message_async(message)
+        if (message.tag.nil?)
+          message.tag = get_free_tag
+        end
+
+        # If this is a Tclunk message we are trying to close the file.
+        # Remember the fid so we can free it from the list of used fids
+        # when we get the Rclunk corresponding to it.
+        if message.mtype == Message::StyxMessage::TCLUNK
+          @pendingclunks[message.tag] = message.fid
+        end
+
+        # puts "sending message #{message.to_s}"
+        @conn.write(message.to_bytes)
+        return(message.tag)
+      end
+
+      ##
+      # Waits for the message with the given tag to arrive, then returns it.
+      #
+      # +tag+:: [Fixnum] Tag to wait for
+      # return:: [Message::StyxMessage] the message received
+      #
+      def get_reply(tag)
+        msg = nil
+        @lock.synchronize do
+          # wait for a new message to arrive
+          while @rmessages[tag].nil?
+            @condvar.wait(@lock)
+          end
+          msg = @rmessages[tag]
+          @rmessages.delete(tag)
+        end
+
+        # puts "Received message #{msg.to_s}"
+        # Special things to do for certain messages
+        case msg.mtype
+        when Message::StyxMessage::RERROR
+          # raise an exception when we receive an Rerror
+          raise StyxException.new(msg.ename)
+        when Message::StyxMessage::RCLUNK
+          # find the fid corresponding to the original Tclunk and free it
+          fid = @pendingclunks[tag]
+          @pendingclunks.delete(tag)
+          return_fid(fid)
+        end
+        return(msg)
+      end
+
+      public
+
+      ##
+      # Get a new fid where it's needed.
+      #
+      def get_free_fid
+        fid = Util.get_first_unused(0xffffffff,
+                                    lambda {|i| @usedfids.include?(i) },
+                                    "fids")
+        @usedfids << fid
+        return(fid)
+      end
+
+      ##
+      # returns a fid after we are finished with it.
+      #
+      # +fid+:: [Fixnum] the fid to return
+      #
+      def return_fid(fid)
+        @usedfids.delete(fid)
+      end
+
+      ##
+      # Send a message and wait for the reply
+      #
+      # +message+:: [StyxMessage] the message to be sent
+      # return:: [StyxMessage] the reply to our message
+      #
+      def send_message(message)
+        tag = send_message_async(message)
+        return(get_reply(tag))
+      end
+
+      ##
+      # Disconnect from the remote server.
+      #
+      def disconnect
+        # Clunk all outstanding fids in reverse order so root fid gets
+        # clunked last.
+        while (@usedfids.length > 0)
+          # The fid is automatically removed from @usedfids when the
+          # Rclunk message is received
+          rclunk = send_message(Message::Tclunk.new(@usedfids[-1]))
+        end
+
+        # Flush all outstanding messages
+        @rmessages.each_key do |tag|
+          rflush = send_message(Message::Tflush.new(tag))
+        end
+        # kill the receiver thread (FIXME: there has got to be a cleaner way!)
+        @receiver.kill
+        @conn.close
+      end
+
+      ##
+      # Open a file on the connection.  Throws a StyxException if it doesn't
+      # exist.  If a block is specified along with the file, it is passed
+      # the new StyxFile, and the StyxFile is closed when the block
+      # terminates.
+      #
+      # +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)
+      #
+      # FIXME: This doesn't deal with the case where MAXWELEM is reached yet.
+      #
+      def open(path, mode='r')
+        # get a new fid for the file
+        fid = get_free_fid
+        # Walk the fid to the given file
+        begin
+          twalk = Message::Twalk.new(@rootfid, 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
+          # Create, open, and return a StyxIO object
+          ropen = send_message(Message::Topen.new(fid, mval))
+          fp = StyxIO.new(self, path, fid, ropen.iounit, mode)
+          if block_given?
+            begin
+              yield fp
+            ensure
+              fp.close
+            end
+          else
+            return(fp)
+          end
+        rescue StyxException => se
+          return_fid(fid)
+          raise se              # reraise the exception
+        end
+      end
+
+    end
+
+    ##
+    # TCP connection instance of a Styx connection
+    #
+    class TCPConnection < Connection
+      attr_reader :host, :port
+
+      ##
+      # Create a Styx connection over TCP
+      #
+      # +host+:: [String] the host to connect to
+      # +port+:: [Fixnum] the port on which to connect
+      # +user+:: [String] the user to connect as
+      #
+      def initialize(host, port, user="")
+        @host = host
+        @port = port
+        super(user)
+      end
+
+      ##
+      # TCP connection version of startconn
+      #
+      def startconn
+        sock = TCPSocket.new(@host, @port)
+        return(sock)
+      end
+
+    end
+
+    ##
+    # A file or directory 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
+
+      def initialize(conn, name, fid, iounit, mode="r")
+        @conn = conn
+        @name = name
+        @mode = mode
+        @closed = false         # closed flag
+        @fid = fid
+        @iounit = iounit        # maximum payload of a Twrite or Rread message
+        @offset = 0             # file offset
+      end
+
+      ##
+      # 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
+      end
+
+      ##
+      # Read at most +size+ bytes from the current file position.
+      # If the size argument is negative or omitted, read until EOF.
+      #
+      # +size+:: number of bytes to read from the file
+      #
+      def read(size=-1)
+        contents = ""
+        bytes_to_read = size
+        loop do
+          if size < 0 || bytes_to_read > @iounit
+            n = @iounit
+          elsif bytes_to_read <= 0
+            break
+          else
+            n = bytes_to_read
+          end
+          rread = @conn.send_message(Message::Tread.new(@fid, @offset, n))
+          if rread.data.length == 0
+            break                 # EOF
+          end
+          @offset += rread.data.length
+          contents << rread.data
+          if size >= 0
+            bytes_to_read -= rread.data.length
+          end
+        end
+        return(contents)
+      end
+
+      ##
+      #
+      # Write data to the file at the current offset.  No buffering is
+      # performed (yet).
+      #
+      # +str+:: data to be written
+      #
+      def write(str)
+        pos = 0
+        loop do
+          bytes_left = str.length - pos
+          if bytes_left <= 0
+            break
+          elsif bytes_left > @iounit
+            n = @iounit
+          else
+            n = bytes_left
+          end
+          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
+        end
+
+      end
+
+      ##
+      # Flushes any buffered data
+      #
+      def flush
+        # TODO
+      end
+
+      ##
+      # Move to a new seek position
+      #
+      def seek(offset, whence=:seek_set)
+        case whence
+        when :seek_set: @offset = offset
+        when :seek_cur: @offset += offset
+          # FIXME: do :seek_end
+        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
+      end
+      
+      ##
+      # Return the current file position
+      #
+      def tell
+        return @offset
+      end
+
+      ##
+      # Give the DirEntry corresponding to this file
+      #
+      def stat
+        rstat = @conn.send_message(Message::Tstat.new(@fid))
+        return(rstat.stat)
+      end
+
+    end
+
+  end                           # module Client
+
+end                             # module RStyx
+
+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
+

data/lib/rstyx/errors.rb

@@ -0,0 +1,40 @@
+#!/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.
+#
+# Styx Exception classes.
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright (c) 2005 Rafael R. Sevilla
+# License:: GNU Lesser General Public License
+#
+# $Id: errors.rb,v 1.1 2005/09/28 15:25:11 dido Exp $
+#
+
+module RStyx
+
+  ##
+  # Exception class for Styx errors.  Same as standard Exception
+  # class for now, but here so we can distinguish Styx errors and
+  # for later extension.
+  #
+  class StyxException < Exception
+  end
+
+end