ruote-maestrodev 2.2.1

data/lib/ruote/storage/fs_storage.rb

@@ -0,0 +1,139 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+require 'rufus/json'
+Rufus::Json.detect_backend
+
+require 'rufus/cloche'
+  # gem install rufus-cloche
+
+require 'ruote/storage/base'
+
+
+module Ruote
+
+  #
+  # A basic FS-bound ruote storage. Leverages rufus-cloche
+  # (http://github.com/jmettraux/rufus-cloche).
+  #
+  # Warning : for JRuby 1.4.0 on Ubuntu, passing the cloche_nolock option set
+  # to true seems necessary.
+  # See http://groups.google.com/group/openwferu-users/t/d82516ed3bdd8f23
+  #
+  class FsStorage
+
+    include StorageBase
+
+    # Creates a FsStorage pointing to the given dir.
+    #
+    # The options are classical engine configuration, but the 'cloche_nolock'
+    # option is read by the storage and followed.
+    #
+    def initialize(dir, options={})
+
+      if dir.is_a?(Hash) && options == {}
+        options = dir
+        dir = options.delete('dir')
+      end
+
+      FileUtils.mkdir_p(dir)
+
+      @cloche = Rufus::Cloche.new(
+        :dir => dir, :nolock => options['cloche_nolock'])
+
+      #@options = options
+
+      replace_engine_configuration(options)
+    end
+
+    def put(doc, opts={})
+
+      @cloche.put(doc.merge!('put_at' => Ruote.now_to_utc_s), opts)
+    end
+
+    def get(type, key)
+
+      @cloche.get(type, key)
+    end
+
+    def delete(doc)
+
+      @cloche.delete(doc)
+    end
+
+    def get_many(type, key=nil, opts={})
+
+      if key
+        key = Array(key)
+        key = key.map { |k| "!#{k}" } if key.first.is_a?(String)
+      end
+        # assuming /!#{wfid}$/...
+
+      @cloche.get_many(type, key, opts)
+    end
+
+    def ids(type)
+
+      @cloche.ids(type)
+    end
+
+    # Purges the storage completely.
+    #
+    def purge!
+
+      FileUtils.rm_rf(@cloche.dir)
+    end
+
+    # No need for that here (FsStorage adds type on the fly).
+    #
+    def add_type(type)
+    end
+
+    def purge_type!(type)
+
+      @cloche.purge_type!(type)
+    end
+
+    def dump(type)
+
+      s = "=== #{type} ===\n"
+
+      @cloche.get_many(type).inject(s) do |s1, e|
+        s1 << "\n"
+        e.keys.sort.inject(s1) do |s2, k|
+          s2 << "  #{k} => #{e[k].inspect}\n"
+        end
+      end
+    end
+
+    # Shuts this storage down.
+    #
+    def shutdown
+
+      # nothing to do
+    end
+  end
+end
+

data/lib/ruote/storage/hash_storage.rb

@@ -0,0 +1,211 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'rufus/json'
+require 'ruote/util/misc'
+require 'ruote/storage/base'
+require 'monitor'
+
+
+module Ruote
+
+  # An in-memory storage.
+  #
+  class HashStorage
+
+    include StorageBase
+    include MonitorMixin
+
+    attr_reader :h
+
+    def initialize(options={})
+
+      super()
+        # since were including MonitorMixin, this super() is necessary
+
+      @options = options
+
+      purge!
+
+      put(options.merge('type' => 'configurations', '_id' => 'engine'))
+    end
+
+    def put(doc, opts={})
+
+      i = @h.size
+
+      synchronize do
+
+        pre = get(doc['type'], doc['_id'])
+
+        if pre && pre['_rev'] != doc['_rev']
+          return pre
+        end
+
+        if pre.nil? && doc['_rev']
+          return true
+        end
+
+        doc = if opts[:update_rev]
+          doc['_rev'] = pre ? pre['_rev'] : -1
+          doc
+        else
+          doc.merge('_rev' => doc['_rev'] || -1)
+        end
+
+        doc['put_at'] = Ruote.now_to_utc_s
+        doc['_rev'] = doc['_rev'] + 1
+
+        @h[doc['type']][doc['_id']] = Rufus::Json.dup(doc)
+
+        nil
+      end
+
+    rescue => e
+      puts "=" * 80
+      File.open('doc.json', 'wb') do |f|
+        f.puts Rufus::Json.pretty_encode(doc)
+      end
+      raise e
+    end
+
+    def get(type, key)
+
+      synchronize do
+        Ruote.fulldup(@h[type][key])
+      end
+    end
+
+    def delete(doc)
+
+      drev = doc['_rev']
+
+      raise ArgumentError.new("can't delete doc without _rev") unless drev
+
+      synchronize do
+
+        prev = get(doc['type'], doc['_id'])
+
+        return true if prev.nil?
+
+        doc['_rev'] ||= 0
+
+        return prev if prev['_rev'] != drev
+
+        @h[doc['type']].delete(doc['_id'])
+
+        nil # success
+      end
+    end
+
+    def get_many(type, key=nil, opts={})
+
+      # NOTE : no dup here for now
+
+      synchronize do
+
+        keys = key ?
+          Array(key).map { |k| k.is_a?(String) ? "!#{k}" : k } : nil
+
+        docs = keys ?
+          @h[type].values.select { |doc|
+            Ruote::StorageBase.key_match?(keys, doc)
+          } :
+          @h[type].values
+
+        docs = docs.sort_by { |d| d['_id'] }
+
+        return docs.size if opts[:count]
+
+        docs = docs.reverse if opts[:descending]
+
+        skip = opts[:skip] || 0
+        limit = opts[:limit] || docs.size
+
+        docs[skip, limit]
+      end
+    end
+
+    # Returns a sorted list of all the ids for a given type.
+    #
+    def ids(type)
+
+      @h[type].keys.sort
+    end
+
+    # Purges the storage completely.
+    #
+    def purge!
+
+      @h = %w[
+
+        variables
+
+        msgs
+        expressions
+        errors
+        schedules
+        configurations
+        workitems
+
+      ].inject({}) { |h, k|
+        h[k] = {}
+        h
+      }
+
+      @h['configurations']['engine'] = @options
+    end
+
+    def add_type(type)
+
+      @h[type] = {}
+    end
+
+    def purge_type!(type)
+
+      @h[type] = {}
+    end
+
+    def dump(type)
+
+      s = "=== #{type} ===\n"
+
+      @h[type].inject(s) do |s1, (k, v)|
+        s1 << "\n"
+        s1 << "#{k} :\n"
+        v.keys.sort.inject(s1) do |s2, k1|
+          s2 << "  #{k1} => #{v[k1].inspect}\n"
+        end
+      end
+    end
+
+    # Shuts this storage down.
+    #
+    def shutdown
+
+      # nothing to do
+    end
+  end
+end
+

