wakame 0.4.1 → 0.4.2

data/lib/wakame/actor/service_monitor.rb

@@ -8,6 +8,7 @@ class Wakame::Actor::ServiceMonitor
       svcmon = agent.monitor_registry.find_monitor('/service')
       svcmon.register(svc_id, type, *args)
     }
+    self.return_value = check_status(svc_id)
   end
 
   expose '/service_monitor/unregister', :unregister
@@ -18,4 +19,13 @@ class Wakame::Actor::ServiceMonitor
     }
   end
 
+  # Immediate status check for the specified Service ID.
+  def check_status(svc_id)
+    self.return_value = EM.barrier {
+      svcmon = agent.monitor_registry.find_monitor('/service')
+      svcmon.check_status(svc_id)
+    }
+    self.return_value
+  end
+
 end

data/lib/wakame/actor/system.rb

@@ -5,22 +5,32 @@ require 'ext/shellwords' unless Shellwords.respond_to? :shellescape
 
 class Wakame::Actor::System
   include Wakame::Actor
- 
+
+  def sync(count = 1)
+    count.to_i.times do |i|
+      Wakame.log.debug("Wakame::Actor::System.sync #{i + 1}/#{count}")
+      Wakame::Util.exec("/bin/sync")
+    end
+  end
+
   def mount(dev, path, opts={})
-    raise "#{path} does not exist or not directory." unless File.directory?(path)
+    Wakame.log.debug("Wakame::Actor::System.mount")
+    cond = ConditionalWait.new { |c|
+      c.poll {
+        self.sync
+        File.blockdev?(dev)
+      }
+    }
+    cond.wait
+
+    raise "#{dev} does not exist or not block device." unless File.blockdev?(dev)
+    raise "#{path} does not exist or not directory."   unless File.directory?(path)
     
     mount_point_dev=`/bin/df "#{path}" | /usr/bin/awk 'NR==2 {print $1}'`.strip
-
-    #mount_point_dev=`/bin/mount | /usr/bin/awk '$3==path {print $1}' path="#{path}"`.strip
     Wakame.log.debug("#{mount_point_dev}: #{dev}, /bin/mount | awk '$3==path {print $1}' path=\"#{path}\"")
     if mount_point_dev != dev
       Wakame.log.debug("Mounting volume: #{dev} as #{path} (with options: #{opts})")
       Wakame::Util.exec("/bin/mount -o #{mount_opts(opts)} '#{Shellwords.shellescape(dev)}' '#{Shellwords.shellescape(path)}'")
-      # sync
-      3.times do |i|
-        system("/bin/sync")
-        sleep 1.0
-      end
     else
       Wakame.log.debug("Mounting EBS volume: #{dev} as #{path} (with options: #{opts})")
     end

data/lib/wakame/actor.rb

@@ -10,7 +10,7 @@ module Wakame
     def self.included(klass)
       klass.extend ClassMethods
       klass.class_eval {
-        attr_accessor :agent
+        attr_accessor :agent, :return_value
       }
     end
 

data/lib/wakame/agent.rb

@@ -38,8 +38,9 @@ module Wakame
       setup_actors
       setup_dispatcher
 
-      publish_to('registry', Packets::Register.new(self, Wakame.config.root_path.to_s).marshal)
-      Wakame.log.info("Started agent process : WAKAME_ROOT=#{Wakame.config.root_path} WAKAME_ENV=#{Wakame.config.environment}")
+      attrs = Wakame::VmManipulator.create.fetch_local_attrs
+      publish_to('registry', Packets::Register.new(self, Wakame.config.root_path.to_s, attrs).marshal)
+      Wakame.log.info("Started agent process : WAKAME_ROOT=#{Wakame.config.root_path} WAKAME_ENV=#{Wakame.config.environment}, attrs=#{attrs.inspect}")
     end
 
 #     def send_event_response(event)
@@ -84,6 +85,7 @@ module Wakame
       @actor_registry.register(Actor::ServiceMonitor.new, '/service_monitor')
       @actor_registry.register(Actor::Daemon.new, '/daemon')
       @actor_registry.register(Actor::System.new, '/system')
+      @actor_registry.register(Actor::MySQL.new, '/mysql')
       @actor_registry.actors.each { |path, actor|
 #        actor.setup(path)
         actor.agent = self
@@ -94,6 +96,7 @@ module Wakame
       require 'wakame/actor/service_monitor'
       require 'wakame/actor/daemon'
       require 'wakame/actor/system'
+      require 'wakame/actor/mysql'
     end
 
 
@@ -198,26 +201,29 @@ module Wakame
       end
 
       EM.defer(proc {
-                 return 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]}")
-                        rescue => e
-                          Wakame.log.error("#{self.class}: Failed the actor: #{actor.class}, token=#{request[:token]}")
-                          Wakame.log.error(e)
-                          e
-                        end
+                 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
+                 else
+                   opts = {:return_value=>res}
                  end
-                 agent.publish_to('agent_event', Packets::ActorResponse.new(self.agent, request[:token], status).marshal)
+                 agent.publish_to('agent_event', Packets::ActorResponse.new(self.agent, request[:token], status, opts).marshal)
                })
     end
   end

