motel 0.2 → 0.3

data/lib/motel/{models → movement_strategies}/elliptical.rb

@@ -1,13 +1,13 @@
 # The Elliptcial MovementStrategy model definition
 #
-# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
-# See COPYING for the License of this software
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
 
 require 'motel/common'
-require 'motel/models/movement_strategy'
+require 'motel/movement_strategy'
 
 module Motel
-module Models
+module MovementStrategies
 
 # The Elliptical MovementStrategy moves a location
 # on an elliptical path described by major/minor 
@@ -19,41 +19,44 @@ module Models
 # Lastly a speed value is required indicating the
 # angular velocity of the location.
 class Elliptical < MovementStrategy
+   attr_accessor :relative_to, :speed
 
-   # Elliptical MovementStrategy must specify x,y,z components of 
-   # the major and minor axis direction vectors
-   validates_presence_of [:direction_major_x, 
-                          :direction_major_y, 
-                          :direction_major_z,
-                          :direction_minor_x, 
-                          :direction_minor_y, 
-                          :direction_minor_z]
-
-   # make sure the unit direction vectors are normal
-   before_validation :normalize_direction_vectors
-   def normalize_direction_vectors
-      dx, dy, dz =
-         normalize(direction_major_x, direction_major_y, direction_major_z)
-      self.direction_major_x, self.direction_major_y, self.direction_major_z = dx, dy, dz
-
-      dx, dy, dz =
-         normalize(direction_minor_x, direction_minor_y, direction_minor_z)
-      self.direction_minor_x, self.direction_minor_y, self.direction_minor_z = dx, dy, dz
-   end
+   attr_accessor :eccentricity, :semi_latus_rectum
+
+   attr_accessor :direction_major_x, :direction_major_y, :direction_major_z,
+                 :direction_minor_x, :direction_minor_y, :direction_minor_z
+
+   def initialize(args = {})
+      @relative_to        = args[:relative_to]       if args.has_key? :relative_to
+      @speed              = args[:speed]             if args.has_key? :speed
+      @eccentricity       = args[:eccentricity]      if args.has_key? :eccentricity
+      @semi_latus_rectum  = args[:semi_latus_rectum] if args.has_key? :semi_latus_rectum
+
+     @direction_major_x   = args[:direction_major_x] if args.has_key? :direction_major_x
+     @direction_major_y   = args[:direction_major_y] if args.has_key? :direction_major_y
+     @direction_major_z   = args[:direction_major_z] if args.has_key? :direction_major_z
 
+     @direction_minor_x   = args[:direction_minor_x] if args.has_key? :direction_minor_x
+     @direction_minor_y   = args[:direction_minor_y] if args.has_key? :direction_minor_y
+     @direction_minor_z   = args[:direction_minor_z] if args.has_key? :direction_minor_z
 
-   # Elliptical MovementStrategy must specify the angular velocity
-   # at which the location is moving
-   validates_presence_of      :speed
-   validates_numericality_of  :speed,
-      :greater_than_or_equal_to => 0,
-      :less_than_or_equal_to    => 2 * Math::PI
+     @direction_major_x   = 1 if @direction_major_x.nil?
+     @direction_major_y   = 0 if @direction_major_y.nil?
+     @direction_major_z   = 0 if @direction_major_z.nil?
+     @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?
 
-   # the eccentricity of the ellipse
-   validates_presence_of     :eccentricity
-   validates_numericality_of :eccentricity,
-      :greater_than_or_equal_to => 0,
-      :less_than_or_equal_to    => 1
+     @direction_major_x, @direction_major_y, @direction_major_z = 
+         normalize(@direction_major_x, @direction_major_y, @direction_major_z)
+
+     @direction_minor_x, @direction_minor_y, @direction_minor_z = 
+        normalize(@direction_minor_x, @direction_minor_y, @direction_minor_z)
+
+     unless orthogonal?(@direction_major_x, @direction_major_y, @direction_major_z, @direction_minor_x, @direction_minor_y, @direction_minor_z)
+        raise InvalidMovementStrategy.new("elliptical direction vectors not orthogonal") 
+     end
+   end
 
    def e
      eccentricity
@@ -62,11 +65,6 @@ class Elliptical < MovementStrategy
     eccentricity= v
    end
 
-   # the semi_latus_rectum of the ellipse
-   validates_presence_of :semi_latus_rectum
-   validates_numericality_of :semi_latus_rectum,
-      :greater_than_or_equal_to => 0
-
    def p
      semi_latus_rectum
    end
@@ -78,56 +76,22 @@ class Elliptical < MovementStrategy
    RELATIVE_TO_CENTER = "center"
    RELATIVE_TO_FOCI   = "foci"
 
