wakame 0.4.2 → 0.5.0

data/lib/wakame/actions/propagate_instances.rb

@@ -1,70 +0,0 @@
-module Wakame
-  module Actions
-    class PropagateInstances < Action
-
-      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
-        }
-
-        acquire_lock { |ary|
-          svc_to_start.each { |svc|
-            ary << svc.resource.class
-          }
-        }
-
-        svc_to_start.each { |svc|
-          target_agent = nil
-          if svc.property.require_agent
-            # Try to arrange agent from existing agent pool.
-            if svc.agent.nil?
-              EM.barrier {
-                agent_monitor.each_online { |ag|
-                  if !ag.has_service_type?(@svc_prop.class) && @svc_prop.vm_spec.current.satisfy?(ag)
-                    target_agent = ag
-                    break
-                  end
-                }
-              }
-            end
-
-            Wakame.log.debug("#{self.class}: arranged agent for #{svc.resource.class}: #{target_agent ? target_agent.agent_id : nil}")
-          end
-
-          trigger_action(StartService.new(svc, target_agent))
-        }
-        flush_subactions
-      end
-
-    end
-  end
-end

data/lib/wakame/manager/commands.rb

@@ -1,134 +0,0 @@
-
-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

data/lib/wakame/rule.rb

@@ -1,116 +0,0 @@
-
-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/triggers/process_command.rb

@@ -1,41 +0,0 @@
-
-module Wakame
-  module Triggers
-    class ProcessCommand < Trigger
-      def_attribute :status
-      def_attribute :job_id
-      def_attribute :completion_status
-      def_attribute :parent_action
-      def_attribute :acquire_lock, false
-
-      attr_reader :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}")
-                res = cmd.run(self)
-                res
-              }
-            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/tests/test_rule_engine.rb

@@ -1,127 +0,0 @@
-
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__))
-
-require 'setup_master.rb'
-
-require 'rubygems'
-require 'eventmachine'
-
-require 'test/unit'
-require 'wakame'
-require 'wakame/rule.rb'
-
-WAKAME_ROOT="#{File.dirname(__FILE__)}/.."
-
-Wakame::EventDispatcher
-
-class TestRuleEngine < Test::Unit::TestCase
-  include Wakame::Rule
-  
-  class Action1 < Action
-    def run
-      trigger_action(Action2.new)
-      flush_subactions
-    end
-  end
-  class Action2 < Action
-    def run
-      act3 = Action3.new
-      trigger_action(act3)
-      flush_subactions
-    end
-  end
-  class Action3 < Action
-    def run
-      puts "sleeping(2)..."
-      sleep 2
-    end
-  end
-
-  class Rule1 < Rule
-    def register_hooks
-      trigger_action(Action1.new)
-    end
-  end
-
-  class DummyMaster
-  end
-
-  def test_nested_actions
-    EM.run {
-      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
-      engine.register_rule(Rule1.new)
-      EM.add_timer(5) { EM.stop }
-    }
-  end
-
-  def test_each_subaction
-    EM.run {
-      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
-      engine.register_rule(Rule1.new)
-      EM.add_timer(1) {
-      engine.active_jobs.each { |k, v|
-        v[:root_action].walk_subactions {|a|
-          puts a
-        }
-      }
-
-      }
-      EM.add_timer(5) { EM.stop }
-    }
-  end
-
-
-  class Rule2 < Rule
-    def register_hooks
-      act1 = Action1.new
-      job_id = trigger_action(act1)
-      puts job_id
-
-      EM.add_timer(1){
-        rule_engine.cancel_action(job_id) 
-      }
-    end
-  end
-
-  def test_cancel_action
-    EM.run {
-      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
-      engine.register_rule(Rule2.new)
-      EM.add_timer(5) { EM.stop }
-    }
-  end
-
-
-  class Action4 < Action
-    def run
-      trigger_action(Action1.new)
-
-      trigger_action(FailAction1.new)
-
-      flush_subactions
-    end
-  end
-
-  class FailAction1 < Action
-    def run
-      trigger_action(Action1.new)
-      raise StandardError
-    end
-  end
-
-  class Rule3 < Rule
-    def register_hooks
-      trigger_action(Action4.new)
-    end
-  end
-
-  def test_cancel_escalation
-    EM.run {
-      engine = RuleEngine.new(Wakame::Service::ServiceCluster.new(Object.new))
-      engine.register_rule(Rule3.new)
-      EM.add_timer(10) { EM.stop }
-    }
-  end
-
-end

