strokedb 0.0.2

data/lib/document/versions.rb

@@ -0,0 +1,106 @@
+module StrokeDB
+  class Document
+    # Versions is a helper class that is used to navigate through versions. You should not
+    # instantiate it directly, but using Document#versions method
+    # 
+    class Versions
+      attr_reader :document
+      def initialize(document)  #:nodoc:
+        @document = document
+        @cache = {}
+      end
+
+
+      #
+      # Get document by version.
+      #
+      # Returns Document instance
+      # Returns <tt>nil</tt> if there is no document with given version
+      #
+      def [](version)
+        @cache[version] ||= @document.store.find(document.uuid, version)
+      end
+
+      #
+      # Get current version of document
+      #
+      def current
+        document.new? ? document.clone.extend(VersionedDocument) : self[document.version]
+      end
+
+      #
+      # Get head version of document
+      #
+      def head
+        document.new? ? document.clone.extend(VersionedDocument) : document.store.find(document.uuid)
+      end
+
+      #
+      # Get first version of document
+      #
+      def first
+        document.new? ? document.clone.extend(VersionedDocument) : self[all_preceding_versions.last]
+      end
+
+
+
+      #
+      # Get document with previous version
+      #
+      # Returns Document instance
+      # Returns <tt>nil</tt> if there is no previous version
+      #
+      def previous
+        self[document.previous_version]
+      end
+
+      #
+      # Find all document versions, treating current one as a head
+      #
+      # Returns an Array of version numbers
+      #
+      def all_versions
+        [document.version, *all_preceding_versions]
+      end
+
+      #
+      # Get all versions of document including currrent one
+      #
+      # Returns an Array of Documents
+      #
+      def all
+        all_versions.map{|v| self[v]}
+      end
+
+
+      #
+      # Find all _previous_ document versions, treating current one as a head
+      #
+      # Returns an Array of version numbers
+      #
+      def all_preceding_versions
+        if previous_version = document.previous_version
+          [previous_version, *self[previous_version].versions.all_preceding_versions]
+        else
+          []
+        end
+      end
+
+      #
+      # Find all previous versions of document
+      #
+      # Returns an Array of Documents
+      #
+      def all_preceding
+        all_preceding_versions.map{|v| self[v]}
+      end
+
+      #
+      # Returns <tt>true</tt> if document has no previous versions
+      #
+      def empty?
+        document.previous_version.nil?
+      end
+    end
+  end
+end

data/lib/document/virtualize.rb

@@ -0,0 +1,82 @@
+module StrokeDB
+  module Virtualizations
+    #
+    # Makes a virtual slot. Virtual slot is by all means a regular slot with
+    # one exception: it doesn't get serialized on save. Nevertheless its value
+    # is preserved while the document is in memory. You can also set :restore
+    # option to false (it is true by default), in such case the slot will be
+    # removed before save and not restored. It may be useful for ad hoc slots.
+    #
+    # Virtual slots get validated as usual.
+    #
+    #   User = Meta.new do
+    #     virtualizes :password, :restore => false
+    #     validates_presence_of :crypted_password
+    #   end
+    #
+    # Regular password is not meant to get serialized in this example, only the
+    # crypted one.
+    #
+    def virtualizes(slotnames, opts = {})
+      opts = opts.stringify_keys
+
+      slotnames = [slotnames] unless slotnames.is_a?(Array)
+      slotnames.each {|slotname| register_virtual(slotname, opts)}
+    end
+
+    private
+
+    # FIXME: willn't usage of instance variables below make a mess in a threaded mode?
+    def initialize_virtualizations
+      after_validation do |doc|
+        @saved_virtual_slots = {}
+        @version = doc.version
+        @previous_version = doc.previous_version
+
+        grep_slots(doc, "virtualizes_") do |virtual_slot, meta_slotname|
+          if doc.meta[meta_slotname][:restore]
+            @saved_virtual_slots[virtual_slot] = doc[virtual_slot]
+          end
+
+          doc.remove_slot!(virtual_slot)
+        end
+      end
+
+      after_save do |doc|
+        @saved_virtual_slots.each do |slot, value|
+          doc[slot] = value
+        end
+        unless @saved_virtual_slots.empty?
+          doc['version'] = @version
+
+          if @previous_version
+            doc['previous_version'] = @previous_version 
+          else
+            doc.remove_slot!('previous_version')
+          end
+        end
+
+        @version = nil
+        @previous_version = nil
+        @saved_virtual_slots = {}
+      end
+    end
+
+    def register_virtual(slotname, opts)
+      slotname = slotname.to_s
+
+      restore = opts['restore'].nil? ? true : !!opts['restore']
+
+      options_hash = { 
+        :slotname => slotname, 
+        :restore => restore
+      }
+
+      virtualize_slot = "virtualizes_#{slotname}"
+
+      @meta_initialization_procs << Proc.new do
+        @args.last.reverse_merge!(virtualize_slot => { :meta => name }.merge(options_hash))
+      end
+    end
+  end
+end