-   # must be relative to a parent center or foci
-   validates_presence_of :relative_to
-   validates_inclusion_of :relative_to,
-     :in => [ RELATIVE_TO_CENTER, RELATIVE_TO_FOCI ]
-
-   # ActiveRecord::Base::validate
-   def validate
-      errors.add("direction vectors must be orthogonal") unless orthogonal?(direction_major_x, direction_major_y, direction_major_z,
-                                                                            direction_minor_x, direction_minor_y, direction_minor_z)
-   end
-
-   # convert non-nil elliptical movement strategy attributes to a hash
-   def to_h
-     result = {}
-     result[:speed] = speed unless speed.nil?
-     result[:eccentricity] = eccentricity unless eccentricity.nil?
-     result[:semi_latus_rectum] = semi_latus_rectum unless semi_latus_rectum.nil?
-     result[:relative_to] = relative_to unless relative_to.nil?
-     result[:direction_major_x] = direction_major_x unless direction_major_x.nil?
-     result[:direction_major_y] = direction_major_y unless direction_major_y.nil?
-     result[:direction_major_z] = direction_major_z unless direction_major_z.nil?
-     result[:direction_minor_x] = direction_minor_x unless direction_minor_x.nil?
-     result[:direction_minor_y] = direction_minor_y unless direction_minor_y.nil?
-     result[:direction_minor_z] = direction_minor_z unless direction_minor_z.nil?
-     return result
-   end
-
-   # convert elliptical movement strategy to a string
-   def to_s
-     super + "; speed:#{speed}; eccentricity:#{eccentricity}; semi_latus_rectum:#{semi_latus_rectum}; relative_to:#{relative_to}; " + 
-               "direction_major_x:#{direction_major_x}; direction_major_y:#{direction_major_y}; direction_major_z:#{direction_major_z}; " +
-               "direction_minor_x:#{direction_minor_x}; direction_minor_y:#{direction_minor_y}; direction_minor_z:#{direction_minor_z}"
-   end
-
    # Motel::Models::MovementStrategy::move
    def move(location, elapsed_seconds)
-      # make sure this movement strategy is valid
-      unless valid?
-         Logger.warn "elliptical movement strategy not valid, not proceeding with move"
-         return
-      end
+      # FIXME make sure this movement strategy is valid
+      #unless valid?
+      #   Logger.warn "elliptical movement strategy not valid, not proceeding with move"
+      #   return
+      #end
 
-      # make sure location is on ellipse
-      unless location_valid? location
-         cx,cy,cz = closest_coordinates location
-         Logger.warn "location #{location} not on ellipse, the closest location is #{cl}, not proceeding with move"
-         return
-      end
+      ## FIXME make sure location is on ellipse
+      #unless location_valid? location
+      #   cx,cy,cz = closest_coordinates location
+      #   Logger.warn "location #{location} not on ellipse, the closest location is #{cl}, not proceeding with move"
+      #   return
+      #end
 
-     Logger.debug "moving location #{location} via elliptical movement strategy"
+     Logger.debug "moving location #{location.id} via elliptical movement strategy"
 
      # calculate distance moved and update x,y,z accordingly
      distance = speed * elapsed_seconds
@@ -136,8 +100,6 @@ class Elliptical < MovementStrategy
      location.x = nX
      location.y = nY
      location.z = nZ
-
-     Logger.debug "moved location #{location} via elliptical movement strategy"
    end
 
   private
@@ -255,5 +217,5 @@ class Elliptical < MovementStrategy
 
 end
 
-end # module Models
+end # module MovementStrategies
 end # module Motel

data/lib/motel/movement_strategies/linear.rb

@@ -0,0 +1,54 @@
+# The Linear MovementStrategy model definition
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'motel/common'
+require 'motel/movement_strategy'
+
+module Motel
+module MovementStrategies
+
+# The Linear MovementStrategy moves a location
+# in a linear manner as defined by a 
+# unit direction vector and a floating point
+# speed
+class Linear < MovementStrategy
+   attr_accessor :direction_vector_x, :direction_vector_y, :direction_vector_z
+   
+   attr_accessor :speed
+
+   def initialize(args = {})
+     @direction_vector_x   = args[:direction_vector_x] if args.has_key? :direction_vector_x
+     @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
+
+     # normalize direction vector
+     @direction_vector_x, @direction_vector_y, @direction_vector_z =
+       normalize(@direction_vector_x, @direction_vector_y, @direction_vector_z)
+   end
+
+
+   # Motel::Models::MovementStrategy::move
+   def move(location, elapsed_seconds)
+     #unless valid?
+     #  Logger.warn "linear movement strategy not valid, not proceeding with move"
+     #  return
+     #end
+
+     Logger.debug "moving location #{location.id} via linear movement strategy " +
+                  "#{speed} #{direction_vector_x}/#{direction_vector_y}/#{direction_vector_z}"
+
+     # calculate distance and update x,y,z accordingly
+     distance = speed * elapsed_seconds
+
+     location.x += distance * direction_vector_x
+     location.y += distance * direction_vector_y
+     location.z += distance * direction_vector_z
+   end
+
+end
+
+end # module Models
+end # module Motel

