cirrocumulus 0.6.3 → 0.9.2

data/README.rdoc

@@ -1,24 +1,3 @@
 = Cirrocumulus
 
-Cirrocumulus is an agent-based (cloud) 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.
-
-== Technical
-=== Message structure
-
-Each message is serialized in XML.
-It contains routing information, action type and content. Content always is an s-expression.
-
-Message structure looks like:
-  <fipa-message
-    receiver="optional receiving agent identifier"
-    ontology="domain, e.g. cirrocumulus-vps, cirrocumulus-xen"
-    act="request|query-ref|query-if|inform|failure">
-    <content>
-      (s-expression)
-    </content>
-  </fipa-message>
-
-=== Action types
-* request - asks receiver to perform some action, described in content
-* query-ref - query receiver for some information
-* query-if - asks receiver, if given proposition in content is true or false
+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.

data/lib/cirrocumulus.rb

@@ -1,2 +1,8 @@
-require 'active_support'
-require 'cirrocumulus/logger'
+require 'thread'
+require 'sexpistol'
+require_relative 'cirrocumulus/identifier'
+require_relative 'cirrocumulus/facts'
+require_relative 'cirrocumulus/channels/jabber'
+require_relative 'cirrocumulus/channels'
+require_relative 'cirrocumulus/ontology'
+require_relative 'cirrocumulus/environment'

data/lib/cirrocumulus/channels.rb

@@ -0,0 +1,129 @@
+require_relative 'channels/jabber'
+
+#
+# Communication channel between agents. This is an abstract class.
+#
+class AbstractChannel
+  #
+  # Informs the other side that given proposition is true.
+  #
+  def inform(sender, proposition, options = {}); end
+
+  #
+  # Request the other side to perform an action
+  #
+  def request(sender, action, options = {}); end
+
+  #
+  # Query the other side about expression value.
+  #
+  def query(sender, expression, options = {}); end
+
+  #
+  # Query the other side if given proposition is true.
+  #
+  def query_if(sender, proposition, options = {}); end
+end
+
+#
+# Communication channel between different threads on local machine.
+#
+class ThreadChannel < AbstractChannel
+  def initialize(ontology)
+    @ontology = ontology
+  end
+
+  def inform(sender, proposition, options = {})
+    @ontology.handle_inform(sender, proposition, options)
+  end
+
+  def request(sender, action, options = {})
+    @ontology.handle_request(sender, action, options)
+  end
+
+  def query(sender, expression, options = {})
+    @ontology.handle_query(sender, expression, options)
+  end
+
+  def query_if(sender, proposition, options = {})
+    @ontology.handle_query_if(sender, proposition, options)
+  end
+end
+
+#
+# Communication channel over network.
+#
+class NetworkChannel < AbstractChannel
+  def initialize(client, remote_jid)
+    @remote_jid = remote_jid
+    @client = client
+    @serializer = Sexpistol.new
+  end
+
+  def inform(sender, proposition, options = {})
+    client.queue(serializer.to_sexp(build_message(remote_jid, :inform, proposition, options)))
+  end
+
+  def request(sender, action, options = {})
+    client.queue(serializer.to_sexp(build_message(remote_jid, :request, action, options)))
+  end
+
+  def query(sender, expression, options = {})
+    client.queue(serializer.to_sexp(build_message(remote_jid, :query, expression, options)))
+  end
+
+  def query_if(sender, proposition, options = {})
+    client.queue(serializer.to_sexp(build_message(remote_jid, :query_if, proposition, options)))
+  end
+
+  private
+
+  attr_reader :client
+  attr_reader :remote_jid
+  attr_reader :serializer
+
+  def build_message(receiver_name, act, content, options)
+    msg = [
+      act,
+      [:receiver,
+        [:agent_identifier, :name, receiver_name]
+      ],
+      [:content, content]
+    ]
+
+    msg << [:reply_with, options[:reply_with]] if options.has_key?(:reply_with)
+    msg << [:in_reply_to, options[:in_reply_to]] if options.has_key?(:in_reply_to)
+    msg << [:conversation_id, options[:conversation_id]] if options.has_key?(:conversation_id)
+
+    msg
+  end
+
+end
+
+#
+# Factory to retrieve proper communication channel for two agents.
+#
+class ChannelFactory
+  def self.retrieve(instance, agent)
+    if agent.is_a?(LocalIdentifier)
+      ontology_instance = Ontology.query_ontology_instance(agent)
+
+      if ontology_instance
+        return ThreadChannel.new(Ontology.query_ontology_instance(agent))
+      else
+        puts "[WARN] Thread-local ontology not found for identifier=%s" % agent.to_s
+      end
+    elsif agent.is_a?(RemoteIdentifier)
+      jabber_client = JabberChannel.query_client(instance.to_s)
+
+      if jabber_client
+        return NetworkChannel.new(jabber_client, agent.to_s)
+      else
+        puts "[WARN] No active Jabber clients."
+      end
+    end
+
+    puts "[WARN] No suitable channel found for #{agent.to_s} (#{agent.class.name})"
+    nil
+  end
+end

