wakame 0.4.0

data/lib/wakame/packets.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/ruby
+
+require 'wakame/agent'
+require 'wakame/util'
+
+module Wakame
+  module Packets
+    VERSION='0.4'
+
+    class ResponseBase
+      include AttributeHelper
+
+      attr_reader :agent_id, :responded_at
+      
+      def initialize(agent)
+        raise TypeError unless agent.respond_to?(:agent_id)
+
+        @agent_id = agent.agent_id.to_s
+        @responded_at = Time.now
+      end
+      protected :initialize
+
+      def marshal
+        dump_attrs.inspect
+      end
+      
+    end
+    
+    class RequestBase
+      include AttributeHelper
+
+      attr_reader :token, :requested_at
+
+      def initialize(token=nil)
+        @token = token || Util.gen_id
+        @requested_at = Time.now
+      end
+      protected :initialize
+
+      def marshal
+        dump_attrs.inspect
+      end
+    end
+    
+    class Ping < ResponseBase
+      attr_reader :attrs, :monitors, :actors, :services
+      def initialize(agent, attrs, actors, monitors, services)
+        super(agent)
+        @attrs = attrs
+        @actors = actors
+        @monitors = monitors
+        @services = services
+      end
+    end
+    
+
+    class Register < ResponseBase
+      attr_reader :root_path
+      def initialize(agent, root_path)
+        super(agent)
+        @root_path = root_path
+      end
+    end
+
+    class UnRegister < ResponseBase
+      def initialize(agent)
+        super(agent)
+      end
+    end
+
+    class MonitoringStarted < ResponseBase
+      attr_reader :svc_id
+      def initialize(agent, svc_id)
+        super(agent)
+        @svc_id = svc_id
+      end
+    end
+
+    class MonitoringStopped < ResponseBase
+      attr_reader :svc_id
+      def initialize(agent, svc_id)
+        super(agent)
+        @svc_id = svc_id
+      end
+    end
+    class MonitoringOutput < ResponseBase
+      attr_reader :svc_id, :outputs
+      def initialize(agent, svc_id, outputs)
+        super(agent)
+        @svc_id = svc_id
+        @outputs = outputs
+      end
+    end
+
+    class EventResponse < ResponseBase
+      attr_reader :event
+      def initialize(agent, event)
+        super(agent)
+        @event = event
+      end
+    end
+
+    class Nop < RequestBase
+    end
+
+#     class ServiceStart < RequestBase
+#       attr_reader :instance_id, :property
+#       def initialize(instance_id, property)
+#         @instance_id = instance_id
+#         @property = property
+#       end
+#     end
+
+#     class ServiceStop < RequestBase
+#       attr_reader :instance_id
+#       def initialize(instance_id)
+#         @instance_id = instance_id
+#       end
+#     end
+
+#     class ServiceReload < RequestBase
+#       attr_reader :instance_id
+#       def initialize(instance_id)
+#         @instance_id = instance_id
+#       end
+#     end
+
+    class ServiceStatusChanged < ResponseBase
+      attr_accessor :svc_id, :prev_status, :new_status, :fail_message
+      def initialize(agent, svc_id, prev_status, new_status, fail_message=nil)
+        super(agent)
+        @svc_id = svc_id
+        @prev_status = prev_status
+        @new_status = new_status
+        @fail_message = fail_message
+      end
+    end
+
+    class ActorRequest < RequestBase
+      attr_reader :agent_id, :token, :path, :args
+      def initialize(agent_id, token, path, *args)
+        super()
+        @agent_id = agent_id
+        @token = token
+        @path = path
+        @args = args
+      end
+    end
+
+    class ActorResponse < ResponseBase
+      attr_reader :agent_id, :token, :status
+      def initialize(agent, token, status)
+        super(agent)
+        @token = token
+        @status = status
+      end
+    end
+
+  end
+end

data/lib/wakame/queue_declare.rb

@@ -0,0 +1,14 @@
+
+
+module Wakame
+  module QueueDeclare
+    def self.included(klass)
+      klass.class_eval {
+        define_exchange 'registry', :fanout
+        define_exchange 'ping', :fanout
+        define_exchange 'agent_command', :topic
+        define_exchange 'agent_event', :fanout
+      }
+    end
+  end
+end

data/lib/wakame/rule.rb

