qwirk 0.0.1

data/examples/advanced_requestor/README.md

@@ -0,0 +1,15 @@
+# Step 0
+# Follow the directions for configuring jms.yml located in examples/README
+
+# Step 1
+# Start an ActiveMQ Server
+
+# Step 2
+# Start up the manager
+rackup -p 4567
+
+# Step 3
+jruby publish.rb foobar 4 2
+
+# Step 4
+# Play around with the options in qwirk_persist.yml and repeat steps 2&3.

data/examples/advanced_requestor/base_request_worker.rb

@@ -0,0 +1,18 @@
+module BaseRequestWorker
+  include Qwirk::RequestWorker
+
+  config_accessor :sleep_time, :float, 'Number of seconds to sleep between messages', 0
+
+  def self.included(base)
+    Qwirk::Worker.included(base)
+  end
+
+  def perform(obj)
+    puts "#{self}: Received #{obj} at #{Time.now}"
+    if config.sleep_time > 0.0
+      puts "#{self}: Sleeping for #{config.sleep_time} at #{Time.now}"
+      sleep config.sleep_time
+    end
+    super
+  end
+end

data/examples/advanced_requestor/char_count_worker.rb

@@ -0,0 +1,16 @@
+class CharCountWorker
+  include Qwirk::RequestWorker
+
+  topic 'test_string', :response => {:marshal => :bson, :time_to_live => 5000}
+  config_accessor :sleep_time, :float, 'Number of seconds to sleep between messages', 0
+
+  def request(obj)
+    if config.sleep_time > 0.0
+      puts "#{self}: Sleeping for #{config.sleep_time} at #{Time.now}"
+      sleep config.sleep_time
+    end
+    hash = Hash.new(0)
+    obj.each_char {|c| hash[c] += 1}
+    hash
+  end
+end

data/examples/advanced_requestor/config.ru

@@ -0,0 +1,24 @@
+require '../setup'
+require './publisher'
+require './char_count_worker'
+require './exception_raiser_worker'
+require './length_worker'
+require './print_worker'
+require './reverse_worker'
+require './triple_worker'
+
+# If we're not starting up a standalone publisher, then start up a manager
+if ENV['RACK_ENV'] != 'publisher'
+  manager = Qwirk[$adapter_key].create_manager(:name => 'Worker', :persist_file => 'qwirk_persist.yml')
+  manager['CharCount'].max_count       = 1
+  manager['ExceptionRaiser'].max_count = 1
+  manager['Length'].max_count          = 1
+  manager['Print'].max_count           = 1
+  manager['Reverse'].max_count         = 1
+  manager['Triple'].max_count          = 1
+  at_exit { manager.stop }
+end
+if ENV['RACK_ENV'] != 'worker'
+  Rumx::Bean.root.bean_add_child(:Publisher, Publisher.new($adapter_key))
+end
+run Rumx::Server

data/examples/advanced_requestor/exception_raiser_worker.rb

@@ -0,0 +1,17 @@
+class ExceptionRaiserWorker
+  include Qwirk::RequestWorker
+
+  topic 'test_string', :response => {:marshal => :string, :time_to_live => 5000}
+
+  config_accessor :raise_exception, :boolean, 'Raise an exception instead of handling the request', false
+  config_accessor :sleep_time, :float, 'Number of seconds to sleep between messages', 0
+
+  def request(obj)
+    if config.sleep_time > 0.0
+      puts "#{self}: Sleeping for #{config.sleep_time} at #{Time.now}"
+      sleep config.sleep_time
+    end
+    raise "Raising dummy exception on #{obj}" if config.raise_exception
+    "We decided not to raise on #{obj}"
+  end
+end

data/examples/advanced_requestor/length_worker.rb

@@ -0,0 +1,14 @@
+class LengthWorker
+  include Qwirk::RequestWorker
+
+  topic 'test_string', :response => {:marshal => :ruby, :time_to_live => 5000}
+  config_accessor :sleep_time, :float, 'Number of seconds to sleep between messages', 0
+
+  def request(obj)
+    if config.sleep_time > 0.0
+      puts "#{self}: Sleeping for #{config.sleep_time} at #{Time.now}"
+      sleep config.sleep_time
+    end
+    obj.length
+  end
+end

