wakame 0.4.1 → 0.4.2

data/History.txt

@@ -1,3 +1,21 @@
+== 0.4.2 2009-07-24
+
+* Add Web API for master control. (Note that the API design is not fixed yet)
+
+* Rewrote the CLI to use HTTP instead of old DRb interface.
+
+* Add support for agent less resource.
+
+* Add LockQueue to avoid confliction when multiple actions run.
+
+* Add MySQL_Slave resource.
+
+* Add Elastic IP resource. 
+
+* Add Elastic Load Balancer resource.
+
+* Add Nginx resource.
+
 == 0.4.1 2009-06-29
 
 * Fixed the packaging bugs.

data/README.rdoc

@@ -6,10 +6,6 @@
 
 * Wakame is a framework to simplify the complex virtual machine manipulation over multiple instances in Clound envrionment. This project aims to provide the management/monitoring services with server/daemon configuration set to build scalable web applications.
 
-== SYNOPSIS:
-
-* 
-
 == REQUIREMENTS:
 
 * eventmachine
@@ -19,6 +15,8 @@
 * right_aws
 * log4r
 * jeweler
+* thin
+* json
 
 == INSTALL:
 

data/Rakefile

@@ -25,7 +25,10 @@ __END__
      ['daemons', '>= 1.0.10'],
      ['rubigen', '>= 1.5.2'],
      ['open4', '>= 0.9.6'],
-     ['jeweler', '>= 1.0.0']
+     ['jeweler', '>= 1.0.0'],
+     ['rack', '>= 1.0.0'],
+     ['thin', '>= 1.2.2'],
+     ['json', '>= 1.1.7']
     ].each { |i|
       gem.add_dependency(i[0], i[1])
     }

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.2

data/app_generators/wakame/templates/config/cluster.rb

@@ -13,11 +13,13 @@ class WebCluster < Wakame::Service::ServiceCluster
       c.add_resource(Apache_APP.new)
       c.add_resource(Apache_LB.new)
       c.add_resource(MySQL_Master.new)
+      #c.add_resource(MySQL_Slave.new)
 
       c.set_dependency(Apache_LB, Ec2ElasticIp)
       c.set_dependency(Apache_WWW, Apache_LB)
       c.set_dependency(Apache_APP, Apache_LB)
       c.set_dependency(MySQL_Master, Apache_APP)
+      #c.set_dependency(MySQL_Master, MySQL_Slave)
     }
 
     define_rule { |r|
@@ -61,4 +63,38 @@ class WebCluster < Wakame::Service::ServiceCluster
     }
   end
 
+  def each_mysql_master(&blk)
+    each_instance(MySQL_Master) { |n|
+      blk.call(n)
+    }
+  end
+
+  def fetch_mysql_master_ip
+    mysql_master_ip = nil
+    each_mysql_master do |mysql|
+      mysql_master_ip = mysql.agent.agent_ip
+    end
+    mysql_master_ip
+  end
+
+  def each_mysql_slave(&blk)
+    each_instance(MySQL_Slave) { |n|
+      blk.call(n)
+    }
+  end
+
+  def fetch_mysql_slave_ip
+    mysql_slave_ips = []
+    each_mysql_slave do |mysql|
+      mysql_slave_ips << mysql.agent.agent_ip
+    end
+    mysql_master_ips
+  end
+
+#  def each_postgresql(&blk)
+#    each_instance(PostgreSQL_Master) { |n|
+#      blk.call(n)
+#    }
+#  end
+
 end

data/app_generators/wakame/wakame_generator.rb

@@ -20,6 +20,7 @@ class WakameGenerator < RubiGen::Base
     config/environments
     lib
     tasks
+    tmp
     vendor
   )
 

data/lib/wakame/action.rb

@@ -7,7 +7,6 @@ module Wakame
     def_attribute :status, :ready
     def_attribute :completion_status
     def_attribute :parent_action
-    def_attribute :acquire_lock, false
     
     attr_reader :trigger
 
@@ -36,20 +35,17 @@ module Wakame
       @subactions ||= []
     end
     
-    def bind_triggered_rule(trigger)
+    def bind_trigger(trigger)
       @trigger = trigger
     end
     
     def trigger_action(subaction, opts={})
-      if opts.is_a? Hash
-        succ_proc = opts[:success] || opts[:succ]
-        fail_proc = opts[:fail]
-      end
       subactions << subaction
       subaction.parent_action = self
-      #subaction.observers << self
+      subaction.job_id = self.job_id
+      subaction.bind_trigger(self.trigger)
       
-      async_trigger_action(subaction, succ_proc, fail_proc)
+      trigger.rule_engine.run_action(subaction)
     end
     
     def flush_subactions(sec=nil)
