redis_object 1.0 → 1.1

data/lib/redis_object/ext/script_cache.rb

@@ -0,0 +1,92 @@
+$ScriptSHAMap = {}
+
+module Seabright
+	
+	class RedisObject
+		module ScriptSources; end
+	end
+	
+	module CachedScripts
+		
+		def run_script(name,keys=[],args=[],source=nil)
+			self.class.run_script(name,keys,args,source,store)
+		end
+		
+		module ClassMethods
+			
+			NoScriptError = "NOSCRIPT No matching script. Please use EVAL.".freeze
+			
+			def run_script(name,keys=[],args=[],source=nil,stor=nil)
+				@tmp_store = stor if stor
+				@rescue_recurse ||= 0
+				begin
+					out = (@tmp_store || store).evalsha(get_script_sha(name,source),keys,args)
+				rescue Redis::CommandError => e
+					if e.message == NoScriptError && @rescue_recurse < 3
+						puts "Rescuing NOSCRIPT error for #{name} - running again..." if DEBUG
+						untrack_script name
+						@rescue_recurse += 1
+						out = (@tmp_store || store).evalsha(get_script_sha(name,source),keys,args)
+					else
+						@rescue_recurse = 0
+						raise e
+					end
+				end
+				@rescue_recurse = 0
+				remove_instance_variable(:@tmp_store) if @tmp_store
+				out
+			end
+			
+			def get_script_sha(name,source=nil)
+				$ScriptSHAMap[name] ||= (script_sha_from_key(name) || store_script(name,source))
+			end
+			
+			def script_sha_from_key(name)
+				(@tmp_store || store).get(script_sha_key(name))
+			end
+			
+			class SourceNotFoundError < RuntimeError
+				def initialize
+					super("Could not locate script source")
+				end
+			end
+			
+			def store_script(name,source=nil)
+				source ||= script_source_from_const(name)
+				raise SourceNotFoundError unless source
+				sha = (@tmp_store || store).script(:load,source)
+				(@tmp_store || store).set(script_sha_key(name),sha)
+				sha
+			end
+			
+			def untrack_script(name)
+				ScriptSHAMap.delete name
+				(@tmp_store || store).del(script_sha_key(name))
+			end
+			
+			def script_source_from_const(name)
+				(self.const_defined?(name.to_sym) && self.const_get(name.to_sym)) || (RedisObject::ScriptSources.const_defined?(name.to_sym) && RedisObject::ScriptSources.const_get(name.to_sym)) || nil
+			end
+			
+			SCRIPT_KEY_PREFIX = "ScriptCache::SHA::".freeze
+			
+			def expire_all_script_shas(store_name=nil)
+				store_obj = store_name.is_a?(String) || store_name.is_a?(Symbol) ? store(store_name.to_sym) : store_name
+				store_obj.keys(script_sha_key("*")).each do |k|
+					store_obj.del k
+				end
+			end
+			
+			def script_sha_key(name)
+				"#{SCRIPT_KEY_PREFIX}#{name.to_s}"
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+	
+end

data/lib/redis_object/ext/shardable.rb

@@ -0,0 +1,18 @@
+module Seabright
+	module Shardable
+		
+		# Intention is to override any methods needed so that the underlying data can be safely sharded
+		
+		module ClassMethods
+			
+			# same here
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+	RedisObject.send(:include,Shardable)
+end

data/lib/redis_object/ext/triggers.rb

@@ -1,20 +1,72 @@
 module Seabright
 	module Triggers
 		
-		def set(k,v)
-			super(k,v)
-			if self.class.field_triggers[k.to_sym]
-				send(self.class.field_triggers[k.to_sym],k,v)
-			end
-			self.class.update_triggers.each do |actn|
-				send(actn.to_sym,k,v)
-			end
-		end
-		
 		module ClassMethods
 			
 			def trigger_on_set(fld,actn)
 				field_triggers[fld.to_sym] = actn.to_sym
