wakame 0.4.0

data/tests/test_agent.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'setup_agent.rb'
+
+require 'rubygems'
+require 'test/unit'
+
+require 'wakame'
+require 'wakame/agent'
+
+class TestAgent < Test::Unit::TestCase
+
+  def setup
+    puts "Start #{@method_name}"
+  end
+  
+  def teardown
+    puts "End #{@method_name}"
+  end
+
+  def test_agent_stop
+    5.times {
+      EM.run{
+        Wakame::Agent.stop
+      }
+    }
+    5.times {
+      EM.run{
+        Wakame::Agent.start
+        assert_equal(Wakame::Agent, Wakame::Agent.start.class) # Get cached instance returned
+        EM.add_timer(1) { Wakame::Agent.stop }
+      }
+    }
+  end
+
+  DUMMY_INSTANCE_ID='dummy_instance_id'
+  class DummyService < Wakame::Service::Property
+    attr_reader :check_count
+    def initialize(check_time=0.3)
+      super(check_time)
+      @check_count = 0
+    end
+
+    def start
+      @start_time ||= Time.now
+      #log.debug "/etc/init.d/apache start"
+      puts "/etc/init.d/apache start"
+      sleep 2
+    end
+
+    def check
+      return false if @start_time.nil?
+      @check_count += 1
+      #log.debug "checking... #{Time.now - @start_time} : #{Thread.current.inspect}"
+      puts "checking... #{Time.now - @start_time} : #{Thread.current.inspect}"
+
+      sleep 0.5
+
+      return Time.now - @start_time > 4.5 ? true : false
+    end
+
+    def stop
+      #log.debug "/etc/init.d/apache stop"
+      puts "/etc/init.d/apache stop"
+      @start_time = nil
+      sleep 2
+    end
+  end
+
+  ## This test dies when the test ran after another test.
+  # The test process stops at sleep() in DummyService#check(). The hang seems to be occured in EM's C backend though check() method runs in EM.defer thread which is Ruby thread.
+  def test_service_monitor
+    status_changed_flag=0
+    Wakame::EH.reset
+    EM.run {
+      monitor = Wakame::ServiceMonitor.new
+      Wakame::EH.subscribe(Wakame::Event::ServiceStatusChanged) { |event|
+        assert_equal(DUMMY_INSTANCE_ID, event.instance_id)
+        status_changed_flag=1
+      }
+      dummy = Wakame::ServiceRunner.new(DUMMY_INSTANCE_ID, DummyService.new(2))
+      monitor.register(dummy)
+
+      Wakame::EH.subscribe(Wakame::Event::ServiceOnline) { |event|
+
+        count = 0
+        monitor.monitors {|i|
+          count+=1
+        }
+
+        assert(dummy.property.check_count > 0)
+        assert_equal(1, count)
+        assert_equal(DUMMY_INSTANCE_ID, event.instance_id)
+        EM.next_tick {
+          EM.stop
+        }
+      }
+
+      
+      EM.defer proc { dummy.start }
+      # Do not use EM.next_tick{ sleep 5 }. This holds EM's main thread up. 
+      # Run DummyService#check() for 5 secs
+    }
+  end
+
+
+  def test_send_cmd
+    EM.run {
+      agent = Wakame::Agent.start
+      EM.next_tick {
+        agent.send_cmd(Wakame::Packets::Agent::Nop.new)
+        Wakame::Agent.stop
+      }
+    }
+  end
+
+
+  class DummyMaster
+    include Wakame::AMQPClient
+    include Wakame::QueueDeclare
+    
+    define_queue 'registry', 'registry'
+    define_queue 'ping', 'ping'
+    define_queue 'agent_event', 'agent_event'
+
+    def initialize()
+      connect()
+      @counters = {'registry'=>0,'ping'=>0,'agent_event'=>0, }
+      add_subscriber('registry') { |data|
+        p data
+        @counters['registry'] += 1
+      }
+
+      add_subscriber('ping') { |data|
+        p data
+        @counters['ping'] += 1
+      }
+
+      add_subscriber('agent_event') { |data|
+        p data
+        @counters['agent_event'] += 1
+      }
+    end
+
+    def debug_counters
+      @counters
+    end
+
+
+    def send_actor_request(agent_id, path, *args)
+      publish_to('agent_command', "agent_id.#{agent_id}", Wakame::Packets::Agent::ActorRequest.new(agent_id, path, *args).marshal)
+    end
+
+    
+  end
+
+  def test_agent_monitor
+    EM.run {
+      DummyMaster.start
+      agent = Wakame::Agent.start
+      EM.add_timer(5){ EM.stop }
+    }
+  end
+
+
+  def test_service_monitor
+    EM.run {
+      master = DummyMaster.start
+      agent = Wakame::Agent.start
+
+      svcmon = agent.find_monitor('/service')
+      svcmon.register('aaaaa', 'ls -l /usr')
+      svcmon.register('bbbbb', 'ls -l /dev')
+
+      assert(svcmon.checkers.keys.member?('aaaaa') && svcmon.checkers.keys.member?('bbbbb'))
+
+      EM.add_timer(8) {
+        svcmon.unregister('aaaaa')
+        svcmon.unregister('bbbbb')
+
+        svcmon.register('ccc', 'ls -l /var')
+
+        assert_equal(['ccc'], svcmon.checkers.keys)
+      }
+
+      EM.add_timer(15){ 
+        assert(master.debug_counters['agent_event'] > 2)
+        EM.stop
+      }
+    }
+  end
+
+
+  def test_actor
+    EM.run {
+      master = DummyMaster.start
+      agent = Wakame::Agent.start
+      EM.next_tick {
+        master.send_actor_request(agent.agent_id, '/service_monitor/register', ['12345', 'pidof ls'])
+        EM.add_timer(1) {
+          p agent.monitor_registry.find_monitor('/service').checkers.keys
+          assert_not_nil(agent.monitor_registry.find_monitor('/service').checkers['12345'])
+          EM.add_timer(4.5){
+            master.send_actor_request(agent.agent_id, '/service_monitor/unregister', ['12345'])
+            EM.add_timer(1) {
+              assert_nil(agent.monitor_registry.find_monitor('/service').checkers['12345'])
+              EM.stop
+            }
+          }
+        }
+      }
+    }
+  end
+
+end

