cirrocumulus 0.1.1

data/README.rdoc

@@ -0,0 +1,24 @@
+= 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

data/Rakefile

@@ -0,0 +1,52 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'cirrocumulus'
+  s.homepage = 'https://github.com/deil/cirrocumulus'
+  s.version = '0.1.1'
+  s.has_rdoc = false
+  s.extra_rdoc_files = ['README.rdoc']
+  s.summary = 'Agent-based infrastructure management system'
+  s.description = 'Engine for agent-based infrastructure management system'
+  s.author = 'Anton Kosyakin'
+  s.email = 'deil@mneko.net'
+  # s.executables = ['your_executable_here']
+  s.files = %w(README.rdoc Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+  s.license = ['GPL-2']
+  s.add_dependency("activesupport", "~> 2.3.11")
+  s.add_dependency("log4r", "~> 1.1.9")
+  s.add_dependency("systemu")
+  s.add_dependency("xmpp4r", "~> 0.5")
+  s.add_dependency("xmpp4r-simple", "~> 0.8.8")
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "cirrocumulus Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+#Rake::TestTask.new do |t|
+#  t.test_files = FileList['test/**/*.rb']
+#end

data/lib/cirrocumulus/agent.rb

@@ -0,0 +1,182 @@
+class Agent
+  class AgentInfo
+    attr_accessor :identifier
+    attr_accessor :default_ontology
+    attr_accessor :last_seen_at
+
+    def initialize
+      @identifier = @default_ontology = @last_seen_at = nil
+    end
+  end
+
+  class NetworkMap
+
+    INVALIDATE_PERIOD = 600*2
+
+    attr_reader :agents
+    attr_accessor :version
+    attr_reader :valid
+
+    def initialize(agent)
+      Log4r::Logger['agent'].debug "initializing empty network map"
+      @agent = agent
+      @agents = []
+      @version = 0
+      @valid = 0
+    end
+
+    def tick(cm)
+      @valid -= 1
+      if @valid <= 0
+        Log4r::Logger['agent'].debug "invalidating network map"
+        msg = Cirrocumulus::Message.new(nil, 'request', [:update, [:map, @version.to_s]])
+        msg.ontology = 'cirrocumulus-map'
+        cm.send(msg)
+        @valid = INVALIDATE_PERIOD
+      end
+    end
+
+    def handle_message(message, cm)
+      if message.ontology == 'cirrocumulus-map'
+        return if !message.receiver.blank? && (message.receiver != @agent.identifier)
+        #p message
+
+        if message.act == 'inform'
+          if message.content.first == :"="
+            ontology = message.content[2].first
+            agent = @agents.find {|a| a.identifier == message.sender}
+            if agent
+              agent.default_ontology = ontology
+              agent.last_seen_at = Time.now.to_i
+              @version = Time.now.to_i
+              Log4r::Logger['agent'].info "got neighbour details: #{agent.inspect}"
+            end
+          else
+            agent_info = message.content
+            agent = AgentInfo.new
+            agent_info.each do |param|
+              if param.first == :identifier
+                agent.identifier = param.second
+              elsif param.first == :default_ontology
+                agent.default_ontology = param.second
+              elsif param.first == :last_seen_at
+                agent.last_seen_at = param.second.to_i
+              end
+            end
+
+            my_agent = @agents.find {|a| a.identifier == agent.identifier}
+            if my_agent.nil?
+              my_agent = agent
+              @agents << agent
+            else
+              my_agent.last_seen_at = [my_agent.last_seen_at, agent.last_seen_at].max
+              my_agent.default_ontology = agent.default_ontology || my_agent.default_ontology
+            end
+
+            Log4r::Logger['agent'].info "neighbour updated: #{my_agent.inspect}"
+            @version = Time.now.to_i
+          end
+        elsif message.act == 'request'
+          map_request = message.content
+          foreign_map = map_request.second
+          foreign_map_version = foreign_map.second.to_i
+          if @version >= foreign_map_version
+            @agents.each do |agent|
+              next if agent.default_ontology.blank?
+              msg = Cirrocumulus::Message.new(nil, 'inform', [
+                  [:identifier, agent.identifier],
+                  [:default_ontology, agent.default_ontology],
+                  [:last_seen_at, agent.last_seen_at.to_s]
+              ])
+              msg.receiver = message.sender
+              msg.ontology = 'cirrocumulus-map'
+              cm.send(msg)
+            end
+          end
+
+          process_agent(message, cm)
+        elsif message.act == 'query-ref'
+          #p message.content
+          if message.content.first == :default_ontology
+            msg = Cirrocumulus::Message.new(nil, 'inform', [:'=', [:default_ontology], [@agent.default_ontology]])
+            msg.receiver = message.sender
+            msg.ontology = 'cirrocumulus-map'
+            cm.send(msg)
+          end
+        end
+      else
+        process_agent(message, cm)
+      end
+    end
+
+    private
+
+    def process_agent(message, cm)
+      agent_id = message.sender
+      return if agent_id == @agent.identifier
+
+      agent = @agents.find {|a| a.identifier == agent_id}
+      if agent
+        agent.last_seen_at = Time.now.to_i
+        @version = Time.now.to_i
+      else
+        agent = AgentInfo.new
+        agent.identifier = agent_id
+        agent.last_seen_at = Time.now.to_i
+        Log4r::Logger['agent'].info "discovered neighbour: #{agent.identifier}"
+        @agents << agent
+        @version = Time.now.to_i
+
+        msg = Cirrocumulus::Message.new(nil, 'query-ref', [:default_ontology])
+        msg.receiver = agent.identifier
+        msg.ontology = 'cirrocumulus-map'
+        cm.send(msg)
+      end
+    end
+  end
+
+  attr_reader :default_ontology
+  attr_reader :identifier
+  attr_reader :network_map
+  
+  def initialize(cm)
+    @cm = cm
+    @identifier = cm.jid
+    @sagas = []
+    @saga_idx = 0
+    @network_map = NetworkMap.new(self)
+  end
+
+  def tick()
+    @network_map.tick(@cm)
+
+    @sagas.each do |saga|
+      next if saga.is_finished?
+      saga.timeout -= 1 if saga.timeout > 0
+      saga.handle(nil) if saga.timeout == 0
+    end
+  end
+  
+  def restore_state()
+  end
+
+  def handles_ontology?(ontology)
+    return @default_ontology == ontology || ontology == 'cirrocumulus-map'
+  end
+
+  def handle_message(message, kb)
+    @network_map.handle_message(message, @cm)
+
+    if message.ontology != 'cirrocumulus-map'
+      handle(message, kb)
+    end
+  end
+  
+  def self.get_node(sender)
+    sender.split('-').first
+  end
+  
+  def self.get_subsystem(sender)
+    sender.split('-').second
+  end
+end

data/lib/cirrocumulus/engine.rb

@@ -0,0 +1,179 @@
+require 'xmpp4r'
+require 'xmpp4r-simple'
+require 'sexpistol'
+require 'systemu'
+require 'activesupport'
+
+class Cirrocumulus
+  class Message
+    attr_accessor :sender, :act, :content
+    attr_accessor :receiver, :reply_with, :in_reply_to
+    attr_accessor :ontology
+
+    def initialize(sender, act, content)
+      @sender = sender
+      @act = act
+      @content = content
+    end
+
+    def failed?
+      act == 'failure' || act == 'refuse'
+    end
+
+    def context
+      Context.new(@sender, @reply_with)
+    end
+  end
+
+  class Context
+    attr_reader :sender
+    attr_reader :reply_with
+
+    def initialize(sender, reply_with)
+      @sender = sender
+      @reply_with = reply_with
+    end
+  end
+
+  def self.platform
+    if PLATFORM =~ /freebsd/
+      return 'freebsd'
+    elsif PLATFORM =~ /linux/
+      return 'linux'
+    end
+
+    return 'unknown'
+  end
+
+  attr_reader :jid
+
+  def initialize(suffix, generate_jid = true)
+    Log4r::Logger['cirrocumulus'].info 'platform: ' + Cirrocumulus::platform
+    _, hostname = systemu 'hostname'
+    hostname.strip!
+    @jid = generate_jid ? "#{hostname}-#{suffix}" : suffix
+    Log4r::Logger['cirrocumulus'].info "logging as " + @jid
+    connect()
+  end
+  
+  def send(message)
+    msg = "<fipa-message ontology=\"#{message.ontology}\""
+    msg += " receiver=\"#{message.receiver}\"" if message.receiver
+    msg += " act=\"#{message.act}\""
+    msg += " reply-with=\"#{message.reply_with}\"" if message.reply_with
+    msg += " in-reply-to=\"#{message.in_reply_to}\"" if message.in_reply_to
+    message_content = message.content if message.content.is_a? String
+    message_content = Sexpistol.new.to_sexp(message.content) if message.content.is_a? Array
+    msg += "><content>#{message_content}</content></fipa-message>"
+    @im.send!("<message type=\"groupchat\" to=\"#{JABBER_CONFERENCE}\" id=\"aaefa\"><body>#{msg.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')}</body></message>")
+  end
+
+  def inform(receiver, answer, ontology = nil)
+    msg = "<fipa-message ontology=\"#{ontology || @ontology}\" receiver=\"#{receiver}\" act=\"inform\"><content>#{answer}</content></fipa-message>"
+    @im.send!("<message type=\"groupchat\" to=\"#{JABBER_CONFERENCE}\" id=\"aaefa\"><body>#{msg.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')}</body></message>")
+  end
+
+  def refuse(receiver, action, reason, ontology = nil)
+    msg = "<fipa-message ontology=\"#{ontology || @ontology}\" receiver=\"#{receiver}\" act=\"refuse\"><content>(#{action} #{reason})</content></fipa-message>"
+    @im.send!("<message type=\"groupchat\" to=\"#{JABBER_CONFERENCE}\" id=\"aaefa\"><body>#{msg.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')}</body></message>")
+  end
+
+  def failure(receiver, action, ontology = nil)
+    msg = "<fipa-message ontology=\"#{ontology || @ontology}\" receiver=\"#{receiver}\" act=\"failure\"><content>#{action}</content></fipa-message>"
+    @im.send!("<message type=\"groupchat\" to=\"#{JABBER_CONFERENCE}\" id=\"aaefa\"><body>#{msg.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')}</body></message>")
+  end
+
+  def request(receiver, action, ontology = nil)
+    msg = "<fipa-message ontology=\"#{ontology || @ontology}\" receiver=\"#{receiver}\" act=\"request\"><content>#{action}</content></fipa-message>"
+    @im.send!("<message type=\"groupchat\" to=\"#{JABBER_CONFERENCE}\" id=\"aaefa\"><body>#{msg.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')}</body></message>")
+  end
+
+  def run(agent, kb, sniff = false)
+    Log4r::Logger['cirrocumulus'].info("entering main loop")
+    agent.restore_state()
+    
+    s = Sexpistol.new
+
+    loop do
+      kb.collect_knowledge()
+      
+      begin
+        connect() if @im.nil? || !@im.connected?
+      rescue Exception => e
+        puts e.to_s
+      end
+      
+      next if @im.nil? || !@im.connected?
+
+      @im.received_messages do |message|
+        next if !message.x('jabber:x:delay').nil?
+
+        begin
+          xml = Hash.from_xml(message.body)['fipa_message']
+ 
+          ontology = xml['ontology']
+          sender = message.from.resource
+          receiver = xml['receiver']
+          supported_ontology = agent.handles_ontology?(ontology)
+          if (supported_ontology && (receiver == @jid || receiver.blank?)) || receiver == @jid || sniff
+              act = xml['act']
+              content_raw = xml['content']
+              content = s.parse_string(content_raw)
+              msg = Cirrocumulus::Message.new(sender, act, content)
+              msg.receiver = receiver
+              msg.reply_with = xml['reply_with']
+              msg.in_reply_to = xml['in_reply_to']
+              msg.ontology = ontology
+              flatten_message_content(msg)
+              agent.handle_message(msg, kb)
+          end
+        rescue Exception => e
+          puts e.to_s
+          puts e.backtrace
+        end
+      end
+
+      agent.tick()
+      sleep 0.5
+    end
+
+    @im.disconnect
+  end
+  
+  private
+  
+  def connect()
+    begin
+      @im.disconnect if @im && @im.connected?
+      full_jid = @jid + "@" + JABBER_SERVER
+      @im = Jabber::Simple.new(full_jid, JABBER_DEFAULT_PASSWORD)
+    rescue Jabber::ClientAuthenticationFailure => ex
+      Log4r::Logger['cirrocumulus'].warn ex.to_s
+      Log4r::Logger['cirrocumulus'].info "registering new account with default password"
+      
+      client = Jabber::Client.new(full_jid)
+      client.connect()
+      client.register(JABBER_DEFAULT_PASSWORD) #, {'username' => full_jid, 'password' => JABBER_DEFAULT_PASSWORD})
+      client.close()
+      @im = Jabber::Simple.new(full_jid, JABBER_DEFAULT_PASSWORD)
+    rescue Exception => ex
+      puts ex
+      #puts ex.backtrace.to_s
+    end
+
+    if !@im.nil? && @im.connected?
+      Log4r::Logger['cirrocumulus'].info 'joining ' + JABBER_CONFERENCE
+      @im.send!("<presence to='#{JABBER_CONFERENCE}/#{@jid}' />")
+    end
+  end
+  
+  def flatten_message_content(message)
+    if !message.content.is_a?(Array)
+      message.content = [message.content]
+    else
+      while message.content.is_a?(Array) && message.content.size == 1 && message.content.first.is_a?(Array)
+        message.content = message.content.first
+      end
+    end
+  end
+end

data/lib/cirrocumulus/kb.rb

@@ -0,0 +1,44 @@
+class Kb
+  def initialize
+    @knowledge = []
+  end
+
+  def add_fact(key, value)
+    s = Sexpistol.new
+    key_str = s.to_sexp(key)
+    #puts "add: #{key_str}"
+    @knowledge << {:key => key_str, :value => value}
+  end
+
+  def query_fact(key)
+    s = Sexpistol.new
+    key_str = s.to_sexp(key)
+
+    #puts "query: #{key}"
+    @knowledge.each do |h|
+      if h[:key] == key_str
+        #puts "found: #{h[:value]}"
+        return h[:value]
+      end
+    end
+
+    nil
+  end
+  
+  def remove_fact(key)
+    #puts "remove fact: #{key}"
+    @knowledge.delete(key)
+  end
+  
+  def keys
+    res = []
+    @knowledge.each do |h|
+      res << h[:key]
+    end
+    
+    res
+  end
+
+  def collect_knowledge()
+  end
+end

data/lib/cirrocumulus/logger.rb

@@ -0,0 +1,4 @@
+require 'log4r'
+require 'log4r/configurator'
+
+Log4r::Configurator.load_xml_file(File.join(AGENT_ROOT, 'config/log4r.xml'))

data/lib/cirrocumulus/master_agent.rb

@@ -0,0 +1,197 @@
+module Agent
+  class AgentInfo
+    attr_accessor :identifier
+    attr_accessor :default_ontology
+    attr_accessor :last_seen_at
+
+    def initialize
+      @identifier = @default_ontology = @last_seen_at = nil
+    end
+  end
+
+  class NetworkMap
+
+    INVALIDATE_PERIOD = 600*2
+
+    attr_reader :agents
+    attr_accessor :version
+    attr_reader :valid
+
+    def initialize(agent)
+      Log4r::Logger['agent'].debug "initializing empty network map"
+      @agent = agent
+      @agents = []
+      @version = 0
+      @valid = 0
+    end
+
+    def tick(cm)
+      @valid -= 1
+      if @valid <= 0
+        Log4r::Logger['agent'].debug "invalidating network map"
+        msg = Cirrocumulus::Message.new(nil, 'request', [:update, [:map, @version.to_s]])
+        msg.ontology = 'cirrocumulus-map'
+        cm.send(msg)
+        @valid = INVALIDATE_PERIOD
+      end
+    end
+
+    def handle_message(message, cm)
+      if message.ontology == 'cirrocumulus-map'
+        return if !message.receiver.blank? && (message.receiver != @agent.identifier)
+        #p message
+
+        if message.act == 'inform'
+          if message.content.first == :"="
+            ontology = message.content[2].first
+            agent = @agents.find {|a| a.identifier == message.sender}
+            if agent
+              agent.default_ontology = ontology
+              agent.last_seen_at = Time.now.to_i
+              @version = Time.now.to_i
+              Log4r::Logger['agent'].info "got neighbour details: #{agent.inspect}"
+            end
+          else
+            agent_info = message.content
+            agent = AgentInfo.new
+            agent_info.each do |param|
+              if param.first == :identifier
+                agent.identifier = param.second
+              elsif param.first == :default_ontology
+                agent.default_ontology = param.second
+              elsif param.first == :last_seen_at
+                agent.last_seen_at = param.second.to_i
+              end
+            end
+
+            my_agent = @agents.find {|a| a.identifier == agent.identifier}
+            if my_agent.nil?
+              my_agent = agent
+              @agents << agent
+            else
+              my_agent.last_seen_at = [my_agent.last_seen_at, agent.last_seen_at].max
+              my_agent.default_ontology = agent.default_ontology || my_agent.default_ontology
+            end
+
+            Log4r::Logger['agent'].info "neighbour updated: #{my_agent.inspect}"
+            @version = Time.now.to_i
+          end
+        elsif message.act == 'request'
+          map_request = message.content
+          foreign_map = map_request.second
+          foreign_map_version = foreign_map.second.to_i
+          if @version >= foreign_map_version
+            @agents.each do |agent|
+              next if agent.default_ontology.blank?
+              msg = Cirrocumulus::Message.new(nil, 'inform', [
+                  [:identifier, agent.identifier],
+                  [:default_ontology, agent.default_ontology],
+                  [:last_seen_at, agent.last_seen_at.to_s]
+              ])
+              msg.receiver = message.sender
+              msg.ontology = 'cirrocumulus-map'
+              cm.send(msg)
+            end
+          end
+
+          process_agent(message, cm)
+        elsif message.act == 'query-ref'
+          #p message.content
+          if message.content.first == :default_ontology
+            msg = Cirrocumulus::Message.new(nil, 'inform', [:'=', [:default_ontology], [@agent.default_ontology]])
+            msg.receiver = message.sender
+            msg.ontology = 'cirrocumulus-map'
+            cm.send(msg)
+          end
+        end
+      else
+        process_agent(message, cm)
+      end
+    end
+
+    private
+
+    def process_agent(message, cm)
+      agent_id = message.sender
+      return if agent_id == @agent.identifier
+
+      agent = @agents.find {|a| a.identifier == agent_id}
+      if agent
+        agent.last_seen_at = Time.now.to_i
+        @version = Time.now.to_i
+      else
+        agent = AgentInfo.new
+        agent.identifier = agent_id
+        agent.last_seen_at = Time.now.to_i
+        Log4r::Logger['agent'].info "discovered neighbour: #{agent.identifier}"
+        @agents << agent
+        @version = Time.now.to_i
+
+        msg = Cirrocumulus::Message.new(nil, 'query-ref', [:default_ontology])
+        msg.receiver = agent.identifier
+        msg.ontology = 'cirrocumulus-map'
+        cm.send(msg)
+      end
+    end
+  end
+
+  class Base
+    attr_reader :identifier
+    attr_reader :network_map
+
+    def initialize(cm)
+      Log4r::Logger['agent'].info('Initializing new agent')
+
+      @cm = cm
+      @identifier = cm.jid
+      @ontologies = []
+      @network_map = NetworkMap.new(self)
+    end
+
+    def load_ontologies(ontologies_list)
+      ontologies_list.each do |ontology_name|
+        ontology = eval("#{ontology_name}.new(self)")
+        self.ontologies << ontology
+      end
+    end
+
+    def handles_ontology?(ontology_name)
+      self.ontologies.any? {|ontology| ontology.name == ontology_name}
+    end
+
+    def restore_state()
+      self.ontologies.each do |ontology|
+        begin
+          ontology.restore_state()
+        rescue Exception => e
+          Log4r::Logger['agent'].warn "failed to restore state for ontology %s" % ontology.name
+          Log4r::Logger['agent'].warn e.backtrace.to_s
+        end
+      end
+    end
+
+    def send_message(message)
+      @cm.send(message)
+    end
+
+    def tick()
+      @network_map.tick(@cm)
+
+      self.ontologies.each {|ontology| ontology.tick() }
+    end
+
+    def handle_message(message, kb)
+      @network_map.handle_message(message, @cm)
+      self.ontologies.each {|ontology| ontology.handle_message(message, kb) if message.ontology == ontology.name}
+    rescue Exception => e
+      Log4r::Logger['agent'].warn "failed to handle incoming message: %s" % e.to_s
+      puts e.backtrace.to_s
+    end
+
+    protected
+
+    attr_reader :cm
+    attr_reader :ontologies
+
+  end
+end

data/lib/cirrocumulus/ontology.rb

@@ -0,0 +1,28 @@
+module Ontology
+  class Base
+    attr_reader :name
+    attr_reader :agent
+
+    def initialize(name, agent)
+      @name = name
+      @agent = agent
+    end
+
+    def restore_state()
+      puts "call to dummy Ontology::Base.restore_state()"
+    end
+
+    def tick()
+    end
+
+    def handle_message(message, kb)
+      puts "call to dummy Ontology::Base.handle_message()"
+    end
+
+    protected
+
+    def logger
+      Log4r::Logger['agent']
+    end
+  end
+end

data/lib/cirrocumulus/saga.rb

@@ -0,0 +1,53 @@
+class Saga
+  attr_reader :id
+  attr_reader :context
+  attr_reader :finished
+  attr_accessor :timeout
+
+  DEFAULT_TIMEOUT = 15
+  LONG_TIMEOUT = 60
+  
+  STATE_ERROR = -1
+  STATE_START = 0
+  STATE_FINISHED = 255
+
+  def initialize(id, cm, agent)
+    @agent = agent
+    @cm = cm
+    @id = id
+    @finished = false
+    @timeout = -1
+    @state = STATE_START
+  end
+
+  def is_finished?
+    @finished || @state == STATE_ERROR
+  end
+
+  protected
+
+  def clear_timeout()
+    @timeout = -1
+  end
+
+  def set_timeout(secs)
+    Log4r::Logger['agent'].debug "[#{id}] waiting for #{secs} second(s)" if secs > 1
+    @timeout = secs*2
+  end
+  
+  def change_state(new_state)
+    Log4r::Logger['agent'].debug "[#{id}] switching state from #{@state} to #{new_state}"
+    @state = new_state
+  end
+  
+  def finish()
+    clear_timeout()
+    change_state(STATE_FINISHED)
+    @finished = true
+    Log4r::Logger['agent'].info "[#{id}] finished"
+  end
+  
+  def error()
+    change_state(STATE_ERROR)
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification 
+name: cirrocumulus
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Anton Kosyakin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-13 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 3
+        - 11
+        version: 2.3.11
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 1
+        - 9
+        version: 1.1.9
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: systemu
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 0
+        - 5
+        version: "0.5"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: xmpp4r-simple
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 47
+        segments: 
+        - 0
+        - 8
+        - 8
+        version: 0.8.8
+  type: :runtime
+  version_requirements: *id005
+description: Engine for agent-based infrastructure management system
+email: deil@mneko.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/cirrocumulus.rb
+- lib/cirrocumulus/agent.rb
+- lib/cirrocumulus/kb.rb
+- lib/cirrocumulus/saga.rb
+- lib/cirrocumulus/logger.rb
+- lib/cirrocumulus/ontology.rb
+- lib/cirrocumulus/engine.rb
+- lib/cirrocumulus/master_agent.rb
+has_rdoc: true
+homepage: https://github.com/deil/cirrocumulus
+licenses: 
+- - GPL-2
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Agent-based infrastructure management system
+test_files: []
+