wakame 0.4.0

data/lib/wakame/actions/propagate_instances.rb

@@ -0,0 +1,95 @@
+
+require 'wakame/actions/util'
+
+module Wakame
+  module Actions
+    class PropagateInstances < Action
+      include Actions::Util
+
+      def initialize(svc_prop, propagate_num=0)
+        raise ArgumentError unless svc_prop.is_a?(Wakame::Service::Resource)
+        @svc_prop = svc_prop
+        @propagate_num = propagate_num
+      end
+
+      def run
+        svc_to_start = []
+
+        EM.barrier {
+          @propagate_num.times {
+            service_cluster.propagate(@svc_prop)
+          }
+
+          # First, look for the service instances which are already created in the cluster. Then they will be scheduled to start the services later.
+          online_svc = []
+          service_cluster.each_instance(@svc_prop.class) { |svc_inst|
+            if svc_inst.status == Service::STATUS_ONLINE || svc_inst.status == Service::STATUS_STARTING
+              online_svc << svc_inst
+            else
+              svc_to_start << svc_inst
+            end
+          }
+
+          # The list is empty means that this action is called to propagate a new service instance instead of just starting scheduled instances.
+          svc_count = service_cluster.instance_count(@svc_prop)
+          if svc_count > online_svc.size + svc_to_start.size
+            Wakame.log.debug("#{self.class}: @svc_prop.instance_count - online_svc.size=#{svc_count - online_svc.size}")
+            (svc_count - (online_svc.size + svc_to_start.size)).times {
+              svc_to_start << service_cluster.propagate(@svc_prop.class)
+            }
+          end
+        }
+
+        svc_to_start.each { |svc|
+          if svc.property.require_agent
+            # Try to arrange agent from existing agent pool.
+            if svc.agent.nil?
+              EM.barrier {
+                arrange_agent(svc)
+              }
+            end
+            
+            # If the agent pool is empty, will start a new VM slice.
+            if svc.agent.nil?
+              inst_id = start_instance(master.attr[:ami_id], @svc_prop.vm_spec.current.attrs)
+              EM.barrier {
+                arrange_agent(svc, inst_id)
+              }
+            end
+            
+            if svc.agent.nil?
+              Wakame.log.error("Failed to arrange the agent #{svc.instance_id} (#{svc.property.class})")
+              raise "Failed to arrange the agent #{@svc_prop.class}"
+            end
+          end
+
+          trigger_action(StartService.new(svc))
+        }
+        flush_subactions
+      end
+
+      private
+      # Arrange an agent for the paticular service instance which does not have agent.
+      def arrange_agent(svc, vm_inst_id=nil)
+        agent = nil
+        if vm_inst_id
+          agent = agent_monitor.registered_agents[vm_inst_id]
+          raise "Cound not find the specified VM instance \"#{vm_inst_id}\"" if agent.nil?
+          raise "Same service is running" if agent.has_service_type? @svc_prop.class
+        else
+          agent_monitor.each_online { |ag|
+            Wakame.log.debug "has_service_type?(#{@svc_prop.class}): #{ag.has_service_type?(@svc_prop.class)}"
+            if test_agent_candidate(@svc_prop, ag)
+              agent = ag
+              break
+            end
+          }
+        end
+        if agent
+          svc.bind_agent(agent)
+        end
+      end
+
+    end
+  end
+end

data/lib/wakame/actions/reload_service.rb

@@ -0,0 +1,21 @@
+module Wakame
+  module Actions
+    class ReloadService < Action
+      def initialize(service_instance)
+        @service_instance = service_instance
+      end
+
+      def run
+        raise "Agent is not bound on this service : #{@service_instance}" if @service_instance.agent.nil?
+        raise "The assigned agent for the service instance #{@service_instance.instance_id} is not online."  unless @service_instance.agent.status == Service::Agent::STATUS_ONLINE
+
+        # Skip to act when the service is having below status.
+        #if @service_instance.status == Service::STATUS_STARTING || @service_instance.status == Service::STATUS_ONLINE
+        #  raise "Canceled as the service is being or already ONLINE: #{@service_instance.property}"
+        #end
+        
+        master.send_agent_command(Packets::ServiceReload.new(@service_instance.instance_id), @service_instance.agent.agent_id)
+      end
+    end
+  end
+end