data/wakame_generators/resource/templates/apache_app/conf/sites-app.conf

@@ -1,23 +0,0 @@
-NameVirtualHost *:<%= property.listen_port %>
-
-# Wild Card Virtual Host
-#<VirtualHost *:<%= property.listen_port %>>
-#DocumentRoot /var/www
-#
-#LogLevel warn
-#CustomLog /var/log/apache2/access-app.log combined
-#ErrorLog /var/log/apache2/error-app.log
-#
-#</VirtualHost>
-
-<%- cluster.virtual_hosts.each { |vh| -%>
-<VirtualHost *:<%= property.listen_port %>>
-ServerName <%= vh.server_name %>
-DocumentRoot /home/wakame/apps/development/test/public
-RailsEnv development
-
-LogLevel warn
-CustomLog /var/log/apache2/access-app.log combined
-ErrorLog /var/log/apache2/error-app.log
-</VirtualHost>
-<%- } -%>

data/wakame_generators/resource/templates/apache_lb/conf/sites-lb.conf

@@ -1,54 +0,0 @@
-NameVirtualHost *:<%= property.listen_port %>
-
-# Wild Card Virtual Host
-#<VirtualHost *:<%= property.listen_port %>>
-#DocumentRoot /var/www/
-#
-#LogLevel warn
-#CustomLog /var/log/apache2/access-lb.log combined
-#ErrorLog /var/log/apache2/error-lb.log
-#
-#</VirtualHost>
-
-<%- service_cluster.virtual_hosts.each { |vh| -%>
-<VirtualHost *:<%= property.listen_port %>>
-  ServerName <%= vh.server_name %>
-  DocumentRoot /var/www/
-
-  LogLevel warn
-  CustomLog /var/log/apache2/<%= vh.server_name %>-access.log combined
-  ErrorLog /var/log/apache2/<%= vh.server_name %>-error.log
-
-  <Location /balancer-manager>
-      SetHandler balancer-manager
-  #    Order deny,allow
-  #    Deny from all
-  #    Allow from 127.0.0.1 localhost.localdomain localhost ip6-localhost
-  </Location>
-  
-  <Proxy balancer://cluster-www>
-    <%- service_cluster.each_www { |n| 
-          next if n.status != STATUS_ONLINE
-    -%>
-    BalancerMember http://<%= n.agent.agent_ip %>:<%= n.property.listen_port %> loadfactor=10
-    <%- } -%>
-  </Proxy>
-  <Proxy balancer://cluster-app>
-    <%- service_cluster.each_app { |n|
-          next if n.status != STATUS_ONLINE
-    -%>
-    BalancerMember http://<%= n.agent.agent_ip %>:<%= n.property.listen_port %> loadfactor=10
-    <%- } -%>
-  </Proxy>
-  ProxyRequests Off
-  ProxyPreserveHost On
-  ProxyPassReverse / balancer://cluster-www/
-  ProxyPassReverse / balancer://cluster-app/
-
-  ProxyPassMatch ^(/(images|image|imgs|img|javascripts|javascript|js|stylesheets|css)/.*)$ balancer://cluster-www$1 lbmethod=byrequests timeout=10
-  ProxyPassMatch ^(/.*\.(htm|html|ico|jpg|jpeg|png|gif|swf|txt))$ balancer://cluster-www$1 lbmethod=byrequests timeout=10
-  ProxyPassMatch ^/balancer-manager.* !
-  ProxyPass / balancer://cluster-app/ lbmethod=byrequests timeout=10
-
-</VirtualHost>
-<%- } -%>

data/wakame_generators/resource/templates/apache_www/conf/sites-www.conf

@@ -1,23 +0,0 @@
-NameVirtualHost *:<%= property.listen_port %>
-
-# Wild Card Virtual Host
-#<VirtualHost *:<%= property.listen_port %>>
-#DocumentRoot /var/www
-#
-#LogLevel warn
-#CustomLog /var/log/apache2/access-www.log combined
-#ErrorLog /var/log/apache2/error-www.log
-#
-#</VirtualHost>
-
-<%- cluster.virtual_hosts.each { |vh| -%>
-<VirtualHost *:<%= property.listen_port %>>
-ServerName <%= vh.server_name %>
-DocumentRoot /home/wakame/apps/development/test/public
-
-LogLevel warn
-CustomLog /var/log/apache2/access-www.log combined
-ErrorLog /var/log/apache2/error-www.log
-
-</VirtualHost>
-<%- } -%>