wakame 0.5.0 → 0.5.1

data/lib/wakame.rb

@@ -34,6 +34,18 @@ module Wakame
   autoload :RuleEngine, 'wakame/rule_engine'
   autoload :StatusDB, 'wakame/status_db'
   autoload :ActionManager, 'wakame/action_manager'
+  autoload :AgentManager, 'wakame/agent_manager'
+  module AgentManagers
+    autoload :MonitorManager, 'wakame/agent_managers/monitor_manager'
+    autoload :ActorManager, 'wakame/agent_managers/actor_manager'
+  end
+  autoload :MasterManager, 'wakame/master_manager'
+  module MasterManagers
+    autoload :ActionManager, 'wakame/master_managers/action_manager'
+    autoload :CommandQueue, 'wakame/master_managers/command_queue'
+    autoload :AgentMonitor, 'wakame/master_managers/agent_monitor'
+    autoload :ClusterManager, 'wakame/master_managers/cluster_manager'
+  end
   #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/lib/wakame/action.rb

@@ -20,10 +20,12 @@ module Wakame
     
     # Tentative utility method for 
     def service_cluster
-      cluster_id = master.cluster_manager.clusters.first
-      raise "There is no cluster loaded" if cluster_id.nil?
+      StatusDB.barrier {
+        cluster_id = master.cluster_manager.clusters.first
+        raise "There is no cluster loaded" if cluster_id.nil?
 
-      Service::ServiceCluster.find(cluster_id)
+        Service::ServiceCluster.find(cluster_id)
+      }
     end
     alias :cluster :service_cluster
 
@@ -124,14 +126,11 @@ module Wakame
       action_manager.active_jobs[self.job_id][:notes]
     end
 
-    # Set the lock flags to resources 
-    def acquire_lock(&blk)
-      StatusDB.barrier {
-        reslist = []
-        blk.call(reslist)
-        reslist.flatten!
-        reslist.each {|r| action_manager.lock_queue.set(r.to_s, self.job_id) }
-      }
+    # Set the lock flags to arbitrary object names.
+    #  acquire_lock('Lock Target 1', 'Lock Target 2')
+    #  acquire_lock(%w(aaaa bbbb cccc))
+    def acquire_lock(*args)
+      args.flatten.each {|r| action_manager.lock_queue.set(r.to_s, self.job_id) }
       
       action_manager.lock_queue.wait(self.job_id)
     end

data/lib/wakame/actions/deploy_application.rb

@@ -0,0 +1,61 @@
+module Wakame
+  module Actions
+    class DeployApplication < Action
+      def initialize(app_name)
+        @app_name = app_name
+      end
+
+      def run
+        Wakame.log.debug("#{self.class}: run() Begin:")
+        #raise "CloudHost is not mapped Agent: CloudHost.id=#{@svc.cloud_host.id}" unless @svc.cloud_host.mapped?
+
+        repo_data = Models::ApplicationRepository.find(:app_name=>@app_name) || raise
+        deploy_opts={}
+        if repo_data[:repo_type] == 's3'
+          deploy_opts[:aws_access_key] ||= Wakame.config.aws_access_key
+          deploy_opts[:aws_secret_key] ||= Wakame.config.aws_secret_key
+        end
+        deploy_ticket = Wakame::Util.gen_id
+
+
+        resclass_names = []
+        svc_lst = []
+        cluster.each_instance { |svc|
+          next  unless svc.resource.tags.member?(repo_data.resource_tag.to_sym)
+          resclass_names << svc.resource.class.to_s
+          svc_lst << svc
+        }
+
+        if svc_lst.empty?
+          return
+        end
+
+        resclass_names.uniq!
+        acquire_lock(resclass_names)
+        
+        # Checkout apps from each repository
+        svc_lst.each { |svc|
+          trigger_action {|action|
+            action.actor_request(svc.cloud_host.agent_id, '/deploy/checkout',
+                                 deploy_ticket,
+                                 repo_data[:repo_type],
+                                 repo_data[:repo_uri],
+                                 repo_data[:revision],
+                                 svc.resource.application_root_path,
+                                 repo_data[:app_name],
+                                 deploy_opts
+                                 ).request.wait
+          }
+        }
+        flush_subactions
+
+        # Reload Appserver
+        svc_lst.each { |svc|
+          actor_request(svc.cloud_host.agent_id, '/deploy/swap_current_link', svc.resource.application_root_path, repo_data[:app_name]).request.wait
+          svc.resource.on_reload_application(svc, self, repo_data)
+        }
+      end
+
+    end
+  end
+end