data/lib/init.rb

@@ -0,0 +1,57 @@
+module StrokeDB
+  VERSION = '0.0.2' + (RUBY_PLATFORM =~ /java/ ? '-java' : '')
+
+  # UUID regexp (like 1e3d02cc-0769-4bd8-9113-e033b246b013)
+  UUID_RE = /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/
+
+  # document version regexp
+  VERSION_RE = UUID_RE
+
+  # following are special UUIDs used by StrokeDB
+
+  # so called Nil UUID, should be used as special UUID for Meta meta
+  NIL_UUID = "00000000-0000-0000-0000-000000000000" 
+
+  # UUID used for DeletedDocument meta
+  DELETED_DOCUMENT_UUID = 'e5e0ef20-e10f-4269-bff3-3040a90e194e'
+
+  # UUID used for StoreInfo meta
+  STORE_INFO_UUID = "23e11d2e-e3d3-4c24-afd2-b3316403dd03"
+
+  # UUID used for Diff meta
+  DIFF_UUID = "5704bd39-4a01-405e-bc72-3650ddd89ca4"
+
+  # UUID used for SynchronizationReport meta
+  SYNCHRONIZATION_REPORT_UUID = "8dbaf160-addd-401a-9c29-06b03f70df93"
+  
+  # UUID used for SynchronizationConflict meta
+  SYNCHRONIZATION_CONFLICT_UUID = "36fce59c-ee3d-4566-969b-7b152814a314"
+
+  # UUID used for View meta
+  VIEW_UUID = "ced0ad12-7419-4db1-a9f4-bc35e9b64112"
+
+  # UUID used for ViewCut meta
+  VIEWCUT_UUID = "2975630e-c877-4eab-b86c-732e1de1adf5"
+
+  class <<self
+    def default_store
+      StrokeDB.default_config.stores[:default] rescue nil
+    end
+    def default_store=(store)
+      cfg = Config.new
+      cfg.stores[:default] = store
+      StrokeDB.default_config = cfg
+    end
+  end
+  
+  if ENV['DEBUG'] || $DEBUG
+    def DEBUG
+      yield
+    end
+  else
+    def DEBUG
+    end
+  end
+  
+  class NoDefaultStoreError < Exception ; end
+end

data/lib/stores/chainable_storage.rb