data/lib/motel/movement_strategies/stopped.rb

@@ -0,0 +1,18 @@
+# The Stopped MovementStrategy model definition
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'singleton'
+require 'motel/movement_strategy'
+
+module Motel
+module MovementStrategies
+
+# Stopped is the default MovementStrategy which does nothing 
+class Stopped < MovementStrategy
+   include Singleton
+end
+
+end # module MovementStrategies
+end # module Motel

data/lib/motel/movement_strategy.rb

@@ -0,0 +1,29 @@
+# The MovementStrategy entity
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'motel/common'
+require 'motel/location'
+
+module Motel
+
+# MovementStrategy subclasses define the rules and params which 
+# a location changes its position. 
+class MovementStrategy
+   attr_accessor :step_delay
+   
+   def initialize(args = {})
+      @step_delay = 5
+      @movement_callbacks = []
+
+      @step_delay = args[:step_delay] if args.has_key? :step_delay
+   end
+
+   # default movement strategy is to do nothing
+   def move(location, elapsed_seconds)
+   end
+
+end
+
+end # module Motel

data/lib/motel/runner.rb

@@ -2,133 +2,119 @@
 # and is responsible for managing locations and moving them according to
 # their corresponding movement_strategies
 #
-# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
-# See COPYING for the License of this software
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
 
-module Motel
+require 'singleton'
+require 'motel/thread_pool'
 
-# A LocationRunner runs a Location by moving it via
-# its associated MovementStrategy.
-class LocationRunner
-   attr_reader :location
-   attr_reader :run_thread
-
-   def initialize(location)
-     return if location.nil? || location.id.nil? || location.class != Location
-
-     @terminate = false
-     @location  = location
-     @location_lock = Mutex.new
-     Logger.info " running location " + location.to_s
-
-     # TODO at some point use a thread pool approach
-     @run_thread = Thread.new { run_move_cycle(location) }
-   end
-
-   # Terminate run cycle, stopping location movement.
-   # After this the runner cannot be used again
-   def terminate
-      @terminate = true
-      @location_lock.synchronize{
-        unless run_thread.nil?
-          @run_thread.join
-          @run_thread = nil
-        end
-      }
-   end
-
- private
-
-  # Launched in a seperate thread, run_move_cycle 
-  # runs a location according to its associated 
-  # movement strategy with a specified delay between
-  # runs. Terminated when the Runner.terminate 
-  # method is invoked
-  def run_move_cycle(location)
-     # track the time between runs
-     start_time = Time.now 
-
-     # run until we are instructed not to
-     until(@terminate) do
-        Logger.debug "runner invoking move on location " + location.to_s + " via " + location.movement_strategy.type.to_s + " movement strategy"
-
-        ## perform the actual move
-        location.movement_strategy.move location, start_time - Time.now
-        start_time = Time.now 
-
-        # TODO see if we've actually moved b4 invoking callbacks
-        location.movement_strategy.movement_callbacks.each { |callback|
-           callback.call(location)
-        }
+module Motel
 
-        ## delay as long as the strategy tells us to
-        sleep location.movement_strategy.step_delay
-     end
-  end
+# Motel::Runner is a singleton class/object which acts as the primary
+# mechanism to run locations in the system. It contains a thread pool
+# which contains a specified number of threads which to move the managed
+# locations in accordance to their location strategies.
+class Runner
+  include Singleton
 
-end
+  # locations being managed
+  attr_accessor :locations
 
+  # for testing purposes
+  attr_reader :thread_pool, :terminate, :run_thread
 
-# A Runner manages groups of LocationRunner instances
-# Restricts use to a single instance, obtained via the
-# 'get' method
-class Runner
+  def initialize(args = {})
+    @terminate = false
+    @locations = []
+    @locations_lock = Mutex.new
 
- private
-  
-  # Default class constructor
-  # private as runner should be accessed through singleton 'get' method
-  def initialize
-     # set to true to terminate the runner
-     @terminate = false
-
-     # locations is a list of instances of LocationRunner to manage
-     @location_runners    = []
-     @runners_lock = Mutex.new
+    @run_thread = nil
+    @run_delay  = 2 # FIXME scale delay (only needed if locations is empty or has very few simple elements)
   end
 
