wakame 0.4.2 → 0.5.0

data/lib/wakame/service.rb

@@ -12,6 +12,8 @@ module Wakame
     class ServicePropagationError < ServiceError; end
 
 
+    STATUS_TERMINATE = -2
+    STATUS_INIT    = -1
     STATUS_OFFLINE = 0
     STATUS_ONLINE  = 1
     STATUS_UNKNOWN = 2
@@ -20,647 +22,877 @@ module Wakame
     STATUS_STOPPING = 5
     STATUS_RELOADING = 6
     STATUS_MIGRATING = 7
-
-    class Agent
-      include ThreadImmutable
-      include AttributeHelper
+    STATUS_ENTERING = 8
+    STATUS_QUITTING = 9
+
+    # Data model for agent
+    # Status life cycle:
+    # STATUS_INIT -> [STATUS_ONLINE|STATUS_OFFLINE|STATUS_TIMEOUT] -> STATUS_END
+    class Agent < StatusDB::Model
+      STATUS_END     = -1
+      STATUS_INIT    = -2
       STATUS_OFFLINE = 0
       STATUS_ONLINE  = 1
       STATUS_UNKNOWN = 2
       STATUS_TIMEOUT = 3
       
-      attr_accessor :agent_id, :uptime, :last_ping_at, :attr, :services, :root_path
-      thread_immutable_methods :agent_id=, :uptime=, :last_ping_at=, :attr=, :services=, :root_path=
+      property :last_ping_at
+      property :vm_attr
+      property :root_path
+      property :status, {:read_only=>true, :default=>STATUS_INIT}
+      property :reported_services, {:read_only=>true, :default=>{}}
+      property :cloud_host_id
+
+      def mapped?
+        !self.cloud_host_id.nil?
+      end
+
+      def id=(agent_id)
+        @id = agent_id
+      end
 
-      def initialize(agent_id=nil)
-        bind_thread
-        @services = {}
-        @agent_id = agent_id
-        @last_ping_at = Time.now
-        @status = STATUS_ONLINE
+      def id
+        @id || raise("Agent.id is unset: #{self}")
       end
 
       def agent_ip
-        attr[:local_ipv4]
+        vm_attr[:local_ipv4]
       end
 
-      def [](key)
-        attr[key]
+      def vm_id
+        vm_attr[:instance_id]
       end
 
-      attr_reader :status
+      # Tentative...
+      def last_ping_at_time
+        require 'time'
+        Time.parse(last_ping_at)
+      end
+
+      def update_status(new_status)
+        if @status != new_status
+          @status = new_status
+          self.save
 
-      def status=(status)
-        if @status != status
-          @status = status
           ED.fire_event(Event::AgentStatusChanged.new(self))
           # Send status specific event
-          case status
+          case @status
           when STATUS_TIMEOUT
             ED.fire_event(Event::AgentTimedOut.new(self))
           end
         end
-        @status
       end