data/lib/wakame/command/action_status.rb

@@ -4,21 +4,6 @@ require 'erb'
 class Wakame::Command::ActionStatus
   include Wakame::Command
 
-  ACTION_STATUS_TMPL=<<__E__
-Running Actions : <%= @status.size %> action(s)
-<%- if @status.size > 0 -%>
-<%- @status.each { |id, j| -%>
-JOB <%= id %> :
-  start : <%= j[:created_at] %>
-  <%= tree_subactions(j[:root_action]) %>
-<%- } -%>
-<%- end -%>
-__E__
-
-
-  def parse(args)
-  end
-
   def run(rule)
     walk_subactions = proc { |a, level|
       res = a.dump_attrs
@@ -29,34 +14,18 @@ __E__
       end
       res
     }
-    
+
     EM.barrier {
       result = {}
-      rule.master.service_cluster.rule_engine.active_jobs.each { |id, v|
-        result[id]={:actions=>[], :created_at=>v[:created_at], :src_rule=>v[:src_rule].class.to_s}
-        
-        result[id][:root_action] = walk_subactions.call(v[:root_action], 0)
-      }
-      
-      @status = result
-    }
-  end
 
-  def print_result
-    puts ERB.new(ACTION_STATUS_TMPL, nil, '-').result(binding)
-  end
+      rule.rule_engine.active_jobs.each { |id, v|
 
+        result[id]={:created_at=>v[:created_at], :src_rule=>v[:src_rule].class.to_s}        
+        result[id][:root_action] = walk_subactions.call(v[:root_action], 0)
 
-  private
-  def tree_subactions(root, level=0)
-    str= ("  " * level) + "#{root[:type]} (#{root[:status]})"
-    unless root[:subactions].nil?
-      root[:subactions].each { |a|
-        str << "\n  "
-        str << tree_subactions(a, level + 1)
       }
-    end
-    str
+      @status = result
+      @status
+    }
   end
-
 end

data/lib/wakame/command/agent_status.rb

@@ -0,0 +1,18 @@
+
+class Wakame::Command::AgentStatus
+  include Wakame::Command
+
+  command_name='agent_status'
+
+  def run(rule)
+    EM.barrier {
+      registered_agents = rule.agent_monitor.registered_agents[@options["agent_id"]]
+      service_cluster = rule.service_cluster
+      res ={
+       :agent_status =>registered_agents.dump_status,
+       :service_cluster =>service_cluster.dump_status
+      }
+      res
+    }
+  end
+end

data/lib/wakame/command/launch_cluster.rb

@@ -5,11 +5,7 @@ class Wakame::Command::LaunchCluster
 
   command_name='launch_cluster'
 
-  def parse(args)
-  end
-
   def run(rule)
     rule.trigger_action(Wakame::Actions::LaunchCluster.new)
   end
-
 end

data/lib/wakame/command/launch_vm.rb

@@ -0,0 +1,11 @@
+
+class Wakame::Command::LaunchVm
+  include Wakame::Command
+
+  command_name='launch_vm'
+
+  def run(rule)
+    inst_id_key = "new_inst_id_" + Wakame::Util.gen_id
+    rule.trigger_action(Wakame::Actions::LaunchVM.new(inst_id_key))
+  end
+end

data/lib/wakame/command/migrate_service.rb

@@ -2,20 +2,23 @@
 class Wakame::Command::MigrateService
   include Wakame::Command
 
-  #command_name='launch_cluster'
-
-  def parse(args)
-    @svc_id = args.shift
-  end
-
   def run(rule)
     svc = nil
-    svc = rule.service_cluster.instances[@svc_id]
+    svc = rule.service_cluster.instances[@options["service_id"]]
     if svc.nil?
-      raise "Unknown Service ID: #{@svc_id}" 
+      raise "Unknown Service ID: #{@options["service_id"]}" 
+    end
+
+    # Optional destination agent 
+    agent = nil
+    if @options["agent_id"]
+      agent = rule.agent_monitor.agent(@options["agent_id"])
+      if agent.nil?
+        raise "Unknown Agent ID: #{@options["agent_id"]}" 
+      end
     end
 
-    rule.trigger_action(Wakame::Actions::MigrateService.new(svc))
+    rule.trigger_action(Wakame::Actions::MigrateService.new(svc, agent))
   end
 
 end

data/lib/wakame/command/propagate_service.rb

@@ -5,20 +5,28 @@ class Wakame::Command::PropagateService
   #command_name='launch_cluster'
 
   def parse(args)
