wakame 0.4.0

data/lib/wakame/command.rb

@@ -0,0 +1,31 @@
+
+module Wakame
+  module Command
+    class CommandArgumentError < StandardError; end
+
+    def self.included(klass)
+      klass.class_eval {
+        class << self
+          def command_name
+            @command_name ||= Util.snake_case(self.to_s.split('::').last)
+          end
+          
+          def command_name=(name)
+            @command_name=name
+          end
+        end
+      }
+    end
+
+
+    def parse(args)
+    end
+
+    def run(rule)
+    end
+
+    def print_result
+    end
+
+  end
+end

data/lib/wakame/command_queue.rb

@@ -0,0 +1,44 @@
+
+require 'drb/drb'
+require 'thread'
+
+module Wakame
+  class CommandQueue
+    attr_reader :master
+
+    def initialize(master)
+      @master = master
+      @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)
+    end
+
+    def shutdown
+      DRb.stop_service()
+      #@drb_server.stop_service()
+    end
+
+    def deq_cmd()
+      @queue.deq
+    end
+
+    def enq_result(res)
+      @result_queue.enq(res)
+    end
+
+    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}:")
+        Wakame.log.error(e)
+      end
+    end
+
+  end
+end

data/lib/wakame/configuration.rb

@@ -0,0 +1,93 @@
+
+
+require 'ostruct'
+
+module Wakame
+  # System wide configuration parameters
+  class Configuration < OpenStruct
+
+    PARAMS = {
+      #:config_template_root => nil,
+      #:config_tmp_root => nil,
+      :config_root => nil,
+      :cluster_class => 'WebCluster',
+      :load_paths => [],
+      :ssh_private_key => nil,
+      :drb_command_server_uri => 'druby://localhost:12345',
+      :amqp_server_uri => nil,
+      :unused_vm_live_period => 60 * 10,
+      :eventmachine_use_epoll => true
+    }
+
+    def initialize(env=WAKAME_ENV)
+      super(PARAMS)
+      if root_path.nil?
+        root_path = Object.const_defined?(:WAKAME_ROOT) ? WAKAME_ROOT : '../'
+      end
+
+      @root_path = root_path
+
+      self.class.const_get(env).new.process(self)
+    end
+
+    def environment
+      ::WAKAME_ENV.to_sym
+    end
+    alias :vm_environment :environment
+
+    def environment_path(key=environment)
+      File.expand_path("config/environments/#{Util.snake_case(key.to_s)}.rb", root_path)
+    end
+    
+    def root_path
+      ::WAKAME_ROOT
+    end
+
+    def tmp_path
+      File.join(root_path, 'tmp')
+    end
+
+    def ssh_known_hosts
+      File.join(self.config_root, "ssh", "known_hosts")
+    end
+
+    def config_tmp_root
+      File.join(self.config_root, "tmp")
+    end
+
+    def framework_root_path
+      defined?(::WAKAME_FRAMEWORK_ROOT) ? ::WAKAME_FRAMEWORK_ROOT : "#{root_path}/vendor/wakame"
+    end
+
+    def framework_paths
+      paths = %w(lib)
+
+      paths.map{|dir| File.join(framework_root_path, dir) }.select{|path| File.directory?(path) }
+    end
+    # 
+    class DefaultSet
+      def process(config)
+      end
+    end
+
+    class EC2 < DefaultSet
+      def process(config)
+        super(config)
+        config.config_root = File.join(config.root_path, 'tmp', 'config')
+
+        config.ssh_private_key = '/home/wakame/config/root.id_rsa'
+
+      end
+    end
+
+    class StandAlone < DefaultSet
+      def process(config)
+        super(config)
+        config.config_root = File.join(config.root_path, 'tmp', 'config')
+        config.amqp_server_uri = 'amqp://localhost/'
+      end
+    end
+
+  end
+
+end

data/lib/wakame/daemonize.rb

