isono 0.1.0 → 0.2.0

data/spec/node_spec.rb

@@ -0,0 +1,64 @@
+
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'isono'
+include Isono
+
+class HookTest < Isono::NodeModules::Base
+  before_connect_hook do
+    $pass.shift.should.equal :before_connect
+  end
+
+  after_connect_hook do
+    $pass.shift.should.equal :after_connect
+  end
+
+  before_close_hook do
+    $pass.shift.should.equal :before_close
+  end
+
+  after_close_hook do
+    $pass.shift.should.equal :after_close
+  end
+end
+
+class MockNode < Isono::Node
+  def initialize()
+    super(Isono::Manifest.new do
+          end)
+  end
+end
+
+describe Isono::Node do
+
+  em "connects to AMQP broker" do
+    a = MockNode.new
+    a.connect('amqp://localhost/') {
+      a.amqp_client.should.not.nil?
+      a.amqp_client.instance_variable_get(:@connection_status).should.is_a?(Proc)
+      EM.next_tick {
+        a.close {
+          EM.stop
+        }
+      }
+    }
+  end
+  
+  em "call node_module hooks" do
+    $pass = [:before_connect, :after_connect,
+            :before_close, :after_close]
+    a = Node.new(Isono::Manifest.new do
+                   load_module HookTest
+                 end)
+    a.connect('amqp://localhost/') {
+      EM.next_tick {
+        a.close {
+          $pass.size.should.equal 0
+          EM.stop
+        }
+      }
+    }
+  end
+  
+
+end

data/spec/resource_loader_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'isono'
+
+MM = Isono::ManagerModules
+
+describe "ResourceLoader Test" do
+
+  it "loads manifest block" do
+    rm = Isono::ResourceManifest.new('./')
+
+    Isono::ResourceManifest::Loader.new(rm).instance_eval {
+      state_monitor 'Hva::XenInstanceStore::XenMonitor'
+      #monitor Hva::XenCapacityMonitor
+
+      description "resource1"
+      
+      statemachine {
+        trans :init,  :on_load, :ready
+        trans :ready, :on_start, :starting
+        trans :starting, :on_online, :running
+        trans :running, :on_attach_volume, :attaching_volume
+        trans :attaching_volume, :on_back_to_run, :running
+        trans :running, :on_stop, :shuttingdown
+        trans :shuttingdown, :on_offline, :terminated
+      }
+
+      #entry_state(:running) do
+      #  resource_graph.find(:connected, my_resource_uuid).each { |res_uuid|
+      #    on_event :stopped, res_uuid do
+      #      #do something
+      #    end
+      #  }
+      #end
+
+      entry_state(:running) do
+        on_event :stop_vm, 'mgr-master' do
+          process_event(:on_stop)
+        end
+        
+        on_event(:attach_volume, 'storage_node') {
+          process_event(:on_attach_volume)
+        }
+
+        task {
+        }
+      end
+      
+      entry_state(:ready) do
+        task do
+          # immediatry change the state
+          state_monitor.start
+          process_event(:on_start)
+        end
+      end
+      
+      entry_state(:starting) {
+        task :rake, 'start_vm'
+      }
+      
+      entry_state(:shuttingdown) {
+        task :rake, 'stop_vm'
+      }
+      
+      entry_state(:attaching_volume) {
+        task :rake, 'attach_file_vol'
+      }
+      
+      entry_state(:terminated) {
+        task do
+          state_monitor.stop
+        end
+      }
+      
+    }
+
+    rm.stm.should.is_a? Statemachine::Statemachine
+
+  end
+
+
+
+  it "resource instance process" do
+
+    rm = Isono::ResourceManifest.new('./')
+
+    Isono::ResourceManifest::Loader.new(rm).instance_eval {
+      state_monitor 'Hva::XenInstanceStore::XenMonitor'
+      #monitor Hva::XenCapacityMonitor
+
+      description "resource1"
+      
+      statemachine {
+        trans :init,  :on_load, :ready
+        trans :ready, :on_start, :starting
+        trans :starting, :on_online, :running
+        trans :running, :on_attach_volume, :attaching_volume
+        trans :attaching_volume, :on_back_to_run, :running
+        trans :running, :on_stop, :shuttingdown
+        trans :shuttingdown, :on_offline, :terminated
+      }
+    }
+
+    EM.run {
+      Isono::ResourceInstance.start('testuuid', rm, {:amqp_server_uri => URI.parse('amqp://guest:guest@localhost/'),
+                                    })
+      EM.add_timer(1) {
+        Isono::ResourceInstance.stop
+        EM.stop
+      }
+    }
+  end
+end