+				intercept_sets_for_triggers!
+			end
+			
+			def intercept_sets_for_triggers!
+				return if @intercepted_sets_for_triggers
+				self.class_eval do
+					alias_method :untriggered_set, :set unless method_defined?(:untriggered_set)
+					def set(k,v)
+						untriggered_set(k,v)
+						unless self.class.untriggerables.include?(k)
+							begin
+								self.class.untriggerables << k
+								if self.class.field_triggers[k.to_sym]
+									send(self.class.field_triggers[k.to_sym],k,v)
+								end
+								self.class.update_triggers.each do |actn|
+									send(actn.to_sym,k,v)
+								end
+							ensure
+								self.class.untriggerables.delete k
+							end
+						end
+					end
+					alias_method :untriggered_setnx, :setnx unless method_defined?(:untriggered_setnx)
+					def setnx(k,v)
+						ret = untriggered_setnx(k,v)
+						unless self.class.untriggerables.include?(k)
+							begin
+								self.class.untriggerables << k
+								if self.class.field_triggers[k.to_sym]
+									send(self.class.field_triggers[k.to_sym],k,v)
+								end
+								self.class.update_triggers.each do |actn|
+									send(actn.to_sym,k,v)
+								end
+							ensure
+								self.class.untriggerables.delete k
+							end
+						end
+						ret
+					end
+					
+				end
+				@intercepted_sets_for_triggers = true
+			end
+			
+			def intercept_reference_for_triggers!
+				return if @intercepted_reference_for_triggers
+				self.class_eval do
+					alias_method :untriggered_reference, :reference unless method_defined?(:untriggered_reference)
+					def reference(obj)
+						untriggered_reference(obj)
+						self.class.reference_triggers.each do |actn|
+							send(actn.to_sym,obj)
+						end
+					end
+				end
+				@intercepted_reference_for_triggers = true
+			end
+			
+			def untriggerables
+				@untriggerables ||= [:updated_at,:created_at]
 			end
 			
 			def field_triggers
@@ -22,11 +74,21 @@ module Seabright
 			end
 			
 			def trigger_on_update(actn)
-				update_triggers.push actn.to_sym
+				update_triggers << actn.to_sym
+				intercept_sets_for_triggers!
 			end
 			
 			def update_triggers
-				@update_triggers ||= []
+				@update_triggers ||= Set.new
+			end
+			
+			def trigger_on_reference(actn)
+				reference_triggers << actn.to_sym
+				intercept_reference_for_triggers!
+			end
+			
+			def reference_triggers
+				@reference_triggers ||= Set.new
 			end
 			
 		end
@@ -36,4 +98,4 @@ module Seabright
 		end
 		
 	end
-end
+end

data/lib/redis_object/ext/view_caching.rb

