qwirk 0.2.1 → 0.2.2

data/History.md

@@ -1,6 +1,11 @@
 Qwirk Changelog
 =====================
 
+0.2.2
+-----
+
+ - Fix bug that sends negative value for timeout to ConditionVariable#wait.
+
 0.2.1
 -----
 

data/lib/qwirk.rb

@@ -12,7 +12,7 @@ module Qwirk
   @@hash        = {}
 
   class MyBean
-    include Rumx::Bean
+    include ::Rumx::Bean
 
     # These are actually AdapterFactory's but presenting as adapters to the user.
     bean_attr_reader :adapters,  :hash, 'Adapters', :hash_type => :bean
@@ -25,7 +25,7 @@ module Qwirk
   def self.config=(config)
     #if config.has_key?(:adapter)
     @@config = config
-    Rumx::Bean.root.bean_add_child(DEFAULT_NAME, MyBean.new(@@hash))
+    ::Rumx::Bean.root.bean_add_child(DEFAULT_NAME, MyBean.new(@@hash))
   end
 
   def self.environment=(environment)
@@ -109,5 +109,6 @@ require 'qwirk/remote_exception'
 require 'qwirk/task'
 require 'qwirk/worker'
 require 'qwirk/reply_worker'
+require 'qwirk/remote'
 
 require 'qwirk/engine' if defined?(Rails)

data/lib/qwirk/adapter/base/expanding_worker_config.rb

@@ -48,7 +48,7 @@ module Qwirk
           @min_count = 1 if @min_count == 0 && new_max_count > 0
           deleted_workers = []
           @worker_mutex.synchronize do
-            @timer ||= Rumx::Beans::TimerAndError.new
+            @timer ||= ::Rumx::Beans::TimerAndError.new
             if @workers.size > new_max_count
               deleted_workers = @workers[new_max_count..-1]
               deleted_workers.each { |worker| worker.stop }

data/lib/qwirk/adapter/base/worker_config.rb

@@ -4,7 +4,7 @@ module Qwirk
   module Adapter
     module Base
       class WorkerConfig
-        include Rumx::Bean
+        include ::Rumx::Bean
 
         # Make explicit the instance variables available to the derived adapter classes
         attr_reader        :adapter_factory, :name, :manager, :worker_class, :default_options, :options,

data/lib/qwirk/adapter/in_memory/reply_queue.rb

@@ -13,6 +13,7 @@ module Qwirk
         def timeout_read(timeout)
           @outstanding_hash_mutex.synchronize do
             return @array.shift unless @array.empty?
+            return nil unless timeout > 0
             timed_read_condition_wait(timeout)
             return @array.shift
           end

data/lib/qwirk/adapter_factory.rb

@@ -2,7 +2,7 @@ module Qwirk
 
   # Defines the queuing adapter.  Currently, only JMS and InMemory.
   class AdapterFactory
-    include Rumx::Bean
+    include ::Rumx::Bean
 
     attr_reader :key, :config, :log_times, :adapter_info, :worker_config_class, :manager
 
@@ -25,11 +25,12 @@ module Qwirk
       key = key.to_sym
       @publisher_class, @worker_config_class, block = @@adapter_hash[key]
       raise "No adapter matching #{key}" unless @publisher_class
+      self.remote = config.delete(:remote)
       @adapter_info = block.call(config) if block
     end
 
     def create_publisher(options={})
-      @publisher_parent ||= Rumx::Beans::Folder.new
+      @publisher_parent ||= ::Rumx::Beans::Folder.new
       publisher = Publisher.new(self, @config.merge(options))
       @publisher_parent.bean_add_child(publisher.to_s, publisher)
       return publisher
@@ -48,5 +49,11 @@ module Qwirk
     def in_process?
       @worker_config_class.in_process?(@config)
     end
+
+    def remote=(remote_options)
+      # If remote was just set to true, then create an empty options hash for it
+      remote_options = {} if remote_options == true
+      Remote.setup(self, remote_options) if remote_options
+    end
   end
 end

data/lib/qwirk/base_worker.rb

@@ -55,7 +55,7 @@ module Qwirk
     end
 
     def self.included(base)
-      Rumx::Bean.included(base)
+      ::Rumx::Bean.included(base)
       base.extend(ClassMethods)
       if base.kind_of?(Class)
         @worker_classes ||= []

data/lib/qwirk/manager.rb

@@ -5,7 +5,7 @@ require 'rumx'
 
 module Qwirk
   class Manager
