wakame 0.4.0

data/lib/wakame/agent.rb

@@ -0,0 +1,226 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+
+require 'eventmachine'
+require 'mq'
+require 'thread'
+
+require 'wakame'
+require 'wakame/amqp_client'
+require 'wakame/queue_declare'
+require 'wakame/event'
+require 'wakame/vm_manipulator'
+
+
+module Wakame
+  class Agent
+    include AMQPClient
+    include QueueDeclare
+
+    #define_queue 'agent_command.%{agent_id}', 'agent_command', {:key=>'agent_id.%{agent_id}', :auto_delete=>true}
+    define_queue 'agent_actor.%{agent_id}', 'agent_command', {:key=>'agent_id.%{agent_id}', :auto_delete=>true}
+
+    attr_reader :actor_registry, :monitor_registry
+
+    def agent_id
+      @agent_id
+    end
+
+    def initialize(opts={})
+      determine_agent_id
+      @actor_registry = ActorRegistry.new
+      @monitor_registry = MonitorRegistry.new
+
+      connect(opts)
+
+      setup_monitors
+      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}")
+    end
+
+#     def send_event_response(event)
+#       Wakame.log.debug("Sending event to master : #{event.class}")
+#       publish_to('agent_event', Marshal.dump(Packets::EventResponse.new(self, event)))
+#     end
+
+    def cleanup
+      publish_to('registry', Packets::UnRegister.new(self).marshal)
+      #@cmd_t.kill
+    end
+
+    def determine_agent_id
+      if Wakame.config.environment == :EC2
+        @agent_id = VmManipulator::EC2::MetadataService.query_metadata_uri('instance-id')
+      else
+        @agent_id = VmManipulator::StandAlone::INSTANCE_ID
+      end
+    end
+
+
+    def setup_monitors
+      load_monitors
+
+      @monitor_registry.register(Monitor::Agent.new, '/agent')
+      @monitor_registry.register(Monitor::Service.new, '/service')
+      
+      @monitor_registry.monitors.each { |path, mon|
+        mon.agent = self
+        mon.setup(path)
+      }
+    end
+
+    def load_monitors
+      require 'wakame/monitor/agent'
+      require 'wakame/monitor/service'
+    end
+
+    def setup_actors
+      load_actors
+
+      @actor_registry.register(Actor::ServiceMonitor.new, '/service_monitor')
+      @actor_registry.register(Actor::Daemon.new, '/daemon')
+      @actor_registry.register(Actor::System.new, '/system')
+      @actor_registry.actors.each { |path, actor|
+#        actor.setup(path)
+        actor.agent = self
+      }
+    end
+    
+    def load_actors
+      require 'wakame/actor/service_monitor'
+      require 'wakame/actor/daemon'
+      require 'wakame/actor/system'
+    end
+
+
+    def setup_dispatcher
+      @dispatcher = Dispatcher.new(self)
+      
+      add_subscriber("agent_actor.#{agent_id}") { |data|
+        begin 
+          request = eval(data)
+          @dispatcher.handle_request(request)
+        rescue => e
+          Wakame.log.error(e)
+          agent.publish_to('agent_event', Packets::ActorResponse.new(self, request[:token], Actor::STATUS_FAILED).marshal)
+        end
+      }
+    end
+
+  end
+
+
+  class ActorRegistry
+    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
+      
+      @actors[path] = actor
+    end
+
+    def unregister(path)
+      @actors.delete(path)
+    end
+
+    def find_actor(path)
+      @actors[path]
+    end
+
+  end
+
+
+  class MonitorRegistry
+    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
+      
+      @monitors[path] = monitor
+    end
+
+    def unregister(path)
+      @monitors.delete(path)
+    end
+
+    def find_monitor(path)
+      @monitors[path]
+    end
+  end
+
+
+  class Dispatcher
+    attr_reader :agent
+
+    def initialize(agent)
+      @agent = agent
+    end
+
+    def handle_request(request)
+      slash = request[:path].rindex('/')
+      raise "Invalid request path: #{request[:path]}" unless slash
+
+      prefix = request[:path][0, slash]
+      action = request[:path][slash+1, request[:path].length]
+
+      actor = agent.actor_registry.find_actor(prefix)
+      unless actor
+        Wakame.log.error("No refered actor instance: #{prefix}")
+        raise
+      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
+               }, proc { |res|
+                 status = Actor::STATUS_SUCCESS
+                 if res.is_a?(Exception)
+                   status = Actor::STATUS_FAILED
+                 end
+                 agent.publish_to('agent_event', Packets::ActorResponse.new(self.agent, request[:token], status).marshal)
+               })
+    end
+  end
+  
+
+end 

