libowl 1.2

data/lib/libowl/solver_world_model.rb

@@ -0,0 +1,220 @@
+#This class abstracts the details of connecting to a
+#GRAIL3 world model as a solver.
+
+require 'socket'
+require 'libowl/buffer_manip.rb'
+require 'libowl/wm_data.rb'
+require 'libowl/transient_request.rb'
+
+class SolverWorldModel
+  #TODO Move constants to their own file
+
+  #Message constants
+  KEEP_ALIVE       = 0;
+  TYPE_ANNOUNCE    = 1;
+  START_TRANSIENT  = 2;
+  STOP_TRANSIENT   = 3;
+  SOLVER_DATA      = 4;
+  CREATE_URI       = 5;
+  EXPIRE_URI       = 6;
+  DELETE_URI       = 7;
+  EXPIRE_ATTRIBUTE = 8;
+  DELETE_ATTRIBUTE = 9;
+
+  attr_accessor :name_to_alias, :alias_to_name, :connected
+  @name_to_alias
+  @alias_to_name
+
+  #The origin string of this solver
+  @origin
+
+  #Callback for when the world model requests transient data
+  @start_transient_callback
+  #Callback for when the world model no longer wants a transient type
+  @stop_transient_callback
+
+  #Handle a message of currently unknown type
+  def handleMessage()
+    #Get the message length as n unsigned integer
+    inlen = (@socket.recvfrom(4)[0]).unpack('N')[0]
+    inbuff = @socket.recvfrom(inlen)[0]
+    #Byte that indicates message type
+    control = inbuff.unpack('C')[0]
+    if control == START_TRANSIENT
+      if (@start_transient_callback != nil)
+        @start_transient_callback.call(decodeStartTransient(inbuff[1, inbuff.length - 1]))
+      end
+    elsif control == STOP_TRANSIENT
+      if (@stop_transient_callback != nil)
+        @stop_transient_callback.call(decodeStopTransient(inbuff[1, inbuff.length - 1]))
+      end
+    end
+    return control
+  end
+
+  #Decode a start transient message
+  def decodeStartTransient(inbuff)
+    num_aliases = inbuff.unpack('N')[0]
+    rest = inbuff[4, inbuff.length - 1]
+    new_trans_requests = []
+    for i in 1..num_aliases do
+      type_alias = rest.unpack('N')[0]
+      total_expressions = rest.unpack('N')[0]
+      t_request = TransientRequest.new(type_alias, [])
+      for j in 1..total_expressions do
+        exp, rest = splitURIFromRest(rest[4, rest.length - 1])
+        t_request.expressions.push(exp)
+      end
+      new_trans_requests.push(t_request)
+    end
+    return new_trans_requests
+  end
+
+  #Decode a stop transient message
+  def decodeStopTransient(inbuff)
+    num_aliases = inbuff.unpack('N')[0]
+    rest = inbuff[4, inbuff.length - 1]
+    new_trans_requests = []
+    for i in 1..num_aliases do
+      type_alias = rest.unpack('N')[0]
+      total_expressions = rest.unpack('N')[0]
+      t_request = TransientRequest.new(type_alias, [])
+      for j in 1..total_expressions do
+        exp, rest = splitURIFromRest(rest[4, rest.length - 1])
+        t_request.expressions.push(exp)
+      end
+      new_trans_requests.push(t_request)
+    end
+    return new_trans_requests
+  end
+
+  def initialize(host, port, origin, start_transient_callback = nil, stop_transient_callback = nil)
+    @origin = origin
+    @connected = false
+    @host = host
+    @port = port
+    @socket = TCPSocket.open(host, port)
+    handshake = ""
+    ver_string = "GRAIL world model protocol"
+    #The handshake is the length of the message, the protocol string, and the version (0).
+    handshake << [ver_string.length].pack('N') << ver_string << "\x00\x00"
+    #Receive a handshake and then send one
+    @socket.send(handshake, 0)
+    inshake = @socket.recvfrom(handshake.length)[0]
+    while (inshake.length < handshake.length)
+      puts "Waiting for #{handshake.length - inshake.length} byte more of handshake."
+      inshake += @socket.recvfrom(handshake.length - inshake.length)[0]
+    end
+
+    @connected = true
+    for i in 1..handshake.length
+      if handshake[i] != inshake[i]
+        puts "Handshake failure!"
+        puts "For byte i we sent #{handshake[i]} but got #{inshake[i]}"
+        @connected = false
+      end
+    end
+
+    @name_to_alias = {}
+    @alias_to_name = {}
+
+    @start_transient_callback = start_transient_callback
+    @stop_transient_callback = stop_transient_callback
+  end
+
+  #Add some SolutionType objects to the known list
+  def addSolutionTypes(attributes)
+    new_aliases = []
+    attributes.each { |attr|
+      if (@name_to_alias[attr.name] == nil)
+        new_alias = @name_to_alias.length
+        @name_to_alias[attr.name] = new_alias
+        @alias_to_name[new_alias] = attr.name
+        new_aliases.push([attr.name, new_alias])
+      end
+    }
+    if (new_aliases.length > 0)
+      makeTypeAnnounce(new_aliases)
+    end
+  end
+
+  def makeTypeAnnounce(type_pairs)
+    buff = [TYPE_ANNOUNCE].pack('C') + [type_pairs.length].pack('N')
+    for pair in type_pairs do
+      #TODO Not supporting transient types for now so always write a zero
+      #for the transient on/off byte
+      buff += [pair[1]].pack('N') + strToSizedUTF16(pair[0]) + [0].pack('C')
+    end
+    #Add the origin string to the end of the message
+    buff += strToUnicode(@origin)
+    @socket.send("#{[buff.length].pack('N')}#{buff}", 0)
+  end
+
+  ##
+  #Push URI attributes, automatically declaring new solution types
+  #as non-stremaing types if they were not previously declared.
+  def pushData(wmdata_vector, create_uris = false)
+    buff = [SOLVER_DATA].pack('C')
+    if (create_uris)
+      buff += [1].pack('C')
+    else
+      buff += [0].pack('C')
+    end
+
+    #Push back the total number of solutions
+    total_solns = wmdata_vector.inject(0){|sum, wmdata|
+      sum + wmdata.attributes.length
+    }
+    buff += [total_solns].pack('N')
+
+    #Now create each solution and push it back into the buffer
+    wmdata_vector.each{|wmdata|
+      #First make sure all of the solutions types have been declared
+      addSolutionTypes(wmdata.attributes)
+      #Now push back this attribute's data using an alias for the name
+      wmdata.attributes.each{|attr|
+        buff += [@name_to_alias[attr.name]].pack('N') +
+          packuint64(attr.creation) +
+          strToSizedUTF16(wmdata.uri) + [attr.data.length].pack('N') + attr.data
+      }
+    }
+    #Send the message with its length prepended to the front
+    @socket.send("#{[buff.length].pack('N')}#{buff}", 0)
+  end
+
+  ##
+  #Create an object with the given name in the world model.
+  def createURI(uri, creation_time)
+    buff = [CREATE_URI].pack('C')
+    buff += strToSizedUTF16(uri)
+    buff += packuint64(creation_time)
+    buff += strToUnicode(@origin)
+    #Send the message with its length prepended to the front
+    @socket.send("#{[buff.length].pack('N')}#{buff}", 0)
+  end
+
+  ##
+  #Expire the object with the given name in the world model, indicating that it
+  #is no longer valid after the given time.
+  def expireURI(uri, expiration_time)
+    buff = [EXPIRE_URI].pack('C')
+    buff += strToSizedUTF16(uri)
+    buff += packuint64(expiration_time)
+    buff += strToUnicode(@origin)
+    #Send the message with its length prepended to the front
+    @socket.send("#{[buff.length].pack('N')}#{buff}", 0)
+  end
+
+  ##
+  #Delete an object in the world model.
+  def deleteURI(uri)
+    buff = [DELETE_URI].pack('C')
+    buff += strToSizedUTF16(uri)
+    buff += strToUnicode(@origin)
+    #Send the message with its length prepended to the front
+    @socket.send("#{[buff.length].pack('N')}#{buff}", 0)
+  end
+
+  #TODO Expire a URI's attribute
+  #TODO Delete a URI's attribute
+end

