strokedb 0.0.2.1 → 0.0.2.2

data/lib/{stores → strokedb/stores}/remote_store.rb

@@ -1,3 +1,7 @@
+require 'drb'
+require 'drb/acl'
+require 'drb/unix'
+
 module StrokeDB
   class Store
     def remote_server(addr, protocol=:drb)
@@ -29,9 +33,10 @@ module StrokeDB
           @server.search(*args).map{ |e| safe_document_from_undumped(e) }
         end
 
-        def exists?(uuid, version=nil)
-          @server.exists?(uuid, version)
+        def include?(uuid, version=nil)
+          @server.include?(uuid, version)
         end
+        alias_method :contains?, :include?
 
         def head_version(uuid)
           raw_doc = find(uuid,nil, :no_instantiation => true)
@@ -111,9 +116,10 @@ module StrokeDB
           @mutex.synchronize { @store.search(*args) }
         end
 
-        def exists?(*args)
-          !!@mutex.synchronize { @store.exists?(*args) }
+        def include?(*args)
+          !!@mutex.synchronize { @store.include?(*args) }
         end
+        alias_method :contains?, :include?
 
         def head_version(uuid)
           raw_doc = @mutex.synchronize { find(uuid, nil, :no_instantiation => true) }

data/lib/strokedb/sync.rb

@@ -0,0 +1,4 @@
+require 'sync/diff'
+require 'sync/chain_sync'
+require 'sync/store_sync'
+require 'sync/lamport_timestamp'

data/lib/{sync → strokedb/sync}/diff.rb

@@ -1,5 +1,11 @@
 require 'diff/lcs'
+
 module StrokeDB
+  
+  PATCH_REPLACE = 'R'.freeze
+  PATCH_PLUS    = '+'.freeze
+  PATCH_MINUS   = '-'.freeze
+  PATCH_DIFF    = 'D'.freeze
 
   class SlotDiffStrategy 
     def self.diff(from, to)
@@ -62,7 +68,7 @@ module StrokeDB
     end
   end
 
-  Diff = Meta.new(:uuid => DIFF_UUID) do
+  Diff = Meta.new do
 
     on_initialization do |diff|
       diff.added_slots = {} unless diff[:added_slots]
@@ -124,3 +130,8 @@ module StrokeDB
   end
   
 end
+
+require 'sync/diff/default'
+require 'sync/diff/string'
+require 'sync/diff/array'
+require 'sync/diff/hash'

data/lib/{sync/stroke_diff → strokedb/sync/diff}/array.rb

@@ -6,7 +6,7 @@ module StrokeDB
       '!' => PATCH_DIFF
     }.freeze
     def stroke_diff(to)
-      return super(to) unless Array === to
+      return super(to) unless to.is_a?(Array)
       return nil if self == to
       
       # sdiff:  +   -   !   = 

data/lib/{sync/stroke_diff → strokedb/sync/diff}/hash.rb

@@ -1,7 +1,7 @@
 module StrokeDB
   class ::Hash
     def stroke_diff(to)
-      return super(to) unless Hash === to
+      return super(to) unless to.is_a?(Hash)
       return nil if self == to
       
       all_keys = self.keys | to.keys

data/lib/{sync/stroke_diff → strokedb/sync/diff}/string.rb

@@ -1,7 +1,7 @@
 module StrokeDB
   class ::String
     def stroke_diff(to)
-      return super(to) unless String === to
+      return super(to) unless to.is_a?(String)
       return nil if self == to
       
       _f = self[0,2]

data/lib/{sync → strokedb/sync}/store_sync.rb

@@ -1,6 +1,6 @@
 module StrokeDB
 
-  SynchronizationReport = Meta.new(:uuid => SYNCHRONIZATION_REPORT_UUID) do
+  SynchronizationReport = Meta.new  do
     on_new_document do |report|
       report.conflicts = []
       report.added_documents = []
@@ -9,7 +9,7 @@ module StrokeDB
     end
   end
   
-  SynchronizationConflict = Meta.new(:uuid => SYNCHRONIZATION_CONFLICT_UUID) do
+  SynchronizationConflict = Meta.new  do
     def resolve!
       # by default, do nothing
     end
@@ -22,7 +22,7 @@ module StrokeDB
       existing_chain = {}
       docs.group_by {|doc| doc.uuid}.each_pair do |uuid, versions|
         doc = find(uuid)
-        existing_chain[uuid] = doc.versions.all_versions if doc 
+        existing_chain[uuid] = doc.versions.all_versions.map {|v| [v, doc.versions[v].to_json ]} if doc 
       end
       case _timestamp
       when Numeric
@@ -31,9 +31,11 @@ module StrokeDB
         @timestamp = LTS.new(_timestamp.counter, timestamp.uuid)
       else
       end
