wakame 0.5.0 → 0.5.1

data/lib/wakame/actions/stop_service.rb

@@ -9,20 +9,15 @@ module Wakame
 
 
       def run
+        acquire_lock(@svc.resource.class.to_s)
+        @svc.reload
+
         # Skip to act when the service is having below status.
-        if @svc.status == Service::STATUS_STOPPING || @svc.status == Service::STATUS_OFFLINE
+        if @svc.status == Service::STATUS_TERMINATE && @svc.monitor_status == Service::STATUS_OFFLINE
           Wakame.log.info("Ignore to stop the service as is being or already OFFLINE: #{@svc.resource.class}")
           return
         end
 
-        acquire_lock { |lst|
-          lst << @svc.resource.class.to_s
-        }
-
-        if @svc.resource.require_agent && !@svc.cloud_host.mapped?
-          raise "Agent is not bound on this service : #{@svc}"
-        end
-
         StatusDB.barrier {
           @svc.update_status(Service::STATUS_STOPPING)
         }
@@ -30,7 +25,10 @@ module Wakame
         trigger_action(NotifyChildChanged.new(@svc))
         flush_subactions
 
-        @svc.resource.stop(@svc, self)
+        @svc.reload
+        if @svc.monitor_status == Wakame::Service::STATUS_ONLINE
+          @svc.resource.stop(@svc, self)
+        end
 
         if @do_terminate
           if @svc.resource.require_agent

data/lib/wakame/actions/unfreeze_cluster.rb

@@ -0,0 +1,15 @@
+module Wakame
+  module Actions
+    class UnfreezeCluster < Action
+
+      def run
+        acquire_lock(cluster.resources.keys.map {|resid| Service::Resource.find(resid).class.to_s  })
+
+        StatusDB.barrier {
+          cluster.update_freeze_status(Service::ServiceCluster::STATUS_UNFROZEN)
+        }
+
+      end
+    end
+  end
+end

data/lib/wakame/actor.rb

@@ -20,13 +20,10 @@ module Wakame
         @exposed[path]=meth
       end
 
-      def map_path
+      def map_path(path=nil)
+        @map_path = path if path
         @map_path ||= Util.snake_case(self.to_s.split('::').last)
       end
-      
-      def map_path=(name)
-        @map_path=name
-      end
     end
     
   end

data/lib/wakame/actor/deploy.rb

