motel 0.3 → 0.3.1

data/spec/spec_helper.rb

@@ -18,6 +18,7 @@ class TestMovementStrategy < MovementStrategy
 
    def initialize
      @times_moved = 0
+     @step_delay = 1
    end
 
    def move(loc, elapsed_time)

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: motel
 version: !ruby/object:Gem::Version 
-  version: "0.3"
+  hash: 17
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Mohammed Morsi
@@ -9,21 +15,36 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-14 00:00:00 -05:00
+date: 2010-09-05 00:00:00 -04:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id001
 description: Motel is a library to track and move the locations of objects in a 3D environment.
 email: movitto@yahoo.com
-executables: []
-
+executables: 
+- motel-server
+- motel-client
+- motel-rage-client
 extensions: []
 
 extra_rdoc_files: []
 
 files: 
-- bin/server/main.rb
-- bin/clients/simple/main.rb
 - conf/motel-schema.xml
 - lib/motel/movement_strategies/elliptical.rb
 - lib/motel/movement_strategies/stopped.rb
@@ -33,10 +54,10 @@ files:
 - lib/motel/location.rb
 - lib/motel/common.rb
 - lib/motel/semaphore.rb
-- lib/motel/thread_pool.rb
+- lib/motel/simrpc_adapter.rb
 - lib/motel/runner.rb
+- lib/motel/callbacks.rb
 - lib/motel/exceptions.rb
-- lib/motel/simrpc.rb
 - lib/motel.rb
 - COPYING
 - LICENSE
@@ -48,10 +69,14 @@ files:
 - spec/common_spec.rb
 - spec/spec_helper.rb
 - spec/movement_strategy_spec.rb
+- spec/callbacks_spec.rb
 - spec/location_spec.rb
 - spec/simrpc_spec.rb
 - spec/runner_spec.rb
 - spec/dsl_spec.rb
+- bin/motel-server
+- bin/motel-client
+- bin/motel-rage-client
 has_rdoc: true
 homepage: http://morsi.org/projects/motel
 licenses: []
@@ -62,21 +87,31 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 8
+      - 1
       version: 1.8.1
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 29
+      segments: 
+      - 1
+      - 3
+      - 3
       version: 1.3.3
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Motel is a library to track and move the locations of objects in a 3D environment.

data/bin/clients/simple/main.rb

