wakame 0.5.0 → 0.5.1

data/lib/wakame/status_db.rb

@@ -1,5 +1,6 @@
 
 require 'thread'
+require 'timeout'
 
 module Wakame
   module StatusDB
@@ -12,28 +13,41 @@ module Wakame
       end
     end
     
-    def self.barrier(&blk)
+    def self.barrier(tout=60*2, &blk)
       abort "Cant use barrier() in side of the EventMachine thread." if Kernel.const_defined?(:EventMachine) && ::EventMachine.reactor_thread?
 
       if Thread.current == WorkerThread.worker_thread
         return blk.call
       end
       
-      @q ||= ::Queue.new
+      Wakame.log.debug("StatusDB.barrier: Called at #{caller(1)[0..1].inspect} on the thread #{Thread.current}.")
+
+      q = ::Queue.new
       time_start = ::Time.now
       
       self.pass {
         begin
           res = blk.call
-          @q << [true, res]
+          q << [true, res]
         rescue => e
-          @q << [false, e]
+          q << [false, e]
         end
       }
-      
-      res = @q.shift
+
+      res = nil
+      begin
+        timeout(tout) do
+          res = q.shift
+        end
+      rescue Timeout::Error => e
+        Wakame.log.error("WorkerThread.queue.size=#{WorkerThread.queue.size}")
+        Wakame.log.error(e)
+        raise e
+      end
+
       time_elapsed = ::Time.now - time_start
       Wakame.log.debug("#{self}.barrier: Elapsed time for #{blk}: #{time_elapsed} sec") if time_elapsed > 0.05
+
       if res[0] == false && res[1].is_a?(Exception)
         raise res[1]
       end
