motel 0.2

data/lib/motel/models/location.rb

@@ -0,0 +1,109 @@
+# The Location model definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel/models/movement_strategy'
+
+module Motel
+module Models
+
+# 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
+# is assumed to be the 'center' of the system to which it belongs
+# Also is related to a movable object defining the parameters
+# of the locations movement 
+class Location < ActiveRecord::Base
+   # a location may have a parent and/or act as a parent to others
+   belongs_to :location,  :foreign_key => :parent_id
+   has_many   :locations, :foreign_key => :parent_id, :dependent => :destroy
+
+   belongs_to :movement_strategy
+
+   # a generic association which this location can belong to
+   belongs_to :entity, :polymorphic => true
+   #validates_presense_of [ :entity_type, :entity_id ]
+
+   # FIXME add optional remote_location_server field
+
+   alias :parent    :location
+   alias :parent=   :location=
+   alias :children  :locations
+   alias :children=  :locations=
+
+   # return this location's root location
+   def root
+     return self if parent.nil?
+     return parent.root
+   end
+
+   # traverse all chilren recursively, calling block for each
+   def traverse_descendants(&bl)
+      children.each { |child|
+         bl.call child
+         child.traverse_descendants &bl
+      }
+   end
+
+   # default to the stopped movement strategy if not set on validation
+   before_validation :default_movement_strategy
+   def default_movement_strategy
+      self.movement_strategy = MovementStrategy.stopped if self.movement_strategy.nil?
+   end
+
+   public
+   validates_presence_of :movement_strategy
+
+   validates_presence_of [:x, :y, :z],
+   :unless => Proc.new { |location| location.location.nil? }
+
+   validates_presence_of :location,
+   :unless => Proc.new { |location| location.x.nil? &&
+                                    location.y.nil? &&
+                                    location.z.nil? }
+
+   public
+
+   # return non-nil attributes in hash
+   def to_h
+     result = {}
+     #result[:id] = id unless id.nil?
+     result[:parent_id] = parent_id unless parent_id.nil?
+     result[:x] = x unless x.nil?
+     result[:y] = y unless y.nil?
+     result[:z] = z unless z.nil?
+     return result
+   end
+
+   # convert location to a string
+   def to_s
+     "id:#{id}; parent_id:#{parent_id}; parent: #{parent.nil? ? "nil" : "notnil"}; entity type: #{entity_type}; x:#{x}; y:#{y}; z:#{z}; " +
+     "movement_strategy:#{movement_strategy.to_s}; children:#{locations.size}"
+   end
+
+   # return sum of the x values of this location and all its parents,
+   # eg the absolute 'x' of the location
+   def total_x
+     return 0 if location.nil?
+     return location.total_x + x
+   end
+
+   # return sum of the y values of this location and all its parents
+   # eg the absolute 'y' of the location
+   def total_y
+     return 0 if location.nil?
+     return location.total_y + y
+   end
+
+   # return sum of the z values of this location and all its parents
+   # eg the absolute 'z' of the location
+   def total_z
+     return 0 if location.nil?
+     return location.total_z + z
+   end
+
+end
+
+end # module Models
+end # module Motel

data/lib/motel/models/movement_strategy.rb

@@ -0,0 +1,82 @@
+# The MovementStrategy model definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel/common'
+require 'motel/models/location'
+
+module Motel
+module Models
+
+# MovementStrategy subclasses define the rules and params which 
+# a location changes its position. 
+class MovementStrategy < ActiveRecord::Base
+   # strategy is associated with location to move it
+   has_many :locations, :dependent => :destroy
+
+   # callbacks invoked when this object is moved
+   attr_accessor :movement_callbacks
+
+   # every movement strategy needs a type
+   validates_presence_of :type
+
+   # as more types are supported, add them here
+   validates_inclusion_of :type, 
+     :in => %w( Stopped Linear Elliptical )
+
+   # step delay is recommended number of seconds 
+   # a runner should sleep for between move invocations
+   validates_presence_of :step_delay
+
+   # default step_delay if not set
+   before_validation :default_step_delay
+   def default_step_delay
+      self.step_delay = 5 if step_delay.nil?
+   end
+
+   # use after_initialize instead of initialize
+   # http://blog.dalethatcher.com/2008/03/rails-dont-override-initialize-on.html
+   def after_initialize
+     @movement_callbacks = []
+   end
+
+   # default movement strategy is to do nothing
+   def move(location, elapsed_seconds)
+   end
+
+   # retreive the 'stopped' movement strategy
+   def self.stopped
+     ms = MovementStrategy.find(:first, :conditions => "type = 'Stopped'")
+     ms.nil? ? Stopped.new(:step_delay => 5) : ms
+   end
+
+   # return subclass corresponding to specified strategy type
+   def self.factory(strategy_type)
+     return MovementStrategy if strategy_type.nil?
+
+     if strategy_type.downcase == "stopped" || strategy_type == "Motel::Models::Stopped"
+       return Stopped
+     elsif strategy_type.downcase == "linear" || strategy_type == "Motel::Models::Linear"
+       return Linear
+     elsif strategy_type.downcase == "elliptical" || strategy_type == "Motel::Models::Elliptical"
+       return Elliptical
+     end
+     
+     return MovementStrategy
+   end
+   
+   # convert movement strategy to a hash
+   def to_h
+     {}
+   end
+
+   # convert movement strategy to a string
+   def to_s
+     "id:#{id}; type:#{self.class}" # XXX should be self.type but ruby will complain, this works for now
+   end
+
+end
+
+end # module Models
+end # module Motel