@@ -1,131 +0,0 @@
-#!/usr/bin/ruby
-# A simple motel client executable
-# Executable to use the motel library to perform operations on
-# a remote location server, simply printing out results
-#
-# Flags: (see below)
-#
-# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
-# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
-
-CURRENT_DIR=File.dirname(__FILE__)
-$: << File.expand_path(CURRENT_DIR + "/../../../lib")
-
-require 'rubygems'
-require 'optparse'
-require 'motel'
-
-include Motel
-include Motel::MovementStrategies
-
-######################
-
-# TODO movement strategy support
-
-def main()
-    # command line parameters
-    schema_file = nil
-    location = {:parent_id => nil,
-                :x => nil,
-                :y => nil,
-                :z => nil}
-    request_target = nil
-
-    # setup cmd line options
-    opts = OptionParser.new do |opts|
-      opts.banner = "Usage: main.rb [command] [options]"
-
-      opts.on("-h", "--help", "Print this help message") do
-         puts opts
-         exit
-      end
-
-      opts.on("-s", "--schema [path]", "Motel Schema File") do |path|
-         schema_file = path
-      end
-
-      opts.separator ""
-      opts.separator "Commands:"
-      opts.on("-g", "--get", "get location specified by id")do
-        request_target = :get_location
-      end
-      opts.on("-c", "--create", "create location w/ id")do
-        request_target = :create_location
-      end
-      opts.on("-u", "--update", "update location specified by id w/ specified options")do
-        request_target = :update_location
-      end
-      opts.on("-b", "--subscribe", "subscribe to updates to location specified by id")do
-        request_target = :subscribe_to_location
-      end
-
-      opts.separator ""
-      opts.separator "Options:"
-      opts.on("-i", "--id [location_id]", "Target location id") do |id|
-        location[:id] = id
-      end
-      opts.on("-p", "--parent-id [location_id]", "Target parent location id") do |id|
-        location[:parent_id] = id
-      end
-      opts.on("-x", "--xcoordinate [coordinate]", "Target location x coordinate") do |x|
-        location[:x] = x
-      end
-      opts.on("-y", "--ycoordinate [coordinate]", "Target location y coordinate") do |y|
-        location[:y] = y
-      end
-      opts.on("-z", "--zcoordinate [coordinate]", "Target location z coordinate") do |z|
-        location[:z] = z
-      end
-
-    end
-
-    # parse cmd line
-    begin
-      opts.parse!(ARGV)
-    rescue OptionParser::InvalidOption => e
-      puts opts
-      puts e.to_s
-      exit
-    end
-
-    if request_target.nil? || location[:id].nil? || schema_file.nil? ||
-       request_target == :update && location[:x].nil? && location[:y].nil? && location[:z].nil? && location[:parent_id].nil?
-         puts opts
-         puts "must specify schema, a command to perform, a location id, and other required options"
-         exit
-    end
-
-    lid = location[:id]
-    location = Motel::Location.new :id => location[:id],
-                                   :parent_id => location[:parent_id],
-                                   :x => location[:x],
-                                   :y => location[:y],
-                                   :z => location[:z]
-    args = []
-    case(request_target)
-    when :get_location
-      args.push location.id
-    when :create_location
-      args.push location.id
-    when :update_location
-      args.push location
-    when :subscribe_to_location
-      args.push location.id
-    end
-
-    # FIXME need configurable amqp broker ip/port
-    client = Motel::Client.new :schema_file => schema_file
-    result = client.request request_target, *args
-
-    if request_target == :subscribe_to_location
-      client.on_location_received = lambda { |loc|
-         puts "location received:"
-         puts "#{loc}"
-      }
-      client.join
-    end
-
-    puts "server returned #{result}"
-end
-
-main()

data/lib/motel/simrpc.rb

@@ -1,131 +0,0 @@
-# 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

data/lib/motel/thread_pool.rb

@@ -1,51 +0,0 @@
-# copied unmodified from the ruby cookbook
-# http://codeidol.com/other/rubyckbk/Multitasking-and-Multithreading/Limiting-Multithreading-with-a-Thread-Pool/
-
-require 'thread'
-
-class ThreadPool
-  attr_reader :max_size
-
-  def initialize(max_size)
-    @pool = []
-    @max_size = max_size
-    @pool_mutex = Mutex.new
-    @pool_cv = ConditionVariable.new
-  end
-
-  def dispatch(*args)
-    Thread.new do
-      # Wait for space in the pool.
-      @pool_mutex.synchronize do
-        while @pool.size >= @max_size
-          print "Pool is full; waiting to run #{args.join(',')}…\n" if $DEBUG
-          # Sleep until some other thread calls @pool_cv.signal.
-          @pool_cv.wait(@pool_mutex)
-        end
-      end
-      @pool << Thread.current
-      begin
-        yield(*args)
-      rescue => e
-        exception(self, e, *args)
-      ensure
-        @pool_mutex.synchronize do
-          # Remove the thread from the pool.
-          @pool.delete(Thread.current)
-          # Signal the next waiting thread that there's a space in the pool.
-          @pool_cv.signal
-        end
-      end
-    end
-  end
-
-  def shutdown
-    @pool_mutex.synchronize { @pool_cv.wait(@pool_mutex) until @pool.empty? }
-  end
-
-  def exception(thread, exception, *original_args)
-    # Subclass this method to handle an exception within a thread.
-    puts "Exception in thread #{thread}: #{exception}"
-  end
-
-end