@@ -0,0 +1,116 @@
+
+require 'thread'
+require 'forwardable'
+require 'timeout'
+
+require 'wakame/util'
+
+module Wakame
+  module Rule
+    module BasicActionSet
+      class Lock
+        def initialize
+          @mutex = Mutex.new
+          @cond = ConditionVariable.new
+        end
+
+        def signal
+          @mutex.synchronize {
+            @cond.signal
+          }
+        end
+
+        def wait(&blk)
+          if blk.nil?
+            i=0
+            blk = proc {
+              i += 1
+              i > 1 ? true : false
+            }
+          end
+          @mutex.synchronize {
+            @cond.wait(@mutex) while blk.call
+          }
+        end
+      end
+
+      class MockLock < Lock
+        def signal
+        end
+
+        def wait(&blk)
+        end
+      end
+
+
+      def wait_lock 
+        Lock.new
+      end
+
+      def start_instance(image_id, attr={})
+        Wakame.log.debug("#{self.class} called start_instance(#{image_id})")
+        
+        attr[:user_data] = "node=agent\namqp_server=amqp://#{master.attr[:local_ipv4]}/"
+        Wakame.log.debug("user_data: #{attr[:user_data]}")
+        vm_manipulator = VmManipulator.create
+        res = vm_manipulator.start_instance(image_id, attr)
+        inst_id = res[:instance_id]
+
+        wait_condition { | cond |
+          cond.wait_event(Event::AgentMonitored) { |event|
+            event.agent.attr[:instance_id] == inst_id
+          }
+          
+          cond.poll(5, 100) {
+            vm_manipulator.check_status(inst_id, :online)
+          }
+        }
+
+        inst_id
+      end
+
+      def self.deploy_configuration(service_instance)
+        Wakame.log.debug("Begin: #{self}.deploy_configuration(#{service_instance.property.class})")
+
+        begin
+          tmpl = Wakame::Template.new(service_instance)
+          tmpl.render_config
+          
+          agent = service_instance.agent
+          src_path = tmpl.tmp_basedir.dup
+          src_path.sub!('/$', '') if File.directory? src_path
+          
+          dest_path = File.expand_path("tmp/config/" + File.basename(tmpl.basedir), service_instance.agent.root_path)
+          Util.exec("rsync -e 'ssh -i #{Wakame.config.ssh_private_key} -o \"UserKnownHostsFile #{Wakame.config.ssh_known_hosts}\"' -au #{src_path}/ root@#{agent.agent_ip}:#{dest_path}")
+          #Util.exec("rsync -au #{src_path}/ #{dest_path}")
+          
+        ensure
+          tmpl.cleanup if tmpl
+        end
+
+        Wakame.log.debug("End: #{self}.deploy_configuration(#{service_instance.property.class})")
+      end
+
+      def test_agent_candidate(svc_prop, agent)
+        return false if agent.has_service_type?(svc_prop.class)
+        svc_prop.vm_spec.current.satisfy?(agent) 
+      end
+      # Arrange an agent for the paticular service instance from agent pool.
+      def arrange_agent(svc_prop)
+        agent = nil
+        agent_monitor.each_online { |ag|
+          if test_agent_candidate(svc_prop, ag)
+            agent = ag
+            break
+          end
+        }
+        agent = agent[1] if agent
+
+        agent
+      end
+
+    end
+
+
+  end      
+end

data/lib/wakame/rule_engine.rb