data/lib/wakame/actions/scaleout_when_high_load.rb

@@ -0,0 +1,44 @@
+module Wakame
+  module Triggers
+    class ScaleoutWhenHighLoad < Trigger
+      def initialize
+      end
+      
+      def register_hooks
+        event_subscribe(LoadHistoryMonitor::AgentLoadHighEvent) { |event|
+          if service_cluster.status != Service::ServiceCluster::STATUS_ONLINE
+            Wakame.log.info("Service Cluster is not online yet. Skip to scaling out")
+            next
+          end
+          Wakame.log.debug("Got load high avg: #{event.agent.agent_id}")
+
+          propagate_svc = nil
+          event.agent.services.each { |id, svc|
+            if svc.property.class == Service::Apache_APP
+              propagate_svc = svc 
+              break
+            end
+          }
+
+          unless propagate_svc.nil?
+            trigger_action(Actions::PropagateInstancesAction.new(propagate_svc.property)) 
+          end
+        }
+
+        event_subscribe(LoadHistoryMonitor::AgentLoadNormalEvent) { |event|
+          next
+
+          if service_cluster.status != Service::ServiceCluster::STATUS_ONLINE
+            Wakame.log.info("Service Cluster is not online yet.")
+            next
+          end
+          Wakame.log.debug("Back to normal load: #{event.agent.agent_id}")
+          event.agent.services.each { |id, svc|
+            trigger_action(Actions::StopService.new(svc))
+          }
+          
+        }
+      end
+    end
+  end
+end

data/lib/wakame/actions/shutdown_cluster.rb

@@ -0,0 +1,22 @@
+module Wakame
+  module Actions
+    class ShutdownCluster < Action
+      def run
+        levels = service_cluster.dg.levels
+
+        levels.reverse.each { |lv|
+          lv.each { |svc_prop|
+            service_cluster.each_instance(svc_prop.class) { |svc_inst|
+              trigger_action(StopService.new(svc_inst))
+            }
+          }
+          flush_subactions
+        }
+
+        agent_monitor.registered_agents.each { |id, agent|
+          trigger_action(ShutdownVM.new(agent))
+        }
+      end
+    end
+  end
+end

data/lib/wakame/actions/shutdown_vm.rb

@@ -0,0 +1,19 @@
+module Wakame
+  module Actions
+    class ShutdownVM < Action
+      def initialize(agent)
+        @agent = agent
+      end
+
+      def run
+        
+        if @agent.agent_id == master.master_local_agent_id
+          Wakame.log.info("Skip to shutdown VM as the master is running on this node: #{@agent.agent_id}")
+          return
+        end
+
+        VmManipulator.create.stop_instance(@agent[:instance_id])
+      end
+    end
+  end
+end

data/lib/wakame/actions/start_service.rb