@@ -0,0 +1,57 @@
+module StrokeDB
+  module ChainableStorage
+    def add_chained_storage!(storage)
+      @chained_storages ||= {}
+      @chained_storages[storage] = []
+      class <<self
+        alias :save! :save_with_chained_storages!
+      end
+      storage.add_chained_storage!(self) unless storage.has_chained_storage?(self)
+    end
+
+    def remove_chained_storage!(storage)
+      @chained_storages.delete(storage)
+      storage.remove_chained_storage!(self) if storage.has_chained_storage?(self)
+      if @chained_storages.keys.empty?
+        class <<self
+          alias :save! :save_without_chained_storages!
+        end
+      end
+    end
+
+    def has_chained_storage?(storage)
+      @chained_storages.nil? ? false : !!@chained_storages[storage]
+    end
+
+    def sync_chained_storages!(origin=nil)
+      return unless @chained_storages.is_a?(Hash)
+      @chained_storages.each_pair do |storage, savings|
+        next if storage == origin
+        savings.each {|saving| storage.save!(saving, self)}
+        storage.sync_chained_storages!(self)
+        @chained_storages[storage] = [] 
+      end
+    end
+    
+    def sync_chained_storage!(storage)
+      return unless @chained_storages.is_a?(Hash)
+      (@chained_storages[storage]||[]).each do |saving|
+        storage.save!(saving, self)
+      end
+      @chained_storages[storage] = []
+    end
+
+    def save_without_chained_storages!(chunk, source=nil)
+      perform_save!(chunk)
+    end
+
+    def save_with_chained_storages!(chunk, source=nil)
+      perform_save!(chunk)
+      (@chained_storages||{}).each_pair do |storage, savings|
+          savings << chunk unless  storage == source || savings.include?(chunk) # TODO: here we had a bug (storage == document), spec it
+      end
+    end
+
+    alias :save! :save_without_chained_storages!
+  end
+end

data/lib/stores/inverted_list_index/inverted_list_file_storage.rb

@@ -0,0 +1,56 @@
+module StrokeDB
+  class InvertedListFileStorage
+    # TODO: 
+    # include ChainableStorage
+
+    attr_accessor :path
+
+    def initialize(opts={})
+      opts = opts.stringify_keys 
+      @path = opts['path']
+    end
+
+    def find_list
+      read(file_path)
+    end
+    
+    def clear!
+      FileUtils.rm_rf @path
+    end
+    
+    def save!(list)
+      FileUtils.mkdir_p @path
+      write(file_path, list)
+    end
+    
+  private
+
+    def read(path)
+      return InvertedList.new unless File.exist?(path)
+      raw_list = StrokeDB.deserialize(IO.read(path))
+      list = InvertedList.new
+      # TODO: Optimize!
+      raw_list.each do |k, vs|
+        vs.each do |v|
+          list.insert_attribute(k, v)
+        end
+      end
+      list
+    end
+    
+    def write(path, list)
+      raw_list = {}
+      # TODO: Optimize!
+      list.each do |n|
+        raw_list[n.key] = n.values
+      end
+      File.open path, "w+" do |f|
+        f.write StrokeDB.serialize(raw_list)
+      end
+    end
+  
+    def file_path
+      "#{@path}/INVERTED_INDEX"
+    end
+  end
+end

data/lib/stores/inverted_list_index/inverted_list_index.rb

@@ -0,0 +1,49 @@
+module StrokeDB
+  class InvertedListIndex
+    attr_accessor :storage, :document_store
+    def initialize(storage)
+      @storage = storage
+      @list = nil
+    end
+    
+    def find_uuids(*args)
+      list.find(*args)
+    end
+    
+    def find(*args)
+      find_uuids(*args).map do |uuid|
+        @document_store.find(uuid)
+      end
+    end
+    
+    def insert(doc)
+      slots = indexable_slots_for_doc(doc)
+      q = PointQuery.new(slots)
+      list.insert(q.slots, doc.uuid)
+    end
+     
+    def delete(doc)
+      slots = indexable_slots_for_doc(doc)
+      q = PointQuery.new(slots)
+      list.delete(q.slots, doc.uuid)
+    end
+    
+    def save!
+      @storage.save!(list)
+    end
+  
+  private
+    
+    def indexable_slots_for_doc(doc)
+      raw_slots = doc.to_raw
+      nkeys = doc.meta['non_indexable_slots']
+      nkeys.each{|nk| raw_slots.delete(nk) } if nkeys
+      raw_slots
+    end
+    
+    def list
+      @list ||= @storage.find_list
+    end
+    
+  end
+end