@@ -0,0 +1,96 @@
+
+
+require 'daemons/daemonize'
+require 'fileutils'
+
+module Process
+  # Returns +true+ the process identied by +pid+ is running.
+  def running?(pid)
+    Process.getpgid(pid) != -1
+  rescue Errno::ESRCH
+    false
+  end
+  module_function :running?
+end
+
+
+module Wakame
+  module Daemonize
+    # Change privileges of the process
+    # to the specified user and group.
+    def change_privilege(user, group=user)
+      Wakame.log.info("Changing process privilege to #{user}:#{group}")
+
+      uid, gid = Process.euid, Process.egid
+      target_uid = Etc.getpwnam(user).uid
+      target_gid = Etc.getgrnam(group).gid
+
+      if uid != target_uid || gid != target_gid
+        if pid_file && File.exist?(pid_file) && uid == 0
+          File.chown(target_uid, target_gid, pid_file)
+        end
+
+        # Change process ownership
+        Process.initgroups(user, target_gid)
+        Process::GID.change_privilege(target_gid)
+        Process::UID.change_privilege(target_uid)
+      end
+    rescue Errno::EPERM => e
+      Wakame.log.error("Couldn't change user and group to #{user}:#{group}: #{e}")
+    end
+
+    def pid_file
+      @options[:pid_file]
+    end
+
+    def pid
+      File.exist?(pid_file) ? open(pid_file).read.to_i : nil
+    end
+
+    def setup_pidfile
+      #raise 'Please implement pid_file() method' unless respond_to? :pid_file
+
+      unless File.exist?(File.dirname(pid_file))
+        FileUtils.mkpath(File.dirname(pid_file))
+      end
+
+      open(pid_file, "w") { |f| f.write(Process.pid) }
+      File.chmod(0644, pid_file)
+    end
+
+    def daemonize(log_path)
+      # Cleanup stale pidfile or prevent from multiple process running.
+      if File.exist?(pid_file)
+        if pid && Process.running?(pid)
+          raise "#{pid_file} already exists, seems like it's already running (process ID: #{pid}). " +
+            "Stop the process or delete #{pid_file}."
+        else
+          Wakame.log.info "Deleting the stale PID file: #{pid_file}"
+          remove_pidfile
+        end
+      end
+
+      ::Daemonize.daemonize(log_path, File.basename($0.to_s))
+
+      setup_pidfile
+      #Signal.trap('HUP') {}
+    end
+
+    def on_restart(&blk)
+      @on_restart = blk
+    end
+
+    def restart
+      raise '' if @on_restart.nil?
+
+      @on_restart.call
+    end
+    
+    def remove_pidfile
+      File.delete(pid_file) if pid_file && File.exists?(pid_file)
+    rescue => e
+      Wakame.log.error(e)
+    end
+    
+  end
+end

data/lib/wakame/event.rb

@@ -0,0 +1,232 @@
+require 'wakame/util'
+
+module Wakame
+  module Event
+    class Base
+      attr_accessor :time
+
+      def initialize
+        @time = Time.now
+      end
+
+      def log_message
+      end
+    end
+
+
+    class ClusterStatusChanged  < Base
+      attr_reader :instance_id, :status
+      def initialize(instance_id, status)
+        super()
+        @instance_id = instance_id
+        @status = status
+      end
+
+      def log_message
+        "#{instance_id}, #{@status}"
+      end
+
+    end
+
+    class ServiceStatus < Base
+      attr_reader :instance_id, :property
+      def initialize(instance_id, property)
+        super()
+        @instance_id = instance_id
+        @property = property
+      end
+    end
+
+    class ServiceStatusChanged < ServiceStatus
+      attr_reader :status, :previous_status
+      def initialize(instance_id, property, new_status, prev_status)
+        super(instance_id, property)
+        @status = new_status
+        @previous_status = prev_status
+      end
+
+      def log_message
+        "#{instance_id}, #{@previous_status} -> #{@status}"
+      end
+    end
+
+    class ServiceOnline < ServiceStatus
+    end
+    class ServiceOffline < ServiceStatus
+    end
+    class ServiceFailed < ServiceStatus
+      attr_reader :message
+      def initialize(instance_id, property, message)
+        super(instance_id, property)
+        @message = message
+      end
+    end
+
+    class AgentEvent < Base
+      attr_reader :agent
+      def initialize(agent)
+        super()
+        @agent = agent
+      end
+    end
+
+    class AgentPong < AgentEvent
+    end
+
+    class AgentTimedOut < AgentEvent
+    end
+    class AgentMonitored < AgentEvent
+    end
+    class AgentUnMonitored < AgentEvent
+    end
+    class AgentStatusChanged < AgentEvent
+    end
+
+
+    class ServiceUnboundAgent < Base
+      attr_reader :service, :agent
+      def initialize(service, agent)
+        super()
+        @service = service
+        @agent = agent
+      end
+    end
+    class ServiceBoundAgent < Base
+      attr_reader :service, :agent
+      def initialize(service, agent)
+        super()
+        @service = service
+        @agent = agent
+      end
+    end
+
+    class ServiceBoundCluster < Base
+      attr_reader :service, :service_cluster
+      def initialize(svc_inst, cluster)
+        super()
+        @service = svc_inst
+        @service_cluster = cluster
+      end
+    end
+
+    class ServiceUnboundCluster < Base
+      attr_reader :service, :service_cluster
+      def initialize(svc_inst, cluster)
+        super()
+        @service = svc_inst
+        @service_cluster = cluster
+      end
+    end
+
+    class ServiceDestroied < Base
+      attr_reader :service
+      def initialize(svc_inst)
+        super()
+        @service = svc_inst
+      end
+    end
+
+    class ServicePropagated < Base
+      attr_reader :service
+      def initialize(svc_inst)
+        super()
+        @service = svc_inst
+      end
+    end
+
+    class CommandReceived < Base
+      attr_reader :command
+      def initialize(command)
+        @command = command
+      end
+    end
+
+    class ActionEvent < Base
+      attr_reader :action
+      def initialize(action)
+        super()
+        @action = action
+      end
+
+      def log_message
+        "#{@action.class}"
+      end
+
+    end
+
+    class ActionStart < ActionEvent
+    end
+    class ActionComplete < ActionEvent
+    end
+    class ActionFailed < ActionEvent
+      attr_reader :exception
+      def initialize(action, e)
+        super(action)
+        @exception = e
+      end
+    end
+
+    class JobEvent < Base
+      attr_reader :job_id
+      def initialize(job_id)
+        super()
+        @action = job_id
+      end
+
+      def log_message
+        "#{@action.class}"
+      end
+    end
+    class JobStart < JobEvent
+    end
+    class JobComplete < JobEvent
+    end
+    class JobFailed < JobEvent
+      attr_reader :exception
+      def initialize(job_id, e)
+        super(job_id)
+        @exception = e
+      end
+    end
+    
+
+    class AgentShutdown < Base; end
+    class MasterShutdown < Base; end
+
+    class InstanceCountChanged < Base
+      attr_reader :resource, :prev_count, :count
+      def initialize(resource, prev_count, count)
+        @resource = resource
+        @prev_count = prev_count
+        @count = count
+      end
+
+      def increased?
+        @prev_count < @count
+      end
+
+      def decreased?
+        @prev_count > @count
+      end
+    end
+
+    class ActorProgress < Base
+      attr_reader :agent_id, :token, :progress
+      def initialize(agent_id, token, progress)
+        @agent_id = agent_id
+        @token = token
+        @progress  = progress
+      end
+    end
+
+    class ActorComplete < Base
+      attr_reader :agent_id, :token, :status
+      def initialize(agent_id, token, status)
+        @agent_id = agent_id
+        @token = token
+        @status = status
+      end
+    end
+
+  end
+end