data/lib/wakame/amqp_client.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/ruby
+
+require 'mutex_m'
+
+require 'eventmachine'
+require 'ext/eventmachine'
+require 'amqp'
+require 'mq'
+
+module Wakame
+  module AMQPClient
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.class_eval {
+      }
+    end
+    
+    module ClassMethods
+      attr_reader :instance
+      attr_reader :defered_setup_calls
+
+      def start(*opts)
+        pr = proc {
+          if self.instance.nil?
+            @instance = new(*opts)
+          end
+          @instance
+        }
+        
+        if EM.reactor_running?
+          return pr.call
+        else
+          EM.run pr
+        end
+      end
+      
+      
+      def stop(&blk)
+        #EM.add_timer(1){
+        EM.next_tick {
+          end_proc = proc {
+            EventDispatcher.reset
+
+            unless blk.nil?
+              blk.call
+            end
+            EM.stop
+          }
+
+          catch(:nop) {
+          if @instance.nil?
+            end_proc.call
+            throw :nop
+          end
+            
+          begin
+            unless @instance.amqp_client.nil?
+              @instance.close { end_proc.call }
+            else
+              end_proc.call
+            end
+          ensure
+            @instance = nil
+          end
+          }
+        }
+      end
+      
+      def amq
+        Thread.current[:mq]
+      end
+
+      def publish_to(*args)
+        self.instance.publish_to(*args)
+      end
+
+      def add_subscriber(*args)
+        self.instance.add_subscriber(*args)
+      end
+
+      def define_exchange(name, type=:fanout)
+        def_ex = proc { |inst|
+          inst.amq.__send__(type, name)
+        }
+
+        (@defered_setup_calls ||= []) << def_ex
+        
+        #if !@instance.nil? && @instance.connected?
+        #  def_ex.call(@instance)
+        #end
+      end
+      
+      def define_queue(name, exchange_name, opts={})
+        def_q = proc { |inst|
+          inst.define_queue(name, exchange_name, opts)
+        }
+
+        (@defered_setup_calls ||= []) << def_q
+
+        #if !@instance.nil? && @instance.connected?
+        #  def_q.call(@instance)
+        #end
+      end
+
+    end
+
+    attr_reader :mq, :amqp_client
+    
+    def connect(*args)
+      close() unless connected?
+      @amqp_client = AMQP.connect(*args)
+      @mq = Thread.current[:mq] = MQ.new(@amqp_client)
+
+      run_defered_callbacks
+      yield if block_given?
+    end
+
+    def connected?
+      !@amqp_client.nil?
+    end
+
+    def amq
+      raise 'AMQP connection is not established yet' if Thread.current[:mq].nil?
+      Thread.current[:mq]
+    end
+
+    def cleanup
+    end
+
+    def close(&blk)
+      closing_proc = proc {
+        begin
+          cleanup
+          yield if block_given?
+        ensure
+          @amqp_client = nil
+          @mq = Thread.current[:mq] = nil
+        end
+      }
+
+      @amqp_client.close {
+        closing_proc.call
+      } unless @amqp_client.nil?
+    end
+
+    #
+    # When you want to broadcast the data to all bound queues:
+    #  publish_to('exchange name', 'data')
+    #  publish_to('exchange name', '*', 'data')
+    # When you want to send the data to keyed  queue(s):
+    #  publish_to('exchange name', 'group.1', 'data')
+    def publish_to(name, *args)
+      publish_proc = proc {
+        ex = amq.exchanges[name] || raise("Undefined exchange name : #{name}")
+        case ex.type
+        when :topic
+          if args.size == 1
+            key = '*'
+            data = args[0]
+          else
+            key = args[0].to_s
+            data = args[1]
+          end
+        else
+          data = args[0]
+        end
+        ex.publish(data, :key=>key)
+      }
+
+      if Thread.current[:mq].nil?
+        EM.next_tick { publish_proc.call }
+      else
+        publish_proc.call
+      end
+    end
+
+    def define_queue(name, exchange_name, opts={})
+      name = instance_eval('"' + name.gsub(/%\{/, '#{') + '"')
+      opts.each { |k,v|
+        if v.is_a? String
+          opts[k] = instance_eval('"' + v.gsub(/%\{/, '#{') + '"')
+        end
+      }
+
+      @queue_subscribers ||= {}
+
+      q = amq.queue(name, opts)
+      q.bind( exchange_name, opts ).subscribe {|data|
+        unless queue_subscribers[name].nil?
+          queue_subscribers[name].each { |p|
+            p.call(data)
+          }
+        end
+      }
+    end
+
+    attr_reader :queue_subscribers
+
+    def add_subscriber(queue_name, &blk)
+      # @mq object can be used here as it is just for checing the member of defined queues.
+      raise "Undefined queue name : #{queue_name}" unless @mq.queues.has_key?(queue_name)
+      EM.barrier {
+        @queue_subscribers ||= {}
+        @queue_subscribers[queue_name] ||= []
+        
+        @queue_subscribers[queue_name] << blk
+      }
+    end
+
+    private
+    def run_defered_callbacks
+      self.class.defered_setup_calls.each { |p|
+        p.call(self)
+      }
+    end
+
+  end
+end

data/lib/wakame/command/action_status.rb

@@ -0,0 +1,62 @@
+
+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
+      unless a.subactions.empty?
+        res[:subactions] = a.subactions.collect { |s|
+          walk_subactions.call(s, level + 1)
+        }
+      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
+
+
+  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
+  end
+
+end

data/lib/wakame/command/actor.rb

@@ -0,0 +1,23 @@
+
+class Wakame::Command::Actor
+  include Wakame::Command
+
+  command_name='launch_cluster'
+
+  def parse(args)
+    raise "Not enugh number of arguments" if args.size < 2
+    @agent_id = args.shift
+    @path = args.shift
+    @args = *args
+  end
+
+  def run(rule)
+    request = rule.master.actor_request(@agent_id, @path, *@args).request
+    request
+  end
+
+
+  def print_result
+    
+  end
+end

data/lib/wakame/command/clone_service.rb

@@ -0,0 +1,12 @@
+
+class Wakame::Command::CloneService
+  include Wakame::Command
+
+  attr_reader :prop_name
+
+  def parser(args)
+    raise CommandArgumentError, "Property name has to be given " if args.size < 1
+    @prop_name = args.shift
+  end
+
+end

data/lib/wakame/command/launch_cluster.rb

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

data/lib/wakame/command/migrate_service.rb

@@ -0,0 +1,21 @@
+
+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]
+    if svc.nil?
+      raise "Unknown Service ID: #{@svc_id}" 
+    end
+
+    rule.trigger_action(Wakame::Actions::MigrateService.new(svc))
+  end
+
+end

data/lib/wakame/command/propagate_service.rb

@@ -0,0 +1,24 @@
+
+class Wakame::Command::PropagateService
+  include Wakame::Command
+
+  #command_name='launch_cluster'
+
+  def parse(args)
+    @resname = args.shift
+    @num = args.shift unless args.empty?
+  end
+
+  def run(rule)
+    prop = nil
+    prop = rule.service_cluster.properties[@resname.to_s]
+    if prop.nil?
+      raise "UnknownProperty: #{@resname}" 
+    end
+
+    @num ||= 1
+
+    rule.trigger_action(Wakame::Actions::PropagateInstances.new(prop, @num))
+  end
+
+end

data/lib/wakame/command/shutdown_cluster.rb

@@ -0,0 +1,15 @@
+
+
+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/status.rb

@@ -0,0 +1,81 @@
+
+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 {
+      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
+    }
+  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