data/examples/advanced_requestor/print_worker.rb

@@ -0,0 +1,14 @@
+class PrintWorker
+  include Qwirk::Worker
+
+  topic 'test_string'
+  config_accessor :sleep_time, :float, 'Number of seconds to sleep between messages', 0
+
+  def perform(obj)
+    if config.sleep_time > 0.0
+      puts "#{self}: Sleeping for #{config.sleep_time} at #{Time.now}"
+      sleep config.sleep_time
+    end
+    puts "#{self}: Received #{obj} at #{Time.now}"
+  end
+end

data/examples/advanced_requestor/publisher.rb

@@ -0,0 +1,49 @@
+require 'rumx'
+require 'qwirk'
+
+class Publisher
+  include Rumx::Bean
+
+  bean_attr_reader :messages, :hash,    'Message', :hash_type => :string, :allow_write => false
+
+  bean_operation :publish, :void, 'Publish and receive messages', [
+      [ :message,      :string,  'Message to get sent',                                                  'Hello' ],
+      [ :timeout,      :float,   'Timeout on receiving response',                                        4.0     ],
+      [ :sleep_time,   :float,   "Time between publishing and receiving where we're supposedly working", 2.0     ]
+  ]
+
+  def initialize(adapter_key)
+    @publisher = Qwirk[adapter_key].create_publisher(:topic_name => 'test_string', :response => true, :marshal => :string)
+  end
+
+  def publish(message, timeout, sleep_time)
+    @messages = {}
+    puts "Publishing at #{Time.now.to_f}"
+    handle = @publisher.publish(message)
+    sleep sleep_time
+
+    handle.read_response(timeout) do |response|
+      response.on_message 'CharCount' do |hash|
+        messages['CharCount'] = "returned #{hash.inspect} in #{response.msec_delta.to_i} ms"
+      end
+      response.on_message 'Length', 'Reverse', 'Triple' do |val|
+        messages[response.name] = "returned #{val} in #{response.msec_delta.to_i} ms"
+      end
+      response.on_message 'ExceptionRaiser' do |val|
+        messages[response.name] = "didn't raise an exception, returned \"#{val}\" in #{response.msec_delta.to_i} ms"
+      end
+      response.on_timeout 'Reverse' do
+        messages[response.name] = "Timed out with it's own timeout handler in #{response.msec_delta.to_i} ms"
+      end
+      response.on_timeout do
+        messages[response.name] = "timed out in #{response.msec_delta.to_i} ms"
+      end
+      response.on_remote_exception 'ExceptionRaiser' do |e|
+        messages[response.name] = "It figures that ExceptionRaiser would raise an exception: #{e.message} in #{response.msec_delta.to_i} ms"
+      end
+      response.on_remote_exception do |e|
+        messages[response.name] = "raised exception: #{e.message} in #{response.msec_delta.to_i} ms"
+      end
+    end
+  end
+end

data/examples/advanced_requestor/qwirk.yml

@@ -0,0 +1,16 @@
+--- 
+CharCount: 
+  :max_count: 1
+ExceptionRaiser: 
+  :max_count: 1
+  :raise_exception: true
+Length: 
+  :max_count: 1
+  :sleep_time: 5.0
+Print: 
+  :max_count: 1
+Reverse: 
+  :max_count: 1
+  :sleep_time: 5.0
+Triple: 
+  :max_count: 1

data/examples/advanced_requestor/reverse_worker.rb

@@ -0,0 +1,14 @@
+class ReverseWorker
+  include Qwirk::RequestWorker
+
+  topic 'test_string', :response => {:marshal => :string, :time_to_live => 5000}
+  config_accessor :sleep_time, :float, 'Number of seconds to sleep between messages', 0
+
+  def request(obj)
+    if config.sleep_time > 0.0
+      puts "#{self}: Sleeping for #{config.sleep_time} at #{Time.now}"
+      sleep config.sleep_time
+    end
+    obj.reverse
+  end
+end

