redis_object 1.0 → 1.1

data/lib/redis_object/ext/views.rb

@@ -0,0 +1,102 @@
+module Seabright
+	module Views
+		
+		ViewFieldGetter = "local out = {}
+			local key
+			local val
+			for i=1,#ARGV do
+				key = ARGV[i]
+				val = redis.call('HGET',KEYS[1],key)
+				if val then
+					table.insert(out,key)
+					table.insert(out,val)
+				end
+			end
+			return out".gsub(/\t/,'').freeze
+		
+		def view_as_hash(name)
+			out = {}
+			if requested_set = self.class.named_views[name]
+				if requested_set.is_a?(Symbol) and self.respond_to?(requested_set)
+					out = send(requested_set)
+				else
+					methods = requested_set[:fields].select {|f| self.respond_to?(f.to_sym) }
+					if methods.count > 0
+						methods.each do |m|
+							out[m.to_s] = send(m.to_sym)
+						end
+					end
+					if requested_set[:fields] && (flds = requested_set[:fields].select {|f| !out.keys.include?(f.to_s) }.map {|f| f.to_s }) && flds.count > 0
+						res = Hash[*store.eval(ViewFieldGetter, [hkey], flds)]
+						out.merge!(res)
+					end
+					if requested_set[:procs]
+						requested_set[:procs].each do |k,proc|
+							out[k.to_s] = proc.call(self)
+						end
+					end
+					if requested_set[:hashes]
+						requested_set[:hashes].each do |k,v|
+							case v
+							when String, Symbol
+								out[k.to_s] = get(v)
+							end
+						end
+					end
+				end
+			end
+			out
+		end
+		
+		def view_as_json(name)
+			Yajl::Encoder.encode(view_as_hash(name))
+		end
+		
+		module ClassMethods
+			
+			def named_view(name,*fields)
+				named_views[name] = normalize_field_options(fields)
+			end
+			
+			def named_views
+				@named_views ||= {}
+			end
+			
+			def normalize_field_options(fields)
+				fields.flatten!
+				fields.uniq!
+
+				options = {}
+				if fields.last.is_a?(Hash) # assume an option hash
+					options.merge!(fields.slice!(fields.size - 1, 1)[0])
+				end
+
+				# assign a the method as a symbol to be exclusively invoked on view
+				# so instead of returning a hash on view, it will return only what was
+				# produced by calling the method.
+				if options.keys.size > 0 and options[:method]
+					out = options[:method].to_sym
+				else
+					hash = fields.select {|f| f.is_a?(Hash) }.inject({},:merge)
+					out = {}
+					if (h = hash.select {|k,v| !v.is_a?(Proc) }) && h.count > 0
+						out[:hashes] = h
+					end
+					if (h = hash.select {|k,v| v.is_a?(Proc) }) && h.count > 0
+						out[:procs] = h
+					end
+					if (h = fields.select {|o| o.is_a?(String) || o.is_a?(Symbol) }) && h.count > 0
+						out[:fields] = h
+					end
+				end
+				out
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/indices.rb

@@ -1,45 +1,50 @@
 module Seabright
 	module Indices
 		
-		# def save_indices
-		# 	# self.class.indices.each do |indx|
-		# 	# 	indx.each do |key,idx|
-		# 	# 		
-		# 	# 	end
-		# 	# end
-		# 	self.class.sort_indices.each do |idx|
-		# 		store.zadd(index_key(idx), send(idx).to_i, hkey)
-		# 	end
-		# end
-		
 		def index_key(idx)
 			self.class.index_key(idx)
 		end
 		
-		# def save
-		# 	super
-		# 	save_indices
-		# end
-		
-		def mset(dat)
-			super(dat)
-			dat.select {|k,v| self.class.has_sort_index?(k) }.each do |k,v|
-				store.zadd(index_key(k), score_format(k,v), hkey)
-			end
-		end
-		
-		def set(k,v)
-			super(k,v)
-			if self.class.has_sort_index?(k)
-				store.zadd(index_key(k), score_format(k,v), hkey)
-			end
-		end
-		
 		module ClassMethods
 			
+			def intercept_sets_for_indices!
+				return if @intercepted_sets_for_indices
+				self.class_eval do
+					alias_method :unindexed_set, :set unless method_defined?(:unindexed_set)
+					def set(k,v)
+						ret = unindexed_set(k,v)
+						if self.class.has_sort_index?(k)
+							store.zrem(index_key(k), hkey)
+							store.zadd(index_key(k), score_format(k,v), hkey)
+						end
+						ret
+					end
+					alias_method :unindexed_mset, :mset unless method_defined?(:unindexed_mset)
+					def mset(dat)
+						ret = unindexed_mset(dat)
+						dat.select {|k,v| self.class.has_sort_index?(k) }.each do |k,v|
+							store.zrem(index_key(k), hkey)
+							store.zadd(index_key(k), score_format(k,v), hkey)
+						end
+						ret
+					end
+					alias_method :unindexed_setnx, :setnx unless method_defined?(:unindexed_setnx)
+					def setnx(k,v)
+						ret = unindexed_setnx(k,v)
+						if self.class.has_sort_index?(k)
+							store.zrem(index_key(k), hkey)
+							store.zadd(index_key(k), score_format(k,v), hkey)
+						end
+						ret
+					end
+					
+				end
+				@intercepted_sets_for_indices = true
+			end
+			
 			def indexed(idx,num=-1,reverse=false)
 				out = Enumerator.new do |yielder|