-      thread_immutable_methods :status=
-      
-      def has_service_type?(key)
-        svc_class = case key
-                    when Service::ServiceInstance
-                      key.resource.class
-                    when Service::Resource
-                      key.class
-                    when Class
-                      key
-                    else
-                      raise ArgumentError
-                    end
-
-        services.any? { |k, v|
-          Wakame.log.debug( "#{agent_id} of service #{v.resource.class}. v.resource.class == svc_class result to #{v.resource.class == svc_class}")
-          
-          v.property.class == svc_class
+
+
+      def renew_reported_services(svc_id_list)
+        reported_services.clear
+        svc_id_list.each { |svc_id, data|
+          reported_services[svc_id] = data
         }
       end
 
+      def has_resource_type?(key)
+        res_id = key.is_a?(ServiceInstance) ? key.resource.id : Resource.id(key)
 
-      def dump_status
-        {:agent_id => @agent_id, :status => @status, :last_ping_at => @last_ping_at, :attr => attr.dup,
-          :services => services.keys.dup
+        reported_services.keys.any? { |k|
+          svc = ServiceInstance.find(k)
+          svc.resource.id == res_id
         }
       end
-      
+
+      def terminate
+      end
     end
 
+    class AgentPool < StatusDB::Model
+      property :group_observed, {:default=>{}}
+      property :group_active, {:default=>{}}
 
-    class ServiceCluster
-      include ThreadImmutable
+      ID=self.to_s
 
-      attr_reader :dg, :instance_id, :status_changed_at, :rule_engine, :master
-      attr_reader :status, :lock_queue
-
-      STATUS_OFFLINE = 0
-      STATUS_ONLINE = 1
-      STATUS_PARTIAL_ONLINE = 2
-      
-      def initialize(master, &blk)
-        bind_thread
-        @master = master
-        @instance_id =Wakame.gen_id
-        @rule_engine ||= RuleEngine.new(self)
-        @lock_queue = LockQueue.new(self)
-        prepare
-        
-        instance_eval(&blk) if blk
+      def self.instance
+        a = self.find(ID)
+        if a.nil?
+          a = self.new
+          a.save
+        end
+        a
       end
 
-      def define_rule(&blk)
-        @rule_engine ||= RuleEngine.new(self)
-        
-        blk.call(@rule_engine)
-      end
-      
-      def add_resource(resource, name=nil)
-        #if name.nil? || @name2prop.has_key? name
-        #  name = "#{resource.class.to_s}#{name2prop.size + 1}"
-        #end
-        raise ArgumentError unless resource.is_a? Resource
-        raise "Duplicate resource type registration" if @properties.has_key? resource.class.to_s
-        @properties[resource.class.to_s]=resource
-        @dg.add_object(resource.class.to_s)
+      def self.reset
+        ap = self.instance
         
-        #name
-      end
-      thread_immutable_methods :add_resource
-      
-      def set_dependency(prop_name1, prop_name2)
-        prop1 = @properties[prop_name1.to_s]
-        prop2 = @properties[prop_name2.to_s]
-        return unless prop1.is_a?(Property) && prop2.is_a?(Property) && prop1 != prop2
-        @dg.set_dependency(prop_name1.to_s, prop_name2.to_s)
-      end
-      thread_immutable_methods :set_dependency
+        nil_cloud_host_id = lambda { |agent_id|
+          agent = Agent.find(agent_id)
+          agent.cloud_host_id = nil
+          agent.save
+        }
 
-      def included_instance?(service_instance_id)
-        @services.has_key? service_instance_id
+        ap.group_observed.keys.each &nil_cloud_host_id
+        ap.group_active.keys.each &nil_cloud_host_id
+        ap.save
       end
 
 
-      def shutdown
+      def id
+        ID
       end
-      thread_immutable_methods :shutdown
 
-      # Create service instance objects which will be equivalent with the number min_instance.
-      # The agents are not assigned at this point.
-      def launch
-        @properties.each { |n, p|
-          count = instance_count(p)
-          if p.min_instances > count
-            (p.min_instances - count).times {
-              propagate(p.class)
-            }
-          end
-        }
+      def create_or_find(agent_id)
+        agent = Service::Agent.find(agent_id)
+        if agent.nil?
+          agent = Service::Agent.new
+          agent.id = agent_id
+          Wakame.log.debug("#{self.class}: Created new agent object with Agent ID: #{agent_id}")
+        end
+        agent
       end
-      thread_immutable_methods :launch
 
-      def destroy(service_instance_id)
-        raise("Unknown service instance : #{service_instance_id}") unless included_instance?(service_instance_id)
-        svc_inst = @services[service_instance_id]
-        old_agent = svc_inst.unbind_agent
-        svc_inst.unbind_cluster
-        @services.delete(service_instance_id)
-        if old_agent
-          Wakame.log.debug("#{svc_inst.property.class}(#{svc_inst.instance_id}) has been destroied from Agent #{old_agent.agent_id}")
+      def register_as_observed(agent)
+        agent_id = agent.id
+        if group_observed.has_key?(agent_id)
         else
-          Wakame.log.debug("#{svc_inst.property.class}(#{svc_inst.instance_id}) has been destroied.")
+          if group_active.has_key?(agent_id)
+            # Move the reference from unregistered group to the registered group.
+            group_active.delete(agent_id)
+            group_observed[agent_id]=1
+          else
+            # The agent is going to be registered at first time.
+            group_observed[agent_id]=1
+          end
+
+          self.save
+          Wakame.log.debug("#{self.class}: Register agent to observed group: #{agent_id}")
         end
       end
-      thread_immutable_methods :destroy
 
-      def propagate(property_name, force=false)
-        property_name = case property_name
-                        when Class, String
-                          property_name.to_s
-                        when Property
-                          property_name.class.to_s
-                        else
-                          raise ArgumentError
-                        end
-        prop = @properties[property_name.to_s] || raise("Unknown property name: #{property_name.to_s}")
-        if force == false
-          instnum = instance_count(property_name)
-          if instnum >= prop.max_instances
-            Wakame.log.info("#{prop.class} has been reached max_instance limit: max=#{prop.max_instance}")
-            raise ServicePropagationError, "#{prop.class} has been reached to max_instance limit" 
+      def register(agent)
+        raise ArgumentError unless agent.is_a?(Agent)
+        agent_id = agent.id
+        if group_active.has_key?(agent_id)
+        else
+          if group_observed.has_key?(agent_id)
+            # Move the reference from unregistered group to the registered group.
+            group_observed.delete(agent_id)
+            group_active[agent_id]=1
+          else
+            # The agent is going to be registered at first time.
+            group_active[agent_id]=1
           end
+
+          self.save
+
+          Wakame.log.debug("#{self.class}: Register agent to active group: #{agent_id}")
+          ED.fire_event(Event::AgentMonitored.new(agent))
         end
+      end
+
+      def unregister(agent)
+        raise ArgumentError unless agent.is_a?(Agent)
+        agent_id = agent.id
         
-        svc_inst = Service::ServiceInstance.new(prop)
-        svc_inst.bind_cluster(self)
-        #svc_inst.bind_agent(agent) if agent
+        unregistered = false
+        if group_active.has_key?(agent_id)
+          group_active.delete(agent_id)
+          unregistered = true
+        end
+
+        if group_observed.has_key?(agent_id)
+          group_observed.delete(agent_id)
+          unregistered = true
+        end
 
-        @services[svc_inst.instance_id]=svc_inst
-        svc_inst
+        if unregistered
+          self.save
+          
+          Wakame.log.debug("#{self.class}: Unregister agent: #{agent.id}")
+          ED.fire_event(Event::AgentUnMonitored.new(agent))
+        end
       end
-      thread_immutable_methods :propagate
 
-      def instance_count(property_name=nil)
-        return @services.size if property_name.nil?
+      def find_agent(agent_id)
+        raise "The agent ID \"#{agent_id}\" is not registered in the pool" unless group_active.has_key? agent_id
+        Agent.find(agent_id) || raise("The agent ID #{agent_id} is registered. but not in the database.")
+      end
 
-        property_name = case property_name
-                        when Class, String
-                          property_name.to_s
-                        when Property
-                          property_name.class.to_s
-                        else
-                          raise ArgumentError
-                        end
+    end
 
-        raise "Unknown property name: #{property_name}" unless @properties.has_key?(property_name.to_s)
-        c = 0
-        each_instance(property_name) { |svc|
-          c += 1
-        }
-        return c
-      end
+    class CloudHost < StatusDB::Model
+      property :agent_id
 
-      def property_count
-        @properties.size
+      # cluster_id will not become nil since ServiceCluster has responsibility for the lifecycle of this class.
+      property :cluster_id
+      
+      # Virtual Machine attributes specified by Resource object.
+      property :vm_attr, {:default=>{}}
+
+      def mapped?
+        !self.agent_id.nil?
       end
+        
+      def map_agent(agent)
+        raise ArgumentError unless agent.is_a?(Agent)
+        raise "Ensure to call unmap_agent() prior to mapping new agent" if self.mapped?
+        raise "The agent \"#{agent.id}\" is already mapped to the cloud host: #{agent.cloud_host_id}" if agent.mapped?
 
-      def each_instance(filter_prop_name=nil, &blk)
-        prop_obj = nil
-        if filter_prop_name.is_a? String
-          filter_prop_name = Util.build_const(filter_prop_name)
-        end
+        self.agent_id = agent.id
+        agent.cloud_host_id = self.id
 
-        if filter_prop_name.is_a? Module
-          prop_obj = @properties.find { |k, v|
-            v.kind_of? filter_prop_name
-          }
-          if prop_obj.is_a? Array
-            prop_obj = prop_obj[1]
-          else
-            raise("Unknown property name: #{filter_prop_name.to_s}")
+        self.save
+        agent.save
+      end
+
+      def unmap_agent()
+        if mapped?
+          agent = Agent.find(self.agent_id)
+          if agent && self.agent_id == agent.id
+            agent.cloud_host_id = nil
+            agent.save
           end
-        end
 
-        ary = []
-        if prop_obj.nil?
-          ary = @services.dup
-        else
-          ary = @services.find_all{|k, v| v.property.class == prop_obj.class }
-          ary = Hash[*ary.flatten]
+          self.agent_id = nil
+          self.save
         end
+      end
 
-        ary.each {|k,v| blk.call v } if block_given?
-        ary
+      def agent
+        raise "#{self.class}: Agent is not mapped yet to this cloud host \"#{self.id}\"." unless mapped?
+        Agent.find(self.agent_id) || raise("#{self.class}: Could not find the mapped agent for #{self.class}.id=\"#{self.id}\"")
       end
-      alias :select_instance :each_instance
 
-      def status=(new_status)
-        if @status != new_status
-          @status = new_status
-          @status_changed_at = Time.now
-          ED.fire_event(Event::ClusterStatusChanged.new(instance_id, new_status))
-        end
-        @status
+      def vm_spec
+        spec = VmSpec.current
+        spec.table = self.vm_attr
+        spec
       end
-      thread_immutable_methods :status=
 
-      def size
-        @dg.size
+
+      # Delegate methods for Agent class
+
+      def status
+        self.agent.status
       end
-      alias :num_services :size
 
-      def properties
-        @properties
+      def reported_services
+        self.agent.reported_services
       end
 
-      def instances
-        @services
+      def root_path
+        self.agent.root_path
       end
 
+      def agent_ip
+        self.agent.agent_ip
+      end
 
-      def dump_status
-        r = {:name => self.class.to_s, :status => self.status, :instances=>{}, :properties=>{} }
-        
-        instances.each { |k, i|
-          r[:instances][k]=i.dump_status
-        }
-        properties.each { |k, i|
-          r[:properties][k] = i.dump_attrs
-          r[:properties][k][:instances] = each_instance(i.class).collect{|k, v| k }
+      def has_resource_type?(key)
+        res_id = key.is_a?(ServiceInstance) ? key.resource.id : Resource.id(key)
+
+        assigned_services.any? { |k|
+          svc = ServiceInstance.find(k)
+          svc.resource.id == res_id
         }
+      end
 
-        r
+      def assigned_services()
+        cluster = ServiceCluster.find(self.cluster_id)
+        cluster.services.keys.find_all { |svc_id| ServiceInstance.find(svc_id).cloud_host_id == self.id }
       end
-      thread_immutable_methods :dump_status
-      
-      private
-      def prepare
-        @dg = DependencyGraph.new(self)
-        @services = {}
-        
-        @properties = {}
-        @name2prop ={}
-        @status = STATUS_OFFLINE
-        @status_changed_at = Time.now
-        @rule_engine = nil
 
-        @status_check_timer = EM::PeriodicTimer.new(5) {
-          update_cluster_status
-        }
+      def assigned_resources()
+        assigned_services.map { |svc_id|
+          ServiceInstance.find(svc_id).resource
+        }.uniq
+      end
 
-        @check_event_tickets = []
-        [Event::ServiceOnline, Event::ServiceOffline, Event::ServiceFailed].each { |evclass|
-          @check_event_tickets << ED.subscribe(evclass) { |event|
-            update_cluster_status
-          }
-        }
+      def validate_on_save
+        raise "#{self.class}.cluster_id property can't be nil." if self.cluster_id.nil?
+      end
 
-#         ED.subscribe(Event::AgentTimedOut) { |event|
-#           svc_in_timedout_agent = service_cluster.instances.select { |k, i|
-#             if !i.agent.nil? && i.agent.agent_id == event.agent.agent_id
-#               i.status = Service::STATUS_FAIL
-#             end
-#           }
-          
-#         }
+    end
+
+    class TriggerSet
+      def initialize(service_cluster_id)
+        @service_cluster_id = service_cluster_id
+        @triggers = []
       end
-      thread_immutable_methods :prepare
 
+      def add_trigger(trigger)
+        raise ArguemntError unless trigger.is_a?(Trigger)
+        @triggers << trigger
+        Wakame.log.debug(trigger.inspect)
+        trigger.register_hooks(@service_cluster_id)
+      end
+      alias :register_trigger :add_trigger
+    end
 
-      def update_cluster_status
-        onlines = []
-        all_offline = false
-        onlines = self.instances.select { |k, i|
-          i.status == Service::STATUS_ONLINE
+
+    class ServiceCluster < StatusDB::Model
+      include ThreadImmutable
+
+      STATUS_OFFLINE = 0
+      STATUS_ONLINE = 1
+      STATUS_PARTIAL_ONLINE = 2
+
+      property :name
+      property :status, {:readonly=>true, :default=>STATUS_OFFLINE}
+      property :status_changed_at, {:readonly=>true, :default=>proc{Time.now} }
+      property :services, {:default=>{}}
+      property :resources, {:default=>{}}
+      property :cloud_hosts, {:default=>{}}
+      property :dg_id
+      property :template_vm_attr, {:default=>{}}
+      property :advertised_amqp_servers
+
+      attr_reader :trigger_set
+
+      def self.id(name)
+        require 'digest/sha1'
+        Digest::SHA1.hexdigest(name)
+      end
+
+      def id
+        raise "Cluster name is not set yes" if self.name.nil?
+        self.class.id(self.name)
+      end
+
+      def define_triggers(&blk)
+        @trigger_set ||= TriggerSet.new(self.id)
+        blk.call(@trigger_set)
+      end
+
+      def template_vm_spec
+        spec = VmSpec.current
+        spec.table = self.template_vm_attr
+        spec
+      end
+
+      def reset
+        services.clear
+        resources.clear
+        cloud_hosts.clear
+        template_vm_attr.clear
+        advertised_amqp_servers = nil
+        @status = self.class.attr_attributes[:status][:default]
+        @status_changed_at = Time.now
+      end
+
+      def mapped_agent?(agent_id)
+        cloud_hosts.keys.any? { |cloud_host_id|
+          h = CloudHost.find(cloud_host_id)
+          h.mapped? && h.agent_id == agent_id
         }
-        all_offline = self.instances.all? { |k, i|
-          i.status == Service::STATUS_OFFLINE
+      end
+
+      def agents
+        res={}
+        cloud_hosts.keys.collect { |cloud_host_id|
+          h = CloudHost.find(cloud_host_id)
+          res[cloud_host_id]=h.agent_id if h.mapped?
         }
-        #Wakame.log.debug "online instances: #{onlines.size}, assigned instances: #{self.instances.size}"
-        if self.instances.size == 0 || all_offline
-          self.status = Service::ServiceCluster::STATUS_OFFLINE
-        elsif onlines.size == self.instances.size
-          self.status = Service::ServiceCluster::STATUS_ONLINE
-        elsif onlines.size > 0
-          self.status = Service::ServiceCluster::STATUS_PARTIAL_ONLINE
+        res
+      end
+
+      def dg
+        unless self.dg_id.nil?
+          graph = DependencyGraph.find(self.dg_id)
+        else
+          graph = DependencyGraph.new
+          graph.save
+          self.dg_id = graph.id
+          self.save
         end
-        
+        graph
       end
-      thread_immutable_methods :update_cluster_status
-      
-    end
 
-    class LockQueue
-      def initialize(cluster)
-        @service_cluster = cluster
-        @locks = {}
-        @id2res = {}
+      # 
+      def add_resource(resource, &blk)
+        if resource.is_a?(Class) && resource <= Resource
+          resource = resource.new
+        elsif resource.is_a? Resource
+        else
+          raise ArgumentError
+        end
+        raise "Duplicate resource registration: #{resource.class}" if self.resources.has_key? resource.id
+
+        blk.call(resource) if blk
 
-        @queue_by_thread = {}
-        @qbt_m = ::Mutex.new
+        resources[resource.id]=1
+        self.dg.add_object(resource)
+
+        resource.save
+        self.save
+        self.dg.save
+        resource
       end
-      
-      def set(resource, id)
-        # Ths Job ID already holds/reserves the lock regarding the resource.
-        return if @id2res.has_key?(id) && @id2res[id].has_key?(resource.to_s)
+      thread_immutable_methods :add_resource
 
-        EM.barrier {
-          @locks[resource.to_s] ||= []
-          @id2res[id] ||= {}
-        
-          @id2res[id][resource.to_s]=1
-          @locks[resource.to_s] << id
+      # Set dependency between two resources.
+      def set_dependency(res_name1, res_name2)
+        validate_arg = proc {|o|
+          o = Util.build_const(o) if o.is_a? String
+          raise ArgumentError unless o.is_a?(Class) && o <= Resource
+          raise "This is not a member of this cluster \"#{self.class}\": #{o}" unless resources.member?(o.id)
+          raise "Unknown resource object: #{o}" unless Resource.exists?(o.id)
+          o
         }
-        Wakame.log.debug("#{self.class}: set(#{resource.to_s}, #{id})" + "\n#{self.inspect}")
+        
+        res_name1 = validate_arg.call(res_name1)
+        res_name2 = validate_arg.call(res_name2)
+        
+        return if res_name1.id == res_name2.id
+
+        self.dg.set_dependency(res_name1, res_name2)
       end
+      thread_immutable_methods :set_dependency
 
-      def reset()
-        @locks.keys { |k|
-          @locks[k].clear
-        }
-        @id2res.clear
+      def has_instance?(svc_id)
+        self.services.has_key? svc_id
       end
 
-      def test(id)
-        reslist = @id2res[id]
-        return :pass if reslist.nil? || reslist.empty?
+      def shutdown
+      end
+      thread_immutable_methods :shutdown
+
+      # Create service instance objects which will be equivalent with the number min_instance.
+      # The agents are not assigned at this point.
+      #def launch
+      #  self.resources.keys.each { |res_id|
+      #    res = Resource.find(res_id)
+      #    count = instance_count(res.class)
+      #    if res.min_instances > count
+      #      (res.min_instances - count).times {
+      #        propagate(res.class)
+      #      }
+      #    end
+      #  }
+      #end
+      #thread_immutable_methods :launch
+
+      def destroy(svc_id)
+        raise("Unknown service instance : #{svc_id}") unless self.services.has_key?(svc_id)
+        svc = ServiceInstance.find(svc_id)
+        svc.unbind_cluster
+        self.services.delete(svc.id)
+        old_host = svc.unbind_cloud_host
 
-        # 
-        if reslist.keys.all? { |r| id == @locks[r.to_s][0] }
-          return :runnable
+        if old_host
+          Wakame.log.debug("#{svc.resource.class}(#{svc.id}) has been destroied from Host #{old_host.inspect}")
         else
-          return :wait
+          Wakame.log.debug("#{svc.resource.class}(#{svc.id}) has been destroied.")
         end
+
+        svc.delete
+        self.save
       end
+      thread_immutable_methods :destroy
+
 
-      def wait(id, tout=60*30)
-        @qbt_m.synchronize { @queue_by_thread[Thread.current] = ::Queue.new }
+      #def propagate(resource, force=false)
+      def propagate_resource(resource, cloud_host_id=nil, force=false)
+        res_id = Resource.id(resource)
+        res_obj = (self.resources.has_key?(res_id) && Resource.find(res_id)) || raise("Unregistered resource: #{resource.to_s}")
+        raise ArgumentError if res_obj.require_agent && cloud_host_id.nil?
 
-        timeout(tout) {
-          while test(id) == :wait
-            Wakame.log.debug("#{self.class}: Job #{id} waits for locked resouces: #{@id2res[id].keys.join(', ')}")
-            break if id == @queue_by_thread[Thread.current].deq
+        if force == false
+          instnum = instance_count(res_obj)
+          if instnum >= res_obj.max_instances
+            raise ServicePropagationError, "#{res_obj.class} has been reached to max_instance limit: max=#{res_obj.max_instances}" 
           end
-        }
-      ensure
-        @qbt_m.synchronize { @queue_by_thread.delete(Thread.current) }
+        end
+        
+        svc = ServiceInstance.new
+        svc.bind_cluster(self)
+        svc.bind_resource(res_obj)
+
+        # cloud_host_id must be set when the resource is placed on agent.
+        if res_obj.require_agent
+          host = CloudHost.find(cloud_host_id) || raise("#{self.class}: Unknown CloudHost ID: #{cloud_host_id}")
+          svc.bind_cloud_host(host)
+        end
+
+        self.services[svc.id]=1
+
+        svc.save
+        self.save
+
+        svc
       end
-      
-      def quit(id)
-        EM.barrier {
-          case test(id)
-          when :runnable, :wait
-            @id2res[id].keys.each { |r| @locks[r.to_s].delete_if{ |i| i == id } }
-            @qbt_m.synchronize {
-              @queue_by_thread.each {|t, q| q.enq(id) }
+      thread_immutable_methods :propagate_resource
+      alias :propagate :propagate_resource
+
+      def propagate_service(svc_id, cloud_host_id=nil, force=false)
+        src_svc = (self.services.has_key?(svc_id) && ServiceInstance.find(svc_id)) || raise("Unregistered service: #{svc_id.to_s}")
+        res_obj = src_svc.resource
+
+        if force == false
+          instnum = instance_count(res_obj)
+          if instnum >= res_obj.max_instances
+            raise ServicePropagationError, "#{res_obj.class} has been reached to max_instance limit: max=#{res_obj.max_instances}" 
+          end
+        end
+        
+        svc = ServiceInstance.new
+        svc.bind_cluster(self)
+        svc.bind_resource(res_obj)
+
+        if res_obj.require_agent
+          if cloud_host_id
+            host = CloudHost.find(cloud_host_id) || raise("#{self.class}: Unknown Host ID: #{cloud_host_id}")
+          else
+            host = add_cloud_host { |h|
+              h.vm_attr = src_svc.cloud_host.vm_attr.dup
             }
           end
-          
-          @id2res.delete(id)
+          svc.bind_cloud_host(host)
+        end
+
+        self.services[svc.id]=1
+
+        svc.save
+        self.save
+
+        svc
+      end
+      thread_immutable_methods :propagate_service
+
+      def add_cloud_host(&blk)
+        h = CloudHost.new
+        h.cluster_id = self.id
+        self.cloud_hosts[h.id]=1
+
+        blk.call(h) if blk
+
+        h.save
+        self.save
+
+        h
+      end
+
+      def remove_cloud_host(cloud_host_id)
+        if self.cloud_hosts.has_key?(cloud_host_id)
+          self.cloud_hosts.delete(cloud_host_id)
+        
+          self.save
+        end
+
+        CloudHost.delete(cloud_host_id) rescue nil
+      end
+
+      def find_service(svc_id)
+        raise "The service ID #{svc_id} is not registered to this cluster \"#{self.name}\"" unless self.services.has_key? svc_id
+        ServiceInstance.find(svc_id) || raise("The service ID #{svc_id} is registered. but not in the database.")
+      end
+
+      def instance_count(resource=nil)
+        return self.services.size if resource.nil?
+
+        c = 0
+        each_instance(resource) { |svc|
+          c += 1
         }
-        Wakame.log.debug("#{self.class}: quit(#{id})" + "\n#{self.inspect}")
+        c
+      end
+
+      # Iterate the service instances in this cluster
+      #
+      # The first argument is used for filtering only specified resource instances. 
+      # Iterated instance objects are passed to the block when it is given. The return value is an array contanins registered service instance objects (filtered).
+      def each_instance(filter_resource=nil, &blk)
+        filter_resource = case filter_resource 
+                          when Resource
+                            filter_resource.class
+                          when String
+                            Util.build_const(filter_resource)
+                          when Module, NilClass
+                            filter_resource
+                          else
+                            raise ArgumentError, "The first argument has to be in form of NilClass, Resource, String or Module: #{filter_resource.class}"
+                          end
+
+        filter_ids = []
+
+        unless filter_resource.nil?
+          filter_ids = self.resources.keys.find_all { |resid|
+            Resource.find(resid).kind_of?(filter_resource)
+          }
+          return [] if filter_ids.empty?
+        end
+        
+        ary = self.services.keys.collect {|k| ServiceInstance.find(k) }
+        if filter_resource.nil?
+        else
+          ary = ary.find_all{|v| filter_ids.member?(v.resource.id) }
+        end
+
+        ary.each {|v| blk.call(v) } if block_given?
+        ary
       end
 
-      def clear_resource(resource)
+      def update_status(new_status)
+        if @status != new_status
+          @status = new_status
+          @status_changed_at = Time.now
+
+          self.save
+
+          ED.fire_event(Event::ClusterStatusChanged.new(id, new_status))
+        end
+      end
+      thread_immutable_methods :update_status
+
+      def size
+        self.dg.size
+      end
+
+      def properties
+        self.resources
       end
 
-      def inspect
-        output = @locks.collect { |k, lst|
-          [k, lst].flatten
+      alias :instances :services
+
+      #private
+
+      def update_cluster_status
+        onlines = []
+        all_offline = false
+
+        onlines = self.each_instance.select { |i|
+          i.status == Service::STATUS_ONLINE
         }
-        return "" if output.empty?
-
-        # Table display
-        maxcolws = (0..(output.size)).zip(*output).collect { |i| i.shift; i.map!{|i| (i.nil? ? "" : i).length }.max }
-        maxcol = maxcolws.size
-        maxcolws.reverse.each { |i| 
-          break if i > 0
-          maxcol -= 1
+        all_offline = self.each_instance.all? { |i|
+          i.status == Service::STATUS_OFFLINE
         }
+        #Wakame.log.debug "online instances: #{onlines.size}, assigned instances: #{self.instances.size}"
 
-        textrows = output.collect { |x|
-          buf=""
-          maxcol.times { |n|
-            buf << "|" + (x[n] || "").ljust(maxcolws[n])
-          }
-          buf << "|"
-        }
+        prev_status = self.status
+        if self.instances.size == 0 || all_offline
+          self.update_status(Service::ServiceCluster::STATUS_OFFLINE)
+        elsif onlines.size == self.instances.size
+          self.update_status(Service::ServiceCluster::STATUS_ONLINE)
+        elsif onlines.size > 0
+          self.update_status(Service::ServiceCluster::STATUS_PARTIAL_ONLINE)
+        end
 
-        "+" + (["-"] * (textrows[0].length - 2)).join('') + "+\n" + \
-        textrows.join("\n") + \
-        "\n+" + (["-"] * (textrows[0].length - 2)).join('')+ "+"
       end
+      thread_immutable_methods :update_cluster_status
+
     end
+
     
-    
-    class DependencyGraph
+    class DependencyGraph < StatusDB::Model
       
-      def initialize(service_cluster)
+      property :nodes, {:default=>{}}
+      property :graph_edges
+
+      def initialize()
         @graph = Graph.new
+        @graph.edges = self.graph_edges = {}
         @graph.add_vertex(0)
-        @service_cluster = service_cluster
-        @nodes = {}
       end
       
-      
       def add_object(obj)
-        @nodes[obj.hash] = obj
-        @graph.add_edge(0, obj.hash)
+        res_id = Resource.id(obj)
+        self.nodes[res_id.hash] = res_id
+        @graph.add_edge(0, res_id.hash)
+        self.save
         self
       end
       
-      def set_dependency(parent_obj, child_obj)
-        return if parent_obj == child_obj
-        @graph.add_edge(parent_obj.hash, child_obj.hash)
-        @graph.remove_edge(0, child_obj.hash) if @graph.has_edge?(0, child_obj.hash)
+      def set_dependency(parent_res, child_res)
+        p_res_id = Resource.id(parent_res)
+        c_res_id = Resource.id(child_res)
+        return if p_res_id == c_res_id
+
+        self.nodes[p_res_id.hash]=p_res_id
+        self.nodes[c_res_id.hash]=c_res_id
+
+        @graph.add_edge(p_res_id.hash, c_res_id.hash)
+        @graph.remove_edge(0, c_res_id.hash) if @graph.has_edge?(0, c_res_id.hash)
+        self.save
         self
       end
-      
+
+      #
       def size
         @graph.size - 1
       end
 
-      def parents(obj)
-        obj = case obj
-               when Class
-                 obj.to_s.hash
-               when String
-                 obj.hash
-               else
-                 raise ArgumentError
-               end
-        @graph.parents(obj).collect { |hashid| property_obj(hashid) }
-      end
-
-      def children(obj)
-        obj = case obj
-               when Class
-                 obj.to_s.hash
-               when String
-                 obj.hash
-               else
-                 raise ArgumentError
-               end
-        @graph.children(obj).collect { |hashid| property_obj(hashid) }
+      # Returns an array with the parent resources of given node
+      def parents(res)
+        # delete() returns nil when nothing was removed. so use delete_if instead.
+        @graph.parents(Resource.id(res).hash).delete_if{|i| i == 0}.collect { |hashid| id2obj(hashid) }
+      end
+
+      # Returns an array with the child resources of given node
+      def children(res)
+        # delete() returns nil when nothing was removed. so use delete_if instead.
+        @graph.children(Resource.id(res).hash).delete_if{|i| i == 0}.collect { |hashid| id2obj(hashid) }
       end
       
       def levels(root=nil)
-        root = case root
-               when nil
-                 0
-               when Class
-                 root.to_s.hash
-               when String
-                 root.hash
-               else
-                 raise ArgumentError
-               end
+        root = root.nil? ? 0 : Resource.id(root).hash
+
         n=[]
         @graph.level_layout(root).each { |l|
           next if l.size == 1 && l[0] == 0
-          n << l.collect { |hashid| property_obj(hashid)}
-          #n << l.collect { |hashid| @nodes[hashid].to_s }
+          n << l.collect { |hashid| id2obj(hashid) }
         }
         n
       end
       
       def each_level(root=nil, &blk)
-        root = case root
-               when nil
-                 0
-               when Class
-                 root.to_s.hash
-               when String
-                 root.hash
-               else
-                 raise ArgumentError
-               end
+        root = root.nil? ? 0 : Resource.id(root).hash
+
         @graph.level_layout(root).each { |l|
           l.each { |hashid|
             next if hashid == 0
-            blk.call(@service_cluster.properties[@nodes[hashid]])
+            blk.call(id2obj(hashid))
           }
         }
       end
+
+      def on_after_load
+        # Delegate the edge data to be handled by Graph class when it is loaded from database.
+        @graph.edges = self.graph_edges
+      end
       
       private
-      def property_obj(hashid)
-        @service_cluster.properties[@nodes[hashid]]
+      def id2obj(hashid)
+        Resource.find(self.nodes[hashid])
       end
     end
     
-    
-    class ServiceInstance
+
+    # The data model represents a service instance.
+    # Status transition:
+    # STATUS_INIT -> [STATUS_OFFLINE|STATUS_ONLINE|STATUS_FAIL] -> STATUS_END
+    # Progress status:
+    # STATUS_NONE, STATUS_MIGRATING, STATUS_PROPAGATING,
+    class ServiceInstance < StatusDB::Model
       include ThreadImmutable
-      attr_reader :instance_id, :service_property, :agent, :service_cluster, :status_changed_at
-      attr_accessor :name
-      alias :cluster :service_cluster
-      alias :property :service_property
-      
-      class << self
-        def instance_collection
-          @collection ||= {}
-        end
-      end
-      
-      def initialize(service_property)
-        bind_thread
-        raise TypeError unless service_property.is_a?(Property)
-        
-        @instance_id = Wakame.gen_id
-        @service_property = service_property
-        @status = Service::STATUS_OFFLINE
-        @status_changed_at = Time.now
 
-        self.class.instance_collection[@instance_id] = self
-      end
-      
+      property :cloud_host_id
+      property :resource_id
+      property :cluster_id
+      property :status, {:read_only=>true, :default=>Service::STATUS_INIT}
+      property :monitor_status, {:default=>Service::STATUS_INIT}
+      property :status_changed_at, {:read_only=>true, :default=>proc{Time.now}}
+
       def update_status(new_status, changed_at=Time.now, fail_message=nil)
         if @status != new_status
           prev_status = @status
           @status = new_status
           @status_changed_at = changed_at
           
-          event = Event::ServiceStatusChanged.new(@instance_id, @service_property, new_status, prev_status)
+          self.save
+
+          event = Event::ServiceStatusChanged.new(self.id, resource, new_status, prev_status)
           event.time = @status_changed_at.dup
           ED.fire_event(event)
 
           tmp_event = nil
           if prev_status != Service::STATUS_ONLINE && new_status == Service::STATUS_ONLINE
-            tmp_event = Event::ServiceOnline.new(self.instance_id, self.property)
+            tmp_event = Event::ServiceOnline.new(self.id, self.resource)
             tmp_event.time = @status_changed_at.dup
           elsif prev_status != Service::STATUS_OFFLINE && new_status == Service::STATUS_OFFLINE
-            tmp_event = Event::ServiceOffline.new(self.instance_id, self.property)
+            tmp_event = Event::ServiceOffline.new(self.id, self.resource)
             tmp_event.time = @status_changed_at.dup
           elsif prev_status != Service::STATUS_FAIL && new_status == Service::STATUS_FAIL
-            tmp_event = Event::ServiceFailed.new(self.instance_id, self.property, fail_message)
+            tmp_event = Event::ServiceFailed.new(self.id, self.resource, fail_message)
             tmp_event.time = @status_changed_at.dup
           end
           ED.fire_event(tmp_event) if tmp_event
 
         end
-        @status
       end
-      thread_immutable_methods :update_status
       
+      def cloud_host
+        raise "The associated resource is not needed to have agent." unless self.resource.require_agent
+          
+        self.cloud_host_id.nil? ? nil : CloudHost.find(self.cloud_host_id)
+      end
 
-      def status
-        @status
+      def bind_cloud_host(new_cloud_host)
+        return if !self.resource.require_agent || self.cloud_host_id == new_cloud_host.id
+        raise "The host (#{new_cloud_host.id}) was assigned same service already: #{resource.class}" if new_cloud_host.has_resource_type?(resource)
+        
+        unbind_cloud_host
+
+        self.cloud_host_id = new_cloud_host.id
+        self.save
+        
+        ED.fire_event(Event::ServiceBoundHost.new(self, new_cloud_host))
       end
+      thread_immutable_methods :bind_cloud_host
       
-      def property
-        @service_property
+      def unbind_cloud_host
+        return if self.cloud_host_id.nil?
+
+        old_item = self.cloud_host
+        self.cloud_host_id = nil
+        
+        self.save
+
+        ED.fire_event(Event::ServiceUnboundHost.new(self, old_item))
+        old_item
       end
+      thread_immutable_methods :unbind_cloud_host
+
       def resource
-        @service_property
-      end
-      
-      def type
-        @service_property.class
+        return nil if self.resource_id.nil?
+        Resource.find(self.resource_id)
       end
       
-      def bind_agent(agent)
-        return if agent.nil? || (@agent && agent.agent_id == @agent.agent_id)
-        raise "The agent (#{agent.agent_id}) was assigned same service already: #{property.class}" if agent.has_service_type?(property.class)
-        
-        # UboundAgent & BoundAgent event occured only when the different agent obejct is assigned.
-        unbind_agent
-        @agent = agent
-        @agent.services[instance_id]=self
-        
-        ED.fire_event(Event::ServiceBoundAgent.new(self, agent))
-        @agent
+      def bind_resource(resource)
+        return if self.resource_id == resource.id
+
+        unbind_resource
+        self.resource_id = resource.id
+        self.save
+
+        #ED.fire_event(Event::ServiceBoundCluster.new(self, cluster))
       end
-      thread_immutable_methods :bind_agent
-      
-      def unbind_agent
-        return nil if @agent.nil?
-        @agent.services.delete(instance_id)
-        old_item = @agent
-        @agent = nil
-        ED.fire_event(Event::ServiceUnboundAgent.new(self, old_item))
+      thread_immutable_methods :bind_resource
+
+      def unbind_resource
+        return if self.resource_id.nil?
+        old_item = self.resource_id
+
+        self.resource_id = nil
+        self.save
+
+        #ED.fire_event(Event::ServiceUnboundCluster.new(self, old_item))
         old_item
       end
-      thread_immutable_methods :unbind_agent
+      thread_immutable_methods :unbind_resource
+
+
+      def cluster
+        return nil if self.cluster_id.nil?
+        ServiceCluster.find(self.cluster_id)
+      end
 
       def bind_cluster(cluster)
-        return if cluster.nil? || (@service_cluster && cluster.instance_id == @service_cluster.instance_id)
+        return if self.cluster_id == cluster.id
+
         unbind_cluster
-        @service_cluster = cluster
+        self.cluster_id = cluster.id
+        self.save
+
         ED.fire_event(Event::ServiceBoundCluster.new(self, cluster))
       end
       thread_immutable_methods :bind_cluster
 
       def unbind_cluster
-        return if @service_cluster.nil?
-        old_item = @service_cluster
-        @service_cluster = nil
+        return if self.cluster_id.nil?
+        old_item = self.cluster_id
+
+        self.cluster_id = nil
+        self.save
+
         ED.fire_event(Event::ServiceUnboundCluster.new(self, old_item))
+        old_item
       end
       thread_immutable_methods :unbind_cluster
       
@@ -668,17 +900,10 @@ module Wakame
         binding
       end
       
-      def dump_status
-        ret = {:type => self.class.to_s, :status => status, :property => property.class.to_s, :instance_id => instance_id}
-        ret[:agent_id] = agent.agent_id if agent
-        ret
-      end
-      thread_immutable_methods :dump_status
-
       def parent_instances
         ary = []
-        @service_cluster.dg.parents(resource.class).each { |r|
-          @service_cluster.each_instance(r.class){ |i|
+        self.cluster.dg.parents(resource.class).each { |r|
+          self.cluster.each_instance(r.class){ |i|
             ary << i
           }
         }
@@ -687,8 +912,8 @@ module Wakame
       
       def child_instances
         ary = []
-        @service_cluster.dg.children(resource.class).each { |r|
-          @service_cluster.each_instance(r.class){ |i|
+        self.cluster.dg.children(resource.class).each { |r|
+          self.cluster.each_instance(r.class){ |i|
             ary << i
           }
         }
@@ -697,78 +922,119 @@ module Wakame
     end
 
 
-    class VmSpec
-      def self.define(&blk)
-        spec = self.new
-        spec.instance_eval(&blk)
-        spec
-      end
-
-      def initialize
-        @environments = {}
-      end
-
-      def current
+    class VmSpec < OpenStruct
+      def self.current
         environment(Wakame.config.environment)
       end
 
-      def environment(klass_key, &blk)
-        envobj = @environments[klass_key]
-        if envobj.nil?
+      def self.environment(klass_key)
+        @templates ||= {}
+
+        tmpl_klass = @templates[klass_key]
+        if tmpl_klass.nil?
           #klass = self.class.constants.find{ |c| c.to_s == klass_key.to_s }
-          if self.class.const_defined?(klass_key)
-            envobj = @environments[klass_key] = Wakame.new_([self.class.to_s, klass_key.to_s].join('::'))
+          if self.const_defined?(klass_key)
+            tmpl_klass = @templates[klass_key] = Util.build_const([self.to_s, klass_key.to_s].join('::'))
           else
-            raise "Undefined VM Spec template : #{klass_key}"
+            raise "Undefined VM Spec Template : #{klass_key}"
           end
         end
 
-        envobj.instance_eval(&blk) if blk
+        self.new(tmpl_klass.new)
+      end
+
 
-        envobj
+      def initialize(template, vm_attr=nil)
+        @template = template
+        if vm_attr.is_a? Hash
+          @table = vm_attr
+        else
+          h = {}
+          @template.class.vm_attr_defs.keys.each {|k| h[k]=nil }
+          super(h)
+        end
+      end
+      protected :initialize
+      
+      def table=(vm_attr)
+        @table = vm_attr
+      end
+      
+      def attrs
+        table
+      end
+      
+      def satisfy?(vm_attr)
+        @template.satisfy?(vm_attr, table)
       end
+      
+      def merge(src_vm_attr)
+        @template.merge(src_vm_attr, table)
+      end
+      
+
 
       class Template
         def self.inherited(klass)
           klass.class_eval {
-            def self.default_attr_values
-              @default_attr_values ||= {}
+            def self.vm_attr_defs
+              @vm_attr_defs ||= {}
             end
-            def self.def_attribute(name, default_value=nil)
-              default_attr_values[name.to_sym]= default_value
-              attr_accessor(name)
+          
+            def self.vm_attr(key, opts=nil)
+              opts ||= {}
+
+              vm_attr_defs[key.to_sym]=opts
             end
           }
-        end
-        
-        def initialize
-          @attribute_keys=[]
-          self.class.default_attr_values.each { |n, v|
-            instance_variable_set("@#{n.to_s}", v)
-            #self.instance_eval %Q{ #{n} = #{v} }
-            @attribute_keys << n
-          }
+          
         end
 
-        def attrs
-          a={}
-          @attribute_keys.each { |k|
-            a[k.to_sym]=instance_variable_get("@#{k.to_s}")
-          }
-          a
+        def satisfy?(vm_attr, diff)
+          raise ""
         end
 
-        def satisfy?(agent)
-          true
+        def merge(src_vm_attr, diff)
+          raise ""
         end
+
       end
 
       class EC2 < Template
         AWS_VERSION=''
-        def_attribute :instance_type, 'm1.small'
-        def_attribute :availability_zone
-        def_attribute :key_name
-        def_attribute :security_groups, []
+        vm_attr :instance_type, {:choice=>%w[m1.small m1.large m1.xlarge c1.medium c1.xlarge], :right_aws_key=>:aws_instance_type}
+        vm_attr :availability_zone, {:right_aws_key=>:aws_availability_zone}
+        vm_attr :key_name, {:right_aws_key=>:ssh_key_name}
+        vm_attr :security_groups, {:default=>['default'], :right_aws_key=>:aws_groups}
+        vm_attr :image_id, {:right_aws_key=>:aws_image_id}
+
+
+        def satisfy?(vm_attr, diff)
+          # Compare critical variables which will return false if they are not same.
+          return false unless [:availability_zone, :instance_type, :image_id].all? { |k| diff[k].nil? ? true : diff[k] == vm_attr[k] }
+          true
+        end
+
+        def merge(vm_attr, diff)
+          self.class.vm_attr_defs.each_key { |k|
+            raise "Passed VM attribute hash is incomplete data set: #{vm_attr}" unless vm_attr.has_key? k
+          }
+
+          merged = vm_attr.merge(diff){ |k,v1,v2|
+            case k
+            when :security_groups
+              if v1.is_a?(Array)
+                (v1.dup << v2).flatten.uniq
+              else
+                v2
+              end
+            else
+              v2.nil? ? v1 : v2
+            end
+          }
+
+          merged
+        end
       end
 
       class StandAlone < Template
@@ -776,37 +1042,54 @@ module Wakame
     end
 
 
-    class Property
-      include AttributeHelper
-      attr_accessor :check_time, :vm_spec
-      def_attribute :duplicable, true
-      def_attribute :min_instances, 1
-      def_attribute :max_instances, 1
-      def_attribute :startup, true
-      def_attribute :require_agent, true
-
-      def initialize(check_time=5)
-        @check_time = check_time
-        @vm_spec = VmSpec.define {
-          environment(:EC2) { |ec2|
-            ec2.instance_type = 'm1.small'
-            ec2.availability_zone = 'us-east-1c'
-            ec2.security_groups = ['default']
-          }
-          
-          environment(:StandAlone) {
-          }
+    class Resource < StatusDB::Model
+      property :duplicable, {:default=>true}
+      property :min_instances, {:default=>1}
+      property :max_instances, {:default=>1}
+      property :startup, {:default=>true}
+      property :require_agent, {:default=>true}
+
+      def self.inherited(klass)
+        klass.class_eval {
+          def self.id
+            Resource.id(self)
+          end
         }
       end
 
-      def basedir
-        File.join(Wakame.config.root_path, 'cluster', 'resources', Util.snake_case(self.class))
+      def self.name(id)
+        find(id).class.to_s
+      end
+
+      # Returns the hashed resource class name representation.
+      #   Resource.id() is as same as sha1.digest('Wakame::Service::Resource')
+      #   With an argument, tries to get the class name and take digest.
+      def self.id(name=nil)
+        res_class_name = case name
+                         when nil
+                           self.to_s
+                         when String
+                           raise "Invalid string as ruby constant: #{name}" unless name =~ /^(:-\:\:)?[A-Z]/
+                           name.to_s
+                         when Class
+                           raise "Can't convert the argument: type of #{name.class}" unless name <= self
+                           name.to_s
+                         when Resource
+                           name.class.to_s
+                         else
+                           raise "Can't convert the argument: type of #{name.class}"
+                         end
+
+        require 'digest/sha1'
+        Digest::SHA1.hexdigest(res_class_name)
+      end
+      
+      def id
+        Resource.id(self.class.to_s)
       end
 
-      def dump_status
-        {:type => self.class.to_s, :min_instances => min_instances, :max_instances=> max_instances,
-          :duplicable=>duplicable
-        }
+      def basedir
+        File.join(Wakame.config.root_path, 'cluster', 'resources', Util.snake_case(self.class))
       end
 
       def start(service_instance, action); end
@@ -816,30 +1099,26 @@ module Wakame
       def render_config(template)
       end
 
-      #def before_start(service_instance, action)
-      #end
-      #def after_start(service_instance, action)
-      #end
-      #def before_stop(service_instance, action)
-      #end
-      #def after_stop(service_instance, action)
-      #end
-
       def on_child_changed(service_instance, action)
       end
       def on_parent_changed(service_instance, action)
       end
+      
+      def on_enter_agent(service_instance, action)
+      end
+      def on_quit_agent(service_instance, action)
+      end
 
     end
 
-    Resource = Property
+    Property = Resource
   end
 end
 
 module Wakame
   module Service
     module ApacheBasicProps
-      attr_accessor :listen_port, :listen_port_https, :server_root
+      
     end
   end
 end