cirrocumulus 0.3.0 → 0.4.2

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.2

data/cirrocumulus.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cirrocumulus}
-  s.version = "0.3.0"
+  s.version = "0.4.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Anton Kosyakin"]
@@ -32,7 +32,9 @@ Gem::Specification.new do |s|
     "lib/cirrocumulus/logger.rb",
     "lib/cirrocumulus/master_agent.rb",
     "lib/cirrocumulus/ontology.rb",
+    "lib/cirrocumulus/rule_engine.rb",
     "lib/cirrocumulus/saga.rb",
+    "lib/test.rb",
     "test/helper.rb",
     "test/test_cirrocumulus.rb"
   ]

data/lib/cirrocumulus/rule_engine.rb

@@ -0,0 +1,224 @@
+module RuleEngine
+  class Base
+    def self.rule(name, facts, &block)
+      current_ruleset << {:name => name, :facts => facts, :body => block}
+    end
+    
+    def dump_kb()
+      log "Dumping current knowledge base:\n"
+      @facts.each_with_index do |fact,i|
+        log "%d) %s" % [i, fact.inspect]
+      end
+      
+      log "Empty" if @facts.empty?
+    end
+    
+    def dump_ruleset()
+      log "Dumping current ruleset:\n"
+      self.class.current_ruleset.each_with_index do |rule,i|
+        log "%d) %s" % [i, rule[:name]]
+      end
+      
+      log "Empty ruleset" if self.class.current_ruleset.empty?
+    end
+
+    def assert(fact, silent = false)
+      log "assert: #{fact.inspect}"
+
+      @facts = [] if @facts.nil?
+      @facts << fact
+      process() if !silent
+    end
+
+    def retract(fact, silent = false)
+      @facts = [] if @facts.nil?
+      if @facts.delete(fact)
+        log "retract: #{fact.inspect}"
+        process() if !silent
+      else
+        puts "fact #{fact.inspect} not found"
+      end
+    end
+    
+    def execute()
+      process()
+    end
+
+    protected
+
+    @@loaded_rules = {}
+    
+    def self.current_ruleset()
+      return @@loaded_rules[self.name] ||= []
+    end
+    
+    def log(msg)
+      Log4r::Logger['kb'].info(msg)
+    rescue
+      puts "[INFO] %s" % msg
+    end
+    
+    def debug(msg)
+      Log4r::Logger['kb'].debug(msg)
+    rescue
+      puts "[DEBUG] %s" % msg
+    end
+
+    def matches?(rule)
+      debug "Processing rule '#{rule[:name]}' (#{rule[:facts].size} condition(s))"
+
+      pattern_candidates = []
+      rule[:facts].each do |pattern|
+        pattern_candidates << match_pattern(pattern)
+      end
+      
+      return nil if !pattern_candidates.all? {|c| c.size > 0}
+
+      debug "Rule '#{rule[:name]}' has candidates for each pattern"
+      
+      match_parameters(rule, pattern_candidates)
+    end
+    
+    def match_pattern(pattern)
+      debug "Attempting to match pattern #{pattern.inspect}"
+      fact_matches = true
+      candidates = []
+      
+      @facts.each do |fact|
+        next if fact.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[i]
+          end
+        end
+        
+        candidates << fact if fact_matches
+      end
+      
+      debug "Found #{candidates.size} candidate(s)"
+      candidates
+    end
+    
+    def match_parameters(rule, candidates)
+      debug "Attempting to match parameters"
+      
+      result = []
+      attempt = []
+      while (attempt = generate_combination(rule, candidates, attempt)) != [] do
+        bindings = test_combination(rule, candidates, attempt)
+        if bindings
+          debug "Matched! %s" % bindings.inspect
+          result << bindings
+        end
+      end
+      
+      result
+    end
+    
+    def test_combination(rule, candidates, attempt)
+      facts = []
+      attempt.each_with_index {|a,i| facts << candidates[i][a]}
+      debug "Testing combination #{attempt.inspect}: %s" % facts.inspect
+
+      binded_params = {}
+      pattern_params = {}
+      facts.each_with_index do |fact,i|
+        pattern_params = bind_parameters(rule[:facts][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[:facts].each {|pattern| next_attempt << 0}
+      else
+        next_attempt = increment_attempt(attempt, rule[:facts].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
+
+      puts "DEBUG: testing pattern %s against fact %s" % [pattern.inspect, fact.inspect]
+      puts "DEBUG: current parameters binding is %s" % current_params.inspect
+      
+      binded_params = {}
+      
+      pattern.each_with_index do |el,i|
+        if el.is_a?(Symbol) && el.to_s.upcase == el.to_s
+          puts "DEBUG: need to bind parameter %s" % 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
+      
+      puts "DEBUG: match! binding parameters: %s" % binded_params.inspect 
+      binded_params
+    end
+
+    def execute_rule(rule, params)
+      debug "executing rule '#{rule[:name]}'"
+      rule[:body].call(self, params)
+    end
+    
+    def process()
+      self.class.current_ruleset.each do |rule|
+        binded_params = matches?(rule)
+        next if binded_params.nil?
+        binded_params.each {|params| execute_rule(rule, params)}
+      end
+    end
+    
+  end
+ 
+end

data/lib/test.rb

@@ -0,0 +1,40 @@
+require 'cirrocumulus/rule_engine.rb'
+
+class Test < RuleEngine::Base
+  rule 'convert', [[:temperature, :X, 'F']] do |engine, params|
+    x = params[:X].to_i
+    engine.retract([:temperature, x, 'F'])
+    y = 5*(x - 32)/9
+    engine.assert([:temperature, y, 'C'])
+  end
+  
+  rule 'monitor_md', [[:virtual_disk, :X, :active], [:mdraid, :X, :failed]] do |engine, params|
+    # md devices is failed, but virtual disk should be up
+    p params
+    puts "virtual disk #{params[:X]} should be up, but corresponding md devices is failed!"
+  end
+end
+
+e = Test.new
+e.assert [:virtual_disk, 163, :active]
+#e.assert [:virtual_disk, 139, :active]
+#e.assert [:virtual_disk, 145, :active]
+#e.assert [:virtual_disk, 146, :active]
+#e.assert [:virtual_disk, 149, :active]
+e.assert [:virtual_disk, 153, :active]
+#e.assert [:virtual_disk, 154, :active]
+#e.assert [:virtual_disk, 156, :active]
+e.assert [:virtual_disk, 158, :active]
+#e.assert [:virtual_disk, 137, :active]
+#e.assert [:virtual_disk, 135, :active]
+#e.assert [:virtual_disk, 159, :active]
+#e.assert [:virtual_disk, 103, :active]
+#e.assert [:virtual_disk, 102, :active]
+#e.assert [:virtual_disk, 20, :active]
+#e.assert [:virtual_disk, 2, :active]
+#e.assert [:virtual_disk, 777, :active]
+#e.assert [:virtual_disk, 90, :active]
+e.assert [:mdraid, 153, :failed], true
+e.assert [:mdraid, 158, :failed], true
+e.execute()
+gets

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cirrocumulus
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 0
-  version: 0.3.0
+  - 4
+  - 2
+  version: 0.4.2
 platform: ruby
 authors: 
 - Anton Kosyakin
@@ -180,7 +180,9 @@ files:
 - lib/cirrocumulus/logger.rb
 - lib/cirrocumulus/master_agent.rb
 - lib/cirrocumulus/ontology.rb
+- lib/cirrocumulus/rule_engine.rb
 - lib/cirrocumulus/saga.rb
+- lib/test.rb
 - test/helper.rb
 - test/test_cirrocumulus.rb
 has_rdoc: true