wakame 0.4.2 → 0.5.0

data/lib/wakame/command/start_service.rb

@@ -0,0 +1,14 @@
+class Wakame::Command::StartService
+  include Wakame::Command
+
+  command_name='start_service'
+
+  def run
+    svc = service_cluster.find_service(params[:service_id])
+    if svc.nil?
+      raise "Unknown Service ID: #{params[:service_id]}"
+    end
+
+    trigger_action(Wakame::Actions::StartService.new(svc))
+  end
+end

data/lib/wakame/command/status.rb

@@ -1,19 +1,41 @@
 
-require 'erb'
-
 class Wakame::Command::Status
   include Wakame::Command
+  include Wakame::Service
 
-  def run(rule)
-   EM.barrier {
-      master = rule.master
-      
-      @service_cluster = master.service_cluster.dump_status
-      @agent_monitor = master.agent_monitor.dump_status
+  def run
+    Wakame::StatusDB.barrier {
       res = {
-        :service_cluster => @service_cluster,
-        :agent_monitor => @agent_monitor
+        :cluster=>nil, 
+        :agent_pool=>nil, 
+        :agents=>{}, 
+        :services=>{}, 
+        :resources=>{},
+        :cloud_hosts=>{}
+      }
+
+      res[:agent_pool] = AgentPool.instance.dump_attrs
+      AgentPool.instance.group_active.keys.each { |id|
+        res[:agents][id] = Agent.find(id).dump_attrs
       }
+
+      cluster_id = master.cluster_manager.clusters.first
+      if cluster_id
+        cluster = ServiceCluster.find(cluster_id)
+        res[:cluster] = cluster.dump_attrs
+        cluster.services.keys.each { |id|
+          res[:services][id]=ServiceInstance.find(id).dump_attrs
+        }
+        
+        cluster.resources.keys.each { |id|
+          res[:resources][id]=Resource.find(id).dump_attrs
+        }
+        
+        cluster.cloud_hosts.keys.each { |id|
+          res[:cloud_hosts][id]=CloudHost.find(id).dump_attrs
+        }
+      end
+#p res[:cluster]
       res
     }
 

data/lib/wakame/command/stop_service.rb

@@ -3,29 +3,35 @@ class Wakame::Command::StopService
 
   command_name='stop_service'
 
-  def run(rule)
-
-    if !@options["service_id"].nil?
-      svc_inst = rule.service_cluster.instances
-      rule.trigger_action(Wakame::Actions::StopService.new(svc_inst[@options["service_id"]]))
-    end
-    if !@options["service_name"].nil?
-      levels = rule.service_cluster.dg.levels
-      levels.reverse.each {|lv|
-       lv.each { |svc_prop|
-         if svc_prop.class.to_s == @options["service_name"].to_s
-           rule.service_cluster.each_instance(svc_prop.class) { |svc_inst|
-             rule.trigger_action(Wakame::Actions::StopService.new(svc_inst))
-           }
-         end
-       }
-     }
+  # terminate
+  # service_id or resource_name
+  def run
+    do_terminate = true
+    if options['do_terminate'] == 'false'
+      do_terminate = false
     end
-    if !@options["agent_id"].nil?
-      registered_agents = rule.agent_monitor.registered_agents[@options["agent_id"]]
-      registered_agents.services.each{|id, svc_inst|
-        rule.trigger_action(Wakame::Actions::StopService.new(svc_inst))
+
+    if options['service_id']
+      svc_inst = service_cluster.find_service(options['service_id'])
+      trigger_action(Wakame::Actions::StopService.new(svc_inst, do_terminate))
+    elsif options['resource_name']
+      # resource_name is expected to be set two types of name: the class name inherited from Resource or the module name.
+      # The user can stop set of service instances as per the filterring rule of each_instace() method.
+      # For example: if you pass "HttpServer" module name to the resource_name option, all the services include "HttpServer" module
+      # will be stopped in one shot.
+      filter_type = Wakame::Util.build_const(options['resource_name'])
+      if (filter_type.is_a?(Module) && !filter_type.is_a?(Class)) ||
+          (filter_type.is_a?(Class) && filter_type < Wakame::Service::Resource)
+        # They are valid filter types.
+      else
+        raise "Invalid names as resource name: #{options['resource_name']}"
+      end
+      service_cluster.each_instance(filter_type).each { |svc_inst|
+        trigger_action(Wakame::Actions::StopService.new(svc_inst, do_terminate))
       }
+    else
+      raise "Could not find valid service_id or resource_name parameter."
     end
+
   end
 end

data/lib/wakame/command.rb

@@ -21,14 +21,30 @@ module Wakame
       @options = path
     end
 
-    def parse(args)
+    def params
+      @options
     end
+    alias :options :params
 
-    def run(rule)
+    def run
     end
 
-    def print_result
+    protected
+    def master
+      Master.instance
     end
 
+    def trigger_action(action)
+      master.action_manager.trigger_action(action)
+    end
+
+    # Tentative utility method for 
+    def service_cluster
+      cluster_id = master.cluster_manager.clusters.first
+      raise "There is no cluster loaded" if cluster_id.nil?
+
+      Service::ServiceCluster.find(cluster_id)
+    end
+    alias :cluster :service_cluster
   end
 end

data/lib/wakame/command_queue.rb

@@ -8,12 +8,40 @@ require 'json'
 
 module Wakame
   class CommandQueue
-    attr_reader :master
+    include Manager
 
-    def initialize(master)
-      @master = master
+    def initialize()
       @queue = Queue.new
       @result_queue = Queue.new
+      @statistics = {
+        :total_command_count => 0
+      }
+    end
+
+    def init
+      @command_thread = Thread.new {
+        Wakame.log.info("#{self.class}: Started command thread: #{Thread.current}")
+        while cmd = @queue.deq
+          begin
+            unless cmd.kind_of?(Wakame::Command)
+              Wakame.log.warn("#{self.class}: Incompatible type of object has been sent to ProcessCommand thread. #{cmd.class}")
+              next
+            end
+
+            res = nil
+            StatusDB.barrier {
+              Wakame.log.debug("#{self.class}: Being processed the command: #{cmd.class}")
+              res = cmd.run
+              res
+            }
+          rescue => e
+            Wakame.log.error(e)
+            res = e
+          ensure
+            @result_queue.enq(res)
+          end
+        end
+      }
 
       cmdsv_uri = URI.parse(Wakame.config.http_command_server_uri)
 
@@ -22,23 +50,13 @@ module Wakame
       @thin_server.start
     end
 
-    def shutdown
+    def terminate
       @thin_server.stop
-    end
-
-    def deq_cmd()
-      @queue.deq
-    end
-
-    def enq_result(res)
-      @result_queue.enq(res)
+      @command_thread.kill
     end
 
     def send_cmd(cmd)
       begin
-
-        #cmd = Marshal.load(cmd)
-
         @queue.enq(cmd)
 
         ED.fire_event(Event::CommandReceived.new(cmd))
@@ -50,66 +68,68 @@ module Wakame
       end
     end
 
-  end
-  class Adapter
-  
-    def initialize(command_queue)
-      @command_queue = command_queue
-    end
- 
-    def call(env)
-Wakame.log.debug EM.reactor_thread?
-      req = Rack::Request.new(env)
-      begin
-        unless req.get?().to_s == "true"
-          raise "No Support Response"
-        end
-        query = req.query_string()
-        params = req.params()
-        if Wakame.config.enable_authentication == "true"
-          auth = authentication(params, query)
-        end
-        cname = params["action"].split("_")
+
+    class Adapter
+      
+      def initialize(command_queue)
+        @command_queue = command_queue
+      end
+      
+      def call(env)
+        req = Rack::Request.new(env)
         begin
-         cmd = eval("Command::#{(cname.collect{|c| c.capitalize}).join}").new 
-	 cmd.options = params
-         command = @command_queue.send_cmd(cmd)
-
-         if command.is_a?(Exception)
-           status = 500
-           body = json_encode(status, command.message)
-         else
-           status = 200
-           body = json_encode(status, "OK", command)
-         end
+          unless req.get?().to_s == "true"
+            raise "No Support Response"
+          end
+          query = req.query_string()
+          params = req.params()
+          if Wakame.config.enable_authentication == "true"
+            auth = authentication(params, query)
+          end
+          cname = params["action"].split("_")
+          begin
+            cmd = eval("Command::#{(cname.collect{|c| c.capitalize}).join}").new 
+            cmd.options = params
+            command = @command_queue.send_cmd(cmd)
+
+            if command.is_a?(Exception)
+              status = 500
+              body = json_encode(status, command.message)
+            else
+              status = 200
+              body = json_encode(status, "OK", command)
+            end
+          rescue => e
+            status = 404
+            body = json_encode(status, e)
+          end
         rescue => e
-           status = 404
-           body = json_encode(status, e)
+          status = 403
+          body = json_encode(status, e)
+          Wakame.log.error(e)
         end
-      rescue => e
-        status = 403
-        body = json_encode(status, e)
+        [ status, {'Content-Type' => 'text/javascript+json'}, body]
       end
-      [ status, {'Content-Type' => 'text/javascript+json'}, body]
-    end
 
-    def authentication(path, query)
-      key = Wakame.config.private_key
-      req = query.split(/\&signature\=/)
-      hash = OpenSSL::HMAC::digest(OpenSSL::Digest::SHA256.new, key, req[0])
-      hmac = Base64.encode64(hash).gsub(/\+/, "").gsub(/\n/, "").to_s
-      if hmac != path["signature"]
-         raise "Authentication failed"
+      def authentication(path, query)
+        key = Wakame.config.private_key
+        req = query.split(/\&signature\=/)
+        hash = OpenSSL::HMAC::digest(OpenSSL::Digest::SHA256.new, key, req[0])
+        hmac = Base64.encode64(hash).gsub(/\+/, "").gsub(/\n/, "").to_s
+        if hmac != path["signature"]
+          raise "Authentication failed"
+        end
       end
-    end
 
-    def json_encode(status, message, data=nil)
-      if status == 200 && data.is_a?(Hash)
-        body = [{:status=>status, :message=>message}, {:data=>data}].to_json
-      else
-        body = [{:status=>status, :message=>message}].to_json
+      def json_encode(status, message, data=nil)
+        if status == 200 && data.is_a?(Hash)
+          body = [{:status=>status, :message=>message}, {:data=>data}].to_json
+        else
+          body = [{:status=>status, :message=>message}].to_json
+        end
+        body
       end
-      body
     end
+
   end
 end

data/lib/wakame/configuration.rb

@@ -9,6 +9,7 @@ module Wakame
     PARAMS = {
       #:config_template_root => nil,
       #:config_tmp_root => nil,
+      :status_db_dsn => nil,
       :config_root => nil,
       :cluster_class => 'WebCluster',
       :load_paths => [],
@@ -69,9 +70,14 @@ module Wakame
       %w(lib).map{|dir| File.join(root_path, dir) }.select{|path| File.directory?(path)}
     end
 
+    def cluster_config_path
+      File.expand_path('config/cluster.rb', root_path)
+    end
+
     # 
     class DefaultSet
       def process(config)
+        config.status_db_dsn = "sqlite://" + File.expand_path('tmp/wakame.db', config.root_path)
       end
     end
 

data/lib/wakame/event.rb

@@ -100,6 +100,23 @@ module Wakame
       end
     end
 
+    class ServiceUnboundHost < Base
+      attr_reader :service, :host
+      def initialize(service, host)
+        super()
+        @service = service
+        @host = host
+      end
+    end
+    class ServiceBoundHost < Base
+      attr_reader :service, :host
+      def initialize(service, host)
+        super()
+        @service = service
+        @host = host
+      end
+    end
+
     class ServiceBoundCluster < Base
       attr_reader :service, :service_cluster
       def initialize(svc_inst, cluster)

data/lib/wakame/event_dispatcher.rb

@@ -14,10 +14,19 @@ module Wakame
         self.instance.subscribe(event_class, *args, &blk)
       end
 
-      def unsubscribe(event_class)
-        self.instance.unsubscribe(event_class)
+      def unsubscribe(ticket)
+        self.instance.unsubscribe(ticket)
       end
 
+      def subscribe_once(event_class, *args, &blk)
+        tkt = self.subscribe(event_class, *args) { |event|
+          begin
+            blk.call(event) if blk
+          ensure
+            self.unsubscribe(tkt)
+          end
+        }
+      end
 
       def fire_event(event_obj)
         self.instance.fire_event(event_obj)
@@ -48,25 +57,25 @@ module Wakame
                       raise ArgumentError, "event_class has to be a form of String or Class type"
                     end
 
-      EM.barrier {
-      tlist = @event_handlers[event_class]
-      if tlist.nil?
-        tlist = @event_handlers[event_class] = []
-      end
-      
-      tickets = []
-      args.each { |o|
-        tickets << Util.gen_id
-        @tickets.store(tickets.last, [event_class, o])
-        tlist << tickets.last
-      }
-      
-      if blk
-        tickets << Util.gen_id
-        @tickets.store(tickets.last, [event_class, blk])
-        tlist << tickets.last
-      end
-
+      StatusDB.barrier {
+        tlist = @event_handlers[event_class]
+        if tlist.nil?
+          tlist = @event_handlers[event_class] = []
+        end
+        
+        tickets = []
+        args.each { |o|
+          tickets << Util.gen_id
+          @tickets.store(tickets.last, [event_class, o])
+          tlist << tickets.last
+        }
+        
+        if blk
+          tickets << Util.gen_id
+          @tickets.store(tickets.last, [event_class, blk])
+          tlist << tickets.last
+        end
+        
         # Return in array if num of ticket to be returned is more than or equal 2.
         tickets.size > 1 ? tickets : tickets.first
       }
@@ -78,7 +87,7 @@ module Wakame
         return nil
       end
       
-      EM.barrier {
+      StatusDB.barrier {
         Wakame.log.debug("#{self.class}.unsubscribe(#{ticket})")
 
         @unsubscribe_queue << ticket
@@ -126,7 +135,7 @@ module Wakame
     
       #@handler_run_queue.push(run_handlers)
       
-      ::EventMachine.barrier {
+      StatusDB.barrier {
         begin 
           run_callbacks.call
         rescue => e

data/lib/wakame/graph.rb

@@ -2,7 +2,8 @@
 module Wakame
   
   class Graph
-    
+    attr_accessor :edges
+
     def initialize
       @edges={}
     end

data/lib/wakame/initializer.rb

@@ -29,7 +29,7 @@ module Wakame
 
     def process_master
       process
-      load_cluster
+      setup_database
       load_resources
       load_core_commands
       load_core_actions
@@ -43,7 +43,6 @@ module Wakame
     
     def process_cli
       process
-      load_core_commands
     end
 
     def setup_load_paths
@@ -60,6 +59,7 @@ module Wakame
                      #log = Logger.new((Wakame.root||Dir.pwd) / "log.log")
                      out = ::Log4r::StdoutOutputter.new('stdout',
                                                         :formatter => Log4r::PatternFormatter.new(
+                                                                                                  :depth => 9999, # stack trace depth
                                                                                                   :pattern => "%d %C [%l]: %M",
                                                                                                   :date_format => "%Y/%m/%d %H:%M:%S"
                                                                                                   )
@@ -113,6 +113,12 @@ module Wakame
     end
 
     def load_resources
+      load_path = File.expand_path('cluster/resources/markers', configuration.root_path)
+      Dir.glob("#{load_path}/*.rb").sort.each do |file|
+        Wakame.log.debug("Loading resource marker: #{file}")
+        load file
+      end
+      
       load_path = File.expand_path('cluster/resources', configuration.root_path)
       Dir.glob("#{load_path}/*/*.rb").sort.each do |file|
         if file =~ %r{\A#{Regexp.escape(load_path)}/([^/]+)/([^/]+)\.rb\Z} && $1 == $2
@@ -121,12 +127,6 @@ module Wakame
         end
         #require file.sub(matcher, '\1')
       end
-      
-    end
-
-
-    def load_cluster
-      load File.expand_path('config/cluster.rb', configuration.root_path)
     end
 
     def load_actors
@@ -157,6 +157,9 @@ module Wakame
       }
     end
 
+    def setup_database
+      Wakame::StatusDB.adapter
+    end
 
   end
 end