@@ -0,0 +1,258 @@
+# View Caching
+# 
+# Cache a named view:
+#   cache_named_view :admin_view
+# 
+# Invalidate all cached views when the I receive notification that something I reference or have been referenced by has changed:
+#   invalidate_caches_from_upstream_updates!
+# 
+# Notify some objects that reference me when I am updated: (objects of these classes)
+#   invalidate_upstream Property, Application, PaymentRequest, PaymentResponse
+# 
+# Notify some objects in my collections when I am updated: (objects in these collections)
+#   invalidate_downstream :properties, :applications, :payment_requests, :payment_responses
+# 
+# You can also set up hooks for when this object is updated by certain types of objects by defining the following:
+#   def invalidated_by(obj,chain)
+#     invalidate_cached_view :blah
+#   end
+#   
+#   def invalidated_by_user(obj,chain)
+#     invalidate_cached_view :users
+#   end
+#   
+
+module Seabright
+	module ViewCaching
+		
+		CachedViewInvalidator = "
+			for i=1,#ARGV do
+				redis.call('HDEL', KEYS[1], ARGV[i])
+			end".gsub(/\t/,'').freeze
+				
+		module ClassMethods
+			
+			def cache_view(name,opts=true)
+				cached_views[name.to_sym] = opts
+				intercept_views_for_caching!
+				set_up_invalidation!
+			end
+			alias_method :cache_named_view, :cache_view
+			
+			def intercept_views_for_caching!
+				return if @cached_views_intercepted
+				self.class_eval do
+					
+					alias_method :uncached_view_as_hash, :view_as_hash unless method_defined?(:uncached_view_as_hash)
+					def view_as_hash(name)
+						return uncached_view_as_hash(name) unless self.class.view_should_be_cached?(name)
+						if v = view_from_cache(name)
+							puts "  Got view from cache: #{name}" if DEBUG
+							Yajl::Parser.parse(v)
+						else
+							puts "  View cache miss: #{name}" if DEBUG
+							cache_view_content(name)[0]
+						end
+					end
+					
+					alias_method :uncached_view_as_json, :view_as_json unless method_defined?(:uncached_view_as_json)
+					def view_as_json(name)
+						return uncached_view_as_json(name) unless self.class.view_should_be_cached?(name)
+						if v = view_from_cache(name)
+							puts "  Got view from cache: #{name}" if DEBUG
+							v
+						else
+							puts "  View cache miss: #{name}" if DEBUG
+							cache_view_content(name)[1]
+						end
+					end
+					
+					def cache_view_content(name,content=nil)
+						content ||= uncached_view_as_hash(name)
+						json = Yajl::Encoder.encode(content)
+						store.hset(cached_view_key,name,json)
+						[content,json]
+					end
+					
+					def view_from_cache(name)
+						if v = store.hget(cached_view_key,name)
+							v
+						else
+							nil
+						end
+					end
+					
+					def view_is_cached?(name)
+						store.hexists(cached_view_key, name)
+					end
+					
+					def cached_view_key
+						"#{hkey}::ViewCache"
+					end
+					
+					def regenerate_cached_views(*names)
+						names.each do |name|
+							cache_view_content name
+						end
+					end
+					
+					def regenerate_cached_views!
+						regenerate_cached_views(*self.class.cached_views.map {|name,opts| name })
+					end
+					
+				end
+				@cached_views_intercepted = true
+			end
+			
+			def set_up_invalidation!
+				return if @invalidation_set_up
+				self.class_eval do
+					
+					def invalidate_cached_views(*names)
+						puts "Invalidating cached views: #{names.join(", ")}" if Debug.verbose?
+						run_script(:CachedViewInvalidator, [cached_view_key], names, CachedViewInvalidator)
+						self.class.cache_invalidation_hooks do |hook|
+							hook.call(names)
+						end
+					end
+					alias_method :invalidate_cached_view, :invalidate_cached_views
+					
+					def invalidate_cached_views!
+						invalidate_cached_views(*self.class.cached_views.map {|name,opts| name })
+					end
+					
+					def invalidate_downstream!
+						return unless self.class.downstream_invalidations && (self.class.downstream_invalidations.size > 0)
+						puts "Invalidating downstream: #{self.class.downstream_invalidations.inspect}" if Debug.verbose?
+						self.class.downstream_invalidations.each do |col|
+							if has_collection?(col) && (colctn = get_collection(col))
+								colctn.each do |obj|
+									obj.invalidated_by_other(self,invalidation_chain + [self.hkey])
+								end
+							end
+						end
+					end
+					
+					def invalidate_upstream!
+						return unless self.class.upstream_invalidations && (self.class.upstream_invalidations.size > 0)
+						puts "Invalidating upstream: #{self.class.upstream_invalidations.inspect}" if Debug.verbose?
+						backreferences.each do |obj|
+							next unless self.class.upstream_invalidations.include?(obj.class.name.split("::").last.to_sym) #|| self.class.invalidate_everything_upstream?
+							obj.invalidated_by_other(self,invalidation_chain + [self.hkey]) if obj.respond_to?(:invalidated_by_other)
+						end
+					end
+					
+					def invalidated_by_update!(*args)
+						Thread.new do
+							invalidate_cached_views!
+							invalidate_up_and_down!
+						end
+					end
+					
+					def invalidated_by_reference!(*args)
+						invalidated_by_update!
+					end
+					
+					def invalidation_chain
+						@invalidation_chain ||= []
+					end
+					
+					def invalidate_up_and_down!
+						unless invalidation_chain.include?(self)
+							invalidate_downstream!
+							invalidate_upstream!
+						end
+					end
+					
+					def invalidated_by_other(obj,chain)
+						unless chain.include?(self.hkey)
+							puts "#{self.class.name}:#{self.id}'s view caches were invalidated by upstream object: #{obj.class.name}:#{obj.id} (chain:#{chain.inspect})" if Debug.verbose?
+							@invalidation_chain = chain
+							[:invalidated_by,"invalidated_by_#{obj.class.name.underscore}".to_sym].each do |meth_sym|
+								send(meth_sym,obj,chain) if respond_to?(meth_sym)
+							end
+							invalidate_up_and_down!
+						end
+					end
+					
+					trigger_on_update :invalidated_by_update!
+					trigger_on_reference :invalidated_by_reference!
+					
+				end
+				@invalidation_set_up = true
+			end
+			
+			def invalidate_caches_from_upstream_updates!
+				self.class_eval do
+					
+					def invalidated_by(obj,chain)
+						invalidate_cached_views!
+					end
+					
+				end
+			end
+			
+			def on_cache_invalidation(&block)
+				cache_invalidation_hooks << block
+			end
+			
+			def cache_invalidation_hooks
+				@cache_invalidation_hooks ||= []
+			end
+			
+			def invalidate_upstream(*args)
+				@upstream_invalidations = (@upstream_invalidations || []) + args
+				set_up_invalidation!
+			end
+			
+			def upstream_invalidations
+				@upstream_invalidations ||= []
+			end
+			
+			# def invalidate_everything_upstream!
+			# 	@invalidate_everything_upstream = true
+			# end
+			# 
+			# def invalidate_everything_upstream?
+			# 	@invalidate_everything_upstream
+			# end
+			
+			def invalidate_downstream(*args)
+				@downstream_invalidations = (@downstream_invalidations || []) + args
+				set_up_invalidation!
+			end
+			
+			def downstream_invalidations
+				@downstream_invalidations ||= []
+			end
+			
+			# def invalidate_everything_downstream!
+			# 	@invalidate_everything_downstream = true
+			# end
+			# 
+			# def invalidate_everything_downstream?
+			# 	@invalidate_everything_downstream
+			# end
+			
+			def view_should_be_cached?(name)
+				!!cached_views[name.to_sym]
+			end
+			
+			def cached_views
+				@cached_view ||= {}
+			end
+			
+			def cache_named_views!
+				named_views.each do |name,view|
+					cache_view name
+				end
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end