@@ -92,8 +88,8 @@ module Wakame
         notify_queue.enq(src) #if notify_queue.num_waiting > 0
       end
     end
-    
-    
+
+    # Recursively iterate the sub action descendants.
     def walk_subactions(&blk)
       blk.call(self)
       self.subactions.each{ |a|
@@ -118,6 +114,18 @@ module Wakame
     def notes
       trigger.rule_engine.active_jobs[self.job_id][:notes]
     end
+
+    # Set the lock flags to resources 
+    def acquire_lock(&blk)
+      EM.barrier {
+        reslist = []
+        blk.call(reslist)
+        reslist.flatten!
+        reslist.each {|r| service_cluster.lock_queue.set(r.to_s, self.job_id) }
+      }
+      
+      service_cluster.lock_queue.wait(self.job_id)
+    end
     
     def run
       raise NotImplementedError
@@ -128,29 +136,6 @@ module Wakame
     
     def on_canceled
     end
-    
-    private
-    def sync_trigger_action(action, succ_proc, fail_proc)
-      action.job_id = self.job_id
-      action.bind_triggered_rule(self.trigger)
-      
-      Wakame.log.debug("Start nested action in SYNC: #{action.class.to_s}")
-      begin
-        action.run
-        succ_proc.call if succ_proc
-      rescue => e
-        fail_proc.call if fail_proc
-        raise
-      end
-      Wakame.log.debug("Complete nested action : #{action.class.to_s}")
-    end
-    
-    def async_trigger_action(action, succ_proc, fail_proc)
-      action.job_id = self.job_id
-      action.bind_triggered_rule(self.trigger)
-      
-      trigger.rule_engine.run_action(action)
-    end
-    
+
   end
 end

data/lib/wakame/actions/launch_cluster.rb

@@ -14,10 +14,13 @@ module Wakame
         EM.barrier {
           service_cluster.launch
         }
+        levels = service_cluster.dg.levels
+        Wakame.log.debug("#{self.class}: Resource launch order: " + levels.collect {|lv| '['+ lv.collect{|prop| "#{prop.class}" }.join(', ') + ']' }.join(', '))
+        acquire_lock { |list|
+          levels.each {|lv| list << lv.collect{|res| res.class } }
+        }
 
-        Wakame.log.debug("#{self.class}: Resource Launch Order: " + service_cluster.dg.levels.collect {|lv| '['+ lv.collect{|prop| "#{prop.class}" }.join(', ') + ']' }.join(', '))
-
-        service_cluster.dg.levels.each { |lv|
+        levels.each { |lv|
           lv.each { |svc_prop|
             trigger_action(PropagateInstances.new(svc_prop))
           }

data/lib/wakame/actions/launch_vm.rb

@@ -0,0 +1,57 @@
+module Wakame
+  module Actions
+    class LaunchVM < Action
+      def initialize(notes_key, ref_agent=nil)
+        @ref_agent = ref_agent
+        @notes_key = notes_key
+      end
+
+      USER_DATA_TMPL=<<__END__
+node=agent
+amqp_server=amqp://%s/
+agent_id=%s
+__END__
+
+      def run
+        require 'right_aws'
+        ec2 = RightAws::Ec2.new(Wakame.config.aws_access_key, Wakame.config.aws_secret_key, {:cache=>false})
+
+        # Fetch the reference vm slice attributes.
+        @ref_agent ||= master.agent_monitor.master_local
+        ref_attr = ec2.describe_instances([@ref_agent.attr[:instance_id]])
+        ref_attr = ref_attr[0]
+        
+
+        user_data = sprintf(USER_DATA_TMPL, master.attr[:local_ipv4], '')
+        Wakame.log.debug("#{self.class}: Lauching VM: #{ref_attr.inspect}\nuser_data: #{user_data}")
+        res = ec2.run_instances(ref_attr[:aws_image_id], 1, 1,
+                                ref_attr[:aws_groups],
+                                ref_attr[:ssh_key_name],
+                                user_data,
+                                'public', # addressing_type
+                                ref_attr[:aws_instance_type], # instance_type
+                                nil, # kernel_id
+                                nil, # ramdisk_id
+                                ref_attr[:aws_availability_zone], # availability_zone
+                                nil # block_device_mappings
+                                )[0]
+        inst_id = res[:aws_instance_id]
+
+        ConditionalWait.wait { | cond |
+          cond.wait_event(Event::AgentMonitored) { |event|
+            event.agent.attr[:instance_id] == inst_id
+          }
+          
+          cond.poll(5, 100) {
+            d = ec2.describe_instances([inst_id])[0]
+            Wakame.log.debug("#{self.class}: Polling describe_instances(#{inst_id}): #{d[:aws_state]} ")
+            d[:aws_state] == "running"
+          }
+        }
+
+        notes[@notes_key] = inst_id
+
+      end
+    end
+  end
+end

data/lib/wakame/actions/migrate_service.rb

@@ -1,23 +1,23 @@
 
-require 'wakame/actions/util'
-
 module Wakame
   module Actions
     class MigrateService < Action
-      include Actions::Util
-
       def initialize(service_instance, dest_agent=nil)
         @service_instance = service_instance
         @destination_agent = dest_agent
       end
 
       def run
+        acquire_lock { |list|
+          list << @service_instance.resource.class
+        }
+
         raise CancelActionError if @service_instance.status == Service::STATUS_MIGRATING
 
         EM.barrier {
           @service_instance.update_status(Service::STATUS_MIGRATING)
         }
-        prop = @service_instance.property
+        prop = @service_instance.resource
         if prop.duplicable
           clone_service(prop)
           flush_subactions
@@ -38,26 +38,7 @@ module Wakame
           new_svc = service_cluster.propagate(resource, true)
         }
 
-        agent = @destination_agent
-        if agent.nil?
-          EM.barrier {
-            agent = arrange_agent(resource)
-          }
-          if agent.nil?
-            inst_id = start_instance(master.attr[:ami_id], resource.vm_spec.current.attrs)
-            agent = agent_monitor.registered_agents[inst_id]
-          end
-        end
-
-        if !(agent && test_agent_candidate(resource, agent))
-          raise "Found confiction(s) when the agent is assigned to sevice: #{resource} #{agent} "
-        end
-
-        EM.barrier {
-          new_svc.bind_agent(agent)
-        }
-
-        trigger_action(StartService.new(new_svc))
+        trigger_action(StartService.new(new_svc, @destination_agent))
         new_svc
       end
     end

data/lib/wakame/actions/propagate_instances.rb

@@ -1,10 +1,6 @@
-
-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)
@@ -40,56 +36,35 @@ module Wakame
           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 {
-                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)
+                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
-            
-            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
+
+            Wakame.log.debug("#{self.class}: arranged agent for #{svc.resource.class}: #{target_agent ? target_agent.agent_id : nil}")
           end
 
-          trigger_action(StartService.new(svc))
+          trigger_action(StartService.new(svc, target_agent))
         }
         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