data/lib/stores/remote_store.rb

@@ -0,0 +1,172 @@
+module StrokeDB
+  class Store
+    def remote_server(addr, protocol=:drb)
+      case protocol
+      when :drb
+        RemoteStore::DRb::Server.new(self,"#{addr}")
+      else
+        raise "No #{protocol} protocol"
+      end
+    end
+  end
+  module RemoteStore
+    module DRb
+      class Client
+
+        attr_reader :addr
+
+        def initialize(addr)
+          @addr = addr
+          ::DRb.start_service
+          @server = ::DRbObject.new(nil, addr)
+        end
+
+        def find(*args)
+          safe_document_from_undumped(@server.find(*args))
+        end
+
+        def search(*args)
+          @server.search(*args).map{ |e| safe_document_from_undumped(e) }
+        end
+
+        def exists?(uuid, version=nil)
+          @server.exists?(uuid, version)
+        end
+
+        def head_version(uuid)
+          raw_doc = find(uuid,nil, :no_instantiation => true)
+          return raw_doc['version'] if raw_doc
+          nil
+        end
+
+        def save!(*args)
+          result = @server.save!(*args)
+          if result.is_a?(Document)
+            safe_document_from_undumped(result)
+          end
+          result
+        end
+
+        def each(options = {})
+          @server.each(options) do |doc_without_store|
+            safe_document_from_undumped(doc_without_store)
+          end
+        end
+
+        def timestamp
+          @server.timestamp
+        end
+
+        def next_timestamp
+          @server.next_timestamp
+        end
+
+        def uuid
+          @server.uuid
+        end
+
+        def document
+          result = @server.document
+          safe_document_from_undumped(result)
+        end
+
+        def empty?
+          @server.empty?
+        end
+
+        def inspect
+          @server.inspect
+        end
+
+        def index_store
+          @server.index_store
+        end
+
+        private 
+
+        def safe_document_from_undumped(doc_without_store)
+          doc_without_store.instance_variable_set(:@store, self) if doc_without_store
+          doc_without_store
+        end
+
+      end    
+
+      class Server
+        attr_reader :store, :addr, :thread
+        def initialize(store, addr)
+          @store, @addr = store, addr
+          @mutex = Mutex.new
+        end
+
+        def start
+          ::DRb.start_service(addr, self)
+          @thread = ::DRb.thread
+        end
+
+        def find(*args)
+          @mutex.synchronize { @store.find(*args) }
+        end
+
+        def search(*args)
+          @mutex.synchronize { @store.search(*args) }
+        end
+
+        def exists?(*args)
+          !!@mutex.synchronize { @store.exists?(*args) }
+        end
+
+        def head_version(uuid)
+          raw_doc = @mutex.synchronize { find(uuid, nil, :no_instantiation => true) }
+          return raw_doc['version'] if raw_doc
+          nil
+        end
+
+        def save!(document)
+          document.instance_variable_set(:@store, @store)
+          @mutex.synchronize { @store.save!(document) }
+        end
+
+        def each(options = {}, &block)
+          @mutex.synchronize { @store.each(options, &block) }
+        end
+
+        def timestamp
+          @mutex.synchronize { @store.timestamp }
+        end
+
+        def next_timestamp
+          @mutex.synchronize { @store.next_timestamp }
+        end
+
+        def uuid
+          @store.uuid
+        end
+
+        def document
+          @mutex.synchronize { @store.document }
+        end
+
+        def empty?
+          @mutex.synchronize { @store.empty? }
+        end
+        
+        def autosync!
+          @mutex.synchronize { @store.autosync! }
+        end
+        
+        def stop_autosync!
+          @mutex.synchronize { @store.stop_autosync! }
+        end
+
+        def inspect
+          @store.inspect
+        end
+
+        def index_store
+          @store.index_store
+        end
+
+      end
+    end
+  end
+end

