wakame 0.5.0 → 0.5.1

data/lib/wakame/agent_manager.rb

@@ -0,0 +1,11 @@
+module Wakame
+  module AgentManager
+    attr_accessor :agent
+
+    def init; end
+    def start; end
+    def reload; end
+    def stop; end
+    def terminate; end
+  end
+end

data/lib/wakame/agent_managers/actor_manager.rb

@@ -0,0 +1,101 @@
+
+module Wakame
+  module AgentManagers
+    class ActorManager
+      include AgentManager
+
+      def init
+        agent.add_subscriber("agent_actor.#{agent.agent_id}") { |data|
+          begin
+            request = eval(data)
+            handle_request(request)
+          rescue => e
+            Wakame.log.error(e)
+            publish_to('agent_event', Packets::ActorResponse.new(self, request[:token], Actor::STATUS_FAILED, {:message=>e.message, :exclass=>e.class.to_s}).marshal)
+          end
+        }
+
+
+        register(Actor::ServiceMonitor.new, '/service_monitor')
+        register(Actor::Daemon.new, '/daemon')
+        register(Actor::System.new, '/system')
+        register(Actor::MySQL.new, '/mysql')
+        register(Actor::Deploy.new, '/deploy')
+        register(Actor::Monitor.new, '/monitor')
+        register(Actor::S3fs.new, '/s3fs')
+        
+      end
+
+      def terminate
+      end
+
+      attr_reader :actors
+
+      def initialize()
+        @actors = {}
+      end
+      
+      def register(actor, path=nil)
+        raise '' unless actor.kind_of?(Wakame::Actor)
+        
+        if path.nil?
+          path = '/' + Util.to_const_path(actor.class.to_s)
+        end
+        
+        if @actors.has_key?(path)
+          Wakame.log.error("#{self.class}: Duplicate registration: #{path}")
+          raise "Duplicate registration: #{path}"
+        end
+        
+        actor.agent = self.agent
+        @actors[path] = actor
+      end
+      
+      def unregister(path)
+        @actors.delete(path)
+      end
+      
+      def find_actor(path)
+        @actors[path]
+      end
+
+
+      private
+      def handle_request(request)
+        slash = request[:path].rindex('/') || raise("Invalid request path: #{request[:path]}")
+        
+        prefix = request[:path][0, slash]
+        action = request[:path][slash+1, request[:path].length]
+
+        actor = find_actor(prefix) || raise("Invalid request path: #{request[:path]}")
+
+        EM.defer(proc {
+                   begin
+                     Wakame.log.debug("#{self.class}: Started to run the actor: #{actor.class}, token=#{request[:token]}")
+                     agent.publish_to('agent_event', Packets::ActorResponse.new(agent, request[:token], Actor::STATUS_RUNNING).marshal)
+                     if request[:args].nil?
+                       actor.send(action)
+                     else
+                       actor.send(action, *request[:args])
+                     end
+                     Wakame.log.debug("#{self.class}: Finished to run the actor: #{actor.class}, token=#{request[:token]}")
+                     actor.return_value
+                   rescue => e
+                     Wakame.log.error("#{self.class}: Failed the actor: #{actor.class}, token=#{request[:token]}")
+                     Wakame.log.error(e)
+                     e
+                   end
+                 }, proc { |res|
+                   status = Actor::STATUS_SUCCESS
+                   if res.is_a?(Exception)
+                     status = Actor::STATUS_FAILED
+                     opts = {:message => res.message, :exclass=>res.class.to_s}
+                   else
+                     opts = {:return_value=>res}
+                   end
+                   agent.publish_to('agent_event', Packets::ActorResponse.new(self.agent, request[:token], status, opts).marshal)
+                 })
+      end
+    end
+  end
+end

data/lib/wakame/agent_managers/monitor_manager.rb

