cirrocumulus 0.6.3 → 0.9.2

data/lib/cirrocumulus/pattern_matching.rb

@@ -0,0 +1,175 @@
+class MatchResult
+	def initialize(rule)
+	  @rule = rule
+	  @matched_facts = []
+	  @parameters = nil
+	end
+
+	attr_reader :rule
+	attr_reader :matched_facts
+	attr_accessor :parameters
+
+  def ==(other)
+    rule == other.rule && matched_facts == other.matched_facts
+  end
+end
+
+class PatternMatcher
+	def initialize(facts)
+		@facts = facts
+	end
+
+	def match(pattern)
+		res = []
+		find_matches_for_condition(pattern).each do |fact|
+			res << bind_parameters(pattern, fact.data, {})
+		end
+
+		res
+	end
+
+	def matches?(rule)
+		trace "Processing rule '#{rule.name}' (#{rule.conditions.size} condition(s)):"
+
+		pattern_candidates = []
+		rule.conditions.each do |pattern|
+      pattern_candidates << find_matches_for_condition(pattern)
+		end
+
+		return nil if !pattern_candidates.all? {|c| c.size > 0}
+
+		intersect_matches_for_each_condition(rule, pattern_candidates)
+	end
+
+  def find_matches_for_condition(pattern)
+    trace "=> attempting to match pattern #{pattern.inspect}"
+    fact_matches = true
+    candidates = []
+
+	 @facts.each do |fact|
+	   next if fact.data.size != pattern.size
+	   fact_matches = true
+
+	   pattern.each_with_index do |el,i|
+	     if el.is_a?(Symbol) && el.to_s.upcase == el.to_s # parameter
+	     else
+	       fact_matches = false if el != fact.data[i]
+	     end
+	   end
+
+      candidates << fact if fact_matches
+    end
+
+		trace "=> candidates: #{candidates.size}" if candidates.size > 0
+    candidates
+  end
+
+	def intersect_matches_for_each_condition(rule, candidates)
+	 result = []
+	 attempt = []
+	 while (attempt = generate_combination(rule, candidates, attempt)) != [] do
+	   bindings = test_condition_parameters_combination(rule, candidates, attempt)
+	   if bindings
+	     match_data = MatchResult.new(rule)
+	     attempt.each_with_index {|a,i| match_data.matched_facts << candidates[i][a]}
+	     match_data.parameters = bindings
+	     result << match_data
+	   end
+	 end
+
+	 result
+	end
+
+	def test_condition_parameters_combination(rule, candidates, attempt)
+	 facts = []
+	 attempt.each_with_index {|a,i| facts << candidates[i][a].data}
+
+	 binded_params = {}
+	 pattern_params = {}
+	 facts.each_with_index do |fact,i|
+	   pattern_params = bind_parameters(rule.conditions[i], fact, binded_params)
+	   if pattern_params.nil? # failure, parameters mismatch
+	     return nil
+	   else
+	     binded_params.merge!(pattern_params)
+	   end
+	 end
+
+	 binded_params
+	end
+
+	def bind_parameters(pattern, fact, current_bindings)
+	 result = {}
+
+	 pattern.each_with_index do |p,i|
+	   if p.is_a?(Symbol) && p.to_s.upcase == p.to_s
+	     return nil if current_bindings.has_key?(p) && current_bindings[p] != fact[i]
+	     result[p] = fact[i]
+	   end
+	 end
+
+	 result
+	end
+
+	def generate_combination(rule, candidates, attempt)
+	 next_attempt = []
+
+	 if attempt == []
+	   rule.conditions.each {|pattern| next_attempt << 0}
+	 else
+	   next_attempt = increment_attempt(attempt, rule.conditions.size - 1, candidates.map {|c| c.size})
+	 end
+
+	 next_attempt
+	end
+
+	def increment_attempt(attempt, idx, limits)
+	 return [] if idx < 0
+
+	 if attempt[idx] < limits[idx] - 1
+	   attempt[idx] += 1
+	 else
+	   i = idx
+	   while i < limits.size do
+	     attempt[i] = 0
+	     i += 1
+	   end
+
+	   return increment_attempt(attempt, idx-1, limits)
+	 end
+
+	 attempt
+	end
+
+	def pattern_matches?(fact, pattern, current_params = {})
+	 return nil if fact.size != pattern.size
+
+	 binded_params = {}
+
+	 pattern.each_with_index do |el,i|
+	   if el.is_a?(Symbol) && el.to_s.upcase == el.to_s
+	     if current_params && current_params.has_key?(el)
+	       current_value = current_params[el]
+	       return nil if fact[i] != current_value
+	     else
+	       binded_params[el] = fact[i]
+	     end
+	   else
+	     return nil if el != fact[i]
+	   end
+	 end
+
+	 binded_params
+	end
+
+	private
+
+	def trace(msg)
+		puts "[TRACE] %s" % msg if false
+	end
+
+	def debug(msg)
+		puts "[DBG] %s" % msg if false
+	end
+
+end

