cirrocumulus 0.9.2 → 0.9.7

data/README.rdoc

@@ -1,3 +1,3 @@
 = Cirrocumulus
 
-Cirrocumulus is an agent-based infrastructure management system. Each agent, running on a host, is responsible for its own problem and cooperates with the rest via XMPP as a transport and FIPA-ACL messages as a protocol.
+Cirrocumulus is an agent-based infrastructure management engine. Each agent, running on a host, is responsible for its own problem and cooperates with the rest via XMPP as a transport and FIPA-ACL messages as a protocol.

data/lib/cirrocumulus/channels.rb

@@ -23,6 +23,21 @@ class AbstractChannel
   # Query the other side if given proposition is true.
   #
   def query_if(sender, proposition, options = {}); end
+
+  #
+  # Agree to perform an action
+  #
+  def agree(sender, action, options = {}); end
+
+  #
+  # Refuse to perform an action, because of reason.
+  #
+  def refuse(sender, action, reason, options = {}); end
+
+  #
+  # Attempted to perform an action, but failed with given reason.
+  #
+  def failure(sender, action, reason, options = {}); end
 end
 
 #
@@ -48,6 +63,18 @@ class ThreadChannel < AbstractChannel
   def query_if(sender, proposition, options = {})
     @ontology.handle_query_if(sender, proposition, options)
   end
+
+  def agree(sender, action, options = {})
+    @ontology.handle_agree(sender, action, options)
+  end
+
+  def refuse(sender, action, reason, options = {})
+    @ontology.handle_refuse(sender, action, reason, options)
+  end
+
+  def failure(sender, action, reason, options = {})
+    @ontology.handle_failure(sender, action, reason, options)
+  end
 end
 
 #
@@ -76,6 +103,18 @@ class NetworkChannel < AbstractChannel
     client.queue(serializer.to_sexp(build_message(remote_jid, :query_if, proposition, options)))
   end
 
+  def agree(sender, action, options = {})
+    client.queue(serializer.to_sexp(build_message(remote_jid, :agree, action, options)))
+  end
+
+  def refuse(sender, action, reason, options = {})
+    client.queue(serializer.to_sexp(build_message(remote_jid, :refuse, [action, reason], options)))
+  end
+
+  def failure(sender, action, reason, options = {})
+    client.queue(serializer.to_sexp(build_message(remote_jid, :failure, [action, reason], options)))
+  end
+
   private
 
   attr_reader :client

data/lib/cirrocumulus/channels/jabber.rb

@@ -6,7 +6,7 @@ require 'thread'
 class JabberIdentifier < RemoteIdentifier
   def initialize(jid)
     @jid = "#{Cirrocumulus::Environment.current.name}-#{jid}"
-    @channel = JabberChannel.new('172.16.11.4', 'cirrocumulus')
+    @channel = JabberChannel.new()
     @channel.connect(@jid, 'q1w2e3r4')
     @thrd = Thread.new do
       parser = Sexpistol.new
@@ -58,6 +58,12 @@ class JabberIdentifier < RemoteIdentifier
                   instance.handle_inform(id, action_content, options)
                 when :request
                   instance.handle_request(id, action_content, options)
+                when :agree
+                  instance.handle_agree(id, action_content, options)
+                when :refuse
+                  instance.handle_refuse(id, action_content[0], action_content[1], options)
+                when :failure
+                  instance.handle_failure(id, action_content[0], action_content[1], options)
               end
             rescue Exception => ex
               puts ex.message
@@ -86,15 +92,27 @@ class JabberChannel
     def query_client(jid)
       @@jabber_clients.find {|c| c.jid == jid}
     end
+
+    def server(server)
+      @@server = server
+    end
+
+    def conference(conf)
+      @@conference = conf
+    end
+
+    def jid_suffix(suffix)
+      @@jid_suffix = suffix
+    end
   end
 
   attr_reader :jid
   attr_reader :conference
 
-  def initialize(server, conference)
+  def initialize(server = nil, conference = nil)
     @jabber = nil
-    @server = server
-    @conference = conference
+    @server = server || @@server
+    @conference = conference || @@conference
     @send_q = Queue.new
     @recv_q = Queue.new
     
@@ -106,7 +124,7 @@ class JabberChannel
   end
   
   def connect(jid, password)
-    @full_jid = "%s@%s" % [jid, @server]
+    @full_jid = "%s@%s" % [jid, @@jid_suffix || @server]
     @jid = jid
 
     puts "Using jid #{@jid}"
@@ -115,6 +133,7 @@ class JabberChannel
       @jabber = Jabber::Simple.new(@full_jid, password)
     rescue Jabber::ClientAuthenticationFailure => ex
       puts ex.class.name