@@ -13,8 +13,8 @@ module Wakame
         #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)
+
+	@service_instance.resource.reload(@service_instance, self)
       end
     end
   end

data/lib/wakame/actions/shutdown_cluster.rb

@@ -3,6 +3,10 @@ module Wakame
     class ShutdownCluster < Action
       def run
         levels = service_cluster.dg.levels
+        Wakame.log.debug("#{self.class}: Resource shutdown order: " + levels.collect {|lv| '['+ lv.collect{|prop| "#{prop.class}" }.join(', ') + ']' }.join(', '))
+        acquire_lock { |list|
+          levels.each {|lv| list << lv.collect{|res| res.class } }
+        }
 
         levels.reverse.each { |lv|
           lv.each { |svc_prop|

data/lib/wakame/actions/start_service.rb

@@ -4,36 +4,57 @@ require 'wakame/rule'
 module Wakame
   module Actions
     class StartService < Action
-      def initialize(service_instance)
-        @acquire_lock = true
+      def initialize(service_instance, target_agent=nil)
         @service_instance = service_instance
+        @target_agent = target_agent
       end
 
       def run
-        if @service_instance.property.require_agent
+        if @service_instance.resource.require_agent
+
+          if @service_instance.agent.nil?
+            # Start new VM when the target agent is nil.
+            if @target_agent.nil?
+              inst_id_key = "new_inst_id_" + Wakame::Util.gen_id
+              trigger_action(LaunchVM.new(inst_id_key))
+              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
+              }
+            end
+
+            EM.barrier {
+              @service_instance.bind_agent(@target_agent)
+            }
+          end
+
+
           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}"
+          raise "Canceled as the service is being or already ONLINE: #{@service_instance.resource}"
         end
         EM.barrier {
           @service_instance.update_status(Service::STATUS_STARTING)
         }
         
-        if @service_instance.property.require_agent
+        if @service_instance.resource.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))
+          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))
           }
         }
 

data/lib/wakame/actions/stop_service.rb

@@ -28,10 +28,7 @@ module Wakame
 
         flush_subactions()
 