data/lib/motel/models/stopped.rb

@@ -0,0 +1,16 @@
+# The Stopped MovementStrategy model definition
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+require 'motel/models/movement_strategy'
+
+module Motel
+module Models
+
+# Stopped is the default MovementStrategy which does nothing 
+class Stopped < MovementStrategy
+end
+
+end # module Models
+end # module Motel

data/lib/motel/runner.rb

@@ -0,0 +1,135 @@
+# Defines the LocationRunner and Runner classes, core to the motel engine,
+# 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
+
+module Motel
+
+# 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)
+        }
+
+        ## delay as long as the strategy tells us to
+        sleep location.movement_strategy.step_delay
+     end
+  end
+
+end
+
+
+# A Runner manages groups of LocationRunner instances
+# Restricts use to a single instance, obtained via the
+# 'get' method
+class Runner
+
+ 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
+  end
+
+ public
+
+  # singleton getter
+  def self.get
+    @@singleton_instance = Runner.new if !defined? @@singleton_instance || @@singleton_instance.nil?
+    return @@singleton_instance
+  end
+
+  attr_reader :location_runners
+
+  # 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
+  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
+        }
+     }
+  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
+
+end
+
+end # module motel

data/lib/motel/semaphore.rb

@@ -0,0 +1,58 @@
+#
+# $Id: semaphore.rb,v 1.2 2003/03/15 20:10:10 fukumoto Exp $
+#
+# Copied unmodified from:
+#   http://www.imasy.or.jp/~fukumoto/ruby/semaphore.rb
+# Originally licensed under The Ruby License:
+#   http://raa.ruby-lang.org/project/semaphore/
+
+class CountingSemaphore
+
+  def initialize(initvalue = 0)
+    @counter = initvalue
+    @waiting_list = []
+  end
+
+  def wait
+    Thread.critical = true
+    if (@counter -= 1) < 0
+      @waiting_list.push(Thread.current)
+      Thread.stop
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  def signal
+    Thread.critical = true
+    begin
+      if (@counter += 1) <= 0
+	t = @waiting_list.shift
+	t.wakeup if t
+      end
+    rescue ThreadError
+      retry
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  alias down wait
+  alias up signal
+  alias P wait
+  alias V signal
+
+  def exclusive
+    wait
+    yield
+  ensure
+    signal
+  end
+
+  alias synchronize exclusive
+
+end
+
+Semaphore = CountingSemaphore

data/lib/motel.rb

@@ -0,0 +1,13 @@
+# include all motel modules
+#
+# Copyright (C) 2009 Mohammed Morsi <movitto@yahoo.com>
+# See COPYING for the License of this software
+
+lib = File.dirname(__FILE__)
+
+require lib + '/motel/conf'
+require lib + '/motel/runner'
+require lib + '/motel/loader'
+require lib + '/motel/simrpc'
+
+Dir[lib + '/motel/models/*.rb'].each { |model| require model }

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: motel
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- Mohammed Morsi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-04 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.1
+    version: 
+description: Motel is a library to track and move the locations of objects in a 3D environment.
+email: movitto@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- conf/amqp.yml
+- conf/database.yml
+- db/migrate/001_create_locations_and_movement_strategies.rb
+- db/migrate/002_create_linear_movement_strategy.rb
+- db/migrate/003_create_elliptical_movement_strategy.rb
+- lib/motel/models/location.rb
+- lib/motel/models/movement_strategy.rb
+- lib/motel/models/stopped.rb
+- lib/motel/models/linear.rb
+- lib/motel/models/elliptical.rb
+- lib/motel/common.rb
+- lib/motel/loader.rb
+- lib/motel/runner.rb
+- lib/motel/semaphore.rb
+- lib/motel.rb
+- LICENSE
+- COPYING
+- README
+has_rdoc: true
+homepage: http://morsi.org/projects/motel
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Motel is a library to track and move the locations of objects in a 3D environment.
+test_files: []
+