@@ -0,0 +1,48 @@
+module Wakame
+  module AgentManagers
+    class MonitorManager
+      include AgentManager
+
+      def init
+        agent_mon = register(Monitor::Agent.new, '/agent')
+        register(Monitor::Service.new, '/service')
+        
+        agent_mon.reload({:interval=>10})
+      end
+
+      def terminate
+      end
+      
+      attr_reader :monitors
+      
+      def initialize()
+        @monitors = {}
+      end
+      
+      def register(monitor, path=nil)
+        raise '' unless monitor.kind_of?(Wakame::Monitor)
+        
+        if path.nil?
+          path = '/' + Util.to_const_path(monitor.class.to_s)
+        end
+        
+        if @monitors.has_key?(path)
+          Wakame.log.error("#{self.class}: Duplicate registration: #{path}")
+          raise "Duplicate registration: #{path}"
+        end
+        
+        monitor.agent = self.agent
+        @monitors[path] = monitor
+      end
+      
+      def unregister(path)
+        @monitors.delete(path)
+      end
+      
+      def find_monitor(path)
+        @monitors[path]
+      end
+      
+    end
+  end
+end

data/lib/wakame/command.rb

@@ -6,13 +6,10 @@ module Wakame
     def self.included(klass)
       klass.class_eval {
         class << self
-          def command_name
+          def command_name(name=nil)
+            @command_name = name if name
             @command_name ||= Util.snake_case(self.to_s.split('::').last)
           end
-          
-          def command_name=(name)
-            @command_name=name
-          end
         end
       }
     end
@@ -34,8 +31,8 @@ module Wakame
       Master.instance
     end
 
-    def trigger_action(action)
-      master.action_manager.trigger_action(action)
+    def trigger_action(action=nil, &blk)
+      master.action_manager.trigger_action(action, &blk)
     end
 
     # Tentative utility method for 

data/lib/wakame/command/actor.rb

@@ -3,21 +3,18 @@ class Wakame::Command::Actor
   include Wakame::Command
   include Wakame::Service
 
-  command_name='actor'
-
-  def parse(args)
-    raise "Not enugh number of arguments" if args.size < 2
-  end
+  command_name 'actor'
 
   def run
-    agent = Agent.find(params[:agent_id])
-    raise "Unknown agent: #{params[:agent_id]}" if agent.nil?
-    raise "Invalid agent status (Not Online): #{agent.status} #{params[:agent_id]}" if agent.status != Agent::STATUS_ONLINE
-
-    raise "Invalid actor path: #{params[:path]}" if params[:path].nil? || params[:path] == ''
+    agent = Agent.find(params['agent_id'])
+    raise "Unknown agent: #{params['agent_id']}" if agent.nil?
+    raise "Invalid agent status (Not Online): #{agent.status} #{params['agent_id']}" if agent.status != Agent::STATUS_ONLINE
+    raise "Invalid actor path: #{params['path']}" if params['path'].nil? || params['path'] == ''
+    if params['args'].is_a? String
+      params['args'] = eval(params['args'])
+    end
 
-    request = rule.master.actor_request(params[:agent_id], params[:path], *params[:args]).request
-    request.wait
+    request = master.actor_request(params['agent_id'], params['path'], *params['args']).request
   end
 
 end

data/lib/wakame/command/agent_status.rb

@@ -2,7 +2,7 @@
 class Wakame::Command::AgentStatus
   include Wakame::Command
 
-  command_name='agent_status'
+  command_name 'agent_status'
 
   def run(rule)
     EM.barrier {
@@ -15,4 +15,4 @@ class Wakame::Command::AgentStatus
       res
     }
   end
-end
+end

data/lib/wakame/command/control_service.rb

