wakame 0.4.2 → 0.5.0

data/lib/wakame/util.rb

@@ -198,6 +198,7 @@ end
 
 module AttributeHelper
 
+  CLASS_TYPE_KEY=:class_type
   PRIMITIVE_CLASSES=[NilClass, TrueClass, FalseClass, Numeric, String, Symbol]
   CONVERT_CLASSES={Time => proc{|i| i.to_s } }
 
@@ -206,49 +207,53 @@ module AttributeHelper
       @attr_attributes ||= {}
     end
 
-#     def attr(name, assignable=false)
-#       attr_attributes[name.to_sym]={}
-#       attr_without_trap(name, assignable)
-#     end
-    
-#     # Override Object.attr_accessor to 
-#     def attr_accessor(*args)
-#       args.each { |name|
-#         attr(name, true)
-#       }
-#     end
-    
-#     def attr_reader(*args)
-#       args.each { |name|
-#         attr(name, false)
-#       }
-#     end
-    
-#     def attr_writer(*args)
-#       args.each { |name|
-#         attr(name, true)
-#       }
-#     end
+    def merged_attr_attributes
+      hash = {}
+      self.ancestors.reverse.each { |klass|
+        next unless klass.include?(AttributeHelper)
+        hash.merge!(klass.attr_attributes.dup)
+      }
+      hash
+    end
+
+    def get_attr_attribute(attr_name)
+      merged_attr_attributes[attr_name]
+    end
 
     def def_attribute(name, *args)
-      attr = {}
-      attr_attributes[name.to_sym] = begin 
-                                       if args.size == 0
-                                         {:default=>nil}
-                                       else
-                                         case args[0]
-                                         when Hash
-                                           args[0].dup
-                                         else
-                                           {:default=>args[0]}
-                                         end
-                                       end
-                                     end
-      class_eval <<-__E__
-      def #{name}=(v)
-        @#{name}=v
+      attr = begin 
+               if args.size == 0
+                 {:default=>nil}
+               else
+                 case args[0]
+                 when Hash
+                   args[0].dup
+                 else
+                   {:default=>args[0]}
+                 end
+               end
+             end
+
+      (attr_attributes[name.to_sym] ||= {}).merge!(attr)
+
+      if attr[:read_only]
+        if self.respond_to? "#{name}=".to_sym
+          class_eval %Q{
+            undef_method "#{name}=".to_sym
+          }
+        end
+      else
+        class_eval <<-__E__
+        def #{name}=(v)
+          self.#{name}
+          @#{name}=v
+        end
+
+        public :#{name}=
+        __E__
       end