-      docs.each {|doc| save!(doc) unless exists?(doc.uuid, doc.version)}
+      @txn = Transaction.new(:store => self)
+      @txn.execute do |txn|
+      docs.each {|doc| save!(doc) }
       docs.group_by {|doc| doc.uuid}.each_pair do |uuid, versions|
-        incoming_chain = find(uuid, versions.last.version).versions.all_versions
+        incoming_chain = find(uuid, versions.last.version).versions.all_versions.map {|v| [v, find(uuid,v).to_json ]}
         if existing_chain[uuid].nil? or existing_chain[uuid].empty? # It is a new document
           added_doc = find(uuid, versions.last.version)
           save_as_head!(added_doc)
@@ -43,6 +45,7 @@ module StrokeDB
             sync = sync_chains(incoming_chain.reverse, existing_chain[uuid].reverse)
           rescue NonMatchingChains
             # raise NonMatchingDocumentCondition.new(uuid) # that will definitely leave garbage in the store (FIXME?)
+            txn.rollback!
             non_matching_doc = find(uuid)
             report.non_matching_documents << non_matching_doc
             next
@@ -51,17 +54,22 @@ module StrokeDB
           case resolution
           when :up_to_date
             # nothing to do
+            txn.commit!
           when :merge
-            report.conflicts << SynchronizationConflict.create!(self, :document => find(uuid), :rev1 => sync[1], :rev2 => sync[2])
+            report.conflicts << SynchronizationConflict.create!(self, :document => find(uuid), :rev1 => sync[1].map{|e| e[0]}.reverse, :rev2 => sync[2].map{|e| e[0]}.reverse)
+            txn.commit!
           when :fast_forward
-            fast_forwarded_doc = find(uuid, sync[1].last)
+            fast_forwarded_doc = find(uuid, sync[1].last.first)
             save_as_head!(fast_forwarded_doc)
             report.fast_forwarded_documents << fast_forwarded_doc
+            txn.commit!
           else
+            txn.rollback!
             raise "Invalid sync resolution #{resolution}"
           end
         end
       end
+      end
       report.conflicts.each do |conflict|
         if resolution_strategy = conflict.document.meta[:resolution_strategy]
           conflict.metas << resolution_strategy

data/lib/strokedb/transaction.rb

@@ -0,0 +1,78 @@
+module StrokeDB
+  
+  class Transaction
+    
+    attr_reader :uuid
+    
+    def initialize(options = {})
+      @options = options.stringify_keys
+      @uuid = Util.random_uuid
+      storage.add_chained_storage!(store.storage)
+    end
+    
+    def storage
+      @options['storage'] ||= setup_storage
+    end
+    
+    def store
+      @options['store']
+    end
+    
+    def inspect
+      "#<Transaction #{@uuid}>"
+    end
+    
+    def find(uuid, version=nil, opts = {})
+      storage.find(uuid,version,opts.merge(:store => self))
+    end
+    
+    def head_version(uuid)
+      storage.head_version(uuid,{ :store => self })
+    end
+    
+    def save!(doc)
+      @timestamp = @timestamp.next
+      storage.save!(doc,@timestamp)
+    end
+    
+    def execute
+      raise ArgumentError, "no block provided" unless block_given?
+
+      Thread.current[:strokedb_transactions] ||= []
+      Thread.current[:strokedb_transactions].push self
+      
+      @timestamp = LTS.new(store.timestamp.counter,uuid)
+
+      begin
+        result = yield(self)
+      rescue 
+        throw $!
+      ensure
+        Thread.current[:strokedb_transactions].pop
+      end
+      
+      
+      result
+    end
+    
+    def commit!
+      storage.sync_chained_storage!(store.storage)
+      true
+    end
+    
+    def rollback!
+      @options['storage'] = setup_storage
+      true
+    end
+    
+    private
+    
+    def setup_storage
+      storage = MemoryStorage.new
+      storage.authoritative_source = store.storage
+      storage
+    end
+    
+  end
+  
+end

data/lib/{util → strokedb}/util.rb

@@ -17,13 +17,6 @@ module StrokeDB
       end
     end
 
-    unless RUBY_PLATFORM =~ /java/
-      require 'uuidtools'
-      def self.random_uuid
-        ::UUID.random_create.to_s
-      end
-    end
-
     class CircularReferenceCondition < Exception ; end
     class << self
       def catch_circular_reference(value,name = 'StrokeDB.reference_stack')
@@ -35,4 +28,18 @@ module StrokeDB
       end
     end
   end
+  
 end
+
+require 'util/blankslate'
+require 'util/class_optimization'
+require 'util/inflect'
+require 'util/lazy_array'
+require 'util/lazy_mapping_array'
+require 'util/lazy_mapping_hash'
+require 'util/serialization'
+require 'util/uuid'
+require 'util/xml'
+require 'util/attach_dsl'
+require 'time'
+require 'util/java_util' if RUBY_PLATFORM =~ /java/

data/lib/strokedb/util/attach_dsl.rb

@@ -0,0 +1,29 @@
+module StrokeDB
+  class ::Module
+    
+    # Attach module as DSL. Module may use store_dsl_options 
+    # method to store DSL.
+    #
+    def attach_dsl(*mods)
+      @dsl_options ||= {}
+      mods.each do |mod|
+        extend(mod)
+      end
+    end
+    alias :attach_dsls :attach_dsl
+    
+    # Store some data associated with a DSL name.
+    #
+    def store_dsl_options(name, opts)
+      @dsl_options[name] = opts
+    end
+    
+    # Return a map of registered DSLs.
+    #
+    def dsl
+      @dsl_options
+    end
+  end
+end
+
+

data/lib/strokedb/util/class_optimization.rb

@@ -0,0 +1,93 @@
+module StrokeDB
+  class ::Class
+    # Declare which methods are optimized for particular language. 
+    # It is assumed, that optimized method name looks that way: 
+    # <tt>method_name_(language name)</tt>
+    #
+    # If you supply a block of code, it will be executed in a context of a class
+    # each time <tt>optimize!</tt> is called.
+    #
+    # You may add some exception handling where you call <tt>optimize!</tt>.
+    #
+    # Example: 
+    #
+    #    # assume, there're methods find_C and insert_C
+    #    declare_optimized_methods(:C, :find, :insert) { require 'bundle' }</tt>
+    #
+    def declare_optimized_methods(lang, *meths, &block)
+      meths.flatten!
+      @optimized_methods ||= {}
+      @optimized_methods_init ||= {}
+      @optimized_methods[lang.to_s] = meths
+      @optimized_methods_init[lang.to_s] = block
+      extend ClassOptimization::ClassMethods
+    end
+    
+    # Returns a list of optimized methods for a given language.
+    # If no language given, a Hash is returned where key is a language name.
+    #
+    def optimized_methods(lang = nil)
+      @optimized_methods ||= {}
+      return @optimized_methods unless lang 
+      @optimized_methods[lang.to_s] || []
+    end
+  end
+  module ClassOptimization
+    module ClassMethods
+      # Switches methods into optimized versions as declared in
+      # <tt>declare_optimized_methods</tt>.
+      # Pure ruby methods become accessible with suffix _PureRuby.
+      #
+      def optimize!(lang)
+        if block = @optimized_methods_init[lang.to_s]
+          self.instance_eval(&block)
+        end
+        optimized_methods(lang).each do |meth|
+          alias_method(:"#{meth}_PureRuby", :"#{meth}")
+          alias_method(:"#{meth}",          :"#{meth}_#{lang}")
+        end
+      end
+      
+      # Reverts method optimization done with <tt>optimize!</tt>
+      # Note: you may call this method only after optimize! was called.
+      # 
+      def deoptimize!(lang)
+        optimized_methods(lang).each do |meth|
+          alias_method(:"#{meth}", :"#{meth}_PureRuby")
+        end
+      end
+      
+      # Executes code in a block with optimizations turned on.
+      # This ensures that appropriate <tt>deoptimize!</tt> method is called.
+      #
+      def optimized_with(lang)
+        optimize!(lang)
+        yield
+      ensure
+        deoptimize!(lang)
+      end
+      
+      # Iterates through all the optimizations. Non-optimized
+      # mode ("pure Ruby") is yielded first. 
+      # Useful for testing and benchmarks.
+      #
+      # Example:
+      #
+      #    Klass.with_optimizations(:InlineC) do |lang|
+      #      puts "Klass#some_method is written in #{lang}"
+      #      puts Klass.new.some_method
+      #    end
+      #
+      def with_optimizations(*langs)
+        langs.flatten!
+        yield("pure Ruby")
+        langs.each do |lang|
+          optimized_with(lang) do
+            yield(lang)
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/strokedb/util/java_util.rb

@@ -0,0 +1,13 @@
+require 'java'
+# Some java overrides
+module StrokeDB
+  module Util
+    def self.random_uuid
+      java.util.UUID.random_uuid.to_s
+    end
+    def self.random_uuid_raw
+      uuid = java.util.UUID.random_uuid
+      [uuid.most_significant_bits, uuid.least_significant_bits].pack("Q2")
+    end
+  end
+end

data/lib/{util → strokedb/util}/lazy_mapping_array.rb

@@ -135,6 +135,10 @@ module StrokeDB
     def to_a
        Array.new(map{|v| v})
     end
+    
+    def ==(arr)
+      to_a == arr
+    end
 
     def class
       Array