-    include Rumx::Bean
+    include ::Rumx::Bean
     attr_reader   :env, :worker_configs, :name
 
     bean_attr_accessor :poll_time, :float, 'How often the manager should poll the workers for their status for use by :idle_worker_timeout and :max_read_threshold'

data/lib/qwirk/publish_handle.rb

@@ -82,6 +82,7 @@ module Qwirk
 
     def read_single_response(consumer, timeout)
       leftover_timeout = @start + timeout - Time.now
+      leftover_timeout = 0 if leftover_timeout < 0
       return consumer.timeout_read(leftover_timeout)
     end
 
@@ -112,6 +113,7 @@ module Qwirk
         @message_hash            = {}
         @timeout_hash            = {}
         @exception_hash          = {}
+        @default_message_block   = nil
         @default_timeout_block   = nil
         @default_exception_block = nil
         @done_array              = []
@@ -123,8 +125,11 @@ module Qwirk
       end
 
       def on_message(*names, &block)
-        raise 'Must explicitly define all message handlers so we know that we\'re done' if names.empty?
-        names.each {|name| @message_hash[name] = block}
+        if names.empty?
+          @default_message_block = block
+        else
+          names.each {|name| @message_hash[name] = block}
+        end
       end
 
       def on_timeout(*names, &block)
@@ -147,13 +152,13 @@ module Qwirk
       def make_message_call(name, obj)
         # Give the client access to the name
         @name = name
-        block = @message_hash[name]
+        block = @message_hash[name] || @default_message_block
         block.call(obj) if block
         @done_array << name
       end
 
       def done?
-        (@message_hash.keys - @done_array).empty?
+        !@default_message_block && (@message_hash.keys - @done_array).empty?
       end
 
       def make_timeout_calls

data/lib/qwirk/publisher.rb

@@ -1,7 +1,7 @@
 # Protocol independent class to handle Publishing
 module Qwirk
   class Publisher
-    include Rumx::Bean
+    include ::Rumx::Bean
 
     #attr_reader :producer_options, :persistent, :reply_queue
     attr_reader :response_options, :impl, :marshaler

data/lib/qwirk/remote.rb

@@ -0,0 +1,62 @@
+module Qwirk
+  module Remote
+
+    # Setup the remote worker with a unique name with which to identify this particular process.
+    # This defaults to the simple hostname (minus the domain name) which can be used if their is only
+    # one qwirk_manager running on this host, otherwise it should be some combination of the hostname
+    # and process name or anything that would uniquely identify the process/host combination.
+    # Options:
+    #   name - overrides the default name for this process/host combination.
+    #   topic_name - name of the topic.  This should be the same for all process/host combinations and
+    #                defaults to 'remote'
+    def self.setup(adapter_factory, options={})
+      require 'qwirk/remote/client'
+      require 'qwirk/remote/worker'
+
+      options = options.dup
+      @@adapter_factory = adapter_factory
+      @@name            = options.delete(:name) || default_name
+      @@topic_name      = options.delete(:topic_name) || 'remote'
+      @@queue_name      = self.queue_name(@@name)
+      @@root_bean_name  = options.delete(:root_bean_name) || @@topic_name
+      default_options   = {:min_count => 1, :max_count => 1}
+      Worker.define_configs(
+          "TRemote_#{@@name}" => default_options.merge(:topic_name => @@topic_name).merge(options),
+          "QRemote_#{@@name}" => default_options.merge(:queue_name => @@queue_name).merge(options)
+      )
+      client = Client.new(adapter_factory, options)
+      @@root_bean = Rumx::Bean.add_root(@@root_bean_name, ::Rumx::Beans::Folder.new)
+      @@root_bean.bean_add_child(:client, client)
+    end
+
+    def self.adapter_factory
+      @@adapter_factory
+    end
+
+    def self.name
+      @@name
+    end
+
+    def self.topic_name
+      @@topic_name
+    end
+
+    def self.queue_name(name)
+      "Remote_#{name}"
+    end
+
+    def self.root_bean
+      @@root_bean
+    end
+
+    def self.default_name
+      require 'socket'
+      name = Socket.gethostname
+      name.sub(/\..*/, '')
+    end
+
+    def self.remote_name(worker_name)
+      worker_name.sub(/^[QT]Remote_/, '')
+    end
+  end
+end

data/lib/qwirk/remote/client.rb