data/tests/test_amqp_client.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/ruby
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'rubygems'
+
+require 'test/unit'
+require 'eventmachine'
+require 'wakame/amqp_client'
+
+class TestAMQPClient < Test::Unit::TestCase
+
+  def setup
+    puts "Start #{@method_name}"
+
+
+  end
+  
+  def teardown
+    puts "End #{@method_name}"
+  end
+
+
+  class TestClient
+    include Wakame::AMQPClient
+
+    define_exchange('ex1', :direct)
+    define_exchange('ex2')
+    define_exchange('ex3')
+
+    def initialize
+      super
+      connect
+
+    end
+  end
+
+
+  class TestClientRecv
+    include Wakame::AMQPClient
+
+    define_queue('recv1', 'ex1', {:exclusive=>true})
+    define_queue('recv2', 'ex2', {:exclusive=>true})
+
+    def initialize
+      super
+      connect
+
+      add_subscriber('recv1') { |data|
+        puts "From recv1 queue : #{data}"
+      }
+      add_subscriber('recv2') { |data|
+        puts "From recv2 queue : #{data}"
+      }
+    end
+  end
+
+
+  def test_stop
+    5.times {
+      EM.run{
+        TestClient.stop
+      }
+    }
+    5.times {
+      EM.run{
+        TestClient.start
+        assert_equal(TestClient, TestClient.start.class) # Get cached instance returned
+        EM.next_tick { TestClient.stop }
+      }
+    }
+  end
+
+
+  def test_publish_to
+    EM.run{
+      TestClientRecv.start
+      c = TestClient.start
+      EM.next_tick {
+        c.publish_to('ex2', 'aaa')
+
+        EM.add_periodic_timer(1) {
+          c.publish_to('ex1', 'test message')
+        }
+
+        EM.add_timer(10) {
+          TestClientRecv.stop
+          TestClient.stop
+        }
+      }
+    }
+  end
+
+end
+

data/tests/test_graph.rb