data/lib/wakame/actions/deploy_config.rb

@@ -9,9 +9,7 @@ module Wakame
         Wakame.log.debug("#{self.class}: run() Begin: #{@svc.resource.class}")
         raise "CloudHost is not mapped Agent: CloudHost.id=#{@svc.cloud_host.id}" unless @svc.cloud_host.mapped?
 
-        acquire_lock { |lst|
-          lst << @svc.resource.class.to_s
-        }
+        acquire_lock(@svc.resource.class.to_s)
 
         begin
           tmpl = Wakame::Template.new(@svc)

data/lib/wakame/actions/freeze_cluster.rb

@@ -0,0 +1,15 @@
+module Wakame
+  module Actions
+    class FreezeCluster < Action
+
+      def run
+        acquire_lock(cluster.resources.keys.map {|resid| Service::Resource.find(resid).class.to_s  })
+
+        StatusDB.barrier {
+          cluster.update_freeze_status(Service::ServiceCluster::STATUS_UNFROZEN)
+        }
+
+      end
+    end
+  end
+end

data/lib/wakame/actions/launch_cluster.rb

@@ -12,9 +12,7 @@ module Wakame
 
         levels = service_cluster.dg.levels
         Wakame.log.debug("#{self.class}: Scheduled resource launch order: " + levels.collect {|lv| '['+ lv.collect{|prop| "#{prop.class}" }.join(', ') + ']' }.join(', '))