data/lib/cirrocumulus/remote_console.rb

@@ -0,0 +1,29 @@
+require 'drb'
+require 'sexpistol'
+require_relative 'identifier'
+
+class RemoteConsole
+	def initialize
+
+	end
+
+	def list_inproc_agents
+		Ontology.list_ontology_instances()
+  end
+
+  def assert(instance, data)
+    Ontology.assert(LocalIdentifier.new(instance), Sexpistol.new.parse_string(data)[0])
+  end
+
+  def retract(instance, data)
+    Ontology.retract(LocalIdentifier.new(instance), Sexpistol.new.parse_string(data)[0])
+  end
+
+  def dump_kb(instance)
+    Ontology.dump_kb(LocalIdentifier.new(instance))
+  end
+
+  def dump_sagas(instance)
+    Ontology.dump_sagas(LocalIdentifier.new(instance))
+  end
+end

data/lib/cirrocumulus/rule_queue.rb

@@ -0,0 +1,69 @@
+require 'thread'
+
+class RuleQueue
+  class QueueEntry
+    attr_reader :run_data
+    attr_reader :rule
+    attr_reader :params
+    attr_reader :run_at
+    attr_accessor :state
+
+    def initialize(run_data, run_at = nil)
+      @run_data = run_data
+      @rule = run_data.rule
+      @params = run_data.parameters
+      @run_at = run_at
+      @state = :queued
+    end
+  end
+
+  def initialize(ontology_instance)
+    @mutex = Mutex.new
+    @queue = []
+    @ontology_instance = ontology_instance
+  end
+
+  def push(entry)
+    @mutex.synchronize do
+      @queue.push(QueueEntry.new(entry)) unless @queue.find {|e| e.state != :finished && e.run_data == entry}
+    end
+  end
+
+  def pop
+    @mutex.synchronize do
+      @queue.empty? ? nil : @queue.shift
+    end
+  end
+
+  def size
+    @mutex.synchronize do
+      @queue.size
+    end
+  end
+
+  def run_queued_rules
+    while (entry = pop) != nil do
+      next if entry.state == :finished
+      if entry.run_at && (entry.run_at < Time.now)
+        push(entry)
+        next
+      end
+
+      if entry.run_data.matched_facts.all? {|fact| !fact.is_deleted}
+        begin
+          debug "Executing #{entry.rule.name}#{entry.params.inspect}"
+          entry.rule.code.call(@ontology_instance, entry.params)
+          entry.state
+        rescue Exception => e
+          puts "[WARN] Exception while executing rule: %s\n%s" % [e.to_s, e.backtrace.to_s]
+        end
+      end
+    end
+  end
+
+  private
+
+  def debug(msg)
+    puts msg
+  end
+end

data/lib/cirrocumulus/rules/engine.rb

@@ -182,10 +182,12 @@ module RuleEngine
     end
 
     def tick()
-      to_retract = []
-      @facts.each {|fact| to_retract << fact if fact.timed_out? }
-      to_retract.each {|fact| retract(fact.data, true) }
-      process() unless to_retract.empty?
+      @mutex.synchronize do
+        to_retract = []
+        @facts.each {|fact| to_retract << fact if fact.timed_out? }
+        to_retract.each {|fact| retract_nonblocking(fact.data, true) }
+        process() unless to_retract.empty?
+      end
     rescue Exception => ex
       p ex
     end
@@ -386,7 +388,7 @@ module RuleEngine
     def process()
       self.class.current_ruleset.each do |rule|
         binded_params = matches?(rule)