-    @resname = args.shift
-    @num = args.shift unless args.empty?
+    @resource
   end
 
   def run(rule)
     prop = nil
-    prop = rule.service_cluster.properties[@resname.to_s]
+    prop = rule.service_cluster.properties[@options["service"]]
     if prop.nil?
-      raise "UnknownProperty: #{@resname}" 
+      raise "UnknownProperty: #{@options["service"]}" 
     end
 
-    @num ||= 1
+    @num = nil
+    @num = @options["num"] || 1
 
-    rule.trigger_action(Wakame::Actions::PropagateInstances.new(prop, @num))
-  end
+    unless /^(\d){1,32}$/ =~ @num.to_s
+      raise "The number is not appropriate: #{@num}"
+    end
 
+    instance = rule.master.service_cluster.dump_status[:properties][@options["service"]]
+    if @num.to_i > (instance[:max_instances].to_i - instance[:instances].count.to_i)
+      raise "The number is not appropriate: #{@num}"
+    end
+
+    rule.trigger_action(Wakame::Actions::PropagateInstances.new(prop, @num.to_i))
+  end
 end

data/lib/wakame/command/reload_service.rb

@@ -0,0 +1,21 @@
+
+class Wakame::Command::ReloadService
+  include Wakame::Command
+
+  command_name='reload_service'
+
+  def run(rule)
+    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::ReloadService.new(svc_inst))
+            }
+          end
+        }
+      }
+    end
+  end
+end

data/lib/wakame/command/shutdown_cluster.rb

@@ -1,15 +1,10 @@
 
-
 class Wakame::Command::ShutdownCluster
   include Wakame::Command
 
   command_name='shutdown_cluster'
 
-  def parse(args)
-  end
-
   def run(rule)
     rule.trigger_action(Wakame::Actions::ShutdownCluster.new)
   end
-
 end

data/lib/wakame/command/shutdown_vm.rb

@@ -0,0 +1,20 @@
+
+class Wakame::Command::ShutdownVm
+  include Wakame::Command
+
+  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))
+	}
+      else
+        raise "Service instances Launched"
+      end
+    end
+    rule.trigger_action(Wakame::Actions::ShutdownVM.new(registered_agents))
+  end
+end

data/lib/wakame/command/status.rb

@@ -4,78 +4,18 @@ require 'erb'
 class Wakame::Command::Status
   include Wakame::Command
 
-  STATUS_TMPL =<<__E__
-Cluster : <%= @service_cluster[:name].to_s %> (<%= @service_cluster[:status].to_s %>)
-<%- @service_cluster[:properties].each { |prop, v| -%>
-  <%= v[:type].to_s %> : <current=<%= v[:instance_count] %> min=<%= v[:min_instances] %>, max=<%= v[:max_instances] %>> 
-  <%- v[:instances].each { |id|
-         svc_inst = @service_cluster[:instances][id]
-  -%>
-     <%= svc_inst[:instance_id] %> (<%= trans_svc_status(svc_inst[:status]) %>)
-  <%- } -%>
-<%- } -%>
-<%- if @service_cluster[:instances].size > 0  -%>
-
-Instances :
-  <%- @service_cluster[:instances].each { |k, v| -%>
-  <%= v[:instance_id] %> : <%= v[:property] %> (<%= trans_svc_status(v[:status]) %>)
-    <%- if v[:agent_id ] -%>
-    On VM instance: <%= v[:agent_id ]%>
-    <%- end -%>
-  <%- } -%>
-<%- end -%>
-<%- if @agent_monitor[:registered].size > 0 -%>
-
-Agents :
-  <%- @agent_monitor[:registered].each { |a| -%>
-  <%= a[:agent_id] %> : <%= a[:attr][:local_ipv4] %>, <%= a[:attr][:public_ipv4] %> load=<%= a[:attr][:uptime] %>, <%= (Time.now - a[:last_ping_at]).to_i %> sec(s) <%= a[:root_path] %>(<%= a[:status] %>)
-    <%- if !a[:services].nil? && a[:services].size > 0 -%>
-    Services (<%= a[:services].size %>): <%= a[:services].collect{|id| @service_cluster[:instances][id][:property] }.join(', ') %>
-    <%- end -%>
-  <%- } -%>
-<%- end -%>
-__E__
-
-  SVC_STATUS_MSG={
-    Wakame::Service::STATUS_OFFLINE=>'Offline',
-    Wakame::Service::STATUS_ONLINE=>'ONLINE',
-    Wakame::Service::STATUS_UNKNOWN=>'Unknown',
-    Wakame::Service::STATUS_FAIL=>'Fail',
-    Wakame::Service::STATUS_STARTING=>'Starting...',
-    Wakame::Service::STATUS_STOPPING=>'Stopping...',
-    Wakame::Service::STATUS_RELOADING=>'Reloading...',
-    Wakame::Service::STATUS_MIGRATING=>'Migrating...',
-  }
-  
-  def parse(args)
-  end
-
   def run(rule)