@@ -0,0 +1,66 @@
+class Wakame::Command::ControlService
+  include Wakame::Command
+  include Wakame
+
+  command_name 'control_service'
+
+  def run
+    num = @options["number"] || 1
+    raise "Invalid format of number: #{num}" unless /^(\d+)$/ =~ num.to_s
+    num = num.to_i
+
+    resname = @options["resource"]
+    resobj = Service::Resource.find(Service::Resource.id(resname))
+
+    if num < 1 || resobj.max_instances < num 
+      raise "The number must be between 1 and #{resobj.max_instances - service_cluster.instance_count(resobj)} (max limit: #{resobj.max_instances})"
+    end
+    raise "The same number of instances running" if service_cluster.instance_count(resobj) == num
+
+    if service_cluster.instance_count(resobj) < num
+      num = (num - service_cluster.instance_count(resobj)).to_i
+      cloud_host_id = nil
+      refsvc = service_cluster.find_service(@options["service_id"])
+      if refsvc.nil?
+        raise("Unknown ServiceInstance ID: #{@options["service_id"]}")
+      end
+      trigger_action{|action|
+        num.times{
+          action.trigger_action(Wakame::Actions::PropagateService.new(refsvc, cloud_host_id))
+        }
+      }
+    else
+      attrs = Master.ec2_fetch_local_attrs
+      agent = Wakame::Models::AgentPool.instance.find_agent(attrs[:instance_id])
+      cloud_host_id = agent.cloud_host.id
+      num = (service_cluster.instance_count(resobj) - num).to_i
+      locksvc = service_cluster.find_service(@options["service_id"])
+      refsvc = service_cluster.each_instance(resobj)
+      svcs, nsvcs = refsvc.partition{|s| s.id == locksvc.id}
+      c = 1
+      res = {}
+      nsvcs.reverse_each {|svc|
+        cloud_host = Service::CloudHost.find(svc.cloud_host_id)
+        res[svc.id] =  cloud_host.agent.vm_attr
+        trigger_action { |action|
+          action.trigger_action(Wakame::Actions::StopService.new(svc))
+          action.flush_subactions
+          action.trigger_action(Wakame::Actions::NotifyParentChanged.new(svc))
+          action.flush_subactions
+          unless cloud_host.id == cloud_host_id
+            action.trigger_action(Wakame::Actions::ShutdownVM.new(cloud_host.agent))
+            action.flush_subactions
+            Wakame::StatusDB.barrier{
+              cluster = Wakame::Service::ServiceCluster.find(cloud_host.cluster_id)
+              cloud_host.unmap_agent
+              cluster.remove_cloud_host(cloud_host.id)
+            }
+          end
+        }
+        c += 1
+        break if c > num
+      }
+    end
+    res
+  end
+end

data/lib/wakame/command/deploy_application.rb

@@ -0,0 +1,18 @@
+
+class Wakame::Command::DeployApplication
+  include Wakame::Command
+  include Wakame::Service
+
+  command_name 'deploy_application'
+
+  def run
+    raise "Invalid application name: \"#{params['app_name']}\"" if params['app_name'].nil? || params['app_name'] !~ /\A[\w\-\.\@]+\Z/
+    if Wakame::Models::ApplicationRepository.find(:app_name=>params['app_name']) == nil
+      raise "The name of application is not registered: #{params['app_name']}"
+    end
+
+    
+    trigger_action(Wakame::Actions::DeployApplication.new(params['app_name']))
+  end
+
+end

data/lib/wakame/command/deploy_config.rb

@@ -0,0 +1,16 @@
+
+class Wakame::Command::DeployConfig
+  include Wakame::Command
+  include Wakame::Service
+
+  command_name 'deploy_config'
+
+  def run
+    cluster.each_instance.map { |svc_inst|
+      next if svc_inst.cloud_host_id.nil?
+      Wakame.log.debug(svc_inst)
+      trigger_action(Wakame::Actions::DeployConfig.new(svc_inst))
+    }
+  end
+
+end

data/lib/wakame/command/launch_cluster.rb

@@ -3,7 +3,7 @@
 class Wakame::Command::LaunchCluster
   include Wakame::Command
 
-  command_name='launch_cluster'
+  command_name 'launch_cluster'
 
   def run
     trigger_action(Wakame::Actions::LaunchCluster.new)

data/lib/wakame/command/launch_vm.rb

@@ -2,7 +2,7 @@
 class Wakame::Command::LaunchVm
   include Wakame::Command
 
-  command_name='launch_vm'
+  command_name 'launch_vm'
 
   def run
     inst_id_key = "new_inst_id_" + Wakame::Util.gen_id

