motel 0.3 → 0.3.1

data/lib/motel/location.rb

@@ -7,6 +7,8 @@ require 'motel/movement_strategy'
 
 module Motel
 
+# FIXME Motel locations need concurrent access protection, add here (?)
+
 # A Location defines an optional parent location and the x,y,z
 # cartesian  coordinates of the location relative to that parent.
 # If parent is not specified x,y,z are ignored and this location
@@ -27,6 +29,9 @@ class Location
    # array of callbacks to be invoked on movement
    attr_accessor :movement_callbacks
 
+   # Array of callbacks to be invoked on proximity
+   attr_accessor :proximity_callbacks
+
    # a generic association which this location can belong to
    attr_accessor :entity
 
@@ -34,8 +39,13 @@ class Location
       # default to the stopped movement strategy
       @movement_strategy = MovementStrategies::Stopped.instance
       @movement_callbacks = []
+      @proximity_callbacks = []
       @children = []
 
+      @x = nil
+      @y = nil
+      @z = nil
+
       @id = args[:id] if args.has_key? :id
       @parent_id = args[:parent_id] if args.has_key? :parent_id
       @x = args[:x] if args.has_key? :x
@@ -44,10 +54,6 @@ class Location
       @parent = args[:parent] if args.has_key? :parent
       @parent.children.push self unless @parent.nil? || @parent.children.include?(self)
       @movement_strategy = args[:movement_strategy] if args.has_key? :movement_strategy
-
-      @x = 0 if @x.nil?
-      @y = 0 if @y.nil?
-      @z = 0 if @z.nil?
    end
 
    # update this location's attributes to match other's set attributes
@@ -60,6 +66,11 @@ class Location
       @parent_id = location.parent_id unless location.parent_id.nil?
    end
 
+   # return this locations coordinates in an array
+   def coordinates
+     [@x, @y, @z]
+   end
+
    # return this location's root location
    def root
      return self if parent.nil?
@@ -95,6 +106,14 @@ class Location
      return parent.total_z + z
    end
 
+   # return the distance between this location and specified other
+   def -(location)
+     dx = x - location.x
+     dy = y - location.y
+     dz = z - location.z
+     Math.sqrt(dx ** 2 + dy ** 2 + dz ** 2)
+   end
+
 end
 
 end # module Motel

data/lib/motel/movement_strategies/elliptical.rb

@@ -46,6 +46,7 @@ class Elliptical < MovementStrategy
      @direction_minor_x   = 0 if @direction_minor_x.nil?
      @direction_minor_y   = 1 if @direction_minor_y.nil?
      @direction_minor_z   = 0 if @direction_minor_z.nil?
+     super(args)
 
      @direction_major_x, @direction_major_y, @direction_major_z = 
          normalize(@direction_major_x, @direction_major_y, @direction_major_z)

data/lib/motel/movement_strategies/linear.rb

@@ -23,6 +23,7 @@ class Linear < MovementStrategy
      @direction_vector_y   = args[:direction_vector_y] if args.has_key? :direction_vector_y
      @direction_vector_z   = args[:direction_vector_z] if args.has_key? :direction_vector_z
      @speed                = args[:speed] if args.has_key? :speed
+     super(args)
 
      # normalize direction vector
      @direction_vector_x, @direction_vector_y, @direction_vector_z =

data/lib/motel/movement_strategy.rb

@@ -11,13 +11,14 @@ module Motel
 # MovementStrategy subclasses define the rules and params which 
 # a location changes its position. 
 class MovementStrategy
+   attr_accessor :id, :type
+
    attr_accessor :step_delay
    
    def initialize(args = {})
-      @step_delay = 5
-      @movement_callbacks = []
+      @step_delay = 1
 
-      @step_delay = args[:step_delay] if args.has_key? :step_delay
+      @step_delay = args[:step_delay] if args.has_key?(:step_delay) && !args[:step_delay].nil?
    end
 
    # default movement strategy is to do nothing

data/lib/motel/runner.rb

@@ -6,7 +6,6 @@
 # Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
 
 require 'singleton'
-require 'motel/thread_pool'
 
 module Motel
 
@@ -17,44 +16,79 @@ module Motel
 class Runner
   include Singleton
 
-  # locations being managed
-  attr_accessor :locations
-
-  # for testing purposes
-  attr_reader :thread_pool, :terminate, :run_thread
+  # For testing purposes
+  attr_reader :terminate, :run_thread
 
   def initialize(args = {})
+    # is set to true upon runner termination
     @terminate = false