-        
+
+      class_eval <<-__E__
       def #{name}
         if @#{name}.nil?
           retrieve_attr_attribute { |a|
@@ -258,7 +263,7 @@ module AttributeHelper
               when Proc
                 @#{name} = defval.call(self)
               else
-                @#{name} = defval
+                @#{name} = defval.dup rescue defval
               end
               break
             end
@@ -267,7 +272,7 @@ module AttributeHelper
         @#{name}
       end
 
-      public :#{name}, :#{name}=
+      public :#{name}
       __E__
     end
     
@@ -275,47 +280,51 @@ module AttributeHelper
 
   private
   def self.included(klass)
-    klass.class.class_eval {
-      #alias :attr_without_trap :attr unless self.respond_to?(:attr_without_trap, true)
-    }
     klass.extend ClassMethods
   end
 
 
   public
-  def dump_attrs(root=nil)
+  def dump_attrs(root=nil, &blk)
     if root.nil? 
       root = self
     end
 
-    return dump_internal(root)
+    return dump_internal(root, &blk)
   end
   #thread_immutable_method :dump_attrs if self.kind_of?(ThreadImmutable)
   #module_function :dump_attrs
 
-
-  private
   def retrieve_attr_attribute(&blk)
     self.class.ancestors.each { |klass|
       blk.call(klass.attr_attributes) if klass.include?(AttributeHelper)
     }
   end
 
-  def dump_internal(root)
+  private
+  def dump_internal(root, &blk)
     case root
     when AttributeHelper
       t={}
-      t[:type] = root.class.to_s
+      t[CLASS_TYPE_KEY] = root.class.to_s
 
-      retrieve_attr_attribute { |a|
-        a.each_key {|k| t[k] = dump_internal(root.__send__(k.to_sym)) }
+      default_dumper = lambda { |k|
+        t[k] = dump_internal(root.__send__(k.to_sym), &blk)
+      }
+
+      self.class.merged_attr_attributes.each { |k,v|
+        if blk
+          blk.call(k,v, default_dumper)
+        else
+          default_dumper.call(k)
+        end
       }
       t
     when Array
-      root.collect { |a| dump_internal(a) }
+      root.collect { |a| dump_internal(a, &blk) }
     when Hash
       t={}
-      root.each {|k,v| t[k] = dump_internal(v) }
+      root.each {|k,v| t[k] = dump_internal(v, &blk) }
       t
     else
       if CONVERT_CLASSES.any?{|t, p| root.kind_of?(t) }

data/lib/wakame.rb

@@ -1,6 +1,8 @@
 
 require 'rubygems'
 
+require 'uri'
+require 'ext/uri'
 # For debugging
 Thread.abort_on_exception = true 
 
@@ -30,6 +32,8 @@ module Wakame
   autoload :Trigger, 'wakame/trigger'
   autoload :Action, 'wakame/action'
   autoload :RuleEngine, 'wakame/rule_engine'
+  autoload :StatusDB, 'wakame/status_db'
+  autoload :ActionManager, 'wakame/action_manager'
   #autoload :Initializer, 'wakame/initializer' # Do not autoload this class since the constant is used for the flag in bootstrap.
 
   def gen_id(str=nil)

data/tests/test_action_manager.rb

@@ -0,0 +1,111 @@
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'setup_master.rb'
+
+require 'eventmachine'
+
+require 'test/unit'
+require 'wakame'
+
+#WAKAME_ROOT="#{File.dirname(__FILE__)}/.."
+
+Wakame::EventDispatcher
+
+class TestRuleEngine < Test::Unit::TestCase
+  
+  class Action1 < Wakame::Action
+    def run
+      trigger_action(Action2.new)
+      flush_subactions
+    end
+  end
+  class Action2 < Wakame::Action
+    def run
+      100.times { 
+        act3 = Action3.new
+        trigger_action(act3)
+      }
+      flush_subactions
+    end
+  end
+  class Action3 < Wakame::Action
+    def run
+      puts "sleeping(2)..."
+      sleep (0.2 + rand(5))
+    end
+  end
+
+  def test_nested_actions
+    EM.run {
+      manager = Wakame::ActionManager.new
+
+      job_id = manager.trigger_action(Action1.new)
+
+      EM.add_periodic_timer(1) {
+        EM.stop if manager.active_jobs[job_id] == nil
+      }
+    }
+  end
+
+
+  class Action4 < Wakame::Action
+    def run
+      trigger_action(Action1.new)
+
+      trigger_action(FailAction1.new)
+
+      flush_subactions
+    end
+  end
+
+  class FailAction1 < Wakame::Action
+    def run
+      trigger_action(Action1.new)
+      raise StandardError
+    end
+  end
+
+  def test_exception_escalation
+    EM.run {
+      manager = Wakame::ActionManager.new
+
+      job_id = manager.trigger_action(Action4.new)
+      EM.add_timer(10) { EM.stop }
+    }
+  end
+
+
+  def test_each_subaction
+    EM.run {
+      manager = Wakame::ActionManager.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
+
+
+  def test_cancel_action
+    EM.run {
+      manager = Wakame::ActionManager.new
+
+      job_id = manager.trigger_action(Action1.new)
+      EM.add_timer(1){
+        manager.cancel_action(job_id) 
+      }
+      EM.add_timer(5) { EM.stop }
+    }
+  end
+
+
+
+end

data/tests/test_service.rb

@@ -5,55 +5,160 @@ $:.unshift(File.dirname(__FILE__))
 
 require 'setup_master.rb'
 
+require 'eventmachine'
 require 'wakame/service.rb'
+require 'wakame/event_dispatcher.rb'
+
+# Store to sqlite memory database
+Wakame.config.status_db_dsn = 'sqlite:///'
 
 class TestService < Test::Unit::TestCase
   include Wakame::Service
 
+  module ResType1; end
+  module ResType2; end
+  module ResType3; end
+
+  class Res1 < Resource
+    include ResType1
+  end
+
+  class Res2 < Resource
+    include ResType2
+  end
+
+  class Res3 < Resource
+    include ResType3
+  end
+
+  class Res4 < Resource
+  end
+
+  def create_dummy_cluster
+    c = ServiceCluster.new
+    c.name= 'TestCluster1'
+    c.add_resource(Res1.new)
+    c.add_resource(Res2.new)
+    c.add_resource(Res3.new)
+    c.add_resource(Res4.new)
+
+    c.set_dependency(Res2, Res1)
+    c.set_dependency(Res3, Res1)
+    c.set_dependency(Res4, Res3)
+
+    c.save
+    c
+  end
+
+  def teardown
+    #Wakame::StatusDB.adapter.clear_store
+  end
+
+  def test_resource
+    assert_equal(Res1.id, Resource.id(Res1))
+    res1 = Res1.new
+    assert_equal(res1.id, Resource.id(Res1))
+    assert_not_equal(Res2.id, Resource.id(Res3))
+    assert_equal(Res4.id, Resource.id(Res4))
+  end
+
+  def test_create_cluster
+    c = create_dummy_cluster
+  end
+
+  def hash_sort_ary(ary)
+    ary.collect{|i| i.id.hash }.sort
+  end
+
   def test_dg
-    c = WebCluster.new(nil)
-    c.dg.each_level{ |s|
-      p s
+    c = create_dummy_cluster
+    
+    assert_equal([hash_sort_ary([Res4, Res2]), hash_sort_ary([Res3]), hash_sort_ary([Res1])], 
+                 c.dg.levels.collect{|i| i.collect{|k| k.id.hash}.sort })
+    
+    assert_equal(hash_sort_ary([Res2, Res3]), hash_sort_ary(c.dg.parents(Res1)))
+    assert_equal([], c.dg.children(Res1))
+    assert_equal(hash_sort_ary([Res1]), hash_sort_ary(c.dg.children(Res2)))
+    assert_equal([], c.dg.parents(Res2))
+    assert_equal(hash_sort_ary([Res1]), hash_sort_ary(c.dg.children(Res3)))
+    assert_equal(hash_sort_ary([Res4]), hash_sort_ary(c.dg.parents(Res3)))
+    assert_equal(hash_sort_ary([Res3]), hash_sort_ary(c.dg.children(Res4)))
+    assert_equal([], c.dg.parents(Res4))
+  end
+
+
+  def test_cluster_methods
+    c = create_dummy_cluster
+    res2 = Resource.find(Res2.id)
+    res2.max_instances = 3
+    res2.save
+
+    h = c.add_host
+
+    c.propagate(Res1, h.id)
+    c.propagate(Res2, h.id)
+    c.propagate(Res3, h.id)
+    c.propagate(Res4, h.id)
+
+    assert_equal(4, c.services.size)
+    assert_equal(1, c.hosts.size)
+    [Res1, Res2, Res3, Res4].each {|r|
+      assert( c.resources.member?(r.id) )
+    }
+
+    assert_raise(RuntimeError) {
+      c.propagate(Res2)
+    }
+    assert_raise(RuntimeError) {
+      c.propagate(Res2, h.id)
     }
 
-    p c.dg.levels
+    h2 = c.add_host { |h|
+      h.vm_spec.attr1 = "attr1"
+      h.vm_spec.attr2 = "attr2"
+      h.vm_spec.attr3 = "attr3"
+    }
+
+    res2_svc2 = c.propagate(Res2, h2.id)
+    assert_equal(2, c.hosts.size)
+    assert_equal(5, c.services.size)
 
-    p c.dg.children(MySQL_Master)
-    p c.dg.parents(Apache_APP)
+    res2_svc3 = c.propagate_service(res2_svc2.id)
+    assert_equal(3, c.hosts.size)
+    assert_equal(6, c.services.size)
+    assert_equal({:attr1=>"attr1", :attr2=>"attr2", :attr3=>"attr3"}, res2_svc3.host.vm_attr)
+    
   end
 
 
   def test_each_instance
-    c = WebCluster.new(nil)
+    c = create_dummy_cluster
     c.launch
-    c.each_instance(WebCluster::HttpLoadBalanceServer) { |svc|
-      assert(svc.property.is_a?(Apache_LB))
+
+    {ResType1=>Res1, ResType2=>Res2, ResType3=>Res3}.each { |k,v|
+      c.each_instance(k) { |svc|
+        assert(svc.resource.is_a?(v))
+      }
     }
   end
 
 
   def test_vmspec
-    spec = VmSpec.define {
-      environment(:EC2) { |ec2|
-        ec2.instance_type = 'm1.small'
-        ec2.availability_zone = 'us-east-c1'
-        ec2.security_groups << 'default'
-      }
-      
-      environment(:StandAlone) {
-      }
-    }
-
 
     Wakame.config.vm_environment = :EC2
-    p spec.current.attrs
+    assert_equal(VmSpec::EC2, VmSpec.current.class)
+
     Wakame.config.vm_environment = :StandAlone
-    p spec.current.attrs
+    assert_equal(VmSpec::StandAlone, VmSpec.current.class)
 
     assert_raise(RuntimeError) {
       Wakame.config.vm_environment = :EC3
-      spec.current.attrs
+      VmSpec.current
     }
+
+    Wakame.config.vm_environment = :EC2
+    spec = VmSpec.current
+    spec
   end
 
 

data/tests/test_status_db.rb

@@ -0,0 +1,82 @@
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'setup_master.rb'
+
+Wakame.config.status_db_dsn = 'sqlite:///'
+
+class TestStatusDB < Test::Unit::TestCase
+
+  class Model1 < Wakame::StatusDB::Model
+    property :a
+    property :b
+    property :c
+    property :d
+
+    property :e, {:default=>"set in Model1"}
+    property :f, {:default=>"f"}
+  end
+
+  class Model2 < Model1
+    property :n
+    property :e, {:default=>"set in Model2"}
+    def_attribute :f, {:persistent=>false}
+  end
+
+  def test_model1
+    m1 = Model1.new
+    m1.a = "a"
+    m1.b = 12.33
+    m1.c = nil
+    time_d = m1.d = Time.new
+
+    pk = m1.id
+
+    assert_equal(true, m1.dirty?)
+    m1.save
+
+    assert_equal(true, Model1.exists?(pk))
+    assert_equal(false, Model1.exists?(pk+"hoge"))
+
+    m1 = Model1.find(pk)
+    assert_equal(pk, m1.id)
+    assert_equal("a", m1.a)
+    assert_equal(12.33, m1.b)
+    assert_equal(nil, m1.c)
+    assert_equal(time_d.to_s, m1.d)
+    assert_equal(false, m1.dirty?)
+
+    m1.a = "b"
+    assert_equal("b", m1.a)
+    assert_equal(true, m1.dirty?)
+    assert_equal(true, m1.dirty?(:a))
+
+    m1.save
+    assert_equal(false, m1.dirty?)
+    assert_equal(false, m1.dirty?(:a))
+    assert_equal("b", m1.a)
+
+  end
+
+  def test_model2
+    m = Model2.new
+    pk = m.id
+    m.a = "a"
+    m.n = "n"
+
+    assert_equal(nil, m.f)
+
+    m.save
+
+    m = Model1.find(pk)
+    assert_equal(Model2, m.class)
+    assert_equal("a", m.a)
+    assert_equal(nil, m.b)
+    assert_equal(nil, m.f)
+    assert_equal("n", m.n)
+    assert_equal("set in Model2", m.e)
+
+  end
+
+end

data/tests/test_uri_amqp.rb

@@ -16,4 +16,14 @@ class TestUriAMQP < Test::Unit::TestCase
     u=URI.parse('amqp://127.0.0.1/vvv')
     assert_equal('/vvv', u.vhost)
   end
+
+  def test_build
+    uri = URI::AMQP.build(:host=>'192.168.1.1', :path=>'/aaa')
+    assert_equal('amqp://192.168.1.1/aaa', uri.to_s)
+    uri.vhost = '/bbb'
+    assert_equal('amqp://192.168.1.1/bbb', uri.to_s)
+
+    uri = URI::AMQP.build(:host=>'192.168.1.1', :userinfo=>'a', :path=>nil)
+    assert_equal('amqp://a@192.168.1.1/', uri.to_s)
+  end
 end

data/wakame_generators/resource/templates/apache_app/apache_app.rb

@@ -1,14 +1,17 @@
 class Apache_APP < Wakame::Service::Resource
-  include Wakame::Service::ApacheBasicProps
-  include WebCluster::HttpAppServer
+  include HttpServer
+  include HttpApplicationServer
 
   def_attribute :listen_port, {:default=>8001}
   def_attribute :listen_port_https, {:default=>443}
-  def_attribute :max_instance, {:default=>5}
 
   def render_config(template)
-    template.cp(%w(conf/envvars-app init.d/apache2-app))
-    template.render(%w(conf/system-app.conf conf/apache2.conf conf/sites-app.conf))
+    template.glob_basedir(%w(conf/envvars-app init.d/apache2-app)) { |d|
+      template.cp(d)
+    }
+    template.glob_basedir(%w(conf/system-app.conf conf/apache2.conf conf/vh/*.conf)) { |d|
+      template.render(d)
+    }
     template.chmod("init.d/apache2-app", 0755)
   end
 
@@ -16,13 +19,13 @@ class Apache_APP < Wakame::Service::Resource
   def start(svc, action)
     cond = ConditionalWait.new { |cond|
       cond.wait_event(Wakame::Event::ServiceOnline) { |event|
-        event.instance_id == svc.instance_id
+        event.instance_id == svc.id
       }
     }
 
-    request = action.actor_request(svc.agent.agent_id,
-                                   '/service_monitor/register', svc.instance_id, :pidfile, '/var/run/apache2-app.pid').request
-    action.actor_request(svc.agent.agent_id,
+    request = action.actor_request(svc.cloud_host.agent_id,
+                                   '/service_monitor/register', svc.id, :pidfile, '/var/run/apache2-app.pid').request
+    action.actor_request(svc.cloud_host.agent_id,
                          '/daemon/start', "apache_app", 'init.d/apache2-app'){ |req|
       req.wait
       Wakame.log.debug("#{self.class} process started")
@@ -34,27 +37,25 @@ class Apache_APP < Wakame::Service::Resource
   def stop(svc, action)
     cond = ConditionalWait.new { |cond|
       cond.wait_event(Wakame::Event::ServiceOffline) { |event|
-        event.instance_id == svc.instance_id
+        event.instance_id == svc.id
       }
     }
 
-    request = action.actor_request(svc.agent.agent_id,
+    request = action.actor_request(svc.cloud_host.agent_id,
                                    '/daemon/stop', 'apache_app', 'init.d/apache2-app'){ |req|
       req.wait
       Wakame.log.debug("#{self.class} process stopped")
     }
     cond.wait
 
-    request = action.actor_request(svc.agent.agent_id,
-                                   '/service_monitor/unregister', svc.instance_id ).request
+    request = action.actor_request(svc.cloud_host.agent_id,
+                                   '/service_monitor/unregister', svc.id ).request
   end
 
   def reload(svc, action)
-    action.actor_request(svc.agent.agent_id,
-                         '/daemon/reload', "apache_app", 'init.d/apache2-app'){ |req|
-      req.wait
-      Wakame.log.debug("#{self.class} process reloaded")
-    }
+    request = action.actor_request(svc.cloud_host.agent_id,
+                                   '/daemon/reload', "apache_app", 'init.d/apache2-app').request
+    request.wait
   end
 
 end

data/wakame_generators/resource/templates/apache_app/conf/apache2.conf

@@ -1,6 +1,6 @@
 #ServerRoot "/etc/apache2"
 #ServerRoot "/home/wakame/config/apache2"
-ServerRoot "<%= agent.root_path %>/tmp/config/apache_app/conf"
+ServerRoot "<%= cloud_host.agent.root_path %>/tmp/config/apache_app/conf"
 
 LockFile /var/lock/apache2/accept.lock
 PidFile ${APACHE_PID_FILE}
@@ -43,4 +43,16 @@ LogFormat "%{Referer}i -> %U" referer
 LogFormat "%{User-agent}i" agent
 </IfModule>
 
-Include ${SITES_INCLUDE_FILE}
+NameVirtualHost *:<%= resource.listen_port %>
+
+# Wild Card Virtual Host
+#<VirtualHost *:<%= resource.listen_port %>>
+#DocumentRoot /var/www
+#
+#LogLevel warn
+#CustomLog /var/log/apache2/access-app.log combined
+#ErrorLog /var/log/apache2/error-app.log
+#
+#</VirtualHost>
+
+Include vh/*.conf