katcp 0.0.7 → 0.1.4

data/lib/katcp/client/roach.rb

@@ -3,6 +3,102 @@ require 'katcp/client'
 # Holds KATCP related classes etc.
 module KATCP
 
+  # Class used to access BRAMs
+  class Bram
+    def initialize(katcp_client, bram_name)
+      @katcp_client = katcp_client
+      @bram_name = bram_name
+    end
+
+    # Calls @katcp_client.bulkread(@bram_name, *args)
+    def [](*args)
+      @katcp_client.bulkread(@bram_name, *args)
+    end
+    alias :get :[]
+
+    # Calls @katcp_client.write(@bram_name, *args)
+    def []=(*args)
+      @katcp_client.write(@bram_name, *args)
+    end
+    alias :set :[]=
+  end
+
+  # Class used to access 10 GbE cores
+  class TenGE < Bram
+    # Read a 64 bit value big endian value starting at 32-bit word offset
+    # +addr+.
+    def read64(addr)
+      hi, lo = get(addr,2).to_a
+      ((hi & 0xffff) << 32) | (lo & 0xffffffff)
+    end
+
+    # Write +val64+ as a 64 bit value big endian value starting at 32-bit word
+    # offset +addr+.
+    def write64(addr, val64)
+      hi = ((val64 >> 32) & 0xffff)
+      lo = val64 & 0xffffffff
+      set(addr, hi, lo)
+    end
+
+    # Return MAC address of 10 GbE core as 48-bit value.
+    def mac
+      read64(0)
+    end
+
+    # Set MAC address of 10 GbE core to 48-bit value +m+.
+    def mac=(m)
+      write64(0, m)
+    end
+
+    # Get gateway IP address as 32-bit integer.
+    def gw    ; get(3)    ; end
+    # Set gateway IP address to 32-bit integer +a+.
+    def gw=(a); set(3, a); end
+
+    # Get source IP address as 32-bit integer.
+    def ip    ; get(4)    ; end
+    # Set source IP address to 32-bit integer +a+.
+    def ip=(a); set(4, a); end
+
+    # Get local rx port as 16-bit integer.
+    def port    ; get(8) & 0xffff                             ; end
+    # Set local rx port to 16-bit integer +p+.
+    def port=(p); set(8, (get(8) & 0xffff0000) | (p & 0xffff)); end
+
+    # Returns xaui status word.  Bits 2 through 5 are lane sync, bit 6 is
+    # channel bonding status.
+    def xaui_status; get(9); end
+    # Four least significant bits represent sync status for each lane.
+    #   1 bit = lane sync OK
+    #   0 bit = lane sync BAD
+    # Proper operation requires all four lanes to have good sync status, so 15
+    # (0b1111) is the desired value.
+    def xaui_sync; (get(9) >> 2) & 0b1111; end
+    # Returns true if #xaui_sync returns 15
+    def xaui_sync_ok?; xaui_sync == 0b1111; end
+    # Returns true if all four XAUI lanes are bonded
+    def xaui_bonded?; (get(9) >> 6) & 1; end
+
+    # Get current value of rx_eq_mix parameter.
+    def rx_eq_mix   ; (get(10) >> 24) & 0xff; end
+    # Get current value of rx_eq_pol parameter.
+    def rx_eq_pol   ; (get(10) >> 16) & 0xff; end
+    # Get current value of tx_preemph parameter.
+    def tx_preemph  ; (get(10) >>  8) & 0xff; end
+    # Get current value of tx_diff_ctrl parameter.
+    def tx_diff_ctrl; (get(10)      ) & 0xff; end
+
+    # Returns current value of ARP table entry +idx+.
+    def [](idx)
+      read64(0xc00+2*idx)
+    end
+
+    # Sets value of ARP table entry +idx+ to +mac+.
+    def []=(idx, mac)
+      write64(0xc00+2*idx, mac)
+    end
+  end
+
   # Facilitates talking to <tt>tcpborphserver2</tt>, a KATCP server
   # implementation that runs on ROACH boards.  In addition to providing
   # convenience wrappers around <tt>tcpborphserver2</tt> requests, it also adds
@@ -15,7 +111,8 @@ module KATCP
   #   writer attributes (i.e. methods) for gateware devices as the FPGA is
   #   programmed (or de-programmed).  This not only provides for very clean and
   #   readable code, it also provides convenient tab completion in irb for
