wakame 0.4.0

data/lib/wakame/graph.rb

@@ -0,0 +1,79 @@
+
+module Wakame
+  
+  class Graph
+    
+    def initialize
+      @edges={}
+    end
+    
+    def add_edge(v, c)
+      return if v == c
+      add_vertex(v)
+      add_vertex(c)
+      @edges[v][c]=1
+    end
+
+    def remove_edge(v, c)
+      @edges[v].delete(c)
+    end
+
+    def has_edge?(v, c)
+      @edges.has_key?(v) && @edges[v].has_key?(c)
+    end
+
+    def add_vertex(v)
+      @edges[v] ||= {}
+    end
+
+    def remove_vertex(v)
+      @edges.keys.each { |n|
+        n.delete(v)
+      }
+      @edges.delete(v)
+    end
+
+    def parents(v)
+      plist=[]
+      @edges.each { |n, c|
+        plist << n if c.has_key?(v)
+      }
+      plist
+    end
+
+    def children(v)
+      @edges[v].keys
+    end
+
+    def inspect
+      str="#{self}:"
+      str << @edges.keys.sort.collect { |v|
+        "#{v}=>#{@edges[v].keys.inspect}"
+      }.join(', ')
+      str
+    end
+
+
+    def level_layout(root)
+      @vtx_ylevels = {root=>0}
+
+      descend(root, 0)
+
+      ycoord=Array.new(@vtx_ylevels.values.max)
+      @vtx_ylevels.each { |v, lv|
+        (ycoord[lv] ||= []) << v
+      }
+      
+      ycoord
+    end
+
+    private
+    def descend(v, ylevel=0)
+      ylevel += 1
+      @edges[v].keys.each { |c|
+        @vtx_ylevels[c]=ylevel if @vtx_ylevels[c].nil? || @vtx_ylevels[c] < ylevel
+        descend(c, ylevel)
+      }
+    end
+  end
+end

data/lib/wakame/initializer.rb