data/lib/wakame/command/propagate_resource.rb

@@ -3,7 +3,7 @@ class Wakame::Command::PropagateResource
   include Wakame::Command
   include Wakame
 
-  command_name='propagate_resource'
+  command_name 'propagate_resource'
 
   def run
     resname = @options["resource"]

data/lib/wakame/command/propagate_service.rb

@@ -3,7 +3,7 @@ class Wakame::Command::PropagateService
   include Wakame::Command
   include Wakame
 
-  command_name='propagate_service'
+  command_name 'propagate_service'
 
   def run
     refsvc = service_cluster.find_service(@options["service_id"])
@@ -27,8 +27,10 @@ class Wakame::Command::PropagateService
       raise "The number must be between 1 and #{refsvc.resource.max_instances - service_cluster.instance_count(refsvc.resource)} (max limit: #{refsvc.resource.max_instances})"
     end
 
-    num.times {
-      trigger_action(Wakame::Actions::PropagateService.new(refsvc, cloud_host_id))
+    trigger_action { |action|
+      num.times {
+        action.trigger_action(Wakame::Actions::PropagateService.new(refsvc, cloud_host_id))
+      }
     }
   end
 end

data/lib/wakame/command/reload_service.rb

@@ -2,7 +2,7 @@
 class Wakame::Command::ReloadService
   include Wakame::Command
 
-  command_name='reload_service'
+  command_name 'reload_service'
 
   def run
     svc = service_cluster.find_service(options['service_id'])

data/lib/wakame/command/shutdown_cluster.rb

@@ -2,7 +2,7 @@
 class Wakame::Command::ShutdownCluster
   include Wakame::Command
 
-  command_name='shutdown_cluster'
+  command_name 'shutdown_cluster'
 
   def run
     trigger_action(Wakame::Actions::ShutdownCluster.new)

data/lib/wakame/command/shutdown_vm.rb

@@ -2,19 +2,45 @@
 class Wakame::Command::ShutdownVm
   include Wakame::Command
 
-  command_name='shutdown_vm'
+  command_name 'shutdown_vm'
 
-  def run(rule)
-    registered_agents = rule.agent_monitor.registered_agents[@options["agent_id"]]
-    if !registered_agents.services.nil?
-      if !@options["force"].nil?
-        registered_agents.services.each{|id, svc_inst|
-	  rule.trigger_action(Wakame::Actions::StopService.new(svc_inst))
-	}
+  def run
+    agent = Wakame::Models::AgentPool.instance.find_agent(@options['agent_id'])
+    if agent.cloud_host_id.nil?
+      trigger_action(Wakame::Actions::ShutdownVM.new(agent))
+    else
+      cloud_host = agent.cloud_host
+      # Check if the agent has the running service(s).
+      live_svcs = cloud_host.assigned_services.find_all {|svc_id|
+        Wakame::Service::ServiceInstance.find(svc_id).monitor_status == Wakame::Service::STATUS_ONLINE
+      }
+      if live_svcs.empty?
+        cloud_host.unmap_agent
+        trigger_action(Wakame::Actions::ShutdownVM.new(agent))
       else
-        raise "Service instances Launched"
+        raise "Service(s) are still running on #{agent.id}" unless @options['force']
+        
+        trigger_action { |action|
+          live_svcs.each {|svc_id|
+            svc = Wakame::Service::ServiceInstance.find(svc_id)
+            action.trigger_action(Wakame::Actions::StopService.new(svc))
+          }
+          action.flush_subactions
+
+          Wakame::StatusDB.barrier {
+            cluster = Wakame::Service::ServiceCluster.find(cloud_host.cluster_id)
+            live_svcs.each {|svc_id|
+              cluster.destroy(svc_id)
+            }
+            
+            cloud_host.unmap_agent
+            cluster.remove_cloud_host(cloud_host.id)
+          }
+
+          action.trigger_action(Wakame::Actions::ShutdownVM.new(agent))
+        }
       end
     end
-    rule.trigger_action(Wakame::Actions::ShutdownVM.new(registered_agents))
+      
   end
-end
+end