data/lib/ruote/svc/dispatch_pool.rb

@@ -0,0 +1,158 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  #
+  # The class where despatchement of workitems towards [real] participant
+  # is done.
+  #
+  # Can be extended/replaced for better handling of Thread (why not something
+  # like a thread pool or no threads at all).
+  #
+  class DispatchPool
+
+    def initialize(context)
+
+      @context = context
+    end
+
+    def handle(msg)
+
+      case msg['action']
+        when 'dispatch' then dispatch(msg)
+        when 'dispatch_cancel' then dispatch_cancel(msg)
+        when 'dispatch_pause', 'dispatch_resume' then dispatch_pause(msg)
+        else # simply discard the message
+      end
+    end
+
+    protected
+
+    def dispatch(msg)
+
+      participant = @context.plist.lookup(
+        msg['participant'] || msg['participant_name'], msg['workitem'])
+
+      if do_not_thread(participant, msg)
+        do_dispatch(participant, msg)
+      else
+        do_threaded_dispatch(participant, msg)
+      end
+    end
+
+    # The actual dispatching (call to Participant#consume).
+    #
+    def do_dispatch(participant, msg)
+
+      workitem = Ruote::Workitem.new(msg['workitem'])
+
+      workitem.fields['dispatched_at'] = Ruote.now_to_utc_s
+
+      participant.consume(workitem)
+
+      @context.storage.put_msg(
+        'dispatched',
+        'fei' => msg['fei'],
+        'participant_name' => workitem.participant_name)
+          # once the consume is done, asynchronously flag the
+          # participant expression as 'dispatched'
+    end
+
+    # Wraps the call to do_dispatch in a thread.
+    #
+    def do_threaded_dispatch(participant, msg)
+
+      msg = Rufus::Json.dup(msg)
+        #
+        # the thread gets its own copy of the message
+        # (especially important if the main thread does something with
+        # the message 'during' the dispatch)
+
+      # Maybe at some point a limit on the number of dispatch threads
+      # would be OK.
+      # Or maybe it's the job of an extension / subclass
+
+      Thread.new do
+        begin
+
+          do_dispatch(participant, msg)
+
+        rescue => exception
+          @context.error_handler.msg_handle(msg, exception)
+        end
+      end
+    end
+
+    # Returns true if the participant doesn't want the #consume to happen
+    # in a new Thread.
+    #
+    def do_not_thread(participant, msg)
+
+      return false unless participant.respond_to?(:do_not_thread)
+
+      if participant.method(:do_not_thread).arity == 0
+        participant.do_not_thread
+      else
+        participant.do_not_thread(Ruote::Workitem.new(msg['workitem']))
+      end
+    end
+
+    # Instantiates the participant and calls its cancel method.
+    #
+    def dispatch_cancel(msg)
+
+      flavour = msg['flavour']
+
+      participant = @context.plist.instantiate(msg['participant'])
+
+      begin
+        participant.cancel(Ruote::FlowExpressionId.new(msg['fei']), flavour)
+      rescue => e
+        raise(e) if flavour != 'kill'
+      end
+
+      @context.storage.put_msg(
+        'reply',
+        'fei' => msg['fei'],
+        'workitem' => msg['workitem'])
+    end
+
+    # Instantiates the participant and calls its on_pause (or on_resume) method.
+    #
+    def dispatch_pause(msg)
+
+      action = (msg['action'] == 'dispatch_resume' ? :on_resume : :on_pause)
+
+      participant = @context.plist.instantiate(
+        msg['participant'], :if_respond_to? => action)
+
+      return unless participant
+
+      participant.send(action, Ruote::FlowExpressionId.new(msg['fei']))
+    end
+  end
+end
+