data/spec/rpc_channel_spec.rb

@@ -0,0 +1,172 @@
+
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'isono'
+
+MM = Isono::NodeModules
+include Isono
+
+def client_connect(main_cb, pre_cb=nil, post_cb=nil)
+  manifest = Manifest.new(File.expand_path('../', __FILE__)) {
+    node_name :cli
+    node_instance_id   :xxx
+    
+    load_module MM::EventChannel
+    load_module MM::RpcChannel
+  }
+  c = Node.new(manifest)
+  pre_cb.call if pre_cb
+  c.connect('amqp://localhost/') {
+    main_cb.call(c)
+  }
+end
+
+
+def svr_connect(main_cb, pre_cb=nil, post_cb=nil)
+  manifest = Manifest.new(File.expand_path('../', __FILE__)) {
+    node_name :endpoint
+    node_instance_id   :xxx
+    
+    load_module MM::EventChannel
+    load_module MM::RpcChannel
+  }
+  c = Node.new(manifest)
+  pre_cb.call if pre_cb
+  c.connect('amqp://localhost/') {
+    main_cb.call(c)
+  }
+end
+
+
+describe Isono::NodeModules::RpcChannel do
+  em "creates connection" do
+    done = []
+    svr_connect(proc{ |c|
+                  c.close {
+                    done << 1
+                  }
+                })
+    
+    client_connect(proc {|c|
+                     c.close {
+                       done << 1
+                     }
+                   })
+    
+    EM.tick_loop {
+      if done == [1, 1]
+        done.should.equal [1, 1]
+        EM.stop
+      end
+    }
+  end
+  
+  em "send async request" do
+    svr_connect(proc{|c|
+                  rpc = MM::RpcChannel.new(c)
+                  rpc.register_endpoint('endpoint1', Isono::Rack::Map.build { |t|
+                                          t.map('kill') {
+                                            request.args[0].should.equal 'arg1'
+                                            request.args[1].should.equal 'arg2'
+                                            request.args[2].should.equal 'arg3'
+                                            
+                                            EM.next_tick { EM.stop }
+                                            response.response({:code=>1})
+                                          }
+                                        })
+                })
+    client_connect(proc {|c|
+                     rpc = MM::RpcChannel.new(c)
+                     req0 = rpc.request('endpoint1', 'kill', 'arg1', "arg2", "arg3") { |req|
+                       req.on_success { |res|
+                         req0.ticket.should.equal req.ticket
+                         res[:code].should.equal 1
+                         c.close
+                       }
+                     }
+                   }
+                   )
+    
+  end
+
+
+  em "request timeout" do
+    client_connect(proc {|c|
+                     rpc = MM::RpcChannel.new(c)
+                     rpc.request('test', 'test1') { |req|
+                       req.timeout_sec = 0.2
+                       req.on_error { |e|
+                         e.should.equal :timeout
+                         c.close { EM.stop }
+                       }
+                     }
+                   })
+  end
+
+
+  em "use Isono::Rack dispatcher" do
+    func1_count = 0
+    svr_connect(proc{|c|
+                  rpc = MM::RpcChannel.new(c)
+                  endpoint1 = Isono::Rack::Map.build { |t|
+                    t.map('kill') {
+                      func1_count.should.equal 10
+                      EM.next_tick { EM.stop }
+                    }
+                    t.map('func1') {
+                      request.args[0].should.equal 'arg1'
+                      func1_count += 1
+                      response.response({:code=>1})
+                    }
+                  }
+
+                  rpc.register_endpoint('endpoint1', Isono::Rack::ThreadPass.new(endpoint1))
+                })
+    client_connect(proc {|c|
+                     rpc = MM::RpcChannel.new(c)
+                     10.times { |no|
+                       req0 = rpc.request('endpoint1', 'func1', 'arg1') { |req|
+                         req.on_success { |res|
+                           req0.ticket.should.equal req.ticket
+                           req0.complete_status.should.equal :success
+                           #((req0.completed_at - req0.sent_at) > 1.5).should.be.true
+                           res[:code].should.equal 1
+                           #puts "#{no} elapesed: #{req0.elapsed_time}"
+                           if no == 9
+                             rpc.request('endpoint1', 'kill') do |req|
+                               req.on_success { |res|
+                                 res[:code].should.equal 1
+                               }
+                             end
+                           end
+                         }
+                       }
+                     }
+                   })
+    
+  end
+
+  em "catch remote exception" do
+    svr_connect(proc{|c|
+                  rpc = MM::RpcChannel.new(c)
+                  rpc.register_endpoint('endpoint1', Isono::Rack::Map.build { |t|
+                                          t.map('kill') {
+                                            raise StandardError, "message"
+                                            response.response({:code=>1})
+                                          }
+                                        })
+                }, proc{
+                })
+    client_connect(proc {|c|
+                     rpc = MM::RpcChannel.new(c)
+                     rpc.request('endpoint1', 'kill') { |req|
+                       req.on_error { |e|
+                         e.should.equal({:error_type=>'StandardError', :message=>'message'})
+                         EM.stop
+                       }
+                     }
+                   })    
+
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+
+require 'rubygems'
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'bacon'
+#require 'spec'
+require 'isono'
+
+class AmqpStub < Isono::Node
+  include Isono::Logger
+
+
+  def fork_and_connect(broker_uri='amqp://localhost/', *args, &blk)
+    EM.fork_reactor {
+      connect(broker_uri, *args, &blk)
+    }
+  end
+
+  def connect(broker_uri='amqp://localhost/', *args, &blk)
+    super
+  end
+
+  def on_connect
+    manifest.managers.each { |a|
+      a[0].class.reset_instance
+    }
+
+    super
+  end
+
+  #def on_close
+  #end
+
+
+  def mm_instance(mgr_class, *args)
+    raise ArgumentError unless mgr_class < Isono::ManagerModules::Base
+
+    m = mgr_class.instance
+    m.agent = self
+    m.on_init(args)
+    m
+  end
+end
+
+
+def em_fork(main_cb, post_cb=nil)
+  fork {
+    EM.run {
+      main_cb.call
+    }
+    post_cb.call if post_cb
+  }
+end
+
+class Bacon::Context
+  def em(desc, &blk)
+    it(desc) {
+      EM.run &blk
+    }
+  end
+end

data/spec/thread_pool_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'isono'
+
+
+describe "ThreadPool Test" do
+
+  it "create a thread pool" do
+    a = Isono::ThreadPool.new
+    #a.should Isono::ThreadPool
+  end
+
+  it "call pass() with single thread" do
+    a = Isono::ThreadPool.new
+    t = 0
+    a.pass { t = 1 }
+    
+    t.should eql(1)
+  end
+
+  it "call barrier() with single thread" do
+    a = Isono::ThreadPool.new
+    t = 0 
+    a.barrier { t = 1 }
+    
+    t.should eql(1)
+  end
+
+  it "catch exception from barrier()" do
+    a = Isono::ThreadPool.new
+    lambda {
+      a.barrier { raise "Error" }
+    }.should raise_error(RuntimeError, "Error")
+  end
+end