-        acquire_lock { |list|
-          levels.each {|lv| list << lv.collect{|res| res.class } }
-        }
+        acquire_lock(levels.map {|lv| lv.map{|res| res.class.to_s } })
 
         levels.each { |lv|
           Wakame.log.info("#{self.class}: Launching resources: #{lv.collect{|prop| "#{prop.class}" }.join(', ')}")

data/lib/wakame/actions/launch_vm.rb

@@ -34,7 +34,7 @@ __END__
 
         ConditionalWait.wait { | cond |
           cond.wait_event(Event::AgentMonitored) { |event|
-            event.agent.vm_attr[:instance_id] == inst_id
+            event.agent.vm_attr[:aws_instance_id] == inst_id
           }
           
           cond.poll(5, 360) {

data/lib/wakame/actions/migrate_service.rb

@@ -9,9 +9,8 @@ module Wakame
       end
 
       def run
-        acquire_lock { |list|
-          list << @svc.resource.class
-        }
+        acquire_lock(@svc.resource.class.to_s)
+        @svc.reload
 
         if @svc.status == Service::STATUS_MIGRATING 
           Wakame.log.info("Ignore to migrate the service as is already MIGRATING: #{@svc.resource.class}")
@@ -25,8 +24,10 @@ module Wakame
           clone_service()
           flush_subactions
           trigger_action(StopService.new(@svc))
+          @svc.reload
         else
           trigger_action(StopService.new(@svc))
+          @svc.reload
           flush_subactions
           clone_service()
         end

data/lib/wakame/actions/notify_child_changed.rb

@@ -6,19 +6,16 @@ module Wakame
       end
       
       def run
-        parents = []
-        StatusDB.barrier {
+        parents = StatusDB.barrier {
           parents = @child_svc.parent_instances
         }
 
-        acquire_lock { |lst|
-          lst << parents.map{|c| c.resource.class.to_s }.uniq
-        }
+        acquire_lock(parents.map{|c| c.resource.class.to_s }.uniq)
         
         Wakame.log.debug("#{self.class}: Parent nodes for #{@child_svc.resource.class}: " + parents.map{|c| c.resource.class }.uniq.inspect )
 
         parents.each { |svc|
-          if svc.status != Service::STATUS_ONLINE
+          if svc.monitor_status != Service::STATUS_ONLINE
             next
           end
 

data/lib/wakame/actions/notify_parent_changed.rb

@@ -6,19 +6,16 @@ module Wakame
       end
       
       def run
-        children = []
-        StatusDB.barrier {
-          children = @parent_svc.child_instances
+        children = StatusDB.barrier {
+          @parent_svc.child_instances
         }
 
-        acquire_lock { |lst|
-          lst << children.map{|c| c.resource.class.to_s }.uniq
-        }
+        acquire_lock(children.map{|c| c.resource.class.to_s }.uniq)
         
         Wakame.log.debug("#{self.class}: Child nodes for #{@parent_svc.resource.class}: " + children.map{|c| c.resource.class }.uniq.inspect )
 
         children.each { |svc|
-          if svc.status != Service::STATUS_ONLINE
+          if svc.monitor_status != Service::STATUS_ONLINE
             next
           end
 

data/lib/wakame/actions/propagate_resource.rb

@@ -9,9 +9,7 @@ module Wakame
       end
 
       def run
-        acquire_lock { |ary|
-          ary << @resource.class.to_s
-        }
+        acquire_lock(@resource.class.to_s)
 
         newsvc=nil
         StatusDB.barrier {

data/lib/wakame/actions/propagate_service.rb

@@ -10,9 +10,7 @@ module Wakame
 
 
       def run
-        acquire_lock { |ary|
-          ary << @svc.resource.class.to_s
-        }
+        acquire_lock(@svc.resource.class.to_s)
 
         newsvc = nil
         StatusDB.barrier {

data/lib/wakame/actions/register_agent.rb

@@ -0,0 +1,43 @@
+module Wakame
+  module Actions
+    class RegisterAgent < Action
+      def initialize(agent)
+        @agent = agent
+      end
+
+      def run
+        Wakame.log.debug("#{self.class}: run() begin: #{@agent.id}")
+        
+        acquire_lock("Agent:#{@agent.id}")
+
+        StatusDB.barrier {
+          @agent.update_vm_attr
+        }
+        
+        # Send monitoring conf
+        if @agent.cloud_host_id
+          Wakame.log.debug("#{self.class}: #{@agent.id} is to be set the monitor conf: #{@agent.cloud_host.live_monitors.inspect}")
+          StatusDB.barrier {
+            @agent.cloud_host.live_monitors.each { |path, data|
+              master.actor_request(@agent.id, '/monitor/reload', path, data).request.wait
+            }
+          }
+        end
+
+        StatusDB.barrier {
+          @agent.update_status(Service::Agent::STATUS_RUNNING)
+          @agent.update_monitor_status(Service::Agent::STATUS_ONLINE)
+          Models::AgentPool.instance.register(@agent)
+        }
+        Wakame.log.debug("#{self.class}: run() end: #{@agent.id}")
+      end
+
+      def on_fail
+        StatusDB.barrier {
+          @agent.update_status(Service::Agent::STATUS_FAIL)
+        }
+      end
+
+    end
+  end
+end

data/lib/wakame/actions/reload_service.rb

@@ -7,7 +7,7 @@ module Wakame
 
       def run
         # Skip to act when the service is having below status.
-        if @svc.status != Service::STATUS_ONLINE
+        if @svc.monitor_status != Service::STATUS_ONLINE
           raise "Canceled as the service is being or already ONLINE: #{@svc.resource.class}"
         end
 
@@ -18,7 +18,7 @@ module Wakame
 	@svc.resource.reload(@svc, self)
 
         StatusDB.barrier {
-          @svc.update_status(Service::STATUS_ONLINE)
+          @svc.update_status(Service::STATUS_RUNNING)
         }
       end
 

data/lib/wakame/actions/shutdown_cluster.rb

@@ -4,9 +4,7 @@ module Wakame
       def run
         levels = cluster.dg.levels
         Wakame.log.debug("#{self.class}: Resource shutdown order: " + levels.collect {|lv| '['+ lv.collect{|prop| "#{prop.class}" }.join(', ') + ']' }.join(', '))
-        acquire_lock { |list|
-          levels.each {|lv| list << lv.collect{|res| res.class } }
-        }
+        acquire_lock(levels.map {|lv| lv.map{|res| res.class.to_s } })
 
         levels.reverse.each { |lv|
           lv.each { |svc_prop|
@@ -16,9 +14,9 @@ module Wakame
           }
           flush_subactions
         }
-
-        agent_monitor.agent_pool.group_active.keys.each { |agent_id|
-          trigger_action(ShutdownVM.new(Service::Agent.find(agent_id)))
+        cluster.cloud_hosts.keys.each { |cloud_host_id|
+          cloud_host = Service::CloudHost.find(cloud_host_id)
+          trigger_action(ShutdownVM.new(cloud_host.agent))
         }
       end
     end

data/lib/wakame/actions/shutdown_vm.rb

@@ -7,11 +7,32 @@ module Wakame
       end
 
       def run
-        #if @agent.id == master.master_local_agent_id
-        #  Wakame.log.info("Skip to shutdown VM as the master is running on this node: #{@agent.agent_id}")
-        #  return
-        #end
-        
+        if @agent.mapped?
+          cloud_host = @agent.cloud_host
+          raise "The VM has running service(s)." if cloud_host.assigned_services.any? {|svc_id|
+            Wakame::Service::ServiceInstance.find(svc_id).monitor_status == Wakame::Service::STATUS_ONLINE
+          }
+        end
+
+        require 'uri'
+        require 'socket'
+        Master.instance.cluster_manager.clusters.each { |cluster_id|
+          cluster = Service::ServiceCluster.find(cluster_id)
+          next if cluster.advertised_amqp_servers.nil?
+          amqp_uri = URI.parse(cluster.advertised_amqp_servers)
+          amqp_svr_ip = IPSocket.getaddress(amqp_uri.host)
+          
+          [@agent.vm_attr[:dns_name], @agent.vm_attr[:private_dns_name]].each { |hostname|
+            if IPSocket.getaddress(hostname) == amqp_svr_ip
+              Wakame.log.info("Skip to shutdown the VM as the master is running on this node: #{@agent.id}")
+              return
+            end
+          }
+        }
+
+        StatusDB.barrier {
+          @agent.update_status(Service::Agent::STATUS_TERMINATING)
+        }
         shutdown_ec2_instance
 
       end
@@ -21,7 +42,7 @@ module Wakame
         require 'right_aws'
         ec2 = RightAws::Ec2.new(Wakame.config.aws_access_key, Wakame.config.aws_secret_key, {:cache=>false})
 
-        res = ec2.terminate_instances([@agent.vm_attr[:instance_id]])
+        res = ec2.terminate_instances([@agent.vm_attr[:aws_instance_id]])
       end
     end
   end

data/lib/wakame/actions/start_service.rb

@@ -2,88 +2,96 @@
 module Wakame
   module Actions
     class StartService < Action
-      def initialize(service_instance)
-        @service_instance = service_instance
+      def initialize(svc)
+        @svc = svc
       end
 
       def run
+        acquire_lock(@svc.resource.class.to_s)
+        @svc.reload
+
         # Skip to act when the service is having below status.
-        if @service_instance.status == Service::STATUS_STARTING || @service_instance.status == Service::STATUS_ONLINE
-          Wakame.log.info("Ignore to start the service as is being or already Online: #{@service_instance.resource.class}")
+        if @svc.status == Service::STATUS_RUNNING && @svc.monitor_status == Service::STATUS_ONLINE
+          Wakame.log.info("Ignore to start the service as is being or already Online: #{@svc.resource.class}")
           return
         end
 
-        acquire_lock { |lst|
-          lst << @service_instance.resource.class.to_s
-        }
-
-        if @service_instance.resource.require_agent
-          raise "The service is not bound cloud host object: #{@service_instance.id}" if @service_instance.cloud_host_id.nil?
+        if @svc.resource.require_agent
+          raise "The service is not bound cloud host object: #{@svc.id}" if @svc.cloud_host_id.nil?
 
-          unless @service_instance.cloud_host.mapped?
-            acquire_lock { |lst|
-              lst << Service::AgentPool.class.to_s
-            }
+          unless @svc.cloud_host.mapped?
+            acquire_lock(Models::AgentPool.to_s)
             
             # Try to arrange agent from existing agent pool.
             StatusDB.barrier {
-              next if Service::AgentPool.instance.group_active.empty?
+              next if Models::AgentPool.group_active.empty?
               agent2host = cluster.agents.invert
               
-              Service::AgentPool.instance.group_active.keys.each { |agent_id|
+              Models::AgentPool.group_active.each { |agent_id|
                 agent = Service::Agent.find(agent_id)
-                if !agent.has_resource_type?(@service_instance.resource) &&
+                if !agent.has_resource_type?(@svc.resource) &&
                     agent2host[agent_id].nil? && # This agent is not mapped to any cloud hosts.
-                    @service_instance.cloud_host.vm_spec.satisfy?(agent.vm_attr)
+                    @svc.cloud_host.vm_spec.satisfy?(agent.vm_attr)
                   
-                  @service_instance.cloud_host.map_agent(agent)
+                  @svc.cloud_host.map_agent(agent)
                   break
                 end
               }
             }
             
             # Start new VM when the target agent is still nil.
-            unless @service_instance.cloud_host.mapped?
+            unless @svc.cloud_host.mapped?
               inst_id_key = "new_inst_id_" + Wakame::Util.gen_id
-              trigger_action(LaunchVM.new(inst_id_key, @service_instance.cloud_host.vm_spec))
+              trigger_action(LaunchVM.new(inst_id_key, @svc.cloud_host.vm_spec))
               flush_subactions
               
               StatusDB.barrier {
                 agent = Service::Agent.find(notes[inst_id_key])
                 raise "Cound not find the specified VM instance \"#{notes[inst_id_key]}\"" if agent.nil?
-                @service_instance.cloud_host.map_agent(agent)
+                @svc.cloud_host.map_agent(agent)
               }
             end
             
-            raise "Could not find the agent to be assigned to : #{@service_instance.resource.class}" unless @service_instance.cloud_host.mapped?
-
-            @service_instance.resource.on_enter_agent(@service_instance, self)
+            raise "Could not find the agent to be assigned to : #{@svc.resource.class}" unless @svc.cloud_host.mapped?
           end
           
-          raise "The assigned agent \"#{@service_instance.cloud_host.agent_id}\" for the service instance #{@service_instance.id} is not online."  unless @service_instance.cloud_host.status == Service::Agent::STATUS_ONLINE
+          raise "The assigned agent \"#{@svc.cloud_host.agent_id}\" for the service instance #{@svc.id} is not online."  unless @svc.cloud_host.agent.monitor_status == Service::Agent::STATUS_ONLINE
+          
+          StatusDB.barrier {
+            @svc.update_status(Service::STATUS_ENTERING)
+          }
 
+          @svc.resource.on_enter_agent(@svc, self)
         end
         
 
         StatusDB.barrier {
-          @service_instance.update_status(Service::STATUS_STARTING)
+          @svc.update_status(Service::STATUS_STARTING)
         }
         
-        if @service_instance.resource.require_agent
-          trigger_action(DeployConfig.new(@service_instance))
+        if @svc.resource.require_agent
+          trigger_action(DeployConfig.new(@svc))
           flush_subactions
         end
 
-        @service_instance.resource.start(@service_instance, self)
+        @svc.reload
+        Wakame.log.debug("#{@svc.resource.class}: svc.monitor_status == Wakame::Service::STATUS_ONLINE => #{@svc.monitor_status == Wakame::Service::STATUS_ONLINE}")
+        if @svc.monitor_status != Wakame::Service::STATUS_ONLINE
+          @svc.resource.start(@svc, self)
+        end
+
+        StatusDB.barrier {
+          @svc.update_status(Service::STATUS_RUNNING)
+        }
         
-        trigger_action(NotifyParentChanged.new(@service_instance))
+        trigger_action(NotifyParentChanged.new(@svc))
         flush_subactions
 
       end
 
       def on_failed
         StatusDB.barrier {
-          @service_instance.update_status(Service::STATUS_FAIL)
+          @svc.update_status(Service::STATUS_FAIL)
         }
       end
     end