data/examples/advanced_requestor/triple_worker.rb

@@ -0,0 +1,14 @@
+class TripleWorker
+  include Qwirk::RequestWorker
+
+  topic 'test_string', :response => {:marshal => :string, :time_to_live => 5000}
+  config_accessor :sleep_time, :float, 'Number of seconds to sleep between messages', 0
+
+  def request(obj)
+    if config.sleep_time > 0.0
+      puts "#{self}: Sleeping for #{config.sleep_time} at #{Time.now}"
+      sleep config.sleep_time
+    end
+    obj * 3
+  end
+end

data/examples/batch/my_batch_worker.rb

@@ -0,0 +1,30 @@
+class MyBatchWorker
+  include Qwirk::Batch::FileWorker
+
+  file :glob => '/home/batch_files/**', :max_outstanding_requests => 100, :fail_threshold => 0.8, :save_period => 30.seconds
+  marshal :bson
+
+  def start_file(file, is_restart)
+    @outfile = File.open(output_file_for(file), 'a')
+  end
+
+  def record_to_object(line)
+    line_to_hash(line)
+  end
+
+  def process_response(hash)
+    @outfile.puts(hash_to_line(hash))
+  end
+
+  def failed
+    @outfile.close
+  end
+
+  def stop
+    @outfile.close
+  end
+
+  def finish_file
+    @outfile.close
+  end
+end

data/examples/batch/my_line_worker.rb

@@ -0,0 +1,8 @@
+class MyLineWorker
+  include Qwirk::Batch::RequestWorker
+  response_marshal :string
+
+  def request(line)
+    line.reverse
+  end
+end

data/examples/qwirk.yml

@@ -0,0 +1,20 @@
+in_mem:
+  :adapter: InMem
+  :log_times: true
+
+active_mq:
+  :adapter: ActiveMQ
+  :log_times: true
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: tcp://localhost:61616
+  #:username: myuser
+  #:password: mypassword
+
+active_mq_invm:
+  :adapter: ActiveMQ
+  :log_times: true
+  :factory: org.apache.activemq.ActiveMQConnectionFactory
+  :broker_url: vm://qwirk?brokerConfig=xbean:../activemq.xml
+  :object_message_serialization_defered: true
+  :username: qwirk
+  :password: qwirk

data/examples/requestor/README.md

@@ -0,0 +1,13 @@
+# Step 0
+# Follow the directions for configuring jms.yml located in examples/README
+
+# Step 1
+# Start an ActiveMQ Server
+
+# Step 2
+# Start up the manager
+rackup -p 4567
+
+# Step 3
+# Request 'my string' get reversed
+jruby request.rb 'my string'

data/examples/requestor/config.ru

@@ -0,0 +1,13 @@
+require '../setup'
+require './reverse_echo_worker'
+require './requestor'
+
+# If we're not starting up a standalone publisher, then start up a manager
+if ENV['RACK_ENV'] != 'publisher'
+  manager = Qwirk[$adapter_key].create_manager(:name => 'Worker', :persist_file => 'qwirk_persist.yml')
+  at_exit { manager.stop }
+end
+if ENV['RACK_ENV'] != 'worker'
+  Rumx::Bean.root.bean_add_child(:Requestor, Requestor.new($adapter_key))
+end
+run Rumx::Server

data/examples/requestor/qwirk_persist.yml

@@ -0,0 +1,5 @@
+---
+ReverseEcho:
+  :min_count: 1
+  :max_count: 1
+...

data/examples/requestor/requestor.rb