@@ -0,0 +1,36 @@
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'rubygems'
+
+require 'test/unit'
+require 'wakame/graph'
+
+WAKAME_ROOT="#{File.dirname(__FILE__)}/.."
+
+class TestGraph < Test::Unit::TestCase
+  def test_graph1
+    g = Wakame::Graph.new
+    g.add_edge(0, 1) # LB
+    g.add_edge(0, 2) # APP
+    g.add_edge(0, 3) # WWW
+    g.add_edge(0, 4) # MySQL
+    g.add_edge(0, 5) # LB0
+    g.add_edge(0, 6) # MySQL_Slave
+    
+    g.remove_edge(0, 1)
+    g.add_edge(2, 1) # APP -> LB
+    g.add_edge(3, 1) # WWW -> LB
+    g.remove_edge(0, 2)
+    g.add_edge(4, 2) # MySQL -> APP
+    g.remove_edge(0, 5)
+    g.add_edge(1, 5) # LB -> LB0
+    g.add_edge(6, 2) # MySQL_Slave -> APP
+    g.remove_edge(0, 4)
+    g.add_edge(6, 4) # MySQL_Slave -> MySQL
+    
+    
+    assert_equal([[3], [1], [5]], g.level_layout(3))
+    assert_equal([[0], [3, 6], [2], [3], [1], [5]], g.level_layout(0))
+
+  end
+end

data/tests/test_master.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/ruby
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'setup_master.rb'
+
+require 'wakame'
+#require 'wakame/master'
+require 'wakame/service'
+require 'wakame/queue_declare'
+#require 'wakame/packets'
+
+class TestMaster < Test::Unit::TestCase
+
+  def setup
+    puts "Start #{@method_name}"
+  end
+  
+  def teardown
+    puts "End #{@method_name}"
+  end
+
+  def test_master_stop
+    5.times {
+      EM.run{
+        Wakame::Master.stop
+      }
+    }
+    5.times {
+      EM.run{
+        Wakame::Master.start
+        EM.add_timer(1) { Wakame::Master.stop }
+      }
+    }
+  end
+
+  def test_command_queue
+  end
+
+  def test_service_cluster
+  end
+
+
+  class MockAgent
+    def initialize
+      # Do nothing
+    end
+
+    def agent_id
+      'asdfasdfasdfasdfasdf'
+    end
+    def agent_ip
+      '127.0.0.1'
+    end
+  end
+
+
+  class DummyResponder2
+    include Wakame::AMQPClient
+    include Wakame::QueueDeclare
+
+    AGENT_ID='__standalone__'
+
+    def self.create_register_hash()
+      {:agent_id=>AGENT_ID, :responded_at=>Time.now.to_s, :type=>Wakame::Packets::Register.to_s}
+    end
+    def self.create_unregister_hash()
+      {:agent_id=>AGENT_ID, :responded_at=>Time.now.to_s, :type=>Wakame::Packets::UnRegister.to_s}
+    end
+    def self.create_ping_hash()
+      {:agent_id=>AGENT_ID, :responded_at=>Time.now.to_s, :type=>Wakame::Packets::Ping.to_s, :attrs=>{}, :monitors=>{}, :actors=>{}, :services=>{}}
+    end
+
+    define_queue 'agent_actor.%{agent_id}', 'agent_command', {:key=>'agent_id.%{agent_id}', :auto_delete=>true}
+
+    def agent_id
+      AGENT_ID
+    end
+
+    def initialize()
+      connect
+
+      add_subscriber("agent_actor.#{agent_id}") { |data|
+        data = eval(data)
+        p data
+
+        if data[:path] == '/test/echo'
+          sleep 5
+          publish_to('agent_event', Wakame::Packets::ActorResponse.new(self, data[:token], Wakame::Actor::STATUS_SUCCESS).marshal)
+        end
+      }
+    end
+    
+    def test_registered_agent
+      self.publish_to('registry', self.class.create_register_hash.inspect)
+      EM.add_periodic_timer(1) {
+        self.publish_to('ping', self.class.create_ping_hash.inspect)
+      }
+    end
+
+    def test_unregistered_agent
+      EM.add_periodic_timer(1) {
+        self.publish_to('ping', self.class.create_ping_hash.inspect)
+      }
+    end
+
+  end
+
+
+  def test_agent_monitor
+    flag_statchanged=false
+    flag_monitored=false
+
+    EM.run {
+      master = Wakame::Master.start
+      dr2 = DummyResponder2.start
+
+      dr2.test_registered_agent
+
+      EM.next_tick {
+        Wakame::ED.subscribe(Wakame::Event::AgentStatusChanged) { |event|
+          flag_statchanged = true
+        }
+        Wakame::ED.subscribe(Wakame::Event::AgentMonitored) { |event|
+          flag_monitored = true
+        }
+        
+        Wakame::ED.subscribe(Wakame::Event::AgentPong) { |event|
+          puts "#{event.class.to_s} has been received from #{event.agent.agent_id}"
+          assert_equal(1, master.agent_monitor.registered_agents.size)
+          assert_equal(0, master.agent_monitor.unregistered_agents.size)
+          
+          EM.add_timer(1) {
+            Wakame::Master.stop
+            DummyResponder2.stop
+          }
+        }
+      }
+      
+    }
+
+    assert(flag_monitored)
+    assert(flag_statchanged)
+  end
+
+
+
+  def test_actor_request
+    EM.run {
+      master = Wakame::Master.start
+      dr2 = DummyResponder2.start
+
+      dr2.test_registered_agent
+
+      EM.next_tick {
+        req = master.actor_request('__standalone__', '/test/echo', 'a', 'b', 'c').request
+        EM.defer proc {
+          req.wait_completion
+        }, proc {
+          EM.stop
+        }
+      }
+    }
+  end
+  
+end