-  #   gateware specific device names.
+  #   gateware specific device names.  Subclasses can exert some control over
+  #   the dynamic method genreation.  See #device_typemap for details.
   #
   # * Word based instead of byte based data offsets and counts.  KATCP::Client
   #   data transfer methods #read and #write deal with byte based offsets and
@@ -32,25 +129,67 @@ module KATCP
     # is currently programmed.
     attr_reader :devices
 
+    # call-seq: RoachClient.new([remote_host, remote_port=7147, local_host=nil, local_port=nil,] opts={}) -> RoachClient
+    #
     # Creates a RoachClient that connects to a KATCP server at +remote_host+ on
     # +remote_port+.  If +local_host+ and +local_port+ are specified, then
     # those parameters are used on the local end to establish the connection.
-    def initialize(remote_host, remote_port=7147, local_host=nil, local_port=nil)
-      super(remote_host, remote_port, local_host, local_port)
+    # Positional parameters can be used OR parameters can be passed via the
+    # +opts+ Hash.
+    #
+    # Supported keys for the +opts+ Hash are:
+    #
+    #   :remote_host  Specifies hostname of KATCP server
+    #   :remote_port  Specifies port used by KATCP server (default 7147)
+    #   :local_host   Specifies local interface to bind to (default nil)
+    #   :local_port   Specifies local port to bind to (default nil)
+    #   :typemap      Provides a default device typemap (default {}).
+    #                 See #device_typemap for details.
+    def initialize(*args)
       # List of all devices
       @devices = [];
       # List of dynamically defined device attrs (readers only, writers implied)
       @device_attrs = [];
+      # @device objects is a Hash of created device objects: key is Class,
+      # value is a Hash mapping device name to instance of Class.
+      @device_objects = {}
+      # Call super *after* initializing subclass instance variables
+      super(*args)
+    end
+
+    # Override KATCP::Client#connect to perform subclass specific
+    # post-connection setup.
+    def connect
+      super
+      # Determine which commands are supported by the server
+      commands = request(:help).to_s
+      # Determine whether bulkread is used by server
+      @bulkread = commands.index('#help bulkread') ? :bulkread : :read
+      # Determine whether status or fpgastatus command is used by server
+      @fpgastatus = commands.index('#help fpgastatus') ? :fpgastatus : :status
+      # Define device-specific attributes (if device is programmed)
       define_device_attrs
+      self
+    end
+
+    # Override KATCP::Client#close to perform subclass specific post-close
+    # cleanup.  Be sure to call super afterwards!
+    def close
+      # Undefine device-specific attributes (if device is programmed)
+      undefine_device_attrs
+    ensure
+      super
     end
 
     # Dynamically define attributes (i.e. methods) for gateware devices, if
-    # currently programmed.
-    def define_device_attrs # :nodoc
+    # currently programmed.  See #device_typemap for more details.
+    def define_device_attrs # :nodoc:
       # First undefine existing device attrs
       undefine_device_attrs
       # Define nothing if FPGA not programmed
       return unless programmed?
+      # Get device typemap (possibly from subclass override!)
+      typemap = device_typemap || {}
       # Dynamically define accessors for all devices (i.e. registers, BRAMs,
       # etc.) except those whose names conflict with existing methods.
       @devices = listdev.lines[0..-2].map {|l| l[1]}
@@ -60,17 +199,19 @@ module KATCP
 
         # Define methods unless they conflict with existing methods
         if ! respond_to?(dev) && ! respond_to?("#{dev}=")
-          # Save attr name
-          @device_attrs << dev
-          # Dynamically define methods
-          instance_eval <<-"_end"
-            def #{dev}(*args)
-              read('#{dev}', *args)
-            end
-            def #{dev}=(*args)
-              write('#{dev}', 0, *args)
-            end
-          _end
+          # Determine type (and aliases) of this device
+          type, *aliases = typemap[dev] || typemap[dev.to_sym]
+          next if type == :skip
+          # Dynamically define methods and aliases
+          case type
+          when Class;  device_object(type,  dev, *aliases)
+          when :bram;  device_object(Bram,  dev, *aliases)
+          when :tenge; device_object(TenGE, dev, *aliases)
+          when :roreg; roreg(dev, *aliases)
+          # else :rwreg or nil (or anything else for that matter) so treat it
+          # as R/W register.
+          else rwreg(dev, *aliases)
+          end
         end
       end
       self