data/lib/libowl/step_response.rb

@@ -0,0 +1,80 @@
+################################################################################
+#This file defines the StepResponse class, an object that represents data from
+#an owl world model that is sent for a streaming request. An instance of this
+#class will continually yield new data until the streaming request is cancelled.
+#
+# Copyright (c) 2013 Bernhard Firner
+# All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+# or visit http://www.gnu.org/licenses/gpl-2.0.html
+#
+################################################################################
+
+#Incrementeal response of a client streaming request to the world model
+class StepResponse
+  ##
+  #Initialize with the ClientWorldConnection that spawed this Response and
+  #the key of the request.
+  def initialize(cwc, key)
+    @cwc = cwc
+    @request_key = key
+  end
+
+  ##
+  #Get the data of this StepResponse, blocking until that data is ready or
+  #an error occurs.
+ def next()
+   while (not (hasNext() or isError()))
+     sleep(1)
+   end
+   if (isError())
+     raise getError()
+   else
+     return @cwc.getNext(@request_key)
+   end
+ end
+
+  ##
+  #Returns true if data is available for a call to next().
+ def hasNext()
+   return @cwc.hasNext(@request_key)
+ end
+
+  ##
+  #Returns true if an error has occured.
+ def isError()
+   return @cwc.hasError(@request_key)
+ end
+
+  ##
+  #Get the error that occured.
+ def getError()
+   return @cwc.getError(@request_key)
+ end
+
+ ##
+ #True if this streaming request will have no more data.
+ def isComplete()
+   return @cwc.isComplete(@request_key)
+ end
+
+ ##
+ #Cancel the streaming request.
+ def cancel()
+   return @cwc.cancelRequest(@request_key)
+ end
+end
+