data/lib/cirrocumulus/channels/jabber.rb

@@ -0,0 +1,168 @@
+require 'xmpp4r'
+require 'xmpp4r-simple'
+require 'guid'
+require 'thread'
+
+class JabberIdentifier < RemoteIdentifier
+  def initialize(jid)
+    @jid = "#{Cirrocumulus::Environment.current.name}-#{jid}"
+    @channel = JabberChannel.new('172.16.11.4', 'cirrocumulus')
+    @channel.connect(@jid, 'q1w2e3r4')
+    @thrd = Thread.new do
+      parser = Sexpistol.new
+      while true do
+        @channel.tick()
+        
+        instance = Ontology.query_ontology_instance(self)
+        if !instance.nil?
+          while true
+            msg = @channel.received_messages.pop(true) rescue nil
+            break if msg.nil?
+            
+            begin
+              fipa_message = parser.parse_string(msg.body)
+              id = RemoteIdentifier.new(msg.from.resource)
+              
+              next if fipa_message.size < 1
+              
+              fipa_message = fipa_message.first
+              
+              next if fipa_message.size < 2
+              
+              act = fipa_message[0]
+              fipa_message.delete_at(0)
+              content = fipa_message
+              
+              receiver = nil
+              action_content = nil
+              options = {}
+              content.each do |parameter|
+                next if !parameter.is_a?(Array) || parameter.size < 1
+                if parameter[0] == :receiver
+                  receiver = parameter[1][2]
+                elsif parameter[0] == :content
+                  action_content = parameter[1]
+                elsif [:reply_with, :in_reply_to, :conversation_id].include?(parameter[0])
+                  options[parameter[0]] = parameter[1]
+                end
+              end
+              
+              next if receiver.nil? || receiver != @jid
+              
+              case act
+                when :query
+                  instance.handle_query(id, action_content, options)
+                when :query_if
+                  instance.handle_query_if(id, action_content, options)
+                when :inform
+                  instance.handle_inform(id, action_content, options)
+                when :request
+                  instance.handle_request(id, action_content, options)
+              end
+            rescue Exception => ex
+              puts ex.message
+              puts ex.backtrace.to_s
+            end
+          end
+        end
+        sleep 0.1
+      end
+    end
+  end
+  
+  def join
+    @thrd.join
+  end
+
+  def to_s
+    @jid
+  end
+end
+
+class JabberChannel
+  class << self
+    @@jabber_clients = []
+    
+    def query_client(jid)
+      @@jabber_clients.find {|c| c.jid == jid}
+    end
+  end
+
+  attr_reader :jid
+  attr_reader :conference
+
+  def initialize(server, conference)
+    @jabber = nil
+    @server = server
+    @conference = conference
+    @send_q = Queue.new
+    @recv_q = Queue.new
+    
+    @@jabber_clients << self
+  end
+  
+  def connected?
+    @jabber && @jabber.connected?
+  end
+  
+  def connect(jid, password)
+    @full_jid = "%s@%s" % [jid, @server]
+    @jid = jid
+
+    puts "Using jid #{@jid}"
+    
+    begin
+      @jabber = Jabber::Simple.new(@full_jid, password)
+    rescue Jabber::ClientAuthenticationFailure => ex
+      puts ex.class.name
+      client = Jabber::Client.new(@full_jid)
+      client.connect()
+      client.register(password)
+      client.close()
+      @jabber = Jabber::Simple.new(@full_jid, password)
+    rescue Exception => ex
+      puts ex.to_s
+    end
+    
+    join_conference(@conference) if connected?
+    connected?
+  end
+  
+  def disconnect()
+    @jabber.disconnect()
+  end
+  
+  def queue(msg)
+    @send_q << msg
+  end
+  
+  def received_messages
+    @recv_q
+  end
+  
+  def tick()
+    return if !connected?
+    
+    @jabber.received_messages do |msg|
+     next unless msg.x('jabber:x:delay').nil?
+     
+     @recv_q << msg
+    end
+    
+    while true do
+      to_send = @send_q.pop(true) rescue nil
+      break if to_send.nil?
+      
+      @jabber.send!('<message type="groupchat" to="%s" id="%s"><body>%s</body></message>' % [                                 
+        "%s@conference.%s" % [@conference, @server], Guid.new.to_s.gsub('-', ''),                                                                                         
+        to_send.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')                                     
+      ]) 
+    end
+  end
+  
+  protected
+  
+  def join_conference(conference)
+    @jabber.send!("<presence to='#{conference}@conference.#{@server}/#{@jid}' />")
+  end
+end