-					store.send(reverse ? :zrevrange : :zrange, index_key(idx), 0, num).each do |member|
+					store.send(reverse ? :zrevrange : :zrange, index_key(idx), 0, num-1).each do |member|
 						if a = self.find_by_key(member)
 							yielder << a
 						end
@@ -58,20 +63,20 @@ module Seabright
 				"#{self.plname}::#{idx}"
 			end
 			
-			# def index(opts)
-			# 	indices << opts
-			# end
-			# 
-			# def indices
-			# 	@@indices ||= []
-			# end
-			
 			def sort_indices
 				@@sort_indices ||= []
 			end
 			
 			def sort_by(k)
 				sort_indices << k.to_sym
+				intercept_sets_for_indices!
+			end
+			
+			def reindex(k)
+				store.del index_key(k)
+				all.each do |obj|
+					obj.set(k,obj.get(k))
+				end
 			end
 			
 			def has_sort_index?(k)

data/lib/redis_object/inheritance_tracking.rb

@@ -0,0 +1,23 @@
+module Seabright
+	module InheritanceTracking
+		
+		module ClassMethods
+			def inherited(child_class)
+				child_classes_set.add(child_class)
+			end
+
+			def child_classes_set
+				@child_classes_set ||= Set.new
+			end
+
+			def child_classes
+				child_classes_set.to_a
+			end
+		end
+
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/keys.rb

@@ -15,15 +15,15 @@ module Seabright
 		
 		module ClassMethods
 			
-			def key(ident)
-				"#{cname}:#{ident.gsub(/^.*:/,'')}"
+			def key(ident=nil)
+				"#{cname}#{ident ? ":#{ident.gsub(/^.*:/,'')}" : ""}"
 			end
 			
-			def reserve_key(ident)
+			def reserve_key(ident=nil)
 				"#{key(ident)}_reserve"
 			end
 			
-			def hkey(ident = id)
+			def hkey(ident = nil)
 				"#{key(ident)}_h"
 			end
 			

data/lib/redis_object/storage.rb

@@ -19,8 +19,12 @@ module Seabright
 				adapters[id] ||= const_get(adapter).new(config(id))
 			end
 			
-			def configure_store(conf,id=store_name)
+			def configure_store(conf,id=store_name,*ids)
 				configs[id] = conf
+				ids.each do |i|
+					configs[i] = conf
+				end
+				store(id)
 			end
 			
 			def use_store(id)
@@ -54,6 +58,31 @@ module Seabright
 				configs[id]
 			end
 			