@@ -0,0 +1,71 @@
+module Qwirk
+  module Remote
+    class Client
+      include ::Rumx::Bean
+
+      bean_attr_reader   :servers, :hash,  'Remote servers', :hash_type => :bean
+      bean_attr_accessor :timeout, :float, 'Timeout for individual calls to remote servers'
+
+      bean_operation   :refresh, :string, 'Query all the remote servers for their current state', [
+          [ :timeout,   :float,  'How long to wait for all the servers to respond', 10.0]
+      ]
+
+      def initialize(adapter_factory, options={})
+        @adapter_factory = adapter_factory
+        @options         = options
+        @servers = {}
+        @timeout = 10.0
+      end
+
+      def refresh(timeout)
+        new_servers = {}
+        success_servers = []
+        failure_servers = []
+        publisher = Qwirk::Publisher.new(@adapter_factory, :topic_name => Qwirk::Remote.topic_name, :marshal => :bson, :ttl => timeout, :response => true)
+        publisher.publish(:command => 'serialize').read_response(timeout) do |response|
+          response.on_message do |hash|
+            remote_name = Remote.remote_name(response.name)
+            new_servers[remote_name] = ::Rumx::RemoteBean.new(hash, self, remote_name)
+            success_servers << remote_name
+          end
+          response.on_remote_exception do |e|
+            remote_name = Remote.remote_name(response.name)
+            new_servers[remote_name] = ::Rumx::Beans::Message.new(e.message)
+            failure_servers << remote_name
+          end
+        end
+        @servers = new_servers
+        answer = ''
+        answer = "Success for #{success_servers.inspect}" unless success_servers.empty?
+        unless failure_servers.empty?
+          answer += ', ' unless answer.empty?
+          answer += 'Failure for #{failure_servers.inspect}'
+        end
+        return answer
+      end
+
+      def run_operation(ancestry, operation, argument_hash, remote_name)
+        puts "In run_operation"
+        value = remote_call(remote_name, :command => 'operation', :operation_name => operation.name, :ancestry => ancestry, :argument_hash => argument_hash)
+        return operation.type.string_to_value(value['value'])
+      end
+
+      def set_attributes(ancestry, params, remote_name)
+        puts "In set_attributes"
+        remote_call(remote_name, :command => 'attributes', :ancestry => ancestry, :params => params)
+      end
+
+      #######
+      private
+      #######
+
+      def remote_call(remote_name, request)
+        publisher = Qwirk::Publisher.new(@adapter_factory, :queue_name => Remote.queue_name(remote_name), :marshal => :bson, :ttl => @timeout, :response => true)
+        handle = publisher.publish(request)
+        response = handle.read_response(timeout)
+        raise Timeout::Error if handle.timeout?
+        return response
+      end
+    end
+  end
+end

data/lib/qwirk/remote/worker.rb

@@ -0,0 +1,33 @@
+module Qwirk
+  module Remote
+    class Worker
+      include Qwirk::ReplyWorker
+
+      response :marshal => :bson
+
+      #config_accessor :update_threshold, :integer, 'Threshold age in seconds where a new call will be made'
+
+      # Process incoming inquiries
+      def request(hash)
+        case command = hash['command']
+          when 'serialize'
+            ::Rumx::Bean.root.bean_to_remote_hash
+          when 'operation'
+            bean, operation, value = ::Rumx::Bean.run_operation(hash['ancestry'], hash['operation_name'], hash['argument_hash'])
+            puts "operation returned #{value}"
+            raise "Invalid operation ancestry = #{hash['ancestry'].inspect} operation=#{hash['operation_name'].inspect}" unless bean
+            # Allow bson to handle it
+            { :value => value }
+          when 'attributes'
+            bean = ::Rumx::Bean.find(hash['ancestry'])
+            raise "Invalid bean ancestry #{hash['ancestry'].inspect}" unless bean
+            attributes = bean.bean_set_and_get_attributes(hash['params'])
+            puts "attributes returned #{attributes.inspect}"
+            attributes
+          else
+            raise "Invalid command: #{command.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/qwirk/task.rb

@@ -6,7 +6,7 @@ module Qwirk
   #     :
   module Task
     #include Qwirk::BaseWorker
-    include Rumx::Bean
+    include ::Rumx::Bean
 
     bean_attr_accessor :max_pending_records, :integer, 'The max number of records that can be published without having been responded to (publishing blocks at this point).'
     bean_attr_reader   :task_id,             :string,  'The ID for this task'
@@ -22,7 +22,7 @@ module Qwirk
 
     def self.included(base)
       #Qwirk::BaseWorker.included(base)
-      Rumx::Bean.included(base)
+      ::Rumx::Bean.included(base)
       base.extend(ClassMethods)
     end
 

data/test/dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.