@@ -78,24 +219,159 @@ module KATCP
 
     protected :define_device_attrs
 
-    # Undefine any attributes (i.e. methods) that were previously defined
-    # dynamically.
-    def undefine_device_attrs # :nodoc
-      @device_attrs.each do |dev|
-        instance_eval <<-"_end"
-          class << self
-            remove_method '#{dev}'
-            remove_method '#{dev}='
-          end
-        _end
+    # Undefine any attributes (i.e. methods) and aliases that were previously
+    # defined dynamically.
+    def undefine_device_attrs # :nodoc:
+      @device_attrs.each do |name|
+        instance_eval "class << self; remove_method '#{name}'; end"
       end
       @device_attrs.clear
       @devices.clear
+      # TODO Support cleanup call for device objects?
+      @device_objects.clear
       self
     end
 
     protected :undefine_device_attrs
 
+    # This method's return value controls how methods and aliases are
+    # dynamically generated for devices within the ROACH gateware.  If
+    # #device_typemap returns +nil+ or an empty Hash, all devices will be
+    # treated as read/write registers.  Otherwise, #device_typemap must
+    # return a Hash-like object.  If the object returned by #device_typemap
+    # contains a key (String or Symbol) for a given device name, the key's
+    # corresponding value specifies how to treat that device when dynamically
+    # generating accessor methods for it and whether to generate any aliases
+    # for it.  If no key exists for a given device, the device will be treated
+    # as a read/write register.  The corresponding value can be one of:
+    #
+    #   :roreg (Read-only register)  Only a reader method will be created.
+    #   :rwreg (Read-write register) Both reader and writer methods will be
+    #                                created.
+    #   :bram (Shared BRAM)          A reader method returning a Bram object
+    #                                will be created.  The returned Bram object
+    #                                provides convenient ways to read and write
+    #                                to the Bram device.
+    #   :tenge (10 GbE)              A reader method returning a TenGE object
+    #                                will be created.  The returned TenGE object
+    #                                provides convenient ways to read and write
+    #                                to the TenGE device.
+    #   :skip (unwanted device)      No method will be created.
+    #
+    # Methods are only created for devices that actually exist on the device.
+    # If no device exists for a given key, no methods will be created for that
+    # key.  In other words, regardless of the keys given, methods will not be
+    # created unless they are backed by an actual device.  Both reader and
+    # writer methods are created for devices for which no key is present.
+    #
+    # The value can also be an Array whose first element is a Symbol from the
+    # list above.  The remaining elements specify aliases to be created for the
+    # given attribute methods.
+    #
+    # RoachClient#device_typemap returns on empty Hash so all devices are
+    # treated as read/write registers by default.  Gateware specific subclasses
+    # of RoachClient can override #device_typemap method to return a object
+    # containing a Hash tailored to a specific gateware design.
+    #
+    # Example: The following would lead to the creation of the following
+    # methods and aliases: "input_selector", "input_selector=", "insel",
+    # "insel=", "switch_gbe_status", "switch_gbe", "adc_rms_levels" (assuming
+    # the named devices all exist!).  No methods would be created for the
+    # device named "unwanted_reg" even if it exists.
+    #
+    #   class MyRoachDesign < RoachClient
+    #     DEVICE_TYPEMAP = {
+    #       :input_selector    => [:rwreg, :insel],
+    #       :switch_gbe_status => :roreg,
+    #       :switch_gbe        => :tenge,
+    #       :adc_rms_levels    => :bram,
+    #       :unwanted_reg      => :skip
+    #     }
+    #
+    #     def device_typemap
+    #       DEVICE_TYPEMAP
+    #     end
+    #   end
+    #
+    # Returns the default device typemap Hash (either the one passed to the
+    # constructor or an empty Hash).  Design specific subclasses can override
+    # this method to return a design specific device typemap.
+    def device_typemap
+      (@opts && @opts[:typemap]) || {}
+    end
+
+    # Allow subclasses to create read accessor method (with optional aliases)
+    # Create read accessor method (with optional aliases)
+    # for register.  Converts reg_name to method name by replacing '/' with
+    # '_'.  Typically used with read-only registers.
+    def roreg(reg_name, *aliases) # :nodoc:
+      method_name = reg_name.to_s.gsub('/', '_')
+      instance_eval <<-"_end"
+        class << self
+          def #{method_name}(off=0,len=1); read('#{reg_name}',off,len); end
+        end
+      _end
+      @device_attrs << method_name
+      aliases.each do |a|
+        a = a.to_s.gsub('/', '_')
+        instance_eval "class << self; alias #{a} #{method_name}; end"
+        @device_attrs << a
+      end
+      self
+    end
+
+    protected :roreg
+
+    # Allow subclasses to create read and write accessor methods (with optional
+    # Create read and write accessor methods (with optional
+    # aliases) for register.  Converts reg_name to method name by replacing '/'
+    # with '_'.
+    def rwreg(reg_name, *aliases) # :nodoc:
+      roreg(reg_name, *aliases)
+      method_name = reg_name.to_s.gsub('/', '_')
+      instance_eval <<-"_end"
+        class << self
+          def #{method_name}=(v,off=0); write('#{reg_name}',off,v); end
+        end
+      _end
+      @device_attrs << "#{method_name}="
+      aliases.each do |a|
+        a = a.to_s.gsub('/', '_')
+        instance_eval "class << self; alias #{a}= #{method_name}=; end"
+        @device_attrs << "#{a}="
+      end
+      self
+    end
+
+    protected :rwreg
+
+    # Create accessor method (with optional aliases) for a device object backed
+    # by instance of Class referred to by clazz.  clazz.to_s must return the
+    # name of a Class whose initialize method accepts two parameters: a
+    # KATCP::Client instance and the name of the device.
+    def device_object(clazz, name, *aliases) # :nodoc:
+      name = name.to_s
+      method_name = name.gsub('/', '_')
+      instance_eval <<-"_end"
+        class << self
+          def #{method_name}()
+            @device_objects[#{clazz}] ||= {}
+            @device_objects[#{clazz}]['#{name}'] ||= #{clazz}.new(self, '#{name}')
+            @device_objects[#{clazz}]['#{name}']
+          end
+        end
+      _end
+      @device_attrs << method_name
+      aliases.each do |a|
+        a = a.to_s.gsub('/', '_')
+        instance_eval "class << self; alias #{a} #{method_name}; end"
+        @device_attrs << "#{a}"
+      end
+      self
+    end
+
+    protected :device_object
+
     # Returns +true+ if the current design has a device named +device+.
     def has_device?(device)
       @devices.include?(device.to_s)
@@ -114,16 +390,19 @@ module KATCP
     # unless +word_count+ is given in which case it returns an
     # NArray.int(word_count).
     #
-    # Equivalent to #read, but uses a bulkread request rather than a read
-    # request.
+    # Equivalent to #read (but uses a bulkread request rather than a read
+    # request if bulkread is supported).
     def bulkread(register_name, *args)
+      # Defer to #read unless server provides bulkread command
+      return read(register_name, *args) unless @bulkread == :bulkread
+
       byte_offset = 4 * (args[0] || 0)
       byte_count  = 4 * (args[1] || 1)
       raise 'word count must be non-negative' if byte_count < 0
       resp = request(:bulkread, register_name, byte_offset, byte_count)
       raise resp.to_s unless resp.ok?
       data = resp.lines[0..-2].map{|l| l[1]}.join
-      if args.length <= 1
+      if args.length <= 1 || args[1] == 1
         data.unpack('N')[0]
       else
         data.to_na(NArray::INT).ntoh
@@ -162,12 +441,16 @@ module KATCP
       request(:listdev, :size).sort!
     end
 
+    # This is the default timeout to use when programming a bitstream via
+    # #progdev.
+    PROGDEV_SOCKET_TIMEOUT = 5
+
     # call-seq:
     #   progdev -> KATCP::Response
     #   progdev(image_file) -> KATCP::Response
     #
     # Programs a gateware image specified by +image_file+.  If +image_file+ is
-    # omitted, de-programs the FPGA.
+    # omitted or nil, de-programs the FPGA.
     #
     # Whenever the FPGA is programmed, reader and writer attributes (i.e.
     # methods) are defined for every device listed by #listdev except for
@@ -177,12 +460,22 @@ module KATCP
     # attributes that were dynamically defined for the previous design are
     # removed.
     def progdev(*args)
-      request(:progdev, *args)
+      prev_socket_timeout = @socket_timeout
+      begin
+        # Adjust @socket_timeout if programming a bitstream
+        @socket_timeout = PROGDEV_SOCKET_TIMEOUT if args[0]
+        request(:progdev, *args)
+      ensure
+        @socket_timeout = prev_socket_timeout
+      end
       define_device_attrs
     end
 
     # Returns true if currently programmed (specifically, it is equivalent to
-    # <tt>status.ok?</tt>).
+    # <tt>request(@fpgastatus).ok?</tt>).  Older versions of tcpborphserver
+    # used the "status" command, while newer versions use the "fpgastatus"
+    # command for the same purpose.  The @connect method checks which is used
+    # by the server and sets @fpgastatus accordingly.
     def programmed?
       status.ok?
     end
@@ -208,7 +501,7 @@ module KATCP
       resp = request(:read, register_name, byte_offset, byte_count)
       raise resp.to_s unless resp.ok?
       data = resp.payload
-      if args.length <= 1
+      if args.length <= 1 || args[1] == 1
         data.unpack('N')[0]
       else
         data.to_na(NArray::INT).ntoh
@@ -223,7 +516,7 @@ module KATCP
     #
     # Reports if gateware has been programmed.
     def status
-      request(:status)
+      request(@fpgastatus||:status)
     end
 
     # call-seq:
@@ -292,7 +585,7 @@ module KATCP
       elsif byte_count == 0
         warn "writing 0 bytes to #{register_name}"
       end
-      resp = request(:write, register_name, byte_offset, data)
+      resp = request(:write, register_name, byte_offset, data, byte_count)
       raise resp.to_s unless resp.ok?
       self
     end

data/lib/katcp/client.rb

@@ -1,3 +1,5 @@
+require 'rubygems'
+require 'thread'
 require 'monitor'
 require 'socket'
 
@@ -10,17 +12,33 @@ module KATCP
   # Facilitates talking to a KATCP server.
   class Client
 
+    # Default timeout for socket operations (in seconds)
+    DEFAULT_SOCKET_TIMEOUT = 0.25
+
+    # call-seq: Client.new([remote_host, remote_port=7147, local_host=nil, local_port=nil,] opts={}) -> Client
+    #
     # Creates a KATCP client that connects to a KATCP server at +remote_host+
     # on +remote_port+.  If +local_host+ and +local_port+ are specified, then
     # those parameters are used on the local end to establish the connection.
-    def initialize(remote_host, remote_port=7147, local_host=nil, local_port=nil)
-
-      # Save remote_host and remote_port for #inspect
-      @remote_host = remote_host
-      @remote_port = remote_port
-
-      # @socket is the socket connecting to the KATCP server
-      @socket = TCPSocket.new(remote_host, remote_port, local_host, local_port)
+    # Positional parameters can be used OR parameters can be passed via the
+    # +opts+ Hash.
+    #
+    # Supported keys for the +opts+ Hash are:
+    #
+    #   :remote_host  Specifies hostname of KATCP server
+    #   :remote_port  Specifies port used by KATCP server (default 7147)
+    #   :local_host   Specifies local interface to bind to (default nil)
+    #   :local_port   Specifies local port to bind to (default nil)
+    def initialize(*args)
+      # If final arg is a Hash, pop it off
+      @opts = (Hash === args[-1]) ? args.pop : {}
+
+      # Save parameters
+      remote_host, remote_port, local_host, local_port = args
+      @remote_host = remote_host ? remote_host.to_s : @opts[:remote_host].to_s
+      @remote_port = remote_port || @opts[:remote_port] || 7147
+      @local_host = local_host || @opts[:local_host]
+      @local_port = local_port || @opts[:local_port]
 
       # Init attribute(s)
       @informs = []
@@ -38,49 +56,158 @@ module KATCP
       # @rxq is an inter-thread queue
       @rxq = Queue.new
 
+      # Timeout value for socket operations
+      @socket_timeout = DEFAULT_SOCKET_TIMEOUT
+
+      # No socket yet
+      @socket = nil
+
+      # Try to connect socket and start listener thread, but stifle exception
+      # if it fails because we need object creation to succeed even if connect
+      # doesn't.  Each request attempt will try to reconnect if needed.
+      # TODO Warn if connection fails?
+      connect rescue self
+    end
+
+    # Connect socket and start listener thread
+    def connect
+      # Close existing connection (if any)
+      close
+
+      # Create new socket.
+      @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      sockaddr = Socket.sockaddr_in(@remote_port, @remote_host)
+
+      # Do non-blocking connect
+      begin
+        @socket.connect_nonblock(sockaddr)
+      rescue Errno::EINPROGRESS
+        # Wait with timeout for @socket to become writable.
+        # Is DEFAULT_SOCKET_TIMEOUT seconds an OK timeout for connect?
+        rd_wr_err = select([], [@socket], [], DEFAULT_SOCKET_TIMEOUT)
+        if rd_wr_err.nil?
+          # Timeout during connect, close socket and raise TimeoutError
+          @socket.close
+          raise TimeoutError.new(
+            'connection timed out in %.3f seconds' % DEFAULT_SOCKET_TIMEOUT)
+        end
+
+        # Verify that we're connected
+        begin
+          @socket.connect_nonblock(sockaddr)
+        rescue Errno::EISCONN # expected
+          # ignore
+        rescue # anything else, unexpected
+          # Close socket and re-raise
+          @socket.close
+          raise
+        end
+      end # non-blocking connect
+
       # Start thread that reads data from server.
       Thread.new do
-        # TODO: Monkey-patch gets so that it recognizes "\r" or "\n" as line
-        # endings.  Currently only recognizes fixed strings, so for now go with
-        # "\n".
-        while line = @socket.gets("\n") do
-          # Split line into words and unescape each word
-          words = line.chomp.split(/[ \t]+/).map! {|w| w.katcp_unescape!}
-          # Handle requests, replies, and informs based on first character of
-          # first word.
-          case words[0][0,1]
-          # Request
-          when '?'
-            # TODO Send 'unsupported' reply (or support requests from server?)
-          # Reply
-          when '!'
-            # TODO: Raise exception if name is not same as @reqname?
-            # TODO: Raise exception on non-ok?
-            # Enqueue words to @rxq
-            @rxq.enq(words)
-          # Inform
-          when '#'
-            # If the name is same as @reqname
-            if @reqname && @reqname == words[0][1..-1]
-              # Enqueue words to @rxq
-              @rxq.enq(words)
-            else
-              # Must be asynchronous inform message, add to list.
-              line.katcp_unescape!
-              line.chomp!
-              @informs << line
-            end
-          else
-            # Malformed line
-            # TODO: Log error better?
-            warn "malformed line: #{line.inspect}"
-          end
+        catch :giveup do
+          while true
+            begin
+              req_timeouts = 0
+              while req_timeouts < 2
+                # Use select to wait with timeout for data or error
+                rd_wr_err = select([@socket], [], [@socket], @socket_timeout)
+
+                # Handle timeout
+                if rd_wr_err.nil?
+                  # Timeout, increment req_timeout if we're expecting a reply,
+                  # then try again
+                  req_timeouts += 1 if @reqname
+                  next
+                end
+
+                # Handle error
+                if rd_wr_err[2][0]
+                  # Ignore unless we're expected a reply
+                  next unless @reqname
+                  # Otherwise, send double-bang error response, and give up
+                  @rxq.enq(['!!socket-error'])
+                  throw :giveup
+                end
+
+                # OK to read!
+
+                # TODO: Monkey-patch gets so that it recognizes "\r" or "\n" as
+                # line endings.  Currently only recognizes fixed strings, so for
+                # now go with "\n".
+                line = @socket.gets("\n")
+
+                # If EOF
+                if line.nil?
+                  # Send double-bang error response, and give up
+                  @rxq.enq(['!!socket-eof'])
+                  throw :giveup
+                end
+
+                # Split line into words and unescape each word
+                words = line.chomp.split(/[ \t]+/).map! {|w| w.katcp_unescape!}
+                # Handle requests, replies, and informs based on first character
+                # of first word.
+                case words[0][0,1]
+                # Request
+                when '?'
+                  # TODO Send 'unsupported' reply (or support requests from server?)
+                # Reply
+                when '!'
+                  # TODO: Raise exception if name is not same as @reqname?
+                  # TODO: Raise exception on non-ok?
+                  # Enqueue words to @rxq
+                  @rxq.enq(words)
+                # Inform
+                when '#'
+                  # If the name is same as @reqname
+                  if @reqname && @reqname == words[0][1..-1]
+                    # Enqueue words to @rxq
+                    @rxq.enq(words)
+                  else
+                    # Must be asynchronous inform message, add to list.
+                    line.katcp_unescape!
+                    line.chomp!
+                    @informs << line
+                  end
+                else
+                  # Malformed line
+                  # TODO: Log error better?
+                  warn "malformed line: #{line.inspect}"
+                end # case words[0][0,1]
+
+                # Reset req_timeouts counter
+                req_timeouts = 0
+
+              end # while req_timeouts < 2
+
+              # Got 2 timeouts in a request!
+              # Send double-bang timeout response
+              @rxq.enq(['!!socket-timeout'])
+              throw :giveup
+
+            rescue Exception => e
+              $stderr.puts e; $stderr.flush
+            end # begin
+          end # while true
+        end # catch :giveup
+      end # Thread.new block
 
-        end # @socket.each_line block
+      self
+    end #connect
 
-        warn "Read on socket returned EOF"
-        #TODO Close socket?  Push EOF flag into @rxq?
-      end # Thread.new block
+    # Close socket if it exists and is not already closed.  Subclasses can
+    # override #close to perform additional cleanup as needed, but they must
+    # either close the socket themselves or call super.
+    def close
+      @socket.close if connected?
+      self
+    end
+
+    # Returns true if socket has been created and not closed
+    def connected?
+      !@socket.nil? && !@socket.closed?
     end
 
     # Return remote hostname
@@ -103,31 +230,63 @@ module KATCP
     #
     #   TODO: Raise exception if reply is not OK?
     def request(name, *arguments)
+      # (Re-)connect if @socket is in an invalid state
+      connect if @socket.nil? || @socket.closed?
+
       # Massage name to allow Symbols and to allow '_' between words (since
       # that is more natural for Symbols) in place of '-'
-      name = name.to_s.gsub('_','-')
+      reqname = name.to_s.gsub('_','-')
 
       # Escape arguments
-      arguments.map! {|arg| arg.to_s.katcp_escape}
-
-      # Create response
-      resp = Response.new
-
-      # Get lock on @reqlock
-      @reqlock.synchronize do
-        # Store request name
-        @reqname = name
-        # Send request
-        req = "?#{[name, *arguments].join(' ')}\n"
-        @socket.print req
-        # Loop on reply queue until done or error
-        begin
-          words = @rxq.deq
-          resp << words
-        end until words[0][0,1] == '!'
-        # Clear request name
-        @reqname = nil
-      end
+      reqargs = arguments.map! {|arg| arg.to_s.katcp_escape}
+
+      # TODO Find a more elegant way to code this retry loop?
+      attempts = 0
+      while true
+        attempts += 1
+
+        # Create response
+        resp = Response.new
+
+        # Give "words" scope outside of synchronize block
+        words = nil
+
+        # Get lock on @reqlock
+        @reqlock.synchronize do
+          # Store request name
+          @reqname = reqname
+          # Send request
+          req = "?#{[reqname, *reqargs].join(' ')}\n"
+          @socket.print req
+          # Loop on reply queue until done or error
+          begin
+            words = @rxq.deq
+            resp << words
+          end until words[0][0,1] == '!'
+          # Clear request name
+          @reqname = nil
+        end # @reqlock.synchronize
+
+        # Break out of retry loop unless double-bang reply
+        break unless words[0][0,2] == '!!'
+
+        # Double-bang reply!!
+
+        # If we've already attempted more than once (i.e. twice)
+        if attempts > 1
+          # Raise exception
+          case words[0]
+          when '!!socket-timeout'; raise TimeoutError.new(resp)
+          when '!!socket-error'; raise SocketError.new(resp)
+          when '!!socket-eof'; raise SocketEOF.new(resp)
+          else raise RuntimeError.new(resp)
+          end
+        end
+
+        # Reconnect and try again
+        connect
+      end # while true
+
       resp
     end
 
@@ -151,7 +310,7 @@ module KATCP
 
     # Provides terse string representation of +self+.
     def to_s
-      s = "#{@remote_host}:#{@remote_port}"
+      "#{@remote_host}:#{@remote_port}"
     end
 
     # Provides more detailed String representation of +self+

data/lib/katcp/version.rb

@@ -3,5 +3,5 @@
 #++
 
 module KATCP
-  VERSION = "0.0.7"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: katcp
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 0
-  - 7
-  version: 0.0.7
+  - 1
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - David MacMahon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-06 00:00:00 Z
+date: 2013-03-04 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: narray
@@ -59,7 +59,7 @@ rdoc_options:
 - -m
 - README
 - --title
-- Ruby/KATCP 0.0.7 Documentation
+- Ruby/KATCP 0.1.4 Documentation
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement