wakame 0.4.2 → 0.5.0

data/lib/wakame/actions/shutdown_vm.rb

@@ -2,17 +2,26 @@ module Wakame
   module Actions
     class ShutdownVM < Action
       def initialize(agent)
+        raise ArgumentError unless agent.is_a?(Service::Agent)
         @agent = agent
       end
 
       def run
+        #if @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
         
-        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
+        shutdown_ec2_instance
 
-        VmManipulator.create.stop_instance(@agent[:instance_id])
+      end
+
+      private
+      def shutdown_ec2_instance
+        require 'right_aws'
+        ec2 = RightAws::Ec2.new(Wakame.config.aws_access_key, Wakame.config.aws_secret_key, {:cache=>false})
+
+        res = ec2.terminate_instances([@agent.vm_attr[:instance_id]])
       end
     end
   end

data/lib/wakame/actions/start_service.rb

@@ -1,85 +1,91 @@
 
-require 'wakame/rule'
-
 module Wakame
   module Actions
     class StartService < Action
-      def initialize(service_instance, target_agent=nil)
+      def initialize(service_instance)
         @service_instance = service_instance
-        @target_agent = target_agent
       end
 
       def run
+        # Skip to act when the service is having below status.
+        if @service_instance.status == Service::STATUS_STARTING || @service_instance.status == Service::STATUS_ONLINE
+          Wakame.log.info("Ignore to start the service as is being or already Online: #{@service_instance.resource.class}")
+          return
+        end
+
+        acquire_lock { |lst|
+          lst << @service_instance.resource.class.to_s
+        }
+
         if @service_instance.resource.require_agent
+          raise "The service is not bound cloud host object: #{@service_instance.id}" if @service_instance.cloud_host_id.nil?
 
-          if @service_instance.agent.nil?
-            # Start new VM when the target agent is nil.
-            if @target_agent.nil?
+          unless @service_instance.cloud_host.mapped?
+            acquire_lock { |lst|
+              lst << Service::AgentPool.class.to_s
+            }
+            
+            # Try to arrange agent from existing agent pool.
+            StatusDB.barrier {
+              next if Service::AgentPool.instance.group_active.empty?
+              agent2host = cluster.agents.invert
+              
+              Service::AgentPool.instance.group_active.keys.each { |agent_id|
+                agent = Service::Agent.find(agent_id)
+                if !agent.has_resource_type?(@service_instance.resource) &&
+                    agent2host[agent_id].nil? && # This agent is not mapped to any cloud hosts.
+                    @service_instance.cloud_host.vm_spec.satisfy?(agent.vm_attr)
+                  
+                  @service_instance.cloud_host.map_agent(agent)
+                  break
+                end
+              }
+            }
+            
+            # Start new VM when the target agent is still nil.
+            unless @service_instance.cloud_host.mapped?
               inst_id_key = "new_inst_id_" + Wakame::Util.gen_id
-              trigger_action(LaunchVM.new(inst_id_key))
+              trigger_action(LaunchVM.new(inst_id_key, @service_instance.cloud_host.vm_spec))
               flush_subactions
               
