wakame 0.4.0

data/lib/wakame/template.rb

@@ -0,0 +1,189 @@
+
+require 'fileutils'
+require 'erb'
+
+module Wakame
+  class Template
+    attr_accessor :service_instance
+    attr_reader :tmp_basedir
+
+    def initialize(service_instance)
+      @service_instance = service_instance
+      @tmp_basedir = File.expand_path(Util.gen_id, File.join(Wakame.config.root_path, 'tmp', 'config') )
+      FileUtils.mkdir_p @tmp_basedir
+    end
+
+    def basedir
+      @service_instance.resource.basedir
+    end
+
+    def render_config
+      service_instance.property.render_config(self)
+    end
+
+    def cleanup
+      FileUtils.rm_r( @tmp_basedir, :force=>true)
+    end
+
+    def render(args)
+      args = [args] if args.is_a? String
+      
+      args.each { |path|
+        update(path) { |buf|
+          ERB.new(buf, nil, '-').result(service_instance.export_binding)
+        }
+      }
+    end
+
+    def cp(args)
+      args = [args] if args.is_a? String
+      args.each { |fname|
+
+        destpath = File.expand_path(fname, @tmp_basedir)
+        FileUtils.mkpath(File.dirname(destpath)) unless File.directory?(File.dirname(destpath))
+
+        FileUtils.cp_r(File.join(basedir, fname),
+                       destpath,
+                       {:preserve=>true}
+                       )
+      }
+    end
+
+    def chmod(fname, mode)
+      File.chmod(mode, File.join(@tmp_basedir, fname))
+    end
+
+    def load(path)
+      path = path.sub(/^\//, '')
+      
+      return File.readlines(File.expand_path(path, basedir), "r").join('')
+    end
+    
+    def save(path, buf)
+      path = path.sub(/^\//, '')
+      
+      destpath = File.expand_path(path, @tmp_basedir)
+      FileUtils.mkpath(File.dirname(destpath)) unless File.directory?(File.dirname(destpath))
+      
+      File.open(destpath, "w", 0644) { |f|
+        f.write(buf)
+      }
+    end
+    
+    def update(path, &blk)
+      buf = load(path)
+      buf = yield buf if block_given?
+      save(path, buf)
+    end
+    
+  end
+
+  module Template2
+    class Base
+      attr_reader :tmp_output_basedir
+      
+      def initialize()
+      end
+
+
+      def pre_render
+        @tmp_output_basedir = File.expand_path(Util.gen_id, Wakame.config.config_tmp_root)
+        FileUtils.mkdir_p @tmp_output_basedir
+      end
+
+      def render(service_instance)
+      end
+
+      def post_render
+        
+      end
+
+      # Returns source path which to be synced to the agent host
+      def sync_src
+      end
+
+
+      def load(path)
+        path = path.sub(/^\//, '')
+
+        return File.readlines(File.expand_path(path, Wakame.config.config_template_root), "r").join('')
+      end
+      
+      def save(path, buf)
+        path = path.sub(/^\//, '')
+
+        destpath = File.expand_path(path, @tmp_output_basedir)
+        FileUtils.mkpath(File.dirname(destpath)) unless File.directory?(File.dirname(destpath))
+
+        File.open(destpath, "w", 0644) {|f|
+          f.write(buf)
+        }
+      end
+      
+      def update(path, &blk)
+        buf = load(path)
+        buf = yield buf if block_given?
+        save(path, buf)
+      end
+
+
+    end
+
+    class MySQLTemplate  < Base
+      def render(service_instance)
+        require 'erb'
+        
+        FileUtils.mkpath File.expand_path('mysql', tmp_output_basedir)
+
+        ["mysql/my.cnf"].each { |path|
+          update(path) { |buf|
+            ERB.new(buf, nil, '-').result service_instance.export_binding
+          }
+        }
+      end
+
+      
+      def sync_src
+        File.join(@tmp_output_basedir, 'mysql')
+      end
+    end
+
+    class ApacheTemplate  < Base
+      attr_accessor :suffix
+
+      def initialize(suffix)
+        super()
+        @suffix = suffix
+      end
+      
+      def render(service_instance)
+#p service_instance.service_cluster.virtual_hosts
+        require 'erb'
+        
+        FileUtils.mkpath File.expand_path('apache2', tmp_output_basedir)
+
+        ["envvars-#{@suffix}", "apache2.conf"].each { |fname|
+          FileUtils.cp_r(File.join(Wakame.config.config_template_root, "apache2/#{fname}"),
+                         File.join(tmp_output_basedir, "apache2/#{fname}"),
+                         {:preserve=>true})
+        }
+
+        ["apache2/system-#{@suffix}.conf", "apache2/sites-#{@suffix}.conf"].each { |path|
+          update(path) { |buf|
+            ERB.new(buf, nil, '-').result service_instance.export_binding
+          }
+        }
+      end
+
+      
+      def sync_src
+        File.join(@tmp_output_basedir, 'apache2')
+      end
+      
+    end
+
+
+  end
+
+  
+end

data/lib/wakame/trigger.rb

@@ -0,0 +1,66 @@
+module Wakame
+  class Trigger
+    include FilterChain
+    include AttributeHelper
+
+    def_attribute :enabled, true
+
+    attr_reader :rule_engine
+    def command_queue
+      @rule_engine.command_queue
+    end
+
+    def service_cluster
+      @rule_engine.service_cluster
+    end
+
+    def master
+      @rule_engine.master
+    end
+
+    def agent_monitor
+      @rule_engine.agent_monitor
+    end
+
+    def bind_engine(rule_engine)
+      @rule_engine = rule_engine
+    end
+
+    def trigger_action(action)
+      found = rule_engine.active_jobs.find { |id, job|
+        job[:src_rule].class == self.class
+      }
+
+      if found
+        Wakame.log.warn("#{self.class}: Exisiting Job \"#{found[:job_id]}\" was kicked from this rule and it's still running. Skipping...")
+        raise CancelActionError
+      end
+
+      rule_engine.create_job_context(self, action)
+      action.bind_triggered_rule(self)
+      
+      rule_engine.run_action(action)
+      action.job_id
+    end
+
+    def register_hooks
+    end
+
+    def cleanup
+    end
+
+    protected
+    def event_subscribe(event_class, &blk)
+      EventDispatcher.subscribe(event_class) { |event|
+        begin
+          run_filter(self)
+          blk.call(event) if self.enabled 
+        rescue => e
+          Wakame.log.error(e)
+        end
+      }
+    end
+
+  end
+
+end

data/lib/wakame/triggers/instance_count_update.rb

@@ -0,0 +1,45 @@
+module Wakame
+  module Triggers
+    class InstanceCountUpdate < Trigger
+      append_filter { |rule|
+        rule.service_cluster.status == Service::ServiceCluster::STATUS_ONLINE
+      }
+
+      def register_hooks
+        @instance_counters = {}
+        ms = Scheduler::PerHourSequence.new
+        #ms[0]=1
+        #ms[30]=5
+        ms[0]=1
+        ms["0:2:00"]=4
+        ms["0:5:00"]=1
+        ms["0:9:00"]=4
+        ms["0:13:00"]=1
+        ms["0:17:00"]=4
+        ms["0:21:00"]=1
+        ms["0:25:00"]=1
+        ms["0:29:00"]=1
+        ms["0:33:00"]=4
+        #ms["0:37:00"]=1
+        #ms["0:41:00"]=4
+        ms["0:45:00"]=1
+        ms["0:49:00"]=4
+        ms["0:53:00"]=1
+        ms["0:57:00"]=4
+        # @instance_counters[Apache_APP.to_s] = TimedCounter.new(Scheduler::LoopSequence.new(ms), self)
+
+        event_subscribe(Event::InstanceCountChanged) { |event|
+          next if service_cluster.status == Service::ServiceCluster::STATUS_OFFLINE
+
+          if event.increased?
+            Wakame.log.debug("#{self.class}: trigger PropagateInstancesAction.new(#{event.resource.class})")
+            trigger_action(Actions::PropagateInstancesAction.new(event.resource))
+          elsif event.decreased?
+            Wakame.log.debug("#{self.class}: trigger DestroyInstancesAction.new(#{event.resource.class})")
+            trigger_action(Actions::DestroyInstancesAction.new(event.resource))
+          end
+        }
+      end
+    end
+  end
+end

data/lib/wakame/triggers/load_history.rb

@@ -0,0 +1,107 @@
+
+module Wakame
+  module Triggers
+    class LoadHistoryMonitor < Trigger
+      class AgentLoadHighEvent < Wakame::Event::Base
+        attr_reader :agent, :load_avg
+        def initialize(agent, load_avg)
+          super()
+          @agent = agent
+          @load_avg = load_avg
+        end
+      end
+      class AgentLoadNormalEvent < Wakame::Event::Base
+        attr_reader :agent, :load_avg
+        def initialize(agent, load_avg)
+          super()
+          @agent = agent
+          @load_avg = load_avg
+        end
+      end
+      class ServiceLoadHighEvent < Wakame::Event::Base
+        attr_reader :service_property, :load_avg
+        def initialize(svc_prop, load_avg)
+          super()
+          @service_property = svc_prop
+          @load_avg = load_avg
+        end
+      end
+      class ServiceLoadNormalEvent < Wakame::Event::Base
+        attr_reader :service_property, :load_avg
+        def initialize(svc_prop, load_avg)
+          super()
+          @service_property = svc_prop
+          @load_avg = load_avg
+        end
+      end
+
+      def initialize
+        @agent_data = {}
+        @service_data = {}
+        @high_threashold = 1.2
+        @history_period = 3
+      end
+      
+      def register_hooks
+        event_subscribe(Event::AgentMonitored) { |event|
+          @agent_data[event.agent.agent_id]={:load_history=>[], :last_event=>:normal}
+          service_cluster.properties.each { |klass, prop|
+            @service_data[klass] ||= {:load_history=>[], :last_event=>:normal}
+          }
+        }
+        event_subscribe(Event::AgentUnMonitored) { |event|
+          @agent_data.delete(event.agent.agent_id)
+        }
+
+        event_subscribe(Event::AgentPong) { |event|
+          calc_load(event.agent)
+        }
+      end
+
+      private
+      def calc_load(agent)
+        data = @agent_data[agent.agent_id] || next
+        data[:load_history] << agent.attr[:uptime]
+        Wakame.log.debug("Load History for agent \"#{agent.agent_id}\": " + data[:load_history].inspect )
+        detect_threadshold(data, proc{
+                             ED.fire_event(AgentLoadHighEvent.new(agent, data[:load_history][-1]))
+                           }, proc{
+                             ED.fire_event(AgentLoadNormalEvent.new(agent, data[:load_history][-1]))
+                           })
+        
+#         service_cluster.services.each { |id, svc|
+#           next unless agent.services.keys.include? id
+#           data = @service_data[svc.property.class.to_s] || next
+
+#           data[:load_history] << agent.attr[:uptime]
+#           Wakame.log.debug("Load History for service \"#{svc.property.class}\": " + data[:load_history].inspect )
+#           detect_threadshold(data, proc{
+#                                ED.fire_event(ServiceLoadHighEvent.new(svc.property, data[:load_history][-1]))
+#                              }, proc{
+#                                ED.fire_event(ServiceLoadNormalEvent.new(svc.property, data[:load_history][-1]))
+#                              })
+#         }
+
+      end
+
+      def detect_threadshold(data, when_high, when_low)
+        hist = data[:load_history]
+        if hist.size >= @history_period
+
+          all_higher = hist.all? { |h| h > @high_threashold }
+
+          if data[:last_event] == :normal && all_higher
+            when_high.call
+            data[:last_event] = :high
+          end
+          if data[:last_event] == :high && !all_higher
+            when_low.call
+            data[:last_event] = :normal
+          end
+        end
+        hist.shift while hist.size > @history_period
+      end
+
+    end
+  end
+end

data/lib/wakame/triggers/maintain_ssh_known_hosts.rb

@@ -0,0 +1,43 @@
+module Wakame
+  module Triggers
+    class MaintainSshKnownHosts < Trigger
+      class UpdateKnownHosts < Action
+        require 'fileutils'
+
+        def run
+          host_keys = []
+          ['/etc/ssh/ssh_host_rsa_key.pub', '/etc/ssh/ssh_host_dsa_key.pub'].each { |k|
+            next unless File.file? k
+            host_keys << File.readlines(k).join('').chomp.sub(/ host$/, '')
+          }
+          return if host_keys.empty?
+
+          basedir = File.dirname(Wakame.config.ssh_known_hosts)
+          FileUtils.mkpath(basedir) unless File.exist? basedir
+
+          tmpfile = File.expand_path(File.basename(Wakame.config.ssh_known_hosts) + '.tmp', basedir)
+          File.open(tmpfile, 'w') { |f|
+            agent_monitor.registered_agents.each { |k, agent|
+              host_keys.each { |k|
+                f << "#{Wakame::Util.ssh_known_hosts_hash(agent.agent_ip)} #{k}\n"
+              }
+            }
+          }
+
+          FileUtils.move(tmpfile, Wakame.config.ssh_known_hosts, {:force=>true})
+        end
+      end
+
+
+      def register_hooks
+        event_subscribe(Event::AgentMonitored) { |event|
+          trigger_action(UpdateKnownHosts.new)
+        }
+
+        event_subscribe(Event::AgentUnMonitored) { |event|
+          trigger_action(UpdateKnownHosts.new)
+        }
+      end
+    end
+  end
+end

data/lib/wakame/triggers/process_command.rb

@@ -0,0 +1,34 @@
+
+module Wakame
+  module Triggers
+    class ProcessCommand < Trigger
+      def register_hooks
+        @@command_thread ||= Thread.new {
+          while cmd = self.command_queue.deq_cmd
+            res = nil
+            begin
+              EM.barrier {
+                Wakame.log.debug("#{self.class}: Being processed the command: #{cmd.class}")
+                cmd.run(self)
+                res = cmd
+              }
+            rescue => e
+              Wakame.log.error(e)
+              res = e
+            ensure
+              self.command_queue.enq_result(res)
+            end
+          end
+        }
+        
+        #event_subscribe(Event::CommandReceived) { |event|
+        #  event.command.run(self)
+        #}
+      end
+      
+      def cleanup
+        @@command_thread.kill if @@command_thread.alive?
+      end
+    end
+  end
+end

data/lib/wakame/triggers/shutdown_unused_vm.rb

@@ -0,0 +1,16 @@
+module Wakame
+  module Triggers
+    class ShutdownUnusedVM < Trigger
+      def register_hooks
+        event_subscribe(Event::AgentPong) { |event|
+          if event.agent.services.empty? &&
+              Time.now - event.agent.last_service_assigned_at > Wakame.config.unused_vm_live_period &&
+              event.agent.agent_id != master.attr[:instance_id]
+            Wakame.log.info("Shutting the unused VM down: #{event.agent.agent.id}")
+            trigger_action(ShutdownVM.new(event.agent))
+          end
+        }
+      end
+    end
+  end
+end