+      puts ex.to_s
       client = Jabber::Client.new(@full_jid)
       client.connect()
       client.register(password)
@@ -163,6 +182,6 @@ class JabberChannel
   protected
   
   def join_conference(conference)
-    @jabber.send!("<presence to='#{conference}@conference.#{@server}/#{@jid}' />")
+    @jabber.send!("<presence to='#{conference}@conference.#{@@jid_suffix || @server}/#{@jid}' />")
   end
 end

data/lib/cirrocumulus/facts.rb

@@ -71,6 +71,20 @@ class KnowledgeClass
       @@classes[self.name].properties << property_name.to_s
     end
 
+    def to_template
+      description = @@classes[self.name]
+      fact = [description.name.to_sym]
+      fact << description.primary_key.upcase.to_sym
+      description.properties.each do |k|
+        next if k == description.primary_key
+
+        fact << k.to_sym
+        fact << k.upcase.to_sym
+      end
+
+      fact
+    end
+
     def from_fact(fact)
       description = @@classes[self.name]
       return nil if fact[0] != description.name.to_sym
@@ -88,8 +102,19 @@ class KnowledgeClass
 
   attr_reader :values
 
-  def initialize
+  def initialize(options = {})
     @values = {}
+
+    description = @@classes[self.class.name]
+    if options.has_key?(description.primary_key.to_sym)
+      @values[description.primary_key] = options[description.primary_key.to_sym]
+    end
+
+    description.properties.each do |prop|
+      next if prop == description.primary_key
+      next unless options.has_key?(prop.to_sym)
+      @values[prop] = options[prop.to_sym]
+    end
   end
 
   def to_template
@@ -100,7 +125,21 @@ class KnowledgeClass
       next if k == description.primary_key
 
       fact << k.to_sym
-      fact << k.upcase.to_sym
+      fact << values[k]
+    end
+
+    fact
+  end
+
+  def to_params
+    description = @@classes[self.class.name]
+    fact = [description.name.to_sym]
+    fact << (values.has_key?(description.primary_key) ? values[description.primary_key] : description.primary_key.upcase.to_sym)
+    description.properties.each do |k|
+      next if k == description.primary_key
+
+      fact << k.to_sym
+      fact << (values.has_key?(k) ? values[k] : k.upcase.to_sym)
     end
 
     fact

data/lib/cirrocumulus/ontology.rb

@@ -79,7 +79,8 @@ class Ontology
       return if predicate.empty?
       return if current_ruleset.count {|rule| rule.name == name} > 0
 
-			current_ruleset << RuleDescription.new(name, predicate, options, block)
+      distilled_predicate = predicate.map {|cond| cond.is_a?(KnowledgeClass) ? cond.to_params : cond}
+			current_ruleset << RuleDescription.new(name, distilled_predicate, options, block)
 		end
 	end
 
@@ -180,6 +181,10 @@ class Ontology
    end
  end
 
+  def report_incident(subject, description)
+
+  end
+
   def dump_kb()
     @facts.enumerate.map {|fact| fact.data.to_s}
   end
@@ -222,7 +227,37 @@ class Ontology
 
 	def inform_and_wait(agent, fact, options = {})
 
-	end
+  end
+
+  #
+  # The action of agreeing to perform some action, possibly in the future.
+  #
+  def agree(agent, action, options = {})
+    puts "%25s | agree with %s to perform %s %s" % [identifier, agent, Sexpistol.new.to_sexp(action), print_message_options(options)]
+
+    channel = ChannelFactory.retrieve(identifier, agent)
+    channel.agree(identifier, action, options) if channel
+  end
+
+  #
+  # The action of refusing to perform a given action, and explaining the reason for the refusal.
+  #
+  def refuse(agent, action, reason, options = {})
+    puts "%25s | refuse %s to perform %s because %s %s" % [identifier, agent, Sexpistol.new.to_sexp(action), Sexpistol.new.to_sexp(reason), print_message_options(options)]
+
+    channel = ChannelFactory.retrieve(identifier, agent)
+    channel.refuse(identifier, action, reason, options) if channel
+  end
+
+  #
+  # The action of telling another agent that an action was attempted but the attempt failed.
+  #
+  def failure(agent, action, reason = true , options = {})
+    puts "%25s | inform %s that action %s failed with reason %s %s" % [identifier, agent, Sexpistol.new.to_sexp(action), Sexpistol.new.to_sexp(reason), print_message_options(options)]
+
+    channel = ChannelFactory.retrieve(identifier, agent)
+    channel.failure(identifier, action, reason, options) if channel
+  end
 
   #
   # Send request to another agent.
@@ -268,29 +303,62 @@ class Ontology
   def handle_inform(sender, proposition, options = {})
     puts "%25s | received %s from %s %s" % [identifier, Sexpistol.new.to_sexp(proposition), sender, print_message_options(options)]
 