-    @locations = []
-    @locations_lock = Mutex.new
+
+    # TODO use ruby tree to store locations w/ heirarchy
+    # management queues, locations to be scheduled and locations to be run
+    @schedule_queue = []
+    @run_queue = []
+
+
+    # locks protecting queues from concurrent access and conditions indicating queues have items
+    @schedule_lock  = Mutex.new
+    @run_lock       = Mutex.new
+    @schedule_cv    = ConditionVariable.new
+    @run_cv         = ConditionVariable.new
 
     @run_thread = nil
-    @run_delay  = 2 # FIXME scale delay (only needed if locations is empty or has very few simple elements)
   end
 
+  # Return complete list of locations being managed/tracked
+  def locations
+    # need conccurrent protection here, or copy the elements into another array and return that?
+    @schedule_queue + @run_queue
+  end
+
+
   # Empty the list of locations being managed/tracked
   def clear
-    @locations_lock.synchronize { 
-      @locations.clear
-    }
+    @schedule_lock.synchronize {
+      @run_lock.synchronize {
+        @schedule_queue.clear
+        @run_queue.clear
+    }}
   end
 
-  # add location to runner to be managed, after this is called, the location's 
+  # Add location to runner to be managed, after this is called, the location's
   # movement strategy's move method will be invoked periodically
   def run(location)