-              EM.barrier {
-                @target_agent = agent_monitor.registered_agents[notes[inst_id_key]]
-                raise "Cound not find the specified VM instance \"#{notes[inst_id_key]}\"" if @target_agent.nil?
-                raise "Same service is running" if @target_agent.has_service_type? @service_instance.resource.class
+              StatusDB.barrier {
+                agent = Service::Agent.find(notes[inst_id_key])
+                raise "Cound not find the specified VM instance \"#{notes[inst_id_key]}\"" if agent.nil?
+                @service_instance.cloud_host.map_agent(agent)
               }
             end
+            
+            raise "Could not find the agent to be assigned to : #{@service_instance.resource.class}" unless @service_instance.cloud_host.mapped?
 
-            EM.barrier {
-              @service_instance.bind_agent(@target_agent)
-            }
+            @service_instance.resource.on_enter_agent(@service_instance, self)
           end
+          
+          raise "The assigned agent \"#{@service_instance.cloud_host.agent_id}\" for the service instance #{@service_instance.id} is not online."  unless @service_instance.cloud_host.status == Service::Agent::STATUS_ONLINE
 
-
-          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.resource}"
-        end
-        EM.barrier {
+
+        StatusDB.barrier {
           @service_instance.update_status(Service::STATUS_STARTING)
         }
         
         if @service_instance.resource.require_agent
-          Rule::BasicActionSet.deploy_configuration(@service_instance)
+          trigger_action(DeployConfig.new(@service_instance))
+          flush_subactions
         end
 
         @service_instance.resource.start(@service_instance, self)
         
-        EM.barrier {
-          Wakame.log.debug("Child nodes: #{@service_instance.resource.class}: " + service_cluster.dg.children(@service_instance.property.class).inspect)
-          service_cluster.dg.children(@service_instance.resource.class).each { |svc_res|
-            Wakame.log.debug("Spreading DG child changed: #{@service_instance.resource.class} -> #{svc_res.class}")
-            trigger_action(Actions::CallChildChangeAction.new(svc_res))
-          }
-        }
+        trigger_action(NotifyParentChanged.new(@service_instance))
+        flush_subactions
 
       end
 
       def on_failed
-        EM.barrier {
+        StatusDB.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

@@ -1,43 +1,55 @@
 module Wakame
   module Actions
     class StopService < Action
-      def initialize(service_instance)
-        @acquire_lock = true
-        @service_instance = service_instance
+      def initialize(svc, do_terminate=true)
+        raise ArgumentError unless svc.is_a?(Service::ServiceInstance)
+        @svc = svc
+        @do_terminate = do_terminate
       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}"
+        if @svc.status == Service::STATUS_STOPPING || @svc.status == Service::STATUS_OFFLINE
+          Wakame.log.info("Ignore to stop the service as is being or already OFFLINE: #{@svc.resource.class}")
+          return
         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))
-          }
+        acquire_lock { |lst|
+          lst << @svc.resource.class.to_s
         }
 
-        flush_subactions()
+        if @svc.resource.require_agent && !@svc.cloud_host.mapped?
+          raise "Agent is not bound on this service : #{@svc}"
+        end
 
-        @service_instance.property.stop(@service_instance, self)
-        
-        EM.barrier {
-          service_cluster.destroy(@service_instance.instance_id)
+        StatusDB.barrier {
+          @svc.update_status(Service::STATUS_STOPPING)
         }
+        
+        trigger_action(NotifyChildChanged.new(@svc))
+        flush_subactions
+
+        @svc.resource.stop(@svc, self)
+
+        if @do_terminate
+          if @svc.resource.require_agent
+            StatusDB.barrier {
+              @svc.update_status(Service::STATUS_QUITTING)
+            }
+            @svc.resource.on_quit_agent(@svc, self)
+          end
+
+          StatusDB.barrier {
+            @svc.update_status(Service::STATUS_TERMINATE)
+            cluster.destroy(@svc.id)
+          }
+        end
       end
 
       def on_failed
-        EM.barrier {
-          @service_instance.update_status(Service::STATUS_FAIL)
+        StatusDB.barrier {
+          @svc.update_status(Service::STATUS_FAIL)
         }
       end
 

data/lib/wakame/actor/system.rb

@@ -30,7 +30,7 @@ class Wakame::Actor::System
     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)}'")
+      Wakame::Util.exec("/bin/mount #{escape_mount_opts(opts)} '#{Shellwords.shellescape(dev)}' '#{Shellwords.shellescape(path)}'")
     else
       Wakame.log.debug("Mounting EBS volume: #{dev} as #{path} (with options: #{opts})")
     end
@@ -45,11 +45,14 @@ class Wakame::Actor::System
   end
   
   private
-  def mount_opts(opts)
+  def escape_mount_opts(opts)
+    return '' if opts.nil?
+    return "-o '#{Shellwords.shellescape(opts)}'" if opts.is_a? String
+
     out = opts.collect { |k,v|
       v.nil? ? k : "#{k}=#{v}"
     }.join(',')
-    Shellwords.shellescape(out)
+    "-o #{Shellwords.shellescape(out)}"
   end
 
 end

data/lib/wakame/agent.rb

@@ -9,8 +9,8 @@ require 'thread'
 require 'wakame'
 require 'wakame/amqp_client'
 require 'wakame/queue_declare'
-require 'wakame/event'
-require 'wakame/vm_manipulator'
+#require 'wakame/event'
+#require 'wakame/vm_manipulator'
 
 
 module Wakame