data/lib/libowl/transient_request.rb

@@ -0,0 +1,14 @@
+#Transient specification - one attribute name an a list of name expressions
+
+class TransientRequest
+  #Attribute name
+  @name
+  #Requested expressions
+  @expressions
+  
+  def initialize(name, expressions)
+    @name = name
+    @expressions = expressions
+  end
+end
+

data/lib/libowl/wm_data.rb

@@ -0,0 +1,61 @@
+#Solution types used when communicating with the world model
+
+##
+#Function to fetch the current time in milliseconds. This is the time format
+#used in the Owl system and is included in every attribute pushed into the
+#world model and every attribute retrieved from the world model.
+def getMsecTime()
+  t = Time.now
+  return t.tv_sec * 1000 + t.usec/10**3
+end
+
+class WMAttribute
+  attr_accessor :name, :data, :creation, :expiration, :origin
+  #Name of this attribute
+  @name
+  #Binary buffer of attribute data
+  @data
+  #The creation and expiration dates of this attribute
+  #in milliseconds since midnight Jan 1, 1970
+  @creation
+  @expiration
+  #The origin of this data
+  @origin
+
+  def initialize(name, data, creation, expiration = 0, origin = "empty")
+    @name = name
+    @data = data
+    @creation = creation
+    @expiration = expiration
+    @origin = origin
+  end
+
+  def to_s()
+    return "\t#{@name}, #{@creation}, #{@expiration}, #{@origin}: #{@data.unpack('H*')}\n"
+  end
+end
+
+class WMData
+  attr_accessor :uri, :attributes, :ticket
+  #The object that this data modifies
+  @uri
+  #The attributes of the object
+  @attributes
+  #The request ticket that this data is associated with
+  @ticket
+
+  def initialize(uri, attributes, ticket = 0)
+    @uri = uri
+    @attributes = attributes
+    @ticket = ticket
+  end
+
+  def to_s()
+    str = "#{@uri}:\n"
+    for attr in @attributes do
+      str += "\t#{attr.name}, #{attr.creation}, #{attr.expiration}, #{attr.origin}: #{attr.data.unpack('H*')}\n"
+    end
+    return str
+  end
+end
+

data/lib/libowl.rb

@@ -0,0 +1,6 @@
+require 'libowl/solver_aggregator'
+require 'libowl/client_world_connection'
+require 'libowl/solver_world_model'
+require 'libowl/wm_data'
+require 'libowl/buffer_manip'
+

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: libowl
+version: !ruby/object:Gem::Version
+  version: '1.2'
+platform: ruby
+authors:
+- Bernhard Firner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-20 00:00:00.000000000 Z
+dependencies: []
+description: The libowl network protocols are the protocols used to interact with
+  the Owl platform or any other system that uses the GRAIL network protocols. Go to
+  www.owlplatform.com and github.com/OwlPlatform for more information.
+email: bfirner@eden.rutgers.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- lib/libowl.rb
+- lib/libowl/solution_types.rb
+- lib/libowl/transient_request.rb
+- lib/libowl/aggregator_rules.rb
+- lib/libowl/client_world_connection.rb
+- lib/libowl/client_world_model.rb
+- lib/libowl/solver_world_model.rb
+- lib/libowl/buffer_manip.rb
+- lib/libowl/response.rb
+- lib/libowl/step_response.rb
+- lib/libowl/message_constants.rb
+- lib/libowl/wm_data.rb
+- lib/libowl/sensor_sample.rb
+- lib/libowl/solver_aggregator.rb
+homepage: https://github.com/OwlPlatform/libruby
+licenses:
+- LGPL-2.1
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 3
+summary: Protocols for interacting with the owl platform.
+test_files: []