+			def stores
+				adapters
+			end
+			
+			def dump_stores_to_files(path)
+				raise "Directory does not exist!" unless Dir.exists?(File.dirname(path))
+				adapters.each do |name,adptr|
+					if adptr.respond_to? :dump_to_file
+						puts "Dumping #{name} into #{path}/#{name.to_s}.dump"
+						adptr.dump_to_file("#{path}/#{name.to_s}.dump")
+					end
+				end
+			end
+			
+			def restore_stores_from_files(path)
+				raise "Directory does not exist!" unless Dir.exists?(File.dirname(path))
+				Dir.glob(path + "/*.dump").each do |file|
+					name = file.gsub(/\.[^\.]+$/,'').gsub(/.*\//,'').to_sym
+					if (stor = store(name)) && stor.respond_to?(:restore_from_file)
+						puts "Restoring #{name} from #{file}"
+						stor.restore_from_file(file)
+					end
+				end
+			end
+			
 		end
 		
 		def self.included(base)

data/lib/redis_object/storage/adapter.rb

@@ -23,15 +23,18 @@ module Seabright
 			end
 			
 			def reset
-				@connections.each_index do |i|
-					@connections[i] = nil
+				connections.each_index do |i|
+					connections[i] = nil
 				end
 			end
 			alias_method :reconnect!, :reset
 			
 			def connection(num=0)
+				connections[num] ||= new_connection
+			end
+			
+			def connections
 				@connections ||= []
-				@connections[num] ||= new_connection
 			end
 			
 			def new_connection

data/lib/redis_object/storage/redis.rb

@@ -3,6 +3,7 @@ module Seabright
 		class Redis < Adapter
 			
 			def method_missing(sym, *args, &block)
+				return super unless connection.respond_to?(sym)
 				puts "[Storage::Redis] #{sym}(#{args.inspect.gsub(/\[|\]/m,'')})" if Debug.verbose?
 				begin
 					connection.send(sym,*args, &block)
@@ -10,15 +11,109 @@ module Seabright
 					puts "Rescued: #{err.inspect}" if DEBUG
 					reset
 					connection.send(sym,*args, &block)
+				rescue ::Redis::TimeoutError => err
+					puts "Rescued connection timeout: #{err.inspect}" if DEBUG
+					reset
+					connection.send(sym,*args, &block)
 				end
 			end
 			
 			def new_connection
 				require 'redis'
-				# puts "Connecting to Redis with: #{config_opts(:path, :db, :password).inspect}" if DEBUG
-				::Redis.new(config_opts(:path, :db, :password))
+				puts "Connecting to Redis with: #{config_opts(:path, :db, :password, :host, :port, :timeout, :tcp_keepalive).inspect}" if DEBUG
+				::Redis.new(config_opts(:path, :db, :password, :host, :port, :timeout, :tcp_keepalive))
+			end
+			
+			DUMP_SEPARATOR = "---:::RedisObject::DUMP_SEPARATOR:::---"
+			REC_SEPARATOR = "---:::RedisObject::REC_SEPARATOR:::---"
+			
+			def dump_to_file(file)
+				File.open(file,'wb') do |f|
+					keys = connection.send(:keys,"*")
+					f.write keys.map {|k|
+						v = connection.dump(k)
+						v.force_encoding(Encoding::BINARY)
+						[k,v].join(DUMP_SEPARATOR)
+					}.join(REC_SEPARATOR)
+				end
+			end
+			
+			def restore_from_file(file)
+				str = File.read(file)
+				str.force_encoding(Encoding::BINARY)
+				str.split(REC_SEPARATOR).each do |line|
+					line.force_encoding(Encoding::BINARY)
+					key, val = line.split(DUMP_SEPARATOR)
+					connection.multi do
+						connection.del key
+						connection.restore key, 0, val
+					end
+				end
+			end
+
+			def rename_class old_name, new_name
+				old_name = old_name.to_s#.split('::').last
+				new_name = new_name.to_s#.split('::').last
+				old_collection_name = old_name.split('::').last.underscore.pluralize
+				new_collection_name = new_name.split('::').last.underscore.pluralize
+
+				# references to type in collection data
+				keys("#{old_name}:*:backreferences").each do |backref_key|
+					smembers(backref_key).each do |hashref|
+						# there are two referenes we need to fix: individual references to items
+						# and lists of collection names.
+						#
+						# this updates the item references in collections
+						backref = hashref.sub(/_h$/,'');
+						old_collection = "#{backref}:COLLECTION:#{old_collection_name}"
+						new_collection = "#{backref}:COLLECTION:#{new_collection_name}"
+						zrange(old_collection, 0, 99999, withscores:true).each do |key, score|
+							zadd(new_collection, score, key.sub(/^#{old_name}/, new_name))
+						end
+						del(old_collection)
+
+						# this updates the lists of collection names
+						collection_names = "#{hashref}:collections"
+						smembers(collection_names).each do |collection_name|
+							if collection_name == old_collection_name
+								sadd(collection_names, new_collection_name)
+								srem(collection_names, old_collection_name)
+							end
+						end
+					end
+					rename(backref_key, backref_key.sub(/^#{old_name}/, new_name))
+				end
+
+				# type-wide id index
+				smembers(old_name.pluralize).each do |key|
+					sadd(new_name.pluralize, key.sub(/^#{old_name}/, new_name))
+					old_class = hget("#{key}_h", :class)
+					old_key = hget("#{key}_h", :key)
+					hset("#{key}_h", :class, old_class.sub(/#{old_name}$/, new_name))
+					hset("#{key}_h", :key, old_key.sub(/^#{old_name}/, new_name))
+					hset("#{key}_h", "#{new_name.downcase}_id", key.sub(/^#{old_name}:/,''))
+					hdel("#{key}_h", "#{old_name.downcase}_id")
+				end
+				del(old_name.pluralize)
+
+				# column indexes
+				keys("#{old_name.pluralize}::*").each do |old_index|
+					new_index = old_index.sub(/^#{old_name.pluralize}/, new_name.pluralize)
+					zrange(old_index, 0, 99999, withscores:true).each do |key, score|
+						zadd(new_index, score, key.sub(/^#{old_name}/, new_name))
+					end
+					del(old_index)
+				end
+
+				# top-level keys
+				keys("#{old_name}:*").each do |key|
+					rename(key, key.sub(/^#{old_name}/, new_name))
+				end
+				keys("#{old_name.pluralize}:*").each do |key|
+					rename(key, key.sub(/^#{old_name.pluralize}/, new_name.pluralize))
+				end
 			end
 			
 		end
 	end
-end
+end