rserve-client 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.1.0 / 2010-05-21
+
+* First operational version. Can void_eval and eval on vectors. List needs more work

data/Manifest.txt

@@ -0,0 +1,31 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/rserve.rb
+lib/rserve/connection.rb
+lib/rserve/engine.rb
+lib/rserve/packet.rb
+lib/rserve/protocol.rb
+lib/rserve/protocol/rexpfactory.rb
+lib/rserve/rexp.rb
+lib/rserve/rexp/double.rb
+lib/rserve/rexp/genericvector.rb
+lib/rserve/rexp/integer.rb
+lib/rserve/rexp/list.rb
+lib/rserve/rexp/logical.rb
+lib/rserve/rexp/string.rb
+lib/rserve/rexp/symbol.rb
+lib/rserve/rexp/vector.rb
+lib/rserve/rlist.rb
+lib/rserve/talk.rb
+spec/rserve_connection_spec.rb
+spec/rserve_double_spec.rb
+spec/rserve_integer_spec.rb
+spec/rserve_packet_spec.rb
+spec/rserve_protocol_spec.rb
+spec/rserve_rexpfactory_spec.rb
+spec/rserve_spec.rb
+spec/rserve_talk_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,50 @@
+= rserve-client
+
+* http://github.com/clbustos/Rserve-Ruby-client
+
+
+== DESCRIPTION:
+
+Ruby client for Rserve, a Binary R server (http://www.rforge.net/Rserve/).
+
+Follows closely the new Java client API, but maintains all Ruby conventions when possible.
+
+Connection to Rserve not yet developed, but between June-July 2010 the system should be operational.
+
+== SYNOPSIS:
+
+  require 'rserve'
+  con=Rserve::Connection.new
+  con.eval("x<-renorm(1)")
+  => #<Rserve::REXP::Double:0x000000011a13c8 
+        @payload=[(5339785585931699/2251799813685248)], 
+	@attr=nil>
+
+== REQUIREMENTS:
+
+* R
+* Rserve
+
+== INSTALL:
+
+  sudo gem install rserve-client
+
+== LICENSE:
+
+REngine - Java interface to R
+Copyright (C) 2004,5,6,7  Simon Urbanek 
+Copyrigth (C) 2010 Claudio Bustos (Ruby version)
+
+This library 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.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY 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 this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

data/Rakefile

@@ -0,0 +1,14 @@
+# -*- ruby -*-
+$:.unshift(File.dirname(__FILE__)+"/lib")
+require 'rubygems'
+require 'hoe'
+require 'rserve'
+Hoe.plugin :git
+Hoe.spec 'rserve-client' do
+  self.testlib=:rspec
+   self.version=Rserve::VERSION
+   self.rubyforge_name = 'ruby-statsample' # if different than 'rserve'
+  self.developer('Claudio Bustos', 'clbustos_AT_gmail.com')
+end
+
+# vim: syntax=ruby

data/lib/rserve.rb

@@ -0,0 +1,14 @@
+require 'socket'
+
+module Rserve
+  VERSION = '0.1.0'
+end
+
+
+require 'rserve/protocol'
+require 'rserve/packet'
+require 'rserve/talk'
+require 'rserve/rexp'
+require 'rserve/engine'
+require 'rserve/connection'
+require 'rserve/rlist'

data/lib/rserve/connection.rb

@@ -0,0 +1,138 @@
+module Rserve
+  class Connection < Rserve::Engine
+    include Rserve::Protocol
+    ServerNotInstalled=Class.new(Exception)
+    IncorrectServer=Class.new(Exception)
+    IncorrectServerVersion=Class.new(Exception)
+    IncorrectProtocol=Class.new(Exception)
+    NotConnected=Class.new(Exception)
+    EvalError=Class.new(Exception)
+    attr_reader :protocol 
+    attr_reader :last_error
+    attr_reader :connected
+    attr_reader :auth_req
+    attr_reader :auth_type
+    attr_reader :key
+    attr_reader :rt
+    attr_reader :s
+    attr_reader :port
+    attr_writer :transfer_charset
+    attr_reader :rsrv_version
+    AT_plain=0
+    AT_crypt=1
+    
+    def host
+      @hostname
+    end
+    def initialize(opts=Hash.new)
+      @auth_req=false
+      @transfer_charset="UTF-8"
+      @auth_type=AT_plain
+      @hostname="127.0.0.1"
+      @port_number=6311
+      @tries=0
+      @max_tries=5
+      @connected=false
+      begin 
+        #puts "Tryin to connect..."
+        connect
+      rescue Errno::ECONNREFUSED
+        if @tries<@max_tries
+          #puts "Init RServe"
+          if system "R CMD Rserve"
+          #puts "Ok"
+            retry
+	  else
+	    raise ServerNotInstalled, "Rserve not installed"
+	  end
+        else
+          raise
+        end
+      end
+      
+    end
+    def is
+      @s
+    end
+    def os
+      @s
+    end
+    def connect
+        close if @connected
+        @s = TCPSocket::new(@hostname, @port_number)
+        @rt=Rserve::Talk.new(@s)
+        #puts "Connected"
+        # Accept first input
+        input=@s.recv(32).unpack("a4a4a4a20")
+        raise IncorrectServer,"Handshake failed: Rsrv signature expected, but received #{input[0]}" unless input[0]=="Rsrv"
+        @rsrv_version=input[1].to_i
+        raise IncorrectServerVersion, "Handshake failed: The server uses more recent protocol than this client." if @rsrv_version>103
+        @protocol=input[2]
+        raise IncorrectProtocol, "Handshake failed: unsupported transfer protocol #{@protocol}, I talk only QAP1." if @protocol!="QAP1"
+        @extra=input[4]
+        @connected=true
+        @last_error="OK"
+
+    end
+    def connected?
+      @connected
+    end
+    def close
+        @s.shutdown if !@s.nil? and !@s.closed?
+        @connected=false
+        return true
+    end
+    def get_server_version
+      @rsrv_version
+    end
+    
+    # evaluates the given command, but does not fetch the result (useful for assignment operations)
+    # * @param cmd command/expression string */
+    def void_eval(cmd) 
+      raise NotConnected if !connected? or rt.nil?
+      rp=rt.request(:cmd=>Rserve::Protocol::CMD_voidEval, :cont=>cmd+"\n")
+      if !rp.nil? and rp.ok?
+        true
+      else
+        raise EvalError, "voidEval failed: #{rp.to_s}"
+      end
+      
+    end
+    
+    
+  # evaluates the given command and retrieves the result
+  # * @param cmd command/expression string
+  # * @return R-xpression or <code>null</code> if an error occured */
+  def eval(cmd) 
+		raise NotConnected if !connected? or rt.nil?
+    rp=rt.request(:cmd=>Rserve::Protocol::CMD_eval, :cont=>cmd+"\n")
+    if !rp.nil? and rp.ok?
+      parse_eval_response(rp)
+    else
+      raise EvalError, "voidEval failed: #{rp.to_s}"
+    end
+  end
+  def parse_eval_response(rp)
+    rxo=0
+    pc=rp.cont
+    if (rsrv_version>100) # /* since 0101 eval responds correctly by using DT_SEXP type/len header which is 4 bytes long */
+			rxo=4
+			# we should check parameter type (should be DT_SEXP) and fail if it's not
+			if (pc[0]!=Rserve::Protocol::DT_SEXP && pc[0]!=(Rserve::Protocol::DT_SEXP|Rserve::Protocol::DT_LARGE))
+				raise "Error while processing eval output: SEXP (type "+Rserve::Protocol::DT_SEXP+") expected but found result type "+pc[0].to_s+"."
+      end
+			if (pc[0]==(Rserve::Protocol::DT_SEXP|Rserve::Protocol::DT_LARGE))
+				rxo=8; # large data need skip of 8 bytes
+      end
+			# warning: we are not checking or using the length - we assume that only the one SEXP is returned. This is true for the current CMD_eval implementation, but may not be in the future. */
+    end
+    if pc.length>rxo 
+        rx=REXPFactory.new;
+				rx.parse_REXP(pc, rxo);
+				return rx.get_REXP();
+      else
+        return nil
+    end
+  end
+end
+end

data/lib/rserve/engine.rb

@@ -0,0 +1,40 @@
+module Rserve
+  class Engine
+    def parse(text,resolve);end
+    def evaluate(what, where, resolve); end;
+    def assign(symbol, value, env=nil);end;
+    def get(symbol, env, resolve);end;
+    def resolve_reference(ref);end;
+    def create_reference(value);end;
+    def finalize_reference(ref);end;
+    def get_parent_enviroment(env,resolve);end;
+    def new_enviroment(parent,resolve);end;
+    def parse_and_eval(text,where=nil,resolve=true)
+      p=parse(text,false)
+      evaluate(p,where,resolve)
+    end
+    def close;
+      false
+    end
+    def supports_references?
+      false
+    end
+    def supports_enviroments?
+      false
+    end
+    def supports_REPL?
+      false
+    end
+    def suuports_locking?
+      false
+    end
+    def try_lock
+      0
+    end
+    def lock
+      0
+    end
+    def unlock;end;
+    
+  end
+end

data/lib/rserve/packet.rb

@@ -0,0 +1,31 @@
+module Rserve
+  class Packet
+    attr_reader :cont
+    attr_reader :cmd
+    def initialize(cmd, cont)
+      raise "cont [#{cont.class} - #{cont.to_s}] should respond to :length" if !cont.nil? and !cont.respond_to? :length
+      @cmd=cmd
+      @cont=cont
+    end
+    def cont_len
+      @cont.nil? ? 0 : @cont.length
+    end
+    def ok?
+      @cmd&15==1
+    end
+    def error?
+      @cmd&15==2
+    end
+    def stat
+      (@cmd>>24)&127
+    end
+    def to_s
+      if error?
+        status="status=error - #{stat}"
+      else
+        status="status=ok"
+      end
+      "Packet[cmd=#{@cmd},len="+((cont.nil?)?"<nil>":(""+cont.length.to_s))+", con='"+(cont.nil?  ? "<nil>" : cont.pack("C*"))+"', status=#{status}]"
+    end
+  end
+end

data/lib/rserve/protocol.rb

@@ -0,0 +1,183 @@
+module Rserve
+  #
+  # This module encapsulates methods and constants related to QAP1 protocol used by Rserv. Follows almost exactly the interface on RTalk class 
+  # on Java version, except for use of undescores instead of CamelCase
+  # Implementation could differ if a cleaner/faster ruby version is available
+  # 
+  # Policy: No other class should know about the internal of protocol!
+  # See Rtalk class on Java version.
+  module Protocol
+    # Defines from Rsrv.h
+    CMD_RESP=0x010000 # all responses have this flag set
+    RESP_OK=(CMD_RESP|0x0001) # command succeeded; returned parameters depend on the command issued 
+    RESP_ERR=(CMD_RESP|0x0002) # command failed, check stats code attached string may describe the error
+    
+    ERR_auth_failed=0x41 # auth.failed or auth.requested but no login came. in case of authentification failure due to name/pwd mismatch, server may send CMD_accessDenied instead
+    ERR_conn_broken=0x42 #  connection closed or broken packet killed it */
+    ERR_inv_cmd=0x43 #  unsupported/invalid command */
+    ERR_inv_par=0x44 #  some parameters are invalid */
+    ERR_Rerror=0x45 #  R-error occured, usually followed by connection shutdown */
+    ERR_IOerror=0x46 #  I/O error */
+    ERR_notOpen=0x47 #  attempt to perform fileRead/Write  on closed file */
+    ERR_accessDenied=0x48 #  this answer is also valid on CMD_login; otherwise it's sent if the server deosn;t allow the user to issue the specified command. (e.g. some server admins may block file I/O operations for some users) 
+    ERR_unsupportedCmd=0x49 #  unsupported command */
+    ERR_unknownCmd=0x4a #  unknown command - the difference between unsupported and unknown is that unsupported commands are known to the server but for some reasons (e.g. platform dependent) it's not supported. unknown commands are simply not recognized by the server at all. */
+    ERR_data_overflow=0x4b #  incoming packet is too big. currently there is a limit as of the size of an incoming packet. */
+    ERR_object_too_big=0x4c #  the requested object is too big to be transported in that way. If received after CMD_eval then the evaluation itself was successful. optional parameter is the size of the object 
+    ERR_out_of_mem=0x4d #  out of memory. the connection is usually closed after this error was sent 
+    ERR_ctrl_closed=0x4e #  control pipe to the master process is closed or broken 
+    ERR_session_busy=0x50 #  session is still busy */
+    ERR_detach_failed=0x51 #  unable to detach seesion (cannot determine peer IP or problems creating a listening socket for resume) */
+    
+    
+    CMD_login=0x001 #  "name\npwd" : - */
+    CMD_voidEval=0x002 #  string : - */
+    CMD_eval=0x003 #  string : encoded SEXP */
+    CMD_shutdown=0x004 #  [admin-pwd] : - */
+    
+    #/* file I/O routines. server may answe */
+    CMD_openFile=0x010 #  fn : - */
+    CMD_createFile=0x011 #  fn : - */
+    CMD_closeFile=0x012 #  - : - */
+    CMD_readFile=0x013 #  [int size] : data... ; if size not present,
+      #server is free to choose any value - usually
+      #it uses the size of its static buffer */
+    CMD_writeFile=0x014 #  data : - */
+    CMD_removeFile=0x015 #  fn : - */
+    
+    # /* object manipulation */
+    CMD_setSEXP=0x020 #  string(name), REXP : - */
+    CMD_assignSEXP=0x021 #  string(name), REXP : - ; same as setSEXP except that the name is parsed */
+    
+    # /* session management (since 0.4-0) */
+    CMD_detachSession=0x030 #  : session key */
+    CMD_detachedVoidEval=0x031 #  string : session key; doesn't */
+    CMD_attachSession=0x032 #  session key : - */  
+    
+    # control commands (since 0.6-0) - passed on to the master process */
+    # Note: currently all control commands are asychronous, i.e. RESP_OK
+    # indicates that the command was enqueued in the master pipe, but there
+    # is no guarantee that it will be processed. Moreover non-forked
+    # connections (e.g. the default debug setup) don't process any
+    # control commands until the current client connection is closed so
+    # the connection issuing the control command will never see its
+    # result.
+    CMD_ctrl=0x40  #  -- not a command - just a constant -- */
+    CMD_ctrlEval=0x42  #  string : - */
+    CMD_ctrlSource=0x45  #  string : - */
+    CMD_ctrlShutdown=0x44  #  - : - */
+    
+    # /* 'internal' commands (since 0.1-9) */
+    CMD_setBufferSize=0x081  #  [int sendBufSize]  this commad allow clients to request bigger buffer sizes if large data is to be transported from Rserve to the client. (incoming buffer is resized automatically) */
+    CMD_setEncoding=0x082  #  string (one of "native","latin1","utf8") : -; since 0.5-3 */
+    
+    # /* special commands - the payload of packages with this mask does not contain defined parameters */
+    
+    CMD_SPECIAL_MASK=0xf0
+    
+    CMD_serEval=0xf5 #  serialized eval - the packets are raw serialized data without data header */
+    CMD_serAssign=0xf6 #  serialized assign - serialized list with [[1]]=name, [[2]]=value */
+    CMD_serEEval=0xf7 #  serialized expression eval - like serEval with one additional evaluation round */
+    
+    #  data types for the transport protocol (QAP1)do NOT confuse with XT_.. values. 
+    
+    DT_INT=1  #  int */
+    DT_CHAR=2  #  char */
+    DT_DOUBLE=3  #  double */
+    DT_STRING=4  #  0 terminted string */
+    DT_BYTESTREAM=5  #  stream of bytes (unlike DT_STRING may contain 0) */
+    DT_SEXP=10 #  encoded SEXP */
+    DT_ARRAY=11 #  array of objects (i.e. first 4 bytes specify how many subsequent objects are part of the array; 0 is legitimate) */
+    DT_LARGE=64 #  new in 0102: if this flag is set then the length of the object is coded as 56-bit integer enlarging the header by 4 bytes */
+    
+    # writes bit-wise int to a byte buffer at specified position in Intel-endian form
+    # Internal: byte buffer will be the result of unpack("CCCC") an integer.
+    # @param v value to be written
+    # @param buf buffer
+    # @param o offset in the buffer to start at. An int takes always 4 bytes */
+    def  set_int(v, buf, o)
+      buf[o]=(v&255);o+=1
+      buf[o]=((v&0xff00)>>8); o+=1
+      buf[o]=((v&0xff0000)>>16); o+=1
+      buf[o]=((v&0xff000000)>>24);
+    end
+    
+    # writes cmd/resp/type byte + 3/7 bytes len into a byte buffer at specified offset.
+    # @param ty type/cmd/resp byte
+    # @param len length
+    # @param buf buffer
+    # @param o offset
+    # @return offset in buf just after the header. Please note that since Rserve 0.3 the header can be either 4 or 8 bytes long, depending on the len parameter.
+    def set_hdr(ty, len, buf, o)
+      buf[o]=((ty&255)|((len>0xfffff0) ? DT_LARGE : 0)); o+=1;
+      buf[o]=(len&255); o+=1;
+      buf[o]=((len&0xff00)>>8); o+=1;
+      buf[o]=((len&0xff0000)>>16); o+=1;
+      if (len>0xfffff0)  # for large data we need to set the next 4 bytes as well
+        buf[o]=((len&0xff000000)>>24); o+=1;
+        buf[o]=0; o+=1; # since len is int, we get 32-bits only
+        buf[o]=0; o+=1;
+        buf[o]=0; o+=1;
+      end
+      o
+    end
+    # creates a new header according to the type and length of the parameter
+    # @param ty type/cmd/resp byte
+    # @param len length 
+    def new_hdr(ty, len)
+      hdr=Array.new(  (len>0xfffff0)?8:4)
+      set_hdr(ty,len,hdr,0);
+      hdr
+    end
+    # 
+    # converts bit-wise stored int in Intel-endian form into ruby int
+    #
+    # @param buf buffer containg the representation
+    # @param o offset where to start (4 bytes will be used)
+    # @return the int value. no bounds checking is done so you need to
+    # make sure that the buffer is big enough 
+    
+    def get_int(buf, o) 
+      return buf.slice(o,4).pack("C*").unpack("I")[0]
+      #return ((buf[o]&255)|((buf[o+1]&255)<<8)|((buf[o+2]&255)<<16)|((buf[o+3]&255)<<24));
+    end
+    
+    # converts bit-wise stored length from a header. "long" format is supported up to 32-bit
+    # @param buf buffer
+    # @param o offset of the header (length is at o+1)
+    # @return length */
+    def get_len(buf, o) 
+# // "long" format; still - we support 32-bit only
+      if  ((buf[o]&64)>0)
+        (buf[o+1]&255)|((buf[o+2]&255)<<8)|((buf[o+3]&255)<<16)|((buf[o+4]&255)<<24)
+      else
+        (buf[o+1]&255)|((buf[o+2]&255)<<8)|((buf[o+3]&255)<<16)
+      end
+    end
+    
+    # converts bit-wise Intel-endian format into long
+    # @param buf buffer
+    # @param o offset (8 bytes will be used)
+    # @return long value */
+    def get_long(buf, o) 
+      low=(get_int(buf,o))&0xffffffff;
+      hi=(get_int(buf,o+4))&0xffffffff;
+      hi<<=32; hi|=low;
+      hi
+    end
+    def longBitsToDouble(bits)
+       s = ((bits >> 63) == 0) ? 1 : -1;
+       e = ((bits >> 52) & 0x7ff)
+       m = (e == 0) ?
+                 (bits & 0xfffffffffffff) << 1 :
+                 (bits & 0xfffffffffffff) | 0x10000000000000;
+       s*m*2**(e-1075)
+    end
+    def set_long(l, buf, o) 
+      set_int((l&0xffffffff),buf,o)
+      set_int((l>>32),buf,o+4)
+    end
+  end
+end
+
+require 'rserve/protocol/rexpfactory'