@@ -0,0 +1,68 @@
+require 'rumx'
+require 'qwirk'
+
+class MessageInfo
+  include Rumx::Bean
+
+  bean_attr_reader :request,  :string, 'The message that was sent'
+  bean_attr_reader :response, :string,  'The response that was received'
+
+  def initialize(request, response)
+    @request, @response = request, response
+  end
+end
+
+class Requestor
+  include Rumx::Bean
+
+  bean_reader :messages,  :list,   'Messages', :list_type => :bean
+
+  bean_operation :publish, :void, 'Publish and receive messages', [
+      [ :message,      :string,  'Message to get sent',                                                       'Hello' ],
+      [ :timeout,      :float,   'Timeout on receiving response',                                             4.0     ],
+      [ :sleep_time,   :float,   "Time between publishing and receiving where we're supposedly working",      2.0     ],
+      [ :thread_count, :integer, 'Number of different threads that are publishing and receiving the message', 10      ]
+  ]
+
+
+  def initialize(adapter_key)
+    @outstanding_hash_mutex = Mutex.new
+    @messages = []
+    @publisher = Qwirk[adapter_key].create_publisher(:queue_name => 'ReverseEcho', :response => {:time_to_live => 10000}, :marshal => :string)
+  end
+
+  def publish(message, timeout, sleep_time, thread_count)
+    @outstanding_hash_mutex.synchronize do
+      @messages = []
+    end
+    threads   = []
+    (0...thread_count).each do |i|
+      threads << Thread.new(i) do |i|
+        puts "#{i}: Publishing at #{Time.now.to_f}"
+        request = "##{i}: #{message}"
+        response = nil
+        begin
+          handle = @publisher.publish(request)
+          # Here's where we'd go off and do other work
+          sleep sleep_time
+          puts "#{i}: Finished sleeping at #{Time.now.to_f}"
+          response = handle.read_response(timeout)
+          puts "#{i}: Received at #{Time.now.to_f}: #{response}"
+        rescue Exception => e
+          puts "#{i}: Exception: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+          response = e.message
+        end
+        @outstanding_hash_mutex.synchronize do
+          @messages << MessageInfo.new(request, response)
+        end
+      end
+    end
+    threads.each {|t| t.join}
+  end
+
+  def messages
+    @outstanding_hash_mutex.synchronize do
+      return @messages.dup
+    end
+  end
+end

data/examples/requestor/reverse_echo_worker.rb

@@ -0,0 +1,15 @@
+class ReverseEchoWorker
+  include Qwirk::RequestWorker
+  
+  def request(obj)
+    puts "#{self}: Received #{obj} at #{Time.now}"
+    if obj =~ /^sleep (.*)/
+      sleep $1.to_f
+      puts "#{self}: Finished sleeping at #{Time.now}"
+    end
+    if obj =~ /^Exception/
+      raise Exception, 'You requested an exception'
+    end
+    obj.reverse
+  end
+end

data/examples/setup.rb

@@ -0,0 +1,13 @@
+# Allow examples to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'qwirk'
+require 'rumx'
+require 'yaml'
+require 'logger'
+
+#Qwirk.logger = Logger.new($stdout)
+file = File.expand_path('../qwirk.yml', __FILE__)
+Qwirk.config = YAML.load(ERB.new(File.read(file), nil, '-').result(binding))
+$adapter_key = ENV['QWIRK_ADAPTER'] || 'in_mem'

data/examples/shared/README.md

@@ -0,0 +1,24 @@
+## Step 0
+### Follow the directions for configuring configuring a JMS or InMem adapter located in examples/README
+
+## Step 1
+### Start up the application
+* rm -f qwirk_persist.yml
+* rackup -p 4567
+
+## Step 2
+* Browse to http://localhost:4567
+* Open up the tree to Qwirk => S1 => Attributes
+* Enter 2 for count and click the Update button.
+* Open up the tree to Qwirk => S2 => Attributes
+* Enter 3 for count and click the Update button.
+* Refresh the browser so that you get the worker updates to the tree
+
+## Step 3
+* Open the tree to Publisher => Operations => send\_bar or send\_baz
+* Enter values for the various arguments and click Execute.
+
+## Step 4
+* cntl-c the rackup process and start it back up.  It should come back with
+  the workers and the config values that have been configured via the browser.
+