-        if @service_instance.status == Service::STATUS_ONLINE
-          @service_instance.property.stop(@service_instance, self)
-        else
-        end
+        @service_instance.property.stop(@service_instance, self)
         
         EM.barrier {
           service_cluster.destroy(@service_instance.instance_id)

data/lib/wakame/actions/util.rb

@@ -42,30 +42,6 @@ module Wakame
 
         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/mysql.rb

@@ -0,0 +1,106 @@
+class Wakame::Actor::MySQL
+  include Wakame::Actor
+
+  # for Amazon EC2
+  def take_master_snapshot(opt_map)
+    Wakame.log.debug("take_master_snapshot: #{opt_map.inspect}")
+
+    mysql_client = "/usr/bin/mysql -h#{opt_map[:master_ip]} -P#{opt_map[:master_port]} -u#{opt_map[:repl_user]} -p#{opt_map[:repl_pass]} -s"
+
+    # master info
+    Wakame::Util.exec("echo 'FLUSH TABLES WITH READ LOCK;' | #{mysql_client}")
+    master_status = `echo show master status | #{mysql_client}`.to_s.split(/\t/)[0..1]
+
+    # mysql/data/master.info
+    master_infos = []
+    master_infos << 14
+    master_infos << master_status[0]
+    master_infos << master_status[1]
+    master_infos << opt_map[:master_ip]
+    master_infos << opt_map[:repl_user]
+    master_infos << opt_map[:repl_pass]
+    master_infos << opt_map[:master_port]
+    master_infos << 60
+    master_infos << 0
+    master_infos << ""
+    master_infos << ""
+    master_infos << ""
+    master_infos << ""
+    master_infos << ""
+    master_infos << ""
+    Wakame.log.debug(master_infos)
+
+    master_info = File.expand_path('master.info', opt_map[:master_mysqld_datadir])
+    Wakame.log.debug("master_info : #{master_info}")
+    file = File.new(master_info, "w")
+    file.puts(master_infos.join("\n"))
+    file.chmod(0664)
+    file.close
+
+    require 'fileutils'
+    FileUtils.chown('mysql', 'mysql', master_info)
+    Wakame::Util.exec("/bin/sync")
+    sleep 1.0
+
+    #
+    require 'right_aws'
+    ec2 = RightAws::Ec2.new(opt_map[:aws_access_key], opt_map[:aws_secret_key])
+
+    volume_map = ec2.describe_volumes([opt_map[:master_ebs_volume]])[0]
+    Wakame.log.debug("describe_volume(#{opt_map[:master_ebs_volume]}): #{volume_map.inspect}")
+    if volume_map[:aws_status] == 'in-use'
+      # Nothin to be done
+    else
+      Wakame.log.debug("The EBS volume(slave) is not ready to attach: #{opt_map[:master_ebs_volume]}")
+      return
+    end
+
+    # create_snapshot
+    snapshot_map = ec2.create_snapshot(opt_map[:master_ebs_volume])
+    Wakame.log.debug("create_snapshot #{snapshot_map.inspect}")
+    cond = ConditionalWait.new { |c|
+      c.poll {
+        snapshot_map = ec2.describe_snapshots([snapshot_map[:aws_id]])[0]
+        Wakame.log.debug("describe_snapshot #{snapshot_map.inspect}")
+        Wakame::Util.exec("/bin/sync")
+        snapshot_map[:aws_status] == "completed"
+      }
+    }
+    cond.wait
+
+    # unlock
+    Wakame::Util.exec("echo 'UNLOCK TABLES;' | #{mysql_client}")
+
+    # create volume from snapshot
+    created_volume_from_snapshot_map = ec2.create_volume(snapshot_map[:aws_id], volume_map[:aws_size], volume_map[:zone])
+    Wakame.log.debug("create_volume_from_snapshot #{created_volume_from_snapshot_map}")
+    cond = ConditionalWait.new { |c|
+      c.poll {
+        volume_map = ec2.describe_volumes([created_volume_from_snapshot_map[:aws_id]])[0]
+        Wakame.log.debug("describe_volume: #{volume_map.inspect}")
+        Wakame::Util.exec("/bin/sync")
+        volume_map[:aws_status] == "available"
+      }
+    }
+    cond.wait
+
+    # delete_snapshot
+    delete_map = ec2.delete_snapshot(snapshot_map[:aws_id])
+    Wakame.log.debug("delete_map #{delete_map.inspect}")
+
+    # attach_volume
+    Wakame.log.debug("attach-target #{volume_map.inspect}")
+    attach_volume_map = ec2.attach_volume(volume_map[:aws_id], agent.agent_id, opt_map[:ebs_device])
+    Wakame.log.debug("attach_volume_map #{attach_volume_map.inspect}")
+    cond = ConditionalWait.new { |c|
+      c.poll {
+        volume_map = ec2.describe_volumes([attach_volume_map[:aws_id]])[0]
+        Wakame.log.debug("describe_volume #{volume_map.inspect}")
+        Wakame::Util.exec("/bin/sync")
+        volume_map[:aws_status] == "in-use"
+      }
+    }
+    cond.wait
+
+  end
+end