-    EM.barrier {
+   EM.barrier {
       master = rule.master
       
-      sc = master.service_cluster
-      #result = {
-      #  :rule_engine => {
-      #    :rules => sc.rule_engine.rules
-      #  },
-      #  :service_cluster => sc.dump_status,
-      #  :agent_monitor => master.agent_monitor.dump_status
-      #}
-
       @service_cluster = master.service_cluster.dump_status
       @agent_monitor = master.agent_monitor.dump_status
+      res = {
+        :service_cluster => @service_cluster,
+        :agent_monitor => @agent_monitor
+      }
+      res
     }
-  end
-  
-  def print_result
-    puts ERB.new(STATUS_TMPL, nil, '-').result(binding)
-  end
-
 
-  private
-  def trans_svc_status(stat)
-    SVC_STATUS_MSG[stat]
   end
-  
 end

data/lib/wakame/command/stop_service.rb

@@ -0,0 +1,31 @@
+class Wakame::Command::StopService
+  include Wakame::Command
+
+  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
+       }
+     }
+    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))
+      }
+    end
+  end
+end

data/lib/wakame/command.rb

@@ -17,6 +17,9 @@ module Wakame
       }
     end
 
+    def options=(path)
+      @options = path
+    end
 
     def parse(args)
     end

data/lib/wakame/command_queue.rb

@@ -1,6 +1,10 @@
 
-require 'drb/drb'
+require 'uri'
+require 'thin'
 require 'thread'
+require 'json'
+#require 'openssl'
+#require 'base64'
 
 module Wakame
   class CommandQueue
@@ -11,13 +15,15 @@ module Wakame
       @queue = Queue.new
       @result_queue = Queue.new
 
-      DRb.start_service(Wakame.config.drb_command_server_uri, self)
-      #@drb_server = DRb.start_drbserver(Wakame.config.drb_command_server_uri, self)
+      cmdsv_uri = URI.parse(Wakame.config.http_command_server_uri)
+
+      @thin_server = Thin::Server.new(cmdsv_uri.host, cmdsv_uri.port, Adapter.new(self))
+      @thin_server.threaded = true
+      @thin_server.start
     end
 
     def shutdown
-      DRb.stop_service()
-      #@drb_server.stop_service()
+      @thin_server.stop
     end
 
     def deq_cmd()
@@ -30,9 +36,13 @@ module Wakame
 
     def send_cmd(cmd)
       begin
+
         #cmd = Marshal.load(cmd)
+
         @queue.enq(cmd)
+
         ED.fire_event(Event::CommandReceived.new(cmd))
+
         return @result_queue.deq()
       rescue => e
         Wakame.log.error("#{self.class}:")
@@ -41,4 +51,65 @@ module Wakame
     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("_")
+        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 = 403
+        body = json_encode(status, e)
+      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"
+      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
+      end
+      body
+    end
+  end
 end

data/lib/wakame/configuration.rb

@@ -13,7 +13,7 @@ module Wakame
       :cluster_class => 'WebCluster',
       :load_paths => [],
       :ssh_private_key => nil,
-      :drb_command_server_uri => 'druby://localhost:12345',
+      :http_command_server_uri => 'http://localhost:3000',
       :amqp_server_uri => nil,
       :unused_vm_live_period => 60 * 10,
       :eventmachine_use_epoll => true
@@ -64,6 +64,11 @@ module Wakame
 
       paths.map{|dir| File.join(framework_root_path, dir) }.select{|path| File.directory?(path) }
     end
+
+    def project_paths
+      %w(lib).map{|dir| File.join(root_path, dir) }.select{|path| File.directory?(path)}
+    end
+
     # 
     class DefaultSet
       def process(config)

data/lib/wakame/event.rb

@@ -149,7 +149,7 @@ module Wakame
       end
 
       def log_message
-        "#{@action.class}"
+        "#{@action.class}, job_id=#{@action.job_id}"
       end
 
     end
@@ -170,11 +170,11 @@ module Wakame
       attr_reader :job_id
       def initialize(job_id)
         super()
-        @action = job_id
+        @job_id = job_id
       end
 
       def log_message
-        "#{@action.class}"
+        "#{@job_id}"
       end
     end
     class JobStart < JobEvent
@@ -220,11 +220,12 @@ module Wakame
     end
 
     class ActorComplete < Base
-      attr_reader :agent_id, :token, :status
-      def initialize(agent_id, token, status)
+      attr_reader :agent_id, :token, :status, :return_value
+      def initialize(agent_id, token, status, return_value)
         @agent_id = agent_id
         @token = token
         @status = status
+        @return_value = return_value
       end
     end