@@ -56,8 +70,11 @@ module Wakame
         if @thread.nil?
           @thread = Thread.new {
             while blk = queue.deq
+              Wakame.log.debug("#{self}: Queued Jobs: #{queue.size}") if queue.size > 0
               begin
-                blk.call
+                Wakame::Models::ObjectStore.db.transaction {
+                  blk.call
+                }
               rescue => e
                 Wakame.log.error("#{self.class}: #{e}")
                 Wakame.log.error(e)
@@ -70,7 +87,7 @@ module Wakame
 
       def self.terminate
         if self.queue.size > 0
-          Wakame.log.warn("#{self.class}: #{self.class.queue.size} of non-processed reqs are going to be ignored to shutdown the worker thread.")
+          Wakame.log.warn("#{self.class}: #{self.class.queue.size} of queued reqs are going to be ignored to shutdown the worker thread.")
           self.queue.clear
         end
         self.worker_thread.kill if !self.worker_thread.nil? && self.worker_thread.alive?
@@ -83,72 +100,20 @@ module Wakame
     end
 
     class SequelAdapter
-      DATA_FORMAT_VERSION='0.4'
 
       def initialize
-        require 'sequel/core'
-        require 'sequel/model'
-
-        #@db = Sequel.connect(Wakame.config.status_db_dsn, {:logger=>Wakame.log})
-        @db = Sequel.connect(Wakame.config.status_db_dsn)
-        
-        if [:metadata, :model_stores].all?{ |i| @db.table_exists?(i) }
-          m = @db[:metadata].where(:id=>1).first
-
-          unless m && m[:version] == DATA_FORMAT_VERSION
-            setup_store
-          end
-
-        else
-          setup_store
-        end
-
-        # Generate Sequel::Model class dynamically.
-        # This is same as below:
-        # class ModelStore < Sequel::Model
-        #    unrestrict_primary_key
-        # end
-        @model_class = Class.new(Sequel::Model(:model_stores)) { |klass|
-          klass.unrestrict_primary_key
-        }
-        @model_class.plugin :schema
-        @model_class.plugin :hook_class_methods
-        @model_class.class_eval {
-          before_create(:set_created_at) do
-            self.updated_at = self.created_at = Time.now
-          end
-          before_update(:set_updated_at) do
-            self.updated_at = Time.now
-          end
-        }
-        # @model_class.plugin :caching, store
-      end
-
-      def setup_store
-        @db.drop_table :metadata rescue nil
-        @db.create_table? :metadata do
-          primary_key :id
-          column :version, :string
-          column :created_at, :datetime
-        end
-
-        @db[:metadata].insert(:version=>DATA_FORMAT_VERSION, :created_at=>Time.now)
-
-        @db.drop_table :model_stores rescue nil
-        @db.create_table? :model_stores do
-          primary_key :id, :string, :size=>50, :auto_increment=>false
-          column :class_type, :string
-          column :dump, :text
-          column :created_at, :datetime
-          column :updated_at, :datetime
-        end
+        @model_class = Wakame::Models::ObjectStore
       end
 
-      def find(id, &blk)
+      def find(id)
+        Wakame.log.debug("StatusDB.find(#{id}) called by #{Thread.current.to_s}")  unless Thread.current == WorkerThread.worker_thread 
         m = @model_class[id]
         if m
           hash = eval(m[:dump])
-          blk.call(id, hash)
+          hash[AttributeHelper::CLASS_TYPE_KEY]=m.class_type
+          hash
+        else
+          nil
         end
       end
 
@@ -164,22 +129,23 @@ module Wakame
       end
 
       def save(id, hash)
+        Wakame.log.debug("StatusDB.save(#{id}) called by #{Thread.current.to_s}") unless Thread.current == WorkerThread.worker_thread 
         m = @model_class[id]
         if m.nil? 
           m = @model_class.new
           m.id = id
           m.class_type = hash[AttributeHelper::CLASS_TYPE_KEY]
-       end 
+        end 
         m.dump = hash.inspect
         m.save
       end
 
       def delete(id)
+        Wakame.log.debug("StatusDB.delete(#{id}) called by #{Thread.current.to_s}") unless Thread.current == WorkerThread.worker_thread 
         @model_class[id].destroy
       end
 
       def clear_store
-        setup_store
       end
       
     end
@@ -214,32 +180,34 @@ module Wakame
           obj = _instance_cache[id]
           return obj unless obj.nil?
 
-          StatusDB.adapter.find(id) { |id, hash|
-            if hash[AttributeHelper::CLASS_TYPE_KEY]
-              klass_const = Util.build_const(hash[AttributeHelper::CLASS_TYPE_KEY])
-            else
-              klass_const = self.class
-            end
-
-            # klass_const class is equal to self class or child of self class
-            if klass_const <= self
-              obj = klass_const.new
-            else
-              raise "Can not instanciate the object #{klass_const.to_s} from #{self}"
-            end
-
-            obj.on_before_load
-
-            obj.instance_variable_set(:@id, id)
-            obj.instance_variable_set(:@_orig, hash.dup.freeze)
-            obj.instance_variable_set(:@load_at, Time.now)
-        
-            hash.each { |k,v|
-              obj.instance_variable_set("@#{k}", v)
-            }
+          hash = StatusDB.barrier {
+            StatusDB.adapter.find(id)
+          }
+          return nil unless hash
 
-            obj.on_after_load
+          if hash[AttributeHelper::CLASS_TYPE_KEY]
+            klass_const = Util.build_const(hash[AttributeHelper::CLASS_TYPE_KEY])
+          else
+            klass_const = self
+          end
+          
+          # klass_const class is equal to self class or child of self class
+          if klass_const <= self
+            obj = klass_const.new
+          else
+            raise "Can not instanciate the object #{klass_const.to_s} from #{self}"
+          end
+          
+          obj.on_before_load
+          
+          obj.instance_variable_set(:@id, id)
+          obj.instance_variable_set(:@load_at, Time.now)
+          
+          hash.each { |k,v|
+            obj.instance_variable_set("@#{k}", v)
           }
+          
+          obj.on_after_load
 
           _instance_cache[id] = obj
           obj
@@ -247,13 +215,17 @@ module Wakame
 
 
         def find_all
-          StatusDB.adapter.find_all(self.to_s).map { |id|
-            find(id)
+          StatusDB.barrier {
+            StatusDB.adapter.find_all(self.to_s).map { |id|
+              find(id)
+            }
           }
         end
 
         def exists?(id) 
-          _instance_cache.has_key?(id) || StatusDB.adapter.exists?(id)
+          StatusDB.barrier {
+            _instance_cache.has_key?(id) || StatusDB.adapter.exists?(id)
+          }
         end
 
         # A helper method to define an accessor with persistent flag.
@@ -271,8 +243,9 @@ module Wakame
           obj = find(id)
           if obj
             obj.on_before_delete
-
-            StatusDB.adapter.delete(id)
+            StatusDB.barrier {
+              StatusDB.adapter.delete(id)
+            }
             _instance_cache.delete(id)
 
             obj.on_after_delete 
@@ -300,33 +273,18 @@ module Wakame
         @load_at.nil?
       end
 
-      def dirty?(key=nil)
-        return true if new_record?
-
-        if key
-          attr_attr = self.class.get_attr_attribute(key.to_sym)
-          raise "#{key} is not the key to be saved" if attr_attr.nil? || !attr_attr[:persistent]
-          return @_orig[key.to_sym] != self.__send__(key.to_sym)
-        else
-          self.class.merged_attr_attributes.each { |k,v|
-            next unless v[:persistent]
-            #p "@_orig[#{k.to_sym}]=#{@_orig[k.to_sym].inspect}"
-            #p "@self.__send__(#{k.to_sym})=#{self.__send__(k.to_sym).inspect}"
-            return true if @_orig[k.to_sym] != self.__send__(k.to_sym)
-          }
-          return false
-        end
+      def dirty?
+        raise NotImplementedError
       end
 
       def save
-#        return unless dirty?
-#       raise "No change" unless dirty?
+        #return unless dirty?
 
         validate_on_save
 
         self.class.merged_attr_attributes.each { |k,v|
           next unless v[:persistent]
-          if dirty?(k) && v[:call_after_changed]
+          if v[:call_after_changed]
             case v[:call_after_changed]
             when Symbol
               self.__send__(v[:call_after_changed].to_sym) # if self.respond_to?(v[:call_after_changed].to_sym)
@@ -341,9 +299,9 @@ module Wakame
             dumper.call(k)
           end
         }
-        @_orig = hash_saved.dup.freeze
-
-        StatusDB.adapter.save(self.id, hash_saved)
+        StatusDB.barrier {
+          StatusDB.adapter.save(self.id, hash_saved)
+        }
       end
 
       def delete
@@ -352,7 +310,29 @@ module Wakame
 
       def reload
         self.class._instance_cache.delete(self.id)
-        self.class.find(self.id)
+        hash = StatusDB.barrier {
+          StatusDB.adapter.find(self.id)
+        }
+        if hash[AttributeHelper::CLASS_TYPE_KEY]
+          klass_const = Util.build_const(hash[AttributeHelper::CLASS_TYPE_KEY])
+        else
+          klass_const = self.class
+        end
+        
+        # klass_const class is equal to self class or child of self class
+        unless klass_const <= self.class
+          raise "The class \"#{klass_const.to_s}\" has no relationship to #{self.class}"
+        end
+        
+        on_before_load
+        
+        @load_at = Time.now
+        
+        hash.each { |k,v|
+          instance_variable_set("@#{k}", v)
+        }
+            
+        on_after_load
       end
 
       # Callback methods

data/lib/wakame/util.rb

@@ -209,9 +209,12 @@ module AttributeHelper
 
     def merged_attr_attributes
       hash = {}
+
+      deep_merge = proc {|key,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &deep_merge) : v2}
+
       self.ancestors.reverse.each { |klass|
         next unless klass.include?(AttributeHelper)
-        hash.merge!(klass.attr_attributes.dup)
+        hash.merge!(klass.attr_attributes, &deep_merge)
       }
       hash
     end
@@ -220,6 +223,16 @@ module AttributeHelper
       merged_attr_attributes[attr_name]
     end
 
+    # Update attr_attributes[name][:default] value.
+    # This works for existing name key.
+    def update_attribute(name, v)
+      attr_attr = get_attr_attribute(name.to_sym)
+      raise "No such defined attribute: #{name}" if attr_attr.nil?
+      attr_attributes[name.to_sym] ||= {}
+      attr_attributes[name.to_sym].merge!({:default=>v})
+      name
+    end
+
     def def_attribute(name, *args)
       attr = begin 
                if args.size == 0
@@ -233,9 +246,10 @@ module AttributeHelper
                  end
                end
              end
-
       (attr_attributes[name.to_sym] ||= {}).merge!(attr)
 
+      attr = self.merged_attr_attributes
+
       if attr[:read_only]
         if self.respond_to? "#{name}=".to_sym
           class_eval %Q{
@@ -245,7 +259,6 @@ module AttributeHelper
       else
         class_eval <<-__E__
         def #{name}=(v)
-          self.#{name}
           @#{name}=v
         end
 
@@ -256,18 +269,16 @@ module AttributeHelper
       class_eval <<-__E__
       def #{name}
         if @#{name}.nil?
-          retrieve_attr_attribute { |a|
-            if a.has_key?(:#{name})
-              defval = a[:#{name}][:default]
-              case defval
-              when Proc
-                @#{name} = defval.call(self)
-              else
-                @#{name} = defval.dup rescue defval
-              end
-              break
-            end
-          }
+          a = self.class.get_attr_attribute(:#{name})
+          if a
+            defval = a[:default]
+            @#{name} = case defval
+                       when Proc
+                         defval.call(self)
+                       else
+                         defval.dup rescue defval
+                       end
+          end
         end
         @#{name}
       end

data/tests/setup_master.rb

@@ -11,6 +11,7 @@ require 'test/unit'
 
 require 'wakame'
 require 'wakame/initializer'
+require 'wakame/util'
 
 require 'ext/eventmachine'
 

data/tests/test_master.rb

@@ -6,10 +6,8 @@ $:.unshift(File.dirname(__FILE__))
 require 'setup_master.rb'
 
 require 'wakame'
-#require 'wakame/master'
 require 'wakame/service'
 require 'wakame/queue_declare'
-#require 'wakame/packets'
 
 class TestMaster < Test::Unit::TestCase
 

data/tests/test_model_agent_pool.rb

@@ -0,0 +1,21 @@
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+
+require 'setup_master.rb'
+
+require 'test/unit'
+
+Wakame.config.status_db_dsn = 'sqlite:/'
+Wakame::Initializer.run(:setup_database)
+
+require 'wakame/models/agent_pool'
+
+class TestModelAgentPool < Test::Unit::TestCase
+  include Wakame::Models
+
+  def test_pool
+    AgentPool.instance
+    AgentPool.instance.reset
+  end
+end