-    @locations_lock.synchronize { 
-      Logger.debug "adding location #{location.id} to run queue"
-      @locations.push location
+    @schedule_lock.synchronize {
+      # autogenerate location.id if nil
+      if location.id.nil?
+        @run_lock.synchronize {
+          i = 1
+          until false
+            break if @schedule_queue.find { |l| l.id == i }.nil? && @run_queue.find { |l| l.id == i }.nil?
+            i += 1
+          end
+          location.id = i
+        }
+      end
+
+      Logger.debug "adding location #{location.id} to runner queue"
+      @schedule_queue.push location
+      @schedule_cv.signal
     }
+    return location
+  end
+
+  # Wrapper around run, except return 'self' when done
+  def <<(location)
+    run(location)
+    return self
   end
 
   # Start moving the locations. If :async => true is passed in, this will immediately
   # return, else this will block until stop is called.
   def start(args = {})
-    num_threads = 5
-    num_threads = args[:num_threads] if args.has_key? :num_threads
+    @num_threads = 5
+    @num_threads = args[:num_threads] if args.has_key? :num_threads
     @terminate = false
-    @thread_pool = ThreadPool.new(num_threads)
 
     if args.has_key?(:async) && args[:async]
       Logger.debug "starting async motel runner"
@@ -70,7 +104,12 @@ class Runner
   def stop
     Logger.debug "stopping motel runner"
     @terminate = true
-    @thread_pool.shutdown
+    @schedule_lock.synchronize {
+      @schedule_cv.signal
+    }
+    @run_lock.synchronize {
+      @run_cv.signal
+    }
     join
     Logger.debug "motel runner stopped"
   end
@@ -85,35 +124,94 @@ class Runner
 
     # Internal helper method performing main runner operations
     def run_cycle
-      # track time between runs
-      start_time = Time.now
+      # location ids which are currently being run -> their run timestamp
+      location_timestamps = {}
+
+      # scheduler thread, to add locations to the run queue
+      scheduler = Thread.new {
+        until @terminate
+          tqueue       = []
+          locs_to_run  = []
+          empty_queue  = true
+          min_delay    = nil
+
+          @schedule_lock.synchronize {
+            # if no locations are to be scheduled, block until there are
+            @schedule_cv.wait(@schedule_lock) if @schedule_queue.empty?
+            @schedule_queue.each { |l| tqueue << l }
+          }
+
+          # run through each location to be scheduled to run, see which ones are due
+          tqueue.each { |loc|
+            location_timestamps[loc.id] = Time.now unless location_timestamps.has_key?(loc.id)
+            locs_to_run << loc if loc.movement_strategy.step_delay < Time.now - location_timestamps[loc.id]
+          }
+
+          # add those the the run queue, signal runner to start operations if blocking
+          @schedule_lock.synchronize {
+            @run_lock.synchronize{
+              locs_to_run.each { |loc| @run_queue << loc ; @schedule_queue.delete(loc) }
+              empty_queue = (@schedule_queue.size == 0)
+              @run_cv.signal unless locs_to_run.empty?
+            }
+          }
 
+          # if there are locations still to be scheduled, sleep for the smallest step_delay
+          unless empty_queue
+            # we use locations instead of @schedule_queue here since a when the scheduler is
+            # sleeping a loc w/ a smaller step_delay may complete running and be added back to the scheduler
+            min_delay= locations.sort { |a,b| 
+              a.movement_strategy.step_delay <=> b.movement_strategy.step_delay 
+            }.first.movement_strategy.step_delay
+            sleep min_delay
+          end
+        end
+      }
+
+      # until we are told to stop
       until @terminate
-        # copy locations into temp 2nd array so we're not holding up lock on locations array
-        tlocations = []
-        @locations_lock.synchronize {
-          @locations.each { |loc| tlocations.push loc }
+        locs_to_schedule = []
+        tqueue           = []
+
+        @run_lock.synchronize{
+          # wait until we have locations to run
+          @run_cv.wait(@run_lock) if @run_queue.empty?
+          @run_queue.each { |l| tqueue << l }
         }
 
-        tlocations.each { |loc|
-          @thread_pool.dispatch(loc) { |loc|
-            Logger.debug "runner moving location #{loc.id} via #{loc.movement_strategy.class.to_s}"
+        # run through each location to be run, perform actual movement, invoke callbacks
+        tqueue.each { |loc|
+          Logger.debug "runner moving location #{loc.id} at #{loc.coordinates.join(",")} via #{loc.movement_strategy.class.to_s}"
 
-            loc.movement_strategy.move loc, start_time - Time.now
-            start_time = Time.now
+          # store the old location coordinates for comparison after the movement
+          old_coords = [loc.x, loc.y, loc.z]
 
-            # TODO see if loc coordinates changed b4 doing this
-            loc.movement_callbacks.each { |callback|
-                callback.call(loc)
-            }
+          elapsed = Time.now - location_timestamps[loc.id]
+          loc.movement_strategy.move loc, elapsed 
+          location_timestamps[loc.id] = Time.now
 
-            ## delay as long as the strategy tells us to
-            sleep loc.movement_strategy.step_delay
+          # TODO invoke these async so as not to hold up the runner
+          # make sure to keep these in sync w/ those invoked in the simrpc adapter "update_location" handler
+          loc.movement_callbacks.each { |callback|
+            callback.invoke(loc, *old_coords)
           }
+          loc.proximity_callbacks.each { |callback|
+            callback.invoke(loc)
+          }
+
+          locs_to_schedule << loc
         }
 
-        sleep @run_delay
+        # add locations back to schedule queue
+        @run_lock.synchronize{
+          @schedule_lock.synchronize{
+            locs_to_schedule.each { |loc| @schedule_queue << loc ; @run_queue.delete(loc) }
+            @schedule_cv.signal unless locs_to_schedule.empty?
+          }
+        }
       end
+
+      scheduler.join
     end
 
 end

data/lib/motel/simrpc_adapter.rb

@@ -0,0 +1,190 @@
+# Motel simrpc adapter
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'simrpc'
+
+module Motel
+
+# Motel::Server defines a server endpoint which manages locations
+# and responds to simrpc requests
+class Server
+  def initialize(args = {})
+    simrpc_args = args
+    simrpc_args[:id] = "location-server"
+
+    # create a simprc node
+    @simrpc_node = Simrpc::Node.new(simrpc_args)
+
+    # register handlers for the various motel simrpc methods
+    @simrpc_node.handle_method("get_location") { |location_id|
+       Logger.info "received get location #{location_id} request"
+       loc = nil
+       begin
+         loc = Runner.instance.locations.find { |loc| loc.id == location_id }
+         # FIXME traverse all of loc's descendants, and if remote location
+         # server is specified, send request to get child location, swapping
+         # it in for the one thats there
+       rescue Exception => e
+         Logger.warn "get location #{location_id} failed w/ exception #{e}"
+       end
+       Logger.info "get location #{location_id} request returning #{loc}"
+       loc
+    }
+
+    @simrpc_node.handle_method("create_location") { |location|
+       Logger.info "received create location request"
+       location = Location.new if location.nil?
+       ret = location
+       begin
+         location.x = 0 if location.x.nil?
+         location.y = 0 if location.y.nil?
+         location.z = 0 if location.z.nil?
+
+         # TODO decendants support w/ remote option (create additional locations on other servers)
+         Runner.instance.run location
+
+       rescue Exception => e
+         Logger.warn "create location failed w/ exception #{e}"
+         ret = nil
+       end
+       Logger.info "create location request created and returning #{ret.id}"
+       ret
+    }
+
+    @simrpc_node.handle_method("update_location") { |location|
+       Logger.info "received update location #{location.id} request"
+       success = true
+       if location.nil?
+         success = false
+       else
+         rloc = Runner.instance.locations.find { |loc| loc.id == location.id  }
+         begin
+           # store the old location coordinates for comparison after the movement
+           old_coords = [location.x, location.y, location.z]
+
+           # FIXME XXX big problem/bug here, client must always specify location.movement_strategy, else location constructor will set it to stopped
+           # FIXME this should halt location movement, update location, then start it again
+           Logger.info "updating location #{location.id} with #{location}/#{location.movement_strategy}"
+           rloc.update(location)
+
+           # FIXME trigger location movement & proximity callbacks (make sure to keep these in sync w/ those invoked the the runner)
+           # right now we can't do this because a single simrpc node can't handle multiple sent message response, see FIXME XXX in lib/simrpc/node.rb
+           #rloc.movement_callbacks.each { |callback|
+           #  callback.invoke(rloc, *old_coords)
+           #}
+           #rloc.proximity_callbacks.each { |callback|
+           #  callback.invoke(rloc)
+           #}
+
+         rescue Exception => e
+           Logger.warn "update location #{location.id} failed w/ exception #{e}"
+           success = false
+         end
+       end
+       Logger.info "update location #{location.id} returning #{success}"
+       success
+    }
+
+    @simrpc_node.handle_method("subscribe_to_location_movement") { |client_id, location_id, min_distance, min_x, min_y, min_z|
+       Logger.info "subscribe client #{client_id} to location #{location_id} movement request received"
+       loc = Runner.instance.locations.find { |loc| loc.id == location_id  }
+       success = true
+       if loc.nil? 
+         success = false
+       else
+         callback = Callbacks::Movement.new :min_distance => min_distance, :min_x => min_x, :min_y => min_y, :min_z => min_z,
+                                            :handler => lambda { |location, d, dx, dy, dz|
+           # send location to client
+           @simrpc_node.send_method("location_moved", client_id, location, d, dx, dy, dz)
+         }
+         loc.movement_callbacks.push callback
+       end
+       Logger.info "subscribe client #{client_id} to location #{location_id} movement returning  #{success}"
+       success
+    }
+
+    @simrpc_node.handle_method("subscribe_to_locations_proximity") { |client_id, location1_id, location2_id, event, max_distance, max_x, max_y, max_z|
+       Logger.info "subscribe client #{client_id} to location #{location1_id}/#{location2_id} proximity request received"
+       loc1 = Runner.instance.locations.find { |loc| loc.id == location1_id  }
+       loc2 = Runner.instance.locations.find { |loc| loc.id == location2_id  }
+       success = true
+       if loc1.nil? || loc2.nil?
+         success = false
+       else
+         callback = Callbacks::Proximity.new :to_location => loc2, :event => event, :max_distance => max_distance, :max_x => max_x, :max_y => max_y, :max_z => max_z,
+                                            :handler => lambda { |location1, location2|
+           # send locations to client
+           @simrpc_node.send_method("locations_proximity", client_id, location1, location2)
+         }
+         loc1.proximity_callbacks.push callback
+       end
+       Logger.info "subscribe client #{client_id} to location #{location1_id}/#{location2_id} proximity request returning  #{success}"
+       success
+    }
+  end
+
+  def terminate
+    @simrpc_node.terminate
+  end
+
+  def join
+     @simrpc_node.join
+  end
+end
+
+# Client defines a client endpoint that performs
+# a request against a Motel Server
+class Client
+  # Set to a callable object that will take a location and distance moved
+  attr_writer :on_location_moved
+
+  # Set to a callable object that will take two locations
+  attr_writer :on_locations_proximity
+
+  # Initialize the client with various args, all of which are passed onto Simrpc::Node constructor
+  def initialize(args = {})
+    simrpc_args = args
+    simrpc_args[:destination] = "location-server"
+
+    @simrpc_node =  Simrpc::Node.new(simrpc_args)
+  end
+
+  def join
+     @simrpc_node.join
+  end
+
+  def request(target, *args)
+     method_missing(target, *args)
+  end
+
+  # pass simrpc method requests right onto the simrpc node
+  def method_missing(method_id, *args)
+     # special case for subsscribe_to_location, 
+     if method_id == :subscribe_to_location_movement
+        # add simrpc node id onto args list
+        args.unshift @simrpc_node.id
+
+        # handle location updates from the server, & issue subscribe request
+        @simrpc_node.handle_method("location_moved") { |location, d, dx, dy, dz| 
+           Logger.info "location #{location.id} moved"
+           @on_location_moved.call(location, d, dx, dy, dz) unless @on_location_moved.nil?
+        }
+
+     elsif method_id == :subscribe_to_locations_proximity
+        # add simrpc node id onto args list
+        args.unshift @simrpc_node.id
+
+        # handle location proximity events from the server, & issue subscribe request
+        @simrpc_node.handle_method("locations_proximity") { |location1, location2|
+           Logger.info "location #{location1.id}/#{location2.id} proximity"
+           @on_locations_proximity.call(location1, location2) unless @on_locations_proximity.nil?
+        }
+     end
+
+     @simrpc_node.method_missing(method_id, *args)
+  end
+end
+
+end