@@ -0,0 +1,64 @@
+
+require 'wakame/rule'
+
+module Wakame
+  module Actions
+    class StartService < Action
+      def initialize(service_instance)
+        @acquire_lock = true
+        @service_instance = service_instance
+      end
+
+      def run
+        if @service_instance.property.require_agent
+          raise "Agent is not bound on this service : #{@service_instance}" if @service_instance.agent.nil?
+          raise "The assigned agent for the service instance #{@service_instance.instance_id} is not online."  unless @service_instance.agent.status == Service::Agent::STATUS_ONLINE
+        end
+        
+        # Skip to act when the service is having below status.
+        if @service_instance.status == Service::STATUS_STARTING || @service_instance.status == Service::STATUS_ONLINE
+          raise "Canceled as the service is being or already ONLINE: #{@service_instance.property}"
+        end
+        EM.barrier {
+          @service_instance.update_status(Service::STATUS_STARTING)
+        }
+        
+        if @service_instance.property.require_agent
+          Rule::BasicActionSet.deploy_configuration(@service_instance)
+        end
+
+        @service_instance.resource.start(@service_instance, self)
+        
+        EM.barrier {
+          Wakame.log.debug("Child nodes: #{@service_instance.property.class}: " + service_cluster.dg.children(@service_instance.property.class).inspect)
+          service_cluster.dg.children(@service_instance.property.class).each { |svc_prop|
+            Wakame.log.debug("Spreading DG child changed: #{@service_instance.property.class} -> #{svc_prop.class}")
+            trigger_action(Actions::CallChildChangeAction.new(svc_prop))
+          }
+        }
+
+      end
+
+      def on_failed
+        EM.barrier {
+          @service_instance.update_status(Service::STATUS_FAIL)
+        }
+      end
+    end
+
+    class CallChildChangeAction < Action
+      def initialize(resource)
+        @resource = resource
+        #@parent_instance = parent_instance
+      end
+      
+      def run
+        Wakame.log.debug("CallChildChangeAction: run: #{@resource.class}")
+        service_cluster.each_instance(@resource.class) { |svc_inst|
+          next if svc_inst.status != Service::STATUS_ONLINE
+          @resource.on_parent_changed(svc_inst, self)
+        }
+      end
+    end
+  end
+end

data/lib/wakame/actions/stop_service.rb

@@ -0,0 +1,49 @@
+module Wakame
+  module Actions
+    class StopService < Action
+      def initialize(service_instance)
+        @acquire_lock = true
+        @service_instance = service_instance
+      end
+
+
+      def run
+        raise "Agent is not bound on this service : #{@service_instance}" if @service_instance.property.require_agent && @service_instance.agent.nil?
+        
+        # Skip to act when the service is having below status.
+        if @service_instance.status == Service::STATUS_STOPPING || @service_instance.status == Service::STATUS_OFFLINE
+          raise CancelActionError, "Canceled as the service is being or already OFFLINE: #{@service_instance.property}"
+        end
+
+        EM.barrier {
+          @service_instance.update_status(Service::STATUS_STOPPING)
+        }
+        
+        EM.barrier {
+          Wakame.log.debug("Child nodes: #{@service_instance.property.class}: " + service_cluster.dg.children(@service_instance.property.class).inspect)
+          service_cluster.dg.children(@service_instance.property.class).each { |svc_prop|
+            trigger_action(CallChildChangeAction.new(svc_prop))
+          }
+        }
+
+        flush_subactions()
+
+        if @service_instance.status == Service::STATUS_ONLINE
+          @service_instance.property.stop(@service_instance, self)
+        else
+        end
+        
+        EM.barrier {
+          service_cluster.destroy(@service_instance.instance_id)
+        }
+      end
+
+      def on_failed
+        EM.barrier {
+          @service_instance.update_status(Service::STATUS_FAIL)
+        }
+      end
+
+    end
+  end
+end

data/lib/wakame/actions/util.rb