data/lib/stores/skiplist_store/chunk.rb

@@ -0,0 +1,119 @@
+module StrokeDB
+  class Chunk
+    attr_accessor :skiplist, :next_chunk, :prev_chunk, :uuid, :cut_level, :timestamp 
+    attr_accessor :next_chunk_uuid
+    attr_accessor :store_uuid 
+    def initialize(cut_level)
+      @skiplist, @cut_level = Skiplist.new({}, nil, cut_level), cut_level
+    end
+    
+    def insert(uuid, raw_doc, __cheaters_level = nil, __timestamp = nil)
+      @uuid ||= uuid
+      __cheaters_level ||= $DEBUG_CHEATERS_LEVEL
+      a, new_list = skiplist.insert(uuid, raw_doc, __cheaters_level, __timestamp)
+      if new_list
+        tmp = Chunk.new(@cut_level)
+        tmp.skiplist = new_list
+        tmp.next_chunk = @next_chunk if @next_chunk
+        @next_chunk = tmp
+        @next_chunk.uuid = uuid
+      end
+      [self, @next_chunk]
+    end
+    
+    def delete(uuid)
+      skiplist.delete(uuid)
+    end
+
+    def find(uuid, default = nil)
+      skiplist.find(uuid, default)
+    end
+    
+    def find_node(uuid)
+      skiplist.find_node(uuid)
+    end
+    
+    def find_nearest(uuid, default = nil)
+      skiplist.find_nearest(uuid, default)
+    end
+    
+    # Finds next node across separate chunks
+    def find_next_node(node)
+      chunk = self
+      node2 = node.next
+      if node2.is_a?(Skiplist::TailNode)
+        chunk = chunk.next_chunk
+        unless chunk.nil?
+          node2 = chunk.first_node
+        else
+          node2 = nil
+        end
+      end
+      node2
+    end
+    
+    
+    def first_uuid
+      skiplist.first_node.key
+    end
+
+    def first_node
+      skiplist.first_node
+    end
+    
+    def size
+      skiplist.size
+    end
+    
+    def each(&block)
+      skiplist.each &block
+    end
+        
+  	# Raw format
+
+    # TODO: lazify
+  	def self.from_raw(raw)
+  	  chunk = Chunk.new(raw['cut_level'])
+  	  chunk.uuid = raw['uuid']
+      chunk.next_chunk_uuid = raw['next_uuid']
+      chunk.timestamp = raw['timestamp']
+      chunk.store_uuid = raw['store_uuid']
+      chunk.skiplist.raw_insert(raw['nodes']) do |rn|
+  	    [rn['key'], rn['value'], rn['forward'].size, rn['timestamp']]
+  	  end
+  	  yield(chunk) if block_given?
+  	  chunk
+  	end
+ 
+  	def to_raw
+  	  # enumerate nodes
+  	  skiplist.each_with_index do |node, i|
+     	  node._serialized_index = i
+      end
+      
+      # now we know keys' positions right in the nodes
+  	  nodes = skiplist.map do |node|
+        {
+          'key'     => node.key,
+          'forward' => node.forward.map{|n| n._serialized_index || 0 },
+          'value'   => node.value,
+          'timestamp' => node.timestamp
+        }
+      end
+      {
+        'nodes'     => nodes, 
+        'cut_level' => @cut_level, 
+        'uuid'      => @uuid,
+        # TODO: may not be needed
+        'next_uuid' => next_chunk ? next_chunk.uuid : nil,
+        'timestamp' => @timestamp,
+        'store_uuid' => @store_uuid
+      }
+  	end
+  	
+  	def eql?(chunk)
+  	 chunk.uuid == @uuid && chunk.skiplist.eql?(@skiplist)
+  	end
+  	
+  end
+end