@@ -0,0 +1,202 @@
+
+require 'timeout'
+
+module Wakame
+  class CancelActionError < StandardError; end
+  class CancelBroadcast < StandardError; end
+  class GlobalLockError < StandardError; end
+
+  class RuleEngine
+    
+    FORWARD_ATTRS=[:command_queue, :agent_monitor, :service_cluster, :master]
+
+    attr_reader :triggers, :active_jobs
+
+    def master
+      service_cluster.master
+    end
+
+    def command_queue
+      master.command_queue
+    end
+
+    def agent_monitor
+      master.agent_monitor
+    end
+
+    def service_cluster
+      @service_cluster
+    end
+
+    def initialize(service_cluster, &blk)
+      @service_cluster = service_cluster
+      @triggers = []
+      
+      @active_jobs = {}
+      @job_history = []
+      @global_lock = nil
+      instance_eval(&blk) if blk
+    end
+
+    def register_trigger(trigger)
+      Wakame.log.debug("Registering trigger #{trigger.class}")
+      trigger.bind_engine(self)
+      trigger.register_hooks
+      @triggers << trigger
+    end
+
+    def create_job_context(trigger, root_action)
+      root_action.job_id = job_id = Wakame.gen_id
+
+      @active_jobs[job_id] = {
+        :job_id=>job_id,
+        :src_trigger=>trigger,
+        :create_at=>Time.now,
+        :start_at=>nil, 
+        :complete_at=>nil,
+        :root_action=>root_action,
+        :notes=>{}
+      }
+    end
+
+    def cancel_action(job_id)
+      job_context = @active_jobs[job_id]
+      if job_context.nil?
+        Wakame.log.warn("JOB ID #{job_id} was not running.")
+        return
+      end
+      
+      return if job_context[:complete_at]
+
+      root_act = job_context[:root_action]
+
+      walk_subactions = proc { |a|
+        if a.status == :running && (a.target_thread && a.target_thread.alive?) && a.target_thread != Thread.current
+          Wakame.log.debug "Raising CancelBroadcast exception: #{a.class} #{a.target_thread}(#{a.target_thread.status}), current=#{Thread.current}"
+          # Broadcast the special exception to all
+          a.target_thread.raise(CancelBroadcast, "It's broadcasted from #{a.class}")
+          # IMPORTANT: Ensure the worker thread to handle the exception.
+          #Thread.pass
+        end
+        a.subactions.each { |n|
+          walk_subactions.call(n)
+        }
+      }
+
+      begin
+        Thread.critical = true
+        walk_subactions.call(root_act)
+      ensure
+        Thread.critical = false
+        # IMPORTANT: Ensure the worker thread to handle the exception.
+        Thread.pass
+      end
+    end
+
+    def run_action(action)
+      job_context = @active_jobs[action.job_id]
+      raise "The job session is killed.: job_id=#{action.job_id}" if job_context.nil?
+
+      if action.acquire_lock
+        if @global_lock.nil?
+          @global_lock = action.job_id
+        else
+          unless @global_lock == action.job_id
+            raise GlobalLockError, "Global Lock is already acquired by the JobID: #{@global_lock}"
+          end
+        end
+      end
+
+      EM.next_tick {
+
+        begin
+          
+          if job_context[:start_at].nil?
+            job_context[:start_at] = Time.new
+            ED.fire_event(Event::JobStart.new(action.job_id))
+          end
+
+          EM.defer proc {
+            res = nil
+            begin
+              action.bind_thread(Thread.current)
+              action.status = :running
+              Wakame.log.debug("Start action : #{action.class.to_s} triggered by [#{action.trigger.class}]")
+              ED.fire_event(Event::ActionStart.new(action))
+              begin
+                action.run
+                action.completion_status = :succeeded
+                Wakame.log.debug("Complete action : #{action.class.to_s}")
+                ED.fire_event(Event::ActionComplete.new(action))
+              end
+            rescue CancelBroadcast => e
+              Wakame.log.info("Received cancel signal: #{e}")
+              action.completion_status = :canceled
+              begin
+                action.on_canceled
+              rescue => e
+                Wakame.log.error(e)
+              end
+              ED.fire_event(Event::ActionFailed.new(action, e))
+              res = e
+            rescue => e
+              Wakame.log.debug("Failed action : #{action.class.to_s} due to #{e}")
+              Wakame.log.error(e)
+              action.completion_status = :failed
+              begin
+                action.on_failed
+              rescue => e
+                Wakame.log.error(e)
+              end
+              ED.fire_event(Event::ActionFailed.new(action, e))
+              # Escalate the cancelation event to parents.
+              unless action.parent_action.nil?
+                action.parent_action.notify(e)
+              end
+              # Force to cancel the current job when the root action ignored the elevated exception.
+              if action === job_context[:root_action]
+                Wakame.log.warn("The escalated exception (#{e.class}) has reached to the root action (#{action.class}). Forcing to cancel the current job #{job_context[:job_id]}")
+                cancel_action(job_context[:job_id]) #rescue Wakame.log.error($!)
+              end
+              res = e
+            ensure
+              action.status = :complete
+              action.bind_thread(nil)
+            end
+
+            res
+          }, proc { |res|
+            unless @active_jobs.has_key?(job_context[:job_id])
+              next
+            end
+            
+            jobary = []
+            job_context[:root_action].walk_subactions {|a| jobary << a }
+            Wakame.log.debug(jobary.collect{|a| {a.class.to_s=>a.status}}.inspect)
+
+            if res.is_a?(Exception)
+              job_context[:exception]=res
+            end
+
+            if jobary.all? { |act| act.status == :complete }
+
+              if jobary.all? { |act| act.completion_status == :succeeded }
+                ED.fire_event(Event::JobComplete.new(action.job_id))
+              else
+                ED.fire_event(Event::JobFailed.new(action.job_id, res))
+              end
+
+              job_context[:complete_at]=Time.now
+              @job_history << job_context
+              @active_jobs.delete(job_context[:job_id])
+              @global_lock = nil
+            end
+          }
+        rescue => e
+          Wakame.log.error(e)
+        end
+      }
+    end
+
+  end
+end

data/lib/wakame/runner/administrator_command.rb

