redis_object 0.5.0

data/lib/redis_object/ext/benchmark.rb

@@ -0,0 +1,34 @@
+module Seabright
+	module Benchmark
+		
+		module ClassMethods
+			
+			def benchmark(*method_names)
+				method_names.each do |method_name|
+					original_method = instance_method(method_name)
+					define_method(method_name) do |*args,&blk|
+						st = Time.now
+						out = original_method.bind(self).call(*args,&blk)
+						self.class.benchmark_out(method_name,args,Time.now - st)
+						out
+					end
+				end
+			end
+			
+			def benchmark_out(method,args,time)
+				puts "[RedisObject::Benchmark] #{method}(#{args.join(",")}): #{time}"
+			end
+			
+			def benchmark!
+				benchmark :set, :get, :<<
+			end
+				
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+	
+end

data/lib/redis_object/ext/cleaner.rb

@@ -0,0 +1,14 @@
+module Seabright
+	module RedisObjectCleaner
+		def self.clean!
+			RedisObject.store.keys("*:collections").each do |key|
+				if obj = RedisObject.find_by_key(key.gsub(/:collections$/,''))
+					obj.collections.each do |nm,col|
+						puts "Cleaning: #{nm} #{col.class} #{col.inspect}" if DEBUG
+						col.cleanup!
+					end
+				end
+			end
+		end
+	end
+end

data/lib/redis_object/ext/filters.rb

@@ -0,0 +1,68 @@
+module Seabright
+	module Filters
+		
+		module ClassMethods
+			
+			def intercept_for_filters!
+				return if @intercept_for_filters
+				self.class_eval do
+					
+					def filtered_method_call(method,*args)
+						if filters = self.class.filters_for(method)
+							filters.each do |f|
+								args = send(f,*args)
+							end
+						end
+						send("unfiltered_#{method.to_s}".to_sym,*args)
+					end
+					
+					alias_method :unfiltered_get, :get unless method_defined?(:unfiltered_get)
+					def get(k)
+						filtered_method_call(:get,k)
+					end
+					
+					alias_method :unfiltered_set, :set unless method_defined?(:unfiltered_set)
+					def set(k,v)
+						filtered_method_call(:set,k,v)
+					end
+					
+					alias_method :unfiltered_setnx, :setnx unless method_defined?(:unfiltered_setnx)
+					def setnx(k,v)
+						filtered_method_call(:setnx,k,v)
+					end
+					
+				end
+				@intercept_for_filters = true
+			end
+			
+			def set_filter(filter)
+				filter_method(:set,filter)
+				filter_method(:setnx,filter)
+			end
+			
+			def get_filter(filter)
+				filter_method(:get,filter)
+			end
+			
+			def filter_method(method, filter)
+				method_filters[method.to_sym] ||= []
+				method_filters[method.to_sym] << filter.to_sym unless method_filters[method.to_sym].include?(filter.to_sym)
+				intercept_for_filters!
+			end
+			
+			def method_filters
+				@method_filters ||= {}
+			end
+			
+			def filters_for(method)
+				method_filters[method.to_sym]
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

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

@@ -0,0 +1,101 @@
+module Seabright
+	module Triggers
+		
+		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
+				@field_triggers ||= {}
+			end
+			
+			def trigger_on_update(actn)
+				update_triggers << actn.to_sym
+				intercept_sets_for_triggers!
+			end
+			
+			def 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
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		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