-    if options.has_key?(:conversation_id) || options.has_key?(:in_reply_to)
-      saga_id = options[:conversation_id] || options[:in_reply_to]
-      saga = @sagas.find {|saga| saga.id == saga_id}
-      saga.handle_reply(sender, proposition, :action => :inform) if saga
-    else
+    if !handle_saga_reply(sender, :inform, proposition, options)
+      @classes.each do |klass|
+        if instance = klass.from_fact(proposition)
+          matcher = PatternMatcher.new(@facts.enumerate)
+          bindings = matcher.match(instance.to_template)
+          if !bindings.empty?
+            replace instance.to_template, matcher.pattern_matches?(proposition, instance.to_template)
+          else
+            assert(proposition)
+          end
+
+          return
+        end
+      end
+
       assert proposition, :origin => sender
     end
   end
 
+
+  def handle_agree(sender, action, options = {})
+    if !handle_saga_reply(sender, :agree, action, options)
+      puts "%25s | %s agreed to perform %s %s" % [identifier, sender, Sexpistol.new.to_sexp(action), print_message_options(options)]
+    end
+  end
+
+  def handle_refuse(sender, action, reason, options = {})
+    if !handle_saga_reply(sender, :refuse, [action, reason], options)
+      puts "%25s | %s refused to perform %s because %s %s" % [identifier, sender, Sexpistol.new.to_sexp(action), Sexpistol.new.to_sexp(reason), print_message_options(options)]
+    end
+  end
+
+  def handle_failure(sender, action, reason, options = {})
+    if !handle_saga_reply(sender, :failure, [action, reason], options)
+      puts "%25s | %s failed to perform %s because %s %s" % [identifier, sender, Sexpistol.new.to_sexp(action), Sexpistol.new.to_sexp(reason), print_message_options(options)]
+    end
+  end
+
   #
   # Abstract method to handle requests to this ontology.
   #
-	def handle_request(sender, contents, options = {}); end
+	def handle_request(sender, contents, options = {})
+    if !handle_saga_reply(sender, :request, contents, options)
+      puts "%25s | %s requests to perform %s %s" % [identifier, sender, Sexpistol.new.to_sexp(contents), print_message_options(options)]
+    end
+  end
 
   def handle_query(sender, expression, options = {})
-    puts "%25s | %s queries %s %s" % [identifier, sender, Sexpistol.new.to_sexp(expression), print_message_options(options)]
+    puts "%25s | %s queries %s %s" % [identifier, sender, Sexpistol.new.to_sexp(expression), print_message_options(options)] unless handle_saga_reply(sender, :query, expression, options)
   end
 
   #
   # Handles query-if to ontology. By default, it lookups the fact in KB and replies to the sender.
   #
   def handle_query_if(sender, proposition, options = {})
-    puts "%25s | %s queries if %s %s" % [identifier, sender, Sexpistol.new.to_sexp(proposition), print_message_options(options)]
+    puts "%25s | %s queries if %s %s" % [identifier, sender, Sexpistol.new.to_sexp(proposition), print_message_options(options)] unless handle_saga_reply(sender, :query, expression, options)
   end
 
 	protected
@@ -298,6 +366,17 @@ class Ontology
 	attr_reader :facts
 	attr_accessor :running
 
+  def handle_saga_reply(sender, action, content, options)
+    if options.has_key?(:conversation_id) || options.has_key?(:in_reply_to)
+      saga_id = options[:conversation_id] || options[:in_reply_to]
+      saga = @sagas.find {|saga| saga.id == saga_id}
+      saga.handle_reply(sender, content, :action => action) if saga
+      return true
+    end
+
+    false
+  end
+
 	def assert_nb(fact, options = {}, silent = false)
 		silent = options unless options.is_a?(Hash)
     options = {} unless options.is_a?(Hash)

data/lib/cirrocumulus/saga.rb

@@ -43,10 +43,23 @@ class Saga
   #
   # Inter-agent communications with context of this saga.
   #
+
   def inform(agent, proposition)
     @ontology.inform agent, proposition, :conversation_id => self.id
   end
 
+  def agree(agent, action)
+    @ontology.agree agent, action, :conversation_id => self.id
+  end
+
+  def refuse(agent, action, reason)
+    @ontology.refuse agent, action, reason, :conversation_id => self.id
+  end
+
+  def failure(agent, action, reason = true)
+    @ontology.failure agent, action, reason, :conversation_id => self.id
+  end
+
   def request(agent, action)
     @ontology.request agent, action, :conversation_id => self.id
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cirrocumulus
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-16 00:00:00.000000000 Z
+date: 2012-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: log4r