data/lib/cirrocumulus/environment.rb

@@ -0,0 +1,46 @@
+module Cirrocumulus
+  #
+  # Cirrocumulus environment. It is a container where all ontologies will be loaded.
+  #
+  class Environment
+
+    def self.current
+      @@instance
+    end
+
+    attr_reader :name
+
+    def initialize(name)
+      puts "Loading #{name} Cirrocumulus environment."
+
+      @name = name
+      @ontologies = []
+      @@instance = self
+    end
+
+    #
+    # Loads ontology instance into environment.
+    #
+    def load_ontology(ontology_instance)
+      puts "Adding #{ontology_instance.name} ontology."
+      @ontologies << ontology_instance
+    end
+
+    #
+    # Runs the environment. It will also restore all loaded ontologies states.
+    #
+    def run
+      @ontologies.each {|ontology| ontology.restore_state }
+      @ontologies.each {|ontology| ontology.run }
+    end
+
+    def join
+      @ontologies.each {|ontology| ontology.join }
+    end
+
+    private
+
+    @@instance = nil
+
+  end
+end

data/lib/cirrocumulus/facts.rb

@@ -0,0 +1,135 @@
+#
+# Fact (piece of knowledge) representation.
+# It holds time when it was observed (added to facts database) and expire time in seconds.
+#
+class Fact
+	def initialize(data, time, options)
+		@data = data
+    @time = time
+    @options = options
+		@is_deleted = false
+  end
+
+	attr_reader :data
+	attr_accessor :is_deleted
+
+	def timed_out?
+		return false if @options[:expires] == nil
+		@time + @options[:expires] < Time.now
+	end
+end
+
+#
+# Adapter for facts database.
+#
+class FactsDatabase
+	def initialize
+		@storage = []
+	end
+
+	def add(fact, options = {})
+		@storage << Fact.new(fact, Time.now, options)
+	end
+
+	def remove(fact)
+		@storage.delete_if {|f| f.data == fact}
+	end
+
+	def enumerate
+		@storage.dup
+	end
+end
+
+class KnowledgeClass
+  class KnowledgeClassDescription
+    attr_accessor :name
+    attr_accessor :primary_key
+    attr_reader :properties
+
+    def initialize(klass)
+      @name = klass.name
+      @properties = []
+    end
+  end
+
+  class << self
+    @@classes = {}
+
+    def klass(class_name)
+      @@classes[self.name] = KnowledgeClassDescription.new(self) if @@classes[self.name].nil?
+      @@classes[self.name].name = class_name.to_s
+    end
+
+    def id(id_name)
+      @@classes[self.name] = KnowledgeClassDescription.new(self) if @@classes[self.name].nil?
+      @@classes[self.name].primary_key = id_name.to_s
+      @@classes[self.name].properties << id_name.to_s
+    end
+
+    def property(property_name)
+      @@classes[self.name] = KnowledgeClassDescription.new(self) if @@classes[self.name].nil?
+      @@classes[self.name].properties << property_name.to_s
+    end
+
+    def from_fact(fact)
+      description = @@classes[self.name]
+      return nil if fact[0] != description.name.to_sym
+
+      instance = self.new
+      instance.values[description.primary_key] = fact[1]
+      description.properties.each_with_index do |k, idx|
+        next if idx == 0
+        instance.values[k] = fact[1 + idx*2]
+      end
+
+      instance
+    end
+  end
+
+  attr_reader :values
+
+  def initialize
+    @values = {}
+  end
+
+  def to_template
+    description = @@classes[self.class.name]
+    fact = [description.name.to_sym]
+    fact << values[description.primary_key]
+    description.properties.each do |k|
+      next if k == description.primary_key
+
+      fact << k.to_sym
+      fact << k.upcase.to_sym
+    end
+
+    fact
+  end
+
+  def to_fact
+    description = @@classes[self.class.name]
+    fact = [description.name.to_sym]
+    fact << values[description.primary_key]
+    description.properties.each do |k|
+      next if k == description.primary_key
+
+      fact << k.to_sym
+      fact << values[k]
+    end
+
+    fact
+  end
+
+  def method_missing(meth, *args, &block)
+    description = @@classes[self.class.name]
+    description.properties.each do |prop|
+      if meth.to_s == "#{prop}="
+        return values[prop] = args[0]
+      elsif meth.to_s == prop
+        return values[prop]
+      end
+    end
+
+    super
+  end
+end