@@ -31,14 +31,19 @@ module Wakame
       determine_agent_id
       @actor_registry = ActorRegistry.new
       @monitor_registry = MonitorRegistry.new
+    end
 
-      connect(opts)
-
+    # post_setup
+    def init
       setup_monitors
       setup_actors
       setup_dispatcher
 
-      attrs = Wakame::VmManipulator.create.fetch_local_attrs
+      if Wakame.config.environment == :EC2
+        attrs = self.class.ec2_fetch_local_attrs
+      else
+        attrs = {}
+      end
       publish_to('registry', Packets::Register.new(self, Wakame.config.root_path.to_s, attrs).marshal)
       Wakame.log.info("Started agent process : WAKAME_ROOT=#{Wakame.config.root_path} WAKAME_ENV=#{Wakame.config.environment}, attrs=#{attrs.inspect}")
     end
@@ -55,9 +60,9 @@ module Wakame
 
     def determine_agent_id
       if Wakame.config.environment == :EC2
-        @agent_id = VmManipulator::EC2::MetadataService.query_metadata_uri('instance-id')
+        @agent_id = self.class.ec2_query_metadata_uri('instance-id')
       else
-        @agent_id = VmManipulator::StandAlone::INSTANCE_ID
+        @agent_id = '__STAND_ALONE__'
       end
     end
 
@@ -114,6 +119,23 @@ module Wakame
       }
     end
 
+    def self.ec2_query_metadata_uri(key)
+      require 'open-uri'
+      open("http://169.254.169.254/2008-02-01/meta-data/#{key}") { |f|
+        return f.readline
+      }
+    end
+
+    def self.ec2_fetch_local_attrs
+      attrs = {}
+      %w[instance-id instance-type local-ipv4 local-hostname public-hostname public-ipv4 ami-id].each { |key|
+        rkey = key.tr('-', '_')
+        attrs[rkey.to_sym]=ec2_query_metadata_uri(key)
+      }
+      attrs[:availability_zone] = ec2_query_metadata_uri('placement/availability-zone')
+      attrs
+    end
+
   end
 
 

data/lib/wakame/amqp_client.rb

@@ -17,21 +17,28 @@ module Wakame
     end
     
     module ClassMethods
-      attr_reader :instance
       attr_reader :defered_setup_calls
 
+
+      def instance
+        @instance
+      end
+
       def start(*opts)