@@ -0,0 +1,112 @@
+
+require 'uri'
+require 'ext/uri'
+require 'optparse'
+
+require 'drb/drb'
+
+require 'erb'
+
+require 'wakame'
+#require 'wakame/util'
+
+$root_constants = Module.constants
+
+module Wakame
+  module Runner
+    class AdministratorCommand
+
+      attr_reader :options
+      
+      def initialize(args)
+        @args = args.dup
+        @options = {
+          :command_server_uri => Wakame.config.drb_command_server_uri
+        }
+      end
+      
+      def parse(args=@args)
+        args = args.dup
+        
+        comm_parser = OptionParser.new { |opts|
+          opts.banner = "Usage: wakameadm [options] command [options]"
+          
+          opts.separator ""
+          opts.separator "options:"
+          opts.on( "-s", "--server DrbURI", "command server" ) {|str| @options[:command_server_uri] = str }
+        }
+        
+        
+        comm_parser.order!(args)
+        @options.freeze
+        return parse_subcommand(args)
+      end
+      
+      def run
+        subcommand = parse
+        
+        begin
+          cmd_queue = DRbObject.new_with_uri(@options[:command_server_uri])
+          #res = cmd_queue.send_cmd(Marshal.dump(subcommand))
+          subcommand = cmd_queue.send_cmd(subcommand)
+          if subcommand.is_a? Exception
+            STDERR.puts subcommand
+            exit 1
+          end
+          #res = cmd_queue.send(subcommand.class.command_name)
+        rescue => e
+          STDERR.puts e
+          exit 1
+        end
+
+        subcommand.print_result
+      end
+      
+      private
+      
+      def parse_subcommand(args)
+        @subcmd = args.shift
+        if @subcmd.nil?
+          fail "Please pass a sub command." 
+        end
+
+        subcommands = {}
+        (Wakame::Command.constants - $root_constants).each { |c|
+          const = Util.build_const("Wakame::Command::#{c}")
+          if const.is_a?(Class)
+            cmdobj = nil
+            begin
+              cmdobj = const.new
+              raise '' unless cmdobj.kind_of?(Wakame::Command)
+            rescue => e
+              next
+            end
+
+            subcommands[cmdobj.class.command_name] = cmdobj
+          end
+        }
+
+        subcommand = subcommands[@subcmd]
+        fail "No such sub command: #{@subcmd}" if subcommand.nil?
+
+        subcommand.parse(args)
+        subcommand
+#         opt_parser = subcommand[:opt_parser]
+#         if opt_parser
+#           sub_parser = OptionParser.new &opt_parser
+#           sub_parser.order!(@tmp_args)
+#         end
+        
+#         left_parser = [:left_parser]
+#         if left_parser
+#           begin
+#             instance_eval(&left_parser)
+#           rescue CommandArgumentError => e
+#             fail e
+#           end
+#         end
+      end
+
+    end
+  end
+end

data/lib/wakame/runner/agent.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/ruby
+
+
+require 'amqp'
+
+require 'uri'
+require 'ext/uri'
+require 'optparse'
+
+module Wakame
+  module Runner
+    class Agent
+      include Wakame::Daemonize
+      
+      def initialize(argv)
+        @argv = argv.dup
+        
+        @options = {
+          :amqp_server => URI.parse('amqp://guest@localhost/'),
+          :log_file => '/var/log/wakame-agent.log',
+          :pid_file => '/var/run/wakame/wakame-agent.pid',
+          :daemonize => true
+        }
+        
+        parser.parse! @argv
+      end
+      
+      
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: agent [options]"
+          
+          opts.separator ""
+          opts.separator "Agent options:"
+          opts.on( "-p", "--pid PIDFILE", "pid file path" ) {|str| @options[:pid_file] = str }
+          opts.on( "-s", "--server AMQP_URI", "amqp server" ) {|str|
+            begin 
+              @options[:amqp_server] = URI.parse(str)
+            rescue URI::InvalidURIError => e
+              fail "#{e}"
+            end
+          }
+          opts.on("-X", "", "daemonize flag" ) { @options[:daemonize] = false }
+          
+        end
+
+
+      end
+
+      
+      def run
+        %w(QUIT INT TERM).each { |i|
+          Signal.trap(i) { Wakame::Agent.stop{ remove_pidfile } }
+        }
+
+        unless @options[:amqp_server].nil?
+          uri = @options[:amqp_server]
+          default = ::AMQP.settings
+          opts = {:host => uri.host, 
+            :port => uri.port || default[:port],
+            :vhost => uri.vhost || default[:vhost],
+            :user=>uri.user || default[:user],
+            :pass=>uri.password ||default[:pass]
+          }
+        else
+          opts = nil
+        end
+        
+        if @options[:daemonize]
+          daemonize(@options[:log_file])
+        end
+
+        EM.epoll if Wakame.config.eventmachine_use_epoll
+        EM.run {
+          Wakame::Agent.start(opts)
+        }
+      end
+
+    end
+  end
+end