@@ -0,0 +1,71 @@
+module Wakame
+  module Actions
+    module Util
+
+      def 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)
+          Wakame::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
+      
+      
+      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]
+        
+        ConditionalWait.wait { | 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
+
+    end
+  end
+end

data/lib/wakame/actor/daemon.rb

@@ -0,0 +1,37 @@
+
+require 'shellwords'
+require 'ext/shellwords' unless Shellwords.respond_to? :shellescape
+
+class Wakame::Actor::Daemon
+  include Wakame::Actor
+
+ 
+  def start(resource_dir, cmd)
+    Wakame::Util.exec("/usr/bin/env #{env_opts} '#{cmd_abs_path(resource_dir, cmd.dup)}' start")
+  end
+
+  def stop(resource_dir, cmd)
+    Wakame::Util.exec("/usr/bin/env #{env_opts} '#{cmd_abs_path(resource_dir, cmd.dup)}' stop")
+  end
+
+  def reload(resource_dir, cmd)
+    Wakame::Util.exec("/usr/bin/env #{env_opts} '#{cmd_abs_path(resource_dir, cmd.dup)}' reload")
+  end
+
+  private
+  def env_opts
+    {'WAKAME_ROOT'=>Wakame.config.root_path}.map {|k,v|
+      "#{k}='#{v}'"
+    }.join(' ')
+  end
+
+  def resource_path(resource_dir)
+    sprintf("%s/%s", Wakame.config.config_root, resource_dir)
+  end
+
+  def cmd_abs_path(resource_dir, cmd)
+    Shellwords.shellescape(File.expand_path(cmd.sub(%r{^/}, ''), resource_path(resource_dir)))
+  end
+
+end
+

data/lib/wakame/actor/service_monitor.rb

@@ -0,0 +1,21 @@
+
+class Wakame::Actor::ServiceMonitor
+  include Wakame::Actor
+
+  expose '/service_monitor/register', :register
+  def register(svc_id, type, *args)
+    EM.barrier {
+      svcmon = agent.monitor_registry.find_monitor('/service')
+      svcmon.register(svc_id, type, *args)
+    }
+  end
+
+  expose '/service_monitor/unregister', :unregister
+  def unregister(svc_id)
+    EM.barrier {
+      svcmon = agent.monitor_registry.find_monitor('/service')
+      svcmon.unregister(svc_id)
+    }
+  end
+
+end

data/lib/wakame/actor/system.rb

@@ -0,0 +1,46 @@
+
+
+require 'shellwords'
+require 'ext/shellwords' unless Shellwords.respond_to? :shellescape
+
+class Wakame::Actor::System
+  include Wakame::Actor
+ 
+  def mount(dev, path, opts={})
+    raise "#{path} does not exist or not directory." unless File.directory?(path)
+    
+    mount_point_dev=`/bin/df "#{path}" | /usr/bin/awk 'NR==2 {print $1}'`.strip
+
+    #mount_point_dev=`/bin/mount | /usr/bin/awk '$3==path {print $1}' path="#{path}"`.strip
+    Wakame.log.debug("#{mount_point_dev}: #{dev}, /bin/mount | awk '$3==path {print $1}' path=\"#{path}\"")
+    if mount_point_dev != dev
+      Wakame.log.debug("Mounting volume: #{dev} as #{path} (with options: #{opts})")
+      Wakame::Util.exec("/bin/mount -o #{mount_opts(opts)} '#{Shellwords.shellescape(dev)}' '#{Shellwords.shellescape(path)}'")
+      # sync
+      3.times do |i|
+        system("/bin/sync")
+        sleep 1.0
+      end
+    else
+      Wakame.log.debug("Mounting EBS volume: #{dev} as #{path} (with options: #{opts})")
+    end
+  end
+
+  def umount(path)
+    raise "#{path} does not exist or not directory." unless File.directory?(path)
+
+    mount_point_dev=`/bin/df "#{path}" | awk 'NR==2 {print $1}'`
+    Wakame.log.debug("Unmounting volume: #{mount_point_dev} on #{path}")
+    Wakame::Util.exec("/bin/umount '#{Shellwords.shellescape(path)}'")
+  end
+  
+  private
+  def mount_opts(opts)
+    out = opts.collect { |k,v|
+      v.nil? ? k : "#{k}=#{v}"
+    }.join(',')
+    Shellwords.shellescape(out)
+  end
+
+end
+

data/lib/wakame/actor.rb

@@ -0,0 +1,33 @@
+
+
+module Wakame
+  module Actor
+    STATUS_RUNNING = 1
+    STATUS_SUCCESS = 2
+    STATUS_FAILED = 0
+    STATUS_CANCELED = 3
+
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.class_eval {
+        attr_accessor :agent
+      }
+    end
+
+    module ClassMethods
+      def expose(path, meth)
+        @exposed ||= {}
+        @exposed[path]=meth
+      end
+
+      def map_path
+        @map_path ||= Util.snake_case(self.to_s.split('::').last)
+      end
+      
+      def map_path=(name)
+        @map_path=name
+      end
+    end
+    
+  end
+end