data/tests/test_monitor.rb

@@ -0,0 +1,47 @@
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'setup_agent.rb'
+
+require 'rubygems'
+
+require 'test/unit'
+
+require 'wakame'
+require 'wakame/packets'
+require 'wakame/monitor'
+require 'wakame/monitor/agent'
+require 'wakame/monitor/service'
+
+class TestMonitor < Test::Unit::TestCase
+  include Wakame
+
+  def test_agent_monitor
+    EM.run {
+      agent = DummyAgent.new
+      a = Monitor::Agent.new(agent)
+      a.setup
+      a.check
+
+      EM.add_timer(21) { 
+        assert_equal(2, agent.publish_count)
+        EM.stop
+      }
+    }
+  end
+
+  def test_checker_timer
+    EM.run {
+      count = 0
+      timer = Monitor::CheckerTimer.new(1) {
+        count += 1
+        puts "a"
+      }
+
+      timer.start 
+      EM.add_timer(5) { puts count; assert((4..5).include?(count) );  EM.stop}
+    }
+  end
+
+end

data/tests/test_rule_engine.rb

@@ -0,0 +1,127 @@
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'setup_master.rb'
+
+require 'rubygems'
+require 'eventmachine'
+
+require 'test/unit'
+require 'wakame'
+require 'wakame/rule.rb'
+
+WAKAME_ROOT="#{File.dirname(__FILE__)}/.."
+
+Wakame::EventDispatcher
+
+class TestRuleEngine < Test::Unit::TestCase
+  include Wakame::Rule
+  
+  class Action1 < Action
+    def run
+      trigger_action(Action2.new)
+      flush_subactions
+    end
+  end
+  class Action2 < Action
+    def run
+      act3 = Action3.new
+      trigger_action(act3)
+      flush_subactions
+    end
+  end
+  class Action3 < Action
+    def run
+      puts "sleeping(2)..."
+      sleep 2
+    end
+  end
+
+  class Rule1 < Rule
+    def register_hooks
+      trigger_action(Action1.new)
+    end
+  end
+
+  class DummyMaster
+  end
+
+  def test_nested_actions
+    EM.run {
+      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
+      engine.register_rule(Rule1.new)
+      EM.add_timer(5) { EM.stop }
+    }
+  end
+
+  def test_each_subaction
+    EM.run {
+      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
+      engine.register_rule(Rule1.new)
+      EM.add_timer(1) {
+      engine.active_jobs.each { |k, v|
+        v[:root_action].walk_subactions {|a|
+          puts a
+        }
+      }
+
+      }
+      EM.add_timer(5) { EM.stop }
+    }
+  end
+
+
+  class Rule2 < Rule
+    def register_hooks
+      act1 = Action1.new
+      job_id = trigger_action(act1)
+      puts job_id
+
+      EM.add_timer(1){
+        rule_engine.cancel_action(job_id) 
+      }
+    end
+  end
+
+  def test_cancel_action
+    EM.run {
+      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
+      engine.register_rule(Rule2.new)
+      EM.add_timer(5) { EM.stop }
+    }
+  end
+
+
+  class Action4 < Action
+    def run
+      trigger_action(Action1.new)
+
+      trigger_action(FailAction1.new)
+
+      flush_subactions
+    end
+  end
+
+  class FailAction1 < Action
+    def run
+      trigger_action(Action1.new)
+      raise StandardError
+    end
+  end
+
+  class Rule3 < Rule
+    def register_hooks
+      trigger_action(Action4.new)
+    end
+  end
+
+  def test_cancel_escalation
+    EM.run {
+      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
+      engine.register_rule(Rule3.new)
+      EM.add_timer(10) { EM.stop }
+    }
+  end
+
+end