@@ -0,0 +1,110 @@
+
+require 'uri'
+require 'fileutils'
+
+class Wakame::Actor::Deploy
+  include Wakame::Actor
+
+  # Download the application from repo_uri using arbitrary SCM tool.
+  def checkout(ticket, repo_type, repo_uri, deploy_rev, app_root, app_name, options={})
+    
+    case repo_type
+    when 's3'
+      tmp_dest = checkout_s3(repo_uri, deploy_rev, options)
+    when 'curl'
+      tmp_dest = checkout_curl(repo_uri, deploy_rev, options)
+    else
+      raise "Unsupported repository type: #{repo_type}"
+    end
+
+    dest = File.expand_path(File.join(app_name, ticket), app_root)
+    
+    begin
+      FileUtils.mkpath(File.dirname(dest))
+      Wakame.log.debug("FileUtils.move('#{tmp_dest}', '#{dest}')")
+      FileUtils.move(tmp_dest, dest)
+
+      FileUtils.rm_f(File.join(File.dirname(dest), 'latest'))
+      FileUtils.symlink(File.basename(dest), File.join(File.dirname(dest), 'latest'))
+    rescue
+      FileUtils.rm_r(dest) rescue nil
+    end
+  end
+
+  # Swap the symlink "current" in /app_root/app_name to point the location as same as
+  # "latest" in the same folder.
+  def swap_current_link(app_root, app_name)
+    raise "Invalid application root path. Must be an absolute path: #{app_root}" unless app_root =~ /\A\//
+
+    latest_lnk_path = File.join(app_root, app_name, 'latest')
+    cur_lnk_path = File.join(app_root, app_name, 'current')
+    raise "'latest' symlink does not exist in #{File.join(app_root, app_name)}" unless File.symlink?(latest_lnk_path)
+    
+
+    tgt = File.readlink(latest_lnk_path)
+    raise "'latest' symlink may point the target in differnt folder: #{tgt}" if tgt =~ /[\/]/
+
+    if File.symlink?(cur_lnk_path)
+      FileUtils.rm_f(cur_lnk_path)
+    end
+    FileUtils.symlink(tgt, cur_lnk_path)
+  end
+
+  private
+
+  def checkout_s3(repo_uri, deploy_rev, options)
+    require 'right_aws'
+    s3 = RightAws::S3Interface.new(options[:aws_access_key], options[:aws_secret_key])
+
+    bucket = nil
+    begin
+      u = URI.parse(repo_uri)
+      if u.host =~ /\A(.+)\.s3.amazonaws.com\Z/
+        bucket = $1
+        key = u.path.sub(/\A\//, '')
+      else
+        bucket, key = u.path.sub(/\A\//, '').split(/\//, 2)
+      end
+
+      key = key.nil? ? deploy_rev.dup : (key + deploy_rev)
+
+    rescue URI::InvalidURIError
+      # Assume that repo_uri has "bucket/key" syntax.
+      bucket, key = repo_uri.sub(/\A\//, '').split(/\//, 2)
+      key = key.nil? ? deploy_rev.dup : (key + deploy_rev)
+    end
+
+    tmp_dest = File.expand_path(File.basename(key), '/var/tmp')
+    dest = File.join(File.dirname(tmp_dest), 'aaa')
+    begin
+      Wakame.log.debug("Fetching archive from: s3.get: #{bucket}/#{key}")
+      tmp_f  = File.new(tmp_dest, "w")
+      s3.get(bucket, key) { |buf|
+        tmp_f.write(buf)
+      }
+      tmp_f.close
+
+      Wakame::Util.exec('/usr/bin/unzip \'%s\' -d \'%s\'' % [tmp_dest, dest])
+      return dest
+    ensure 
+      File.unlink(tmp_dest) rescue nil
+    end
+
+  end
+
+  def checkout_curl(repo_uri, deploy_rev, options)
+    src_uri = URI.parse(repo_uri + deploy_rev)
+    tmp_dest = File.expand_path(File.basename(src_uri.path), '/var/tmp')
+    dest = File.join(File.dirname(tmp_dest), 'aaa')
+
+    begin 
+      Wakame::Util.exec('/usr/bin/curl -o \'%s\' \'%s\'' % [tmp_dest, src_uri])
+      raise "" unless File.exists?(tmp_dest)
+      Wakame::Util.exec('/usr/bin/unzip \'%s\' -d \'%s\'' % [tmp_dest, dest])
+      return dest
+    ensure
+      File.unlink(tmp_dest) rescue nil
+    end
+  end
+
+end

data/lib/wakame/actor/monitor.rb

@@ -0,0 +1,14 @@
+
+class Wakame::Actor::Monitor
+  include Wakame::Actor
+
+  def reload(monitor_path, config)
+    mon = agent.monitor_manager.find_monitor(monitor_path) ||
+      raise("#{self.class}: The monitor namespace was not found: #{monitor_path}")
+    
+    EM.barrier {
+      mon.reload(config)
+    }
+  end
+  
+end

data/lib/wakame/actor/s3fs.rb

@@ -0,0 +1,45 @@
+
+require 'shellwords'
+require 'ext/shellwords' unless Shellwords.respond_to? :shellescape
+
+class Wakame::Actor::S3fs
+  include Wakame::Actor
+
+  def mount(bucket, path, opts={})
+    Wakame.log.debug("Wakame::Actor::S3fs.mount")
+    #return
+    raise "#{path} does not exist or not directory." unless File.directory?(path)
+    #  's3fs' or '/dev/xxx' ?
+    mount_point_dev=`/bin/df "#{path}" | /usr/bin/awk 'NR==2 {print $1}'`.strip
+    Wakame.log.debug("#{mount_point_dev}: #{bucket}, /bin/mount | awk '$3==path {print $1}' path=\"#{path}\"")
+
+    if mount_point_dev != 's3fs'
+      Wakame.log.debug("Mounting volume: #{bucket} as #{path} (with options: #{opts})")
+      Wakame::Util.exec("/usr/local/sbin/s3fs #{escape_mount_opts(opts)} '#{Shellwords.shellescape(bucket)}' '#{Shellwords.shellescape(path)}'")
+    else
+      Wakame.log.debug("Mounting s3fs bucket: #{bucket} as #{path} (with options: #{opts})")
+    end
+  end
+
+  def umount(path)
+    Wakame.log.debug("Wakame::Actor::S3fs.umount")
+    #return
+    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 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(',')
+    "-o #{Shellwords.shellescape(out)}"
+  end
+
+end

data/lib/wakame/actor/service_monitor.rb

@@ -2,23 +2,6 @@
 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)
-    }
-    self.return_value = check_status(svc_id)
-  end
-
-  expose '/service_monitor/unregister', :unregister
-  def unregister(svc_id)
-    EM.barrier {
-      svcmon = agent.monitor_registry.find_monitor('/service')
-      svcmon.unregister(svc_id)
-    }
-  end
-
   # Immediate status check for the specified Service ID.
   def check_status(svc_id)
     self.return_value = EM.barrier {

data/lib/wakame/actor/system.rb

@@ -1,7 +1,7 @@
 
-
 require 'shellwords'
 require 'ext/shellwords' unless Shellwords.respond_to? :shellescape
+require 'fileutils'
 
 class Wakame::Actor::System
   include Wakame::Actor
@@ -43,6 +43,10 @@ class Wakame::Actor::System
     Wakame.log.debug("Unmounting volume: #{mount_point_dev} on #{path}")
     Wakame::Util.exec("/bin/umount '#{Shellwords.shellescape(path)}'")
   end
+
+  def touch(path)
+    FileUtils.touch(path)
+  end
   
   private
   def escape_mount_opts(opts)

data/lib/wakame/agent.rb

@@ -9,35 +9,33 @@ require 'thread'
 require 'wakame'
 require 'wakame/amqp_client'
 require 'wakame/queue_declare'
-#require 'wakame/event'
-#require 'wakame/vm_manipulator'
-
 
 module Wakame
   class Agent
     include AMQPClient
     include QueueDeclare
 
-    #define_queue 'agent_command.%{agent_id}', 'agent_command', {:key=>'agent_id.%{agent_id}', :auto_delete=>true}
     define_queue 'agent_actor.%{agent_id}', 'agent_command', {:key=>'agent_id.%{agent_id}', :auto_delete=>true}
 
-    attr_reader :actor_registry, :monitor_registry
+    attr_reader :managers, :monitor_manager, :actor_manager
 
     def agent_id
       @agent_id
     end
 
     def initialize(opts={})
+      @managers = {}
       determine_agent_id
-      @actor_registry = ActorRegistry.new
-      @monitor_registry = MonitorRegistry.new
     end
 
     # post_setup
     def init
-      setup_monitors
-      setup_actors
-      setup_dispatcher
+      @monitor_manager = register_manager(AgentManagers::MonitorManager.new)
+      @actor_manager = register_manager(AgentManagers::ActorManager.new)
+
+      @managers.values.each { |mgr|
+        mgr.init
+      }
 
       if Wakame.config.environment == :EC2
         attrs = self.class.ec2_fetch_local_attrs
@@ -45,78 +43,31 @@ module Wakame
         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}")
+      Wakame.log.info("Started agent process : AMQP Server=#{amqp_server_uri.to_s} WAKAME_ROOT=#{Wakame.config.root_path} WAKAME_ENV=#{Wakame.config.environment}, attrs=#{attrs.inspect}")
     end
 
-#     def send_event_response(event)
-#       Wakame.log.debug("Sending event to master : #{event.class}")
-#       publish_to('agent_event', Marshal.dump(Packets::EventResponse.new(self, event)))
-#     end
-
     def cleanup
       publish_to('registry', Packets::UnRegister.new(self).marshal)
-      #@cmd_t.kill
     end
 
     def determine_agent_id
       if Wakame.config.environment == :EC2
         @agent_id = self.class.ec2_query_metadata_uri('instance-id')
       else
-        @agent_id = '__STAND_ALONE__'
-      end
-    end
-
-
-    def setup_monitors
-      load_monitors
-
-      @monitor_registry.register(Monitor::Agent.new, '/agent')
-      @monitor_registry.register(Monitor::Service.new, '/service')
-      
-      @monitor_registry.monitors.each { |path, mon|
-        mon.agent = self
-        mon.setup(path)
-      }
-    end
-
-    def load_monitors
-      require 'wakame/monitor/agent'
-      require 'wakame/monitor/service'
-    end
-
-    def setup_actors
-      load_actors
+        # for Linux
+        @nic = 'eth0'
 
-      @actor_registry.register(Actor::ServiceMonitor.new, '/service_monitor')
-      @actor_registry.register(Actor::Daemon.new, '/daemon')
-      @actor_registry.register(Actor::System.new, '/system')
-      @actor_registry.register(Actor::MySQL.new, '/mysql')
-      @actor_registry.actors.each { |path, actor|
-#        actor.setup(path)
-        actor.agent = self
-      }
-    end
-    
-    def load_actors
-      require 'wakame/actor/service_monitor'
-      require 'wakame/actor/daemon'
-      require 'wakame/actor/system'
-      require 'wakame/actor/mysql'
-    end
+        cmd = (`/sbin/ifconfig #{@nic}`).split(/\n+/)
+        cmd[0] =~ %r/^#{@nic}\s+Link\sencap:Ethernet\s+HWaddr\s(\S+)\s+$/m
+        @macaddr = $1
 
+        cmd[1] =~ %r/^\s+inet addr:(\d+\.\d+\.\d+\.\d+).*$/m
+        abort("Failed to get ipaddress") if cmd[1].nil?
+        @ipaddr = $1
 
-    def setup_dispatcher
-      @dispatcher = Dispatcher.new(self)
-      
-      add_subscriber("agent_actor.#{agent_id}") { |data|
-        begin 
-          request = eval(data)
-          @dispatcher.handle_request(request)
-        rescue => e
-          Wakame.log.error(e)
-          agent.publish_to('agent_event', Packets::ActorResponse.new(self, request[:token], Actor::STATUS_FAILED).marshal)
-        end
-      }
+        @agent_id = "#{@ipaddr}-#{@macaddr}"
+        @agent_id
+      end
     end
 
     def self.ec2_query_metadata_uri(key)
@@ -136,119 +87,18 @@ module Wakame
       attrs
     end
 
-  end
-
-
-  class ActorRegistry
-    attr_reader :actors
-    def initialize()
-      @actors = {}
-    end
-
-    def register(actor, path=nil)
-      raise '' unless actor.kind_of?(Wakame::Actor)
 
-      if path.nil?
-        path = '/' + Util.to_const_path(actor.class.to_s)
-      end
-
-      if @actors.has_key?(path)
-        Wakame.log.error("#{self.class}: Duplicate registration: #{path}")
-        raise "Duplicate registration: #{path}"
-      end
-      
-      @actors[path] = actor
+    def register_manager(agent_mgr)
+      raise ArgumentError unless agent_mgr.kind_of? Wakame::AgentManager
+      agent_mgr.agent = self
+      raise "The manager module is registered: #{agent_mgr.class.to_s}" if @managers.has_key? agent_mgr.class.to_s
+      @managers[agent_mgr.class.to_s] = agent_mgr
+      agent_mgr
     end
 
-    def unregister(path)
-      @actors.delete(path)
-    end
-
-    def find_actor(path)
-      @actors[path]
+    def unregister_manager(agent_mgr_name)
+      @managers.delete(agent_mgr_name.to_s)
     end
 
   end
-
-
-  class MonitorRegistry
-    attr_reader :monitors
-    def initialize()
-      @monitors = {}
-    end
-
-    def register(monitor, path=nil)
-      raise '' unless monitor.kind_of?(Wakame::Monitor)
-
-      if path.nil?
-        path = '/' + Util.to_const_path(monitor.class.to_s)
-      end
-
-      if @monitors.has_key?(path)
-        Wakame.log.error("#{self.class}: Duplicate registration: #{path}")
-        raise "Duplicate registration: #{path}"
-      end
-      
-      @monitors[path] = monitor
-    end
-
-    def unregister(path)
-      @monitors.delete(path)
-    end
-
-    def find_monitor(path)
-      @monitors[path]
-    end
-  end
-
-
-  class Dispatcher
-    attr_reader :agent
-
-    def initialize(agent)
-      @agent = agent
-    end
-
-    def handle_request(request)
-      slash = request[:path].rindex('/')
-      raise "Invalid request path: #{request[:path]}" unless slash
-
-      prefix = request[:path][0, slash]
-      action = request[:path][slash+1, request[:path].length]
-
-      actor = agent.actor_registry.find_actor(prefix)
-      unless actor
-        Wakame.log.error("No refered actor instance: #{prefix}")
-        raise
-      end
-
-      EM.defer(proc {
-                 begin
-                   Wakame.log.debug("#{self.class}: Started to run the actor: #{actor.class}, token=#{request[:token]}")
-                   agent.publish_to('agent_event', Packets::ActorResponse.new(agent, request[:token], Actor::STATUS_RUNNING).marshal)
-                   if request[:args].nil?
-                     actor.send(action)
-                   else
-                     actor.send(action, *request[:args])
-                   end
-                   Wakame.log.debug("#{self.class}: Finished to run the actor: #{actor.class}, token=#{request[:token]}")
-                   actor.return_value
-                 rescue => e
-                   Wakame.log.error("#{self.class}: Failed the actor: #{actor.class}, token=#{request[:token]}")
-                   Wakame.log.error(e)
-                   e
-                 end
-               }, proc { |res|
-                 status = Actor::STATUS_SUCCESS
-                 if res.is_a?(Exception)
-                   status = Actor::STATUS_FAILED
-                 else
-                   opts = {:return_value=>res}
-                 end
-                 agent.publish_to('agent_event', Packets::ActorResponse.new(self.agent, request[:token], status, opts).marshal)
-               })
-    end
-  end
-  
-
-end 
+end