@@ -0,0 +1,162 @@
+
+WAKAME_ENV = (ENV['WAKAME_ENV'] || 'StandAlone').dup.to_sym unless defined?(WAKAME_ENV)
+
+module Wakame
+  class Initializer
+
+    class << self
+      def run(command, configuration=Configuration.new)
+        @instance ||= new(configuration)
+        @instance.send(command)
+      end
+
+      def instance
+        @instance
+      end
+    end
+
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def process
+      setup_load_paths
+      setup_logger
+      load_environment
+    end
+
+    def process_master
+      process
+      load_cluster
+      load_resources
+      load_core_commands
+      load_core_actions
+      load_core_triggers
+    end
+    
+    def process_agent
+      process
+      load_actors
+    end
+    
+    def process_cli
+      process
+      load_core_commands
+    end
+
+    def setup_load_paths
+      load_paths = configuration.load_paths + configuration.framework_paths
+      load_paths.reverse_each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) }
+      $LOAD_PATH.uniq!
+
+      require 'wakame'
+    end
+
+    def setup_logger
+      require 'log4r'
+      Logger.log = begin
+                     #log = Logger.new((Wakame.root||Dir.pwd) / "log.log")
+                     out = ::Log4r::StdoutOutputter.new('stdout',
+                                                        :formatter => Log4r::PatternFormatter.new(
+                                                                                                  :pattern => "%d %C [%l]: %M",
+                                                                                                  :date_format => "%Y/%m/%d %H:%M:%S"
+                                                                                                  )
+                                                        )
+                     log = ::Log4r::Logger.new(File.basename($0.to_s))
+                     log.add(out)
+                     log
+                   end
+    end
+
+
+    def setup_system_actors
+    end
+
+    def load_system_monitors
+    end
+
+    def load_core_commands
+#       %w( cluster/commands ).each { |load_path|
+#         load_path = File.expand_path(load_path, configuration.root_path)
+#         matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
+#         Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+#           require file.sub(matcher, '\1')
+#         end
+#       }
+
+      $LOAD_PATH.each{ |d|
+        Dir.glob("#{d}/wakame/command/**/*.rb").each{ |f|
+          f =~ %r{(wakame/command/.+)\.rb\Z}
+          require "#{$1}"
+        }
+      }
+      
+      #%w(launch_cluster shutdown_cluster status action_status actor).each { |f|
+      #  require "wakame/command/#{f}"
+      #}
+    end
+
+
+    def load_environment
+      config = configuration
+      constants = self.class.constants
+
+      [:common, config.environment].each { |key|
+        eval(IO.read(config.environment_path(key)), binding, config.environment_path(key))
+      }
+
+      (self.class.constants - constants).each do |const|
+        Object.const_set(const, self.class.const_get(const))
+      end
+    end
+
+    def load_resources
+      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
+          Wakame.log.debug("Loading resource definition: #{file}")
+          load file
+        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
+      load_path = File.expand_path('cluster/actors', configuration.root_path)
+      Dir.glob("#{load_path}/*.rb").sort.each do |file|
+        if file =~ %r{\A#{Regexp.escape(load_path)}/([^/]+)\.rb\Z}
+          Wakame.log.debug("Loading Actor: #{file}")
+          load file
+        end
+      end
+    end
+
+    def load_core_triggers
+      $LOAD_PATH.each{ |d|
+        Dir.glob("#{d}/wakame/triggers/**/*.rb").each{ |f|
+          f =~ %r{(wakame/triggers/.+)\.rb\Z}
+          require "#{$1}"
+        }
+      }
+    end
+
+    def load_core_actions
+      $LOAD_PATH.each{ |d|
+        Dir.glob("#{d}/wakame/actions/**/*.rb").each{ |f|
+          f =~ %r{(wakame/actions/.+)\.rb\Z}
+          require "#{$1}"
+        }
+      }
+    end
+
+
+  end
+end

data/lib/wakame/instance_counter.rb

@@ -0,0 +1,78 @@
+module Wakame
+  class InstanceCounter
+    class OutOfLimitRangeError < StandardError; end
+    
+    include AttributeHelper
+    
+    def bind_resource(resource)
+      @resource = resource
+    end
+    
+    def resource
+      @resource
+    end
+    
+    def instance_count
+      raise NotImplementedError
+    end
+    
+    protected
+    def check_hard_limit(count=self.instance_count)
+      Range.new(@resource.min_instances, @resource.max_instances, true).include?(count)
+    end
+  end
+  
+  
+  class ConstantCounter < InstanceCounter
+    def initialize(resource)
+      @instance_count = 1
+      bind_resource(resource)
+    end
+    
+    def instance_count
+      @instance_count
+    end
+    
+    def instance_count=(count)
+      raise OutOfLimitRangeError unless check_hard_limit(count)
+      if @instance_count != count
+        prev = @instance_count
+        @instance_count = count
+        ED.fire_event(Event::InstanceCountChanged.new(@resource, prev, count))
+      end
+    end
+  end
+  
+  class TimedCounter < InstanceCounter
+    def initialize(seq, resource)
+      @sequence = seq
+      bind_resource(resource)
+      @timer = Scheduler::SequenceTimer.new(seq)
+      @timer.add_observer(self)
+      @instance_count = 1
+    end
+    
+    def instance_count
+      @instance_count
+    end
+    
+    def update(*args)
+      new_count = args[0]
+      if @instance_count != count
+        prev = @instance_count
+        @instance_count = count
+        ED.fire_event(Event::InstanceCountChanged.new(@resource, prev, count))
+      end
+      #if self.min > new_count || self.max < new_count
+      #if self.min != new_count || self.max != new_count
+      #  prev_min = self.min
+      #  prev_max = self.max
+      
+      #  self.max = self.min = new_count
+      #  ED.fire_event(Event::InstanceCountChanged.new(@resource, prev_min, prev_max, self.min, self.max))
+      #end
+      
+    end
+  end
+
+end

data/lib/wakame/logger.rb

@@ -0,0 +1,12 @@
+
+module Wakame
+  module Logger
+    def self.log
+      @log
+    end
+
+    def self.log=(log)
+      @log = log
+    end
+  end
+end

data/lib/wakame/manager/commands.rb

@@ -0,0 +1,134 @@
+
+module Wakame
+  module Manager
+    module Commands
+
+      class Nop
+      end
+
+      class ClusterLaunch
+      end
+
+      class ClusterShutdown
+      end
+      
+      class DeployConfig
+        attr_reader :property
+        def initialize(prop=nil)
+          @property = prop
+        end
+      end
+
+      class PropagateService
+        attr_reader :property
+        def initialize(prop)
+          @property = prop
+        end
+      end
+
+      class MigrateService
+        attr_reader :service_instance, :agent
+        def initialize(svc_inst, agent=nil)
+          @service_instance = svc_inst
+          @agent = agent
+        end
+      end
+
+    end
+
+    class CommandDelegator
+
+      attr_reader :command_queue
+      def initialize(command_queue)
+        @command_queue = command_queue
+      end
+
+      def nop
+        @command_queue.send_cmd(Commands::Nop.new)
+      end
+      
+      def launch_cluster
+        @command_queue.send_cmd(Commands::ClusterLaunch.new)
+      end
+
+      def shutdown_cluster
+        @command_queue.send_cmd(Commands::ClusterShutdown.new)
+      end
+      def propagate_service(prop_name)
+        prop = nil
+        prop = master.service_cluster.properties[prop_name.to_s]
+        if prop.nil?
+          raise "UnknownProperty: #{prop_name}" 
+        end
+
+        @command_queue.send_cmd(Commands::PropagateService.new(prop))
+      end
+      def migrate_service(svc_inst_id, agent_id=nil)
+        svc = master.service_cluster.instances[svc_inst_id]
+        if svc.nil?
+          raise "Unknown Service Instance: #{svc_inst_id}" 
+        end
+        agent = nil
+        if agent_id
+          agent = master.agent_monitor.agents.has_key?(agent_id)
+          if agent.nil?
+            raise "Unknown Agent: #{agent_id}" 
+          end
+        end
+
+        @command_queue.send_cmd(Commands::MigrateService.new(svc, agent))
+      end
+      def deploy_config(prop_name=nil)
+        prop = nil
+        @command_queue.send_cmd(Commands::DeployConfig.new)
+      end
+
+      def status
+        EM.barrier {
+          master = Master.instance
+          
+          sc = master.service_cluster
+          result = {
+            :rule_engine => {
+              :rules => sc.rule_engine.rules
+            },
+            :service_cluster => sc.dump_status,
+            :agent_monitor => master.agent_monitor.dump_status
+          }
+          result
+        }
+      end
+
+      def action_status
+        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 = {}
+          Master.instance.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)
+          }
+
+          result
+        }
+      end
+
+
+      private
+      def master
+        command_queue.master
+      end
+
+    end
+
+  end
+end