- public
+  # Empty the list of locations being managed/tracked
+  def clear
+    @locations_lock.synchronize { 
+      @locations.clear
+    }
+  end
 
-  # singleton getter
-  def self.get
-    @@singleton_instance = Runner.new if !defined? @@singleton_instance || @@singleton_instance.nil?
-    return @@singleton_instance
+  # 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
+    }
   end
 
-  attr_reader :location_runners
+  # 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
+    @terminate = false
+    @thread_pool = ThreadPool.new(num_threads)
+
+    if args.has_key?(:async) && args[:async]
+      Logger.debug "starting async motel runner"
+      @run_thread = Thread.new { run_cycle }
+    else
+      Logger.debug "starting motel runner"
+      run_cycle
+    end
 
-  # helper method, return all locations associated w/ runners
-  def locations
-     [] if @location_runners.nil? || @location_runners.size == 0
-     @location_runners.collect { |runner| runner.location }
   end
 
-  # clear all location_runners
-  def clear
-     @location_runners.clear
+  # Stop locations movement
+  def stop
+    Logger.debug "stopping motel runner"
+    @terminate = true
+    @thread_pool.shutdown
+    join
+    Logger.debug "motel runner stopped"
   end
 
-  # Terminate all run cycles, stopping all location movements.
-  # After this the runner cannot be used again
-  def terminate
-     @terminate = true
-     @runners_lock.synchronize{
-        @location_runners.each { |runner|
-          runner.terminate
-        }
-     }
+  # Block until runner is shutdown before returning
+  def join
+    @run_thread.join unless @run_thread.nil?
+    @run_thread = nil
   end
 
-  # Run a location using this runner. If the location
-  # is already being run by this runner, do nothing.
-  # A new thread will be launched to run the actual move cycle
-  def run(location)
-     @runners_lock.synchronize{
-        unless @location_runners.find { |l| l.location.id == location.id}
-          @location_runners.push LocationRunner.new(location)
-        end
-     }
-  end
+  private
+
+    # Internal helper method performing main runner operations
+    def run_cycle
+      # track time between runs
+      start_time = Time.now
+
+      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 }
+        }
+
+        tlocations.each { |loc|
+          @thread_pool.dispatch(loc) { |loc|
+            Logger.debug "runner moving location #{loc.id} via #{loc.movement_strategy.class.to_s}"
+
+            loc.movement_strategy.move loc, start_time - Time.now
+            start_time = Time.now
+
+            # TODO see if loc coordinates changed b4 doing this
+            loc.movement_callbacks.each { |callback|
+                callback.call(loc)
+            }
+
+            ## delay as long as the strategy tells us to
+            sleep loc.movement_strategy.step_delay
+          }
+        }
+
+        sleep @run_delay
+      end
+    end
 
 end
 

data/lib/motel/simrpc.rb

@@ -0,0 +1,131 @@
+# 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_id|
+       Logger.info "received create location #{location_id} request"
+       success = true
+       begin
+         Runner.instance.run Location.new(:id => location_id)
+         # TODO decendants support w/ remote option (create additional locations on other servers)
+       rescue Exception => e
+         Logger.warn "create location #{location_id} failed w/ exception #{e}"
+         success = false
+       end
+       Logger.info "create location #{location_id} request returning #{success}"
+       success
+    }
+
+    @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
+           Logger.info "updating location #{location.id} with #{location}/#{location.movement_strategy}"
+           rloc.update(location)
+         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") { |location_id, client_id|
+       Logger.info "subscribe client #{client_id} to location #{location_id}  request received"
+       loc = Runner.instance.locations.find { |loc| loc.id == location_id  }
+       success = true
+       if loc.nil? 
+         success = false
+       else
+         loc.movement_callbacks.push lambda { |location|
+           # send location to client
+           @simrpc_node.send_method("location_moved", client_id, location)
+         }
+       end
+       Logger.info "subscribe client #{client_id} to location #{location_id}  returning  #{success}"
+       success
+    }
+  end
+
+  def join
+     @simrpc_node.join
+  end
+end
+
+# Client defines a client endpoint that performs
+# a request against a Motel Server
+class Client
+  # should be a callable object that takes a location to be
+  # invoked when the server sends a location to the client
+  attr_writer :on_location_received
+
+  # 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
+        # add simrpc node id onto args list
+        args.push @simrpc_node.id
+
+        # handle location updates from the server, & issue subscribe request
+        @simrpc_node.handle_method("location_moved") { |location| 
+           Logger.info "location #{location.id} moved"
+           @on_location_received.call(location) unless @on_location_received.nil?
+        }
+     end
+     @simrpc_node.method_missing(method_id, *args)
+  end
+end
+
+end