-        next if binded_params.blank?
+        next if binded_params.nil? || binded_params.empty?
 
         binded_params.each {|params| execute_rule(params)}
       end

data/lib/cirrocumulus/rules/fact.rb

@@ -0,0 +1,22 @@
+module Cirrocumulus
+  module Ruler
+    # Fact.
+    # Piece of information, collected and operated in Cirrocumulus.
+    # We also remember the time, when this fact was created (observed). Optionally can have expiration time
+    class Fact
+      attr_reader :data
+      attr_accessor :is_deleted
+
+      def initialize(data, time, options)
+        @data = data
+        @time = time
+        @options = options
+      end
+
+      def expired?
+        return false if @options[:expires] == nil
+        @time + @options[:expires] < Time.now
+      end
+    end
+  end
+end

data/lib/cirrocumulus/rules/pattern_matcher.rb

@@ -0,0 +1,19 @@
+module Cirrocumulus
+  module Ruler
+    # The Matcher.
+    # Matches and compares facts with each other. Searches and bind variables.
+    class PatternMatcher
+      def match(pattern, fact)
+        return false if fact.data.size != pattern.size
+        fact_matches = true
+
+        pattern.each_with_index do |el,i|
+          next if el.is_a?(Symbol) && el.to_s.upcase == el.to_s
+          fact_matches = false if el != fact.data[i]
+        end
+
+        fact_matches
+      end
+    end
+  end
+end

data/lib/cirrocumulus/rules/run_queue.rb

@@ -64,6 +64,7 @@ module RuleEngine
               entry.state = :running
             end
 
+            idx += 1
             count -= 1
           end
         end

data/lib/cirrocumulus/saga.rb

@@ -1,55 +1,74 @@
+#
+# Saga. Implements long-running workflows
+#
 class Saga
-  attr_reader :id
-  attr_reader :context
-  attr_reader :finished
+  class << self
+    @@saga_names = {}
+
+    def saga(saga_name = nil)
+      return @@saga_names[name] if saga_name.nil?
+      @@saga_names[name] = saga_name
+    end
+  end
 
-  DEFAULT_TIMEOUT = 15
-  LONG_TIMEOUT = 60
-  
   STATE_ERROR = -1
   STATE_START = 0
   STATE_FINISHED = 255
 
+  attr_reader :id
+
   def initialize(id, ontology)
     @id = id
     @ontology = ontology
-    @finished = false
-    @timeout_at = -1
     @state = STATE_START
+    @started_at = Time.now
   end
 
   def is_finished?
-    @finished || @state == STATE_ERROR
+    @state == STATE_ERROR || @state == STATE_FINISHED
   end
 
-  def timed_out?(time)
-    @timeout_at > 0 && @timeout_at <= time
+  def handle_reply(sender, contents, options = {}); end
+
+  def dump_parameters
+    ""
+  end
+
+  def to_s
+    "%s type=%s, started at %s, state=%d, params: %s" % [@id, @@saga_names[self.class.name], @started_at, @state, dump_parameters]
   end
 
   protected
 
-  def clear_timeout()
-    @timeout_at = -1
+  #
+  # Inter-agent communications with context of this saga.
+  #
+  def inform(agent, proposition)
+    @ontology.inform agent, proposition, :conversation_id => self.id
   end
 
-  def set_timeout(secs)
-    Log4r::Logger['agent'].debug "[#{id}] waiting for #{secs} second(s)" if secs > 1
-    @timeout_at = Time.now.to_i + secs
+  def request(agent, action)
+    @ontology.request agent, action, :conversation_id => self.id
   end
-  
-  def change_state(new_state)
-    Log4r::Logger['agent'].debug "[#{id}] switching state from #{@state} to #{new_state}"
-    @state = new_state
+
+  def query(agent, expression)
+    @ontology.query agent, expression, :reply_with => self.id
+  end
+
+  def query_if(agent, proposition)
+    @ontology.query_if agent, proposition, :reply_with => self.id
   end
-  
+
   def finish()
-    clear_timeout()
     change_state(STATE_FINISHED)
-    @finished = true
-    Log4r::Logger['agent'].debug "[#{id}] finished"
   end
-  
+
   def error()
     change_state(STATE_ERROR)
   end
+
+  def change_state(new_state)
+    @state = new_state
+  end
+
 end