data/lib/wakame/event_dispatcher.rb

@@ -0,0 +1,154 @@
+
+module Wakame
+  class EventDispatcher
+    class << self
+      
+      def instance
+        if @instance.nil?
+          @instance = self.new
+        end
+        @instance
+      end
+      
+      def subscribe(event_class, *args, &blk)
+        self.instance.subscribe(event_class, *args, &blk)
+      end
+
+      def unsubscribe(event_class)
+        self.instance.unsubscribe(event_class)
+      end
+
+
+      def fire_event(event_obj)
+        self.instance.fire_event(event_obj)
+      end
+
+      def reset
+        @instance = nil
+      end
+
+    end
+    
+    include ThreadImmutable
+
+    def initialize
+      @event_handlers = {}
+      @tickets = {}
+
+      @unsubscribe_queue = []
+    end
+
+    def subscribe(event_class, *args, &blk)
+      event_class = case event_class
+                    when Class
+                      event_class
+                    when String
+                      Util.str2const(event_class)
+                    else
+                      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
+
+        # Return in array if num of ticket to be returned is more than or equal 2.
+        tickets.size > 1 ? tickets : tickets.first
+      }
+    end
+
+    def unsubscribe(ticket)
+      unless @tickets.has_key?(ticket)
+        #Wakame.log.warn("EventHander.unsubscribe(#{ticket}) has been tried but the ticket was not registered.")
+        return nil
+      end
+      
+      EM.barrier {
+        Wakame.log.debug("#{self.class}.unsubscribe(#{ticket})")
+
+        @unsubscribe_queue << ticket
+        ticket
+      }
+    end
+    
+    def fire_event(event_obj)
+      raise ArgumentError unless event_obj.is_a?(Event::Base)
+      log_msg = ""
+      log_msg = " #{event_obj.log_message}" unless event_obj.log_message.nil?
+
+      Wakame.log.debug("Event #{event_obj.class} has been fired:" + log_msg )
+      tlist = @event_handlers[event_obj.class]
+      return if tlist.nil?
+
+      run_callbacks = proc {
+        @unsubscribe_queue.each { |t|
+          @tickets.delete(t)
+          tlist.delete(t)
+        }
+
+        tlist.each { |t|
+          ary = @tickets[t]
+          c = ary[1]
+          if c.nil?
+            next
+          end
+          
+          begin 
+            c.call(event_obj)
+          rescue => e
+            Wakame.log.error(e)
+            #raise e
+          end
+        }
+        
+        @unsubscribe_queue.each { |t|
+          @tickets.delete(t)
+          tlist.delete(t)
+        }
+      }
+    
+      #@handler_run_queue.push(run_handlers)
+      
+      ::EventMachine.barrier {
+        begin 
+          run_callbacks.call
+        rescue => e
+          Wakame.log.error(e)
+        end
+      }
+    end
+    
+    def reset(event_class=nil)
+      if event_class.nil?
+        @event_handlers.clear
+        @tickets.clear
+      else
+        unless @event_handlers[event_class.to_s].nil?
+          @event_handlers[event_class.to_s].each_key { |k|
+            @tickets.delete(k)
+          }
+          @event_handlers[event_class.to_s].clear
+        end
+      end
+    end
+    thread_immutable_methods :reset
+
+  end
+
+  ED = EventDispatcher
+end