-        pr = proc {
-          if self.instance.nil?
+        new_instance = proc {
+          if @instance.nil?
             @instance = new(*opts)
+            @instance.connect(*opts) do
+              @instance.init
+            end
           end
           @instance
         }
         
         if EM.reactor_running?
-          return pr.call
+          return new_instance.call
         else
-          EM.run pr
+          EM.run new_instance
         end
       end
       
@@ -107,9 +114,23 @@ module Wakame
 
     attr_reader :mq, :amqp_client
     
+    def amqp_server_uri
+      raise "The connection is not established yet." unless @amqp_client && connected?
+
+      URI::AMQP.build(:host => @amqp_client.settings[:host],
+                      :port => @amqp_client.settings[:port],
+                      :path => @amqp_client.settings[:vhost]
+                      )
+    end
+
     def connect(*args)
       close() unless connected?
       @amqp_client = AMQP.connect(*args)
+      @amqp_client.instance_eval {
+        def settings
+          @settings
+        end
+      }
       @mq = Thread.current[:mq] = MQ.new(@amqp_client)
 
       run_defered_callbacks

data/lib/wakame/command/action_status.rb

@@ -1,10 +1,8 @@
 
-require 'erb'
-
 class Wakame::Command::ActionStatus
   include Wakame::Command
 
-  def run(rule)
+  def run
     walk_subactions = proc { |a, level|
       res = a.dump_attrs
       unless a.subactions.empty?
@@ -15,12 +13,14 @@ class Wakame::Command::ActionStatus
       res
     }
 
-    EM.barrier {
+    Wakame::StatusDB.barrier {
       result = {}
 
-      rule.rule_engine.active_jobs.each { |id, v|
-
-        result[id]={:created_at=>v[:created_at], :src_rule=>v[:src_rule].class.to_s}        
+      master.action_manager.active_jobs.each { |id, v|
+        result[id]={}
+        (v.keys - [:root_action]).each { |k|
+          result[id][k]=v[k]
+        }
         result[id][:root_action] = walk_subactions.call(v[:root_action], 0)
 
       }

data/lib/wakame/command/actor.rb

@@ -1,23 +1,23 @@
 
 class Wakame::Command::Actor
   include Wakame::Command
+  include Wakame::Service
 
-  command_name='launch_cluster'
+  command_name='actor'
 
   def parse(args)
     raise "Not enugh number of arguments" if args.size < 2
-    @agent_id = args.shift
-    @path = args.shift
-    @args = *args
   end
 
-  def run(rule)
-    request = rule.master.actor_request(@agent_id, @path, *@args).request
-    request
-  end
+  def run
+    agent = Agent.find(params[:agent_id])
+    raise "Unknown agent: #{params[:agent_id]}" if agent.nil?
+    raise "Invalid agent status (Not Online): #{agent.status} #{params[:agent_id]}" if agent.status != Agent::STATUS_ONLINE
 
+    raise "Invalid actor path: #{params[:path]}" if params[:path].nil? || params[:path] == ''
 
-  def print_result
-    
+    request = rule.master.actor_request(params[:agent_id], params[:path], *params[:args]).request
+    request.wait
   end
+
 end

data/lib/wakame/command/import_cluster_config.rb

@@ -0,0 +1,10 @@
+
+class Wakame::Command::ImportClusterConfig
+  include Wakame::Command
+
+  def run
+    Wakame::StatusDB.barrier {
+      master.cluster_manager.load_config_cluster
+    }
+  end
+end

data/lib/wakame/command/launch_cluster.rb

@@ -5,7 +5,7 @@ class Wakame::Command::LaunchCluster
 
   command_name='launch_cluster'
 
-  def run(rule)
-    rule.trigger_action(Wakame::Actions::LaunchCluster.new)
+  def run
+    trigger_action(Wakame::Actions::LaunchCluster.new)
   end
 end

data/lib/wakame/command/launch_vm.rb

@@ -4,8 +4,8 @@ class Wakame::Command::LaunchVm
 
   command_name='launch_vm'
 
-  def run(rule)
+  def run
     inst_id_key = "new_inst_id_" + Wakame::Util.gen_id
-    rule.trigger_action(Wakame::Actions::LaunchVM.new(inst_id_key))
+    trigger_action(Wakame::Actions::LaunchVM.new(inst_id_key))
   end
-end
+end

data/lib/wakame/command/migrate_service.rb

@@ -2,23 +2,23 @@
 class Wakame::Command::MigrateService
   include Wakame::Command
 
-  def run(rule)
+  def run
     svc = nil
-    svc = rule.service_cluster.instances[@options["service_id"]]
+    svc = service_cluster.find_service(options["service_id"])
     if svc.nil?
-      raise "Unknown Service ID: #{@options["service_id"]}" 
+      raise "Unknown Service ID: #{options["service_id"]}" 
     end
 
     # Optional destination agent 
     agent = nil
-    if @options["agent_id"]
-      agent = rule.agent_monitor.agent(@options["agent_id"])
+    if options["agent_id"]
+      agent = master.agent_monitor.agent_pool.find_agent(options["agent_id"])
       if agent.nil?
-        raise "Unknown Agent ID: #{@options["agent_id"]}" 
+        raise "Unknown Agent ID: #{options["agent_id"]}" 
       end
     end
 
-    rule.trigger_action(Wakame::Actions::MigrateService.new(svc, agent))
+    trigger_action(Wakame::Actions::MigrateService.new(svc, agent))
   end
 
 end

data/lib/wakame/command/propagate_resource.rb

@@ -0,0 +1,42 @@
+
+class Wakame::Command::PropagateResource
+  include Wakame::Command
+  include Wakame
+
+  command_name='propagate_resource'
+
+  def run
+    resname = @options["resource"]
+
+    resobj = Service::Resource.find(Service::Resource.id(resname))
+    if resobj.nil?
+      raise "Unknown Resource: #{resname}" 
+    end
+
+    cloud_host_id = @options["cloud_host_id"]
+    if cloud_host_id.nil?
+      cloud_host = service_cluster.add_cloud_host { |h|
+        if @options["vm_attr"].is_a? Hash
+          h.vm_attr = @options["vm_attr"]
+        end
+      }
+    else
+      cloud_host = Service::CloudHost.find(cloud_host_id) || raise("Specified host was not found: #{cloud_host_id}")
+      raise "Same resouce type is already assigned: #{resobj.class} on #{cloud_host_id}" if cloud_host.has_resource_type?(resobj)
+    end
+    
+
+    num = options["number"] || 1
+    raise "Invalid format of number: #{num}" unless /^(\d+)$/ =~ num.to_s
+    num = num.to_i
+
+    if num < 1 || resobj.max_instances < service_cluster.instance_count(resobj) + num
+      raise "The number must be between 1 and #{resobj.max_instances - service_cluster.instance_count(resobj)} (max limit: #{resobj.max_instances})"
+    end
+
+    num.times {
+      trigger_action(Wakame::Actions::PropagateResource.new(resobj, cloud_host.id))
+    }
+
+  end
+end

data/lib/wakame/command/propagate_service.rb

@@ -1,32 +1,34 @@
 
 class Wakame::Command::PropagateService
   include Wakame::Command
+  include Wakame
 
-  #command_name='launch_cluster'
+  command_name='propagate_service'
 
-  def parse(args)
-    @resource
-  end
-
-  def run(rule)
-    prop = nil
-    prop = rule.service_cluster.properties[@options["service"]]
-    if prop.nil?
-      raise "UnknownProperty: #{@options["service"]}" 
+  def run
+    refsvc = service_cluster.find_service(@options["service_id"])
+    if refsvc.nil?
+      raise("Unknown ServiceInstance ID: #{@options["service_id"]}")
     end
 
-    @num = nil
-    @num = @options["num"] || 1
-
-    unless /^(\d){1,32}$/ =~ @num.to_s
-      raise "The number is not appropriate: #{@num}"
+    cloud_host_id = @options["cloud_host_id"]
+    if cloud_host_id.nil? || cloud_host_id == ""
+      cloud_host_id = nil
+    else
+      cloud_host = Service::CloudHost.find(cloud_host_id) || raise("Specified cloud host was not found: #{cloud_host_id}")
+      raise "Same resouce type is already assigned: #{refsvc.resource.class} on #{cloud_host_id}" if cloud_host.has_resource_type?(refsvc.resource)
     end
 
-    instance = rule.master.service_cluster.dump_status[:properties][@options["service"]]
-    if @num.to_i > (instance[:max_instances].to_i - instance[:instances].count.to_i)
-      raise "The number is not appropriate: #{@num}"
+    num = @options["number"] || 1
+    raise "Invalid format of number: #{num}" unless /^(\d+)$/ =~ num.to_s
+    num = num.to_i
+
+    if num < 1 || refsvc.resource.max_instances < service_cluster.instance_count(refsvc.resource) + num
+      raise "The number must be between 1 and #{refsvc.resource.max_instances - service_cluster.instance_count(refsvc.resource)} (max limit: #{refsvc.resource.max_instances})"
     end
 
-    rule.trigger_action(Wakame::Actions::PropagateInstances.new(prop, @num.to_i))
+    num.times {
+      trigger_action(Wakame::Actions::PropagateService.new(refsvc, cloud_host_id))
+    }
   end
 end

data/lib/wakame/command/reload_service.rb

@@ -4,18 +4,8 @@ class Wakame::Command::ReloadService
 
   command_name='reload_service'
 
-  def run(rule)
-    if !@options["service_name"].nil?
-      levels = rule.service_cluster.dg.levels
-      levels.reverse.each {|lv|
-        lv.each { |svc_prop|
-          if svc_prop.class.to_s == @options["service_name"].to_s
-            rule.service_cluster.each_instance(svc_prop.class) { |svc_inst|
-              rule.trigger_action(Wakame::Actions::ReloadService.new(svc_inst))
-            }
-          end
-        }
-      }
-    end
+  def run
+    svc = service_cluster.find_service(options['service_id'])
+    trigger_action(Wakame::Actions::ReloadService.new(svc))
   end
 end

data/lib/wakame/command/shutdown_cluster.rb

@@ -4,7 +4,7 @@ class Wakame::Command::ShutdownCluster
 
   command_name='shutdown_cluster'
 
-  def run(rule)
-    rule.trigger_action(Wakame::Actions::ShutdownCluster.new)
+  def run
+    trigger_action(Wakame::Actions::ShutdownCluster.new)
   end
 end