dp_stm_map 0.0.2

data/lib/dp_stm_map/Client.rb

@@ -0,0 +1,268 @@
+require 'socket'
+require 'dp_stm_map'
+require 'securerandom'
+require 'digest/sha2'
+
+
+module DpStmMap
+
+  class ShutdownError < StandardError
+  end
+
+
+
+  class DistributedPersistentStmMap
+
+    def initialize host, port, local_storage
+      @host=host
+      @port=port
+      @connect_listeners=[]
+      @disconnect_listeners=[]
+      @connect_state=:disconnected
+      @mutex=Mutex.new
+
+
+      @content={}
+
+
+      @state=ClientLocalStore.new local_storage
+
+
+      @validators=[]
+      @listeners=[]
+
+      @outgoing_queue=Queue.new
+
+
+      @outcome_futures={}
+
+      @transaction_id_condition_variable=ConditionVariable.new
+
+    end
+
+    def start
+
+
+      latch=Queue.new
+
+      @reading_thread=Thread.new do
+        begin
+          # puts "connecting"
+          @client_socket=nil
+          @client_socket=TCPSocket.new @host,@port
+
+          @client_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+          # puts "connected"
+          @connect_state=:connected
+
+
+          Thread.new do
+            begin
+              loop do
+                message=@outgoing_queue.pop
+                serialized=message.serialize
+                @client_socket.write([serialized.bytesize].pack("Q>"))
+                @client_socket.write(serialized)
+                @client_socket.flush
+                # puts "sent #{message}"
+              end
+            rescue => e
+              # puts "Error during processing: #{$!}"
+              # puts "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+            end
+          end
+
+          send_to_server ClientHelloMessage.new(@state.current_transaction_sequence)
+
+
+          latch << "connected"
+
+          @connect_listeners.each do |listener|
+            listener.call
+          end
+
+
+
+          loop do
+            read=@client_socket.read(8)
+            # break unless read
+            len=read.unpack("Q>")[0]
+
+            msg=JsonMessage.deserialize(@client_socket.read(len))
+            # puts "got from server %s " % msg
+            if ClientTransactionOutcomeMessage === msg
+              # pp msg
+              @mutex.synchronize do
+                if @outcome_futures.has_key? msg.transaction_id
+                  @outcome_futures.delete(msg.transaction_id).push msg
+                end
+              end
+            end
+            if TransactionMessage === msg
+              # pp msg
+              @mutex.synchronize do
+
+                changes=@state.update msg.transaction_sequence, msg.new_content, msg.transitions, msg.delete_content
+
+
+                @listeners.each do |listener|
+                  begin
+                    listener.call changes
+                  rescue
+                  end
+                end
+
+                @transaction_id_condition_variable.broadcast
+
+              end
+
+            end
+          end
+        rescue ShutdownError => e
+          # puts "shutdown"
+        rescue => e          
+          # puts "Error during processing: #{$!}"
+          # puts "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+          # puts "error %s" % e
+          if @client_socket
+            @client_socket.close
+          end
+          if @connect_state == :connected
+            @connect_state=:disconnected
+            @disconnect_listeners.each do |listener|
+              listener.call
+            end
+          end
+          # puts "Exception: %s" % e
+          sleep 0.1
+          retry
+        ensure
+          if @connect_state == :connected
+            @connect_state=:disconnected
+            @disconnect_listeners.each do |listener|
+              listener.call
+            end
+          end
+          if @client_socket && !@client_socket.closed?
+            @client_socket.close
+          end
+        end
+
+      end
+
+      latch.pop
+    end
+
+    def stop
+      @reading_thread.raise ShutdownError
+      begin
+        @reading_thread.join
+      rescue => e
+      end
+      # puts "stopped"
+    end
+
+
+    def on_connected &block
+      @connect_listeners << block
+    end
+
+    def on_disconnected &block
+      @disconnect_listeners << block
+    end
+
+
+
+    def on_atomic &block
+      @listeners << block
+    end
+
+
+    def validate_atomic &block
+      @validators << block
+    end
+
+
+    def atomic timeout=nil
+
+      outcome_future=Queue.new
+
+
+      result=nil
+
+
+      tx_id=SecureRandom.uuid
+
+      view=AtomicView.new @state
+
+      @mutex.synchronize do
+        result=yield view
+        @outcome_futures[tx_id]=outcome_future
+      end
+
+      changes=view.changes
+
+      @validators.each do |validator|
+        validator.call changes
+      end
+
+
+
+      changes=view.changes
+
+      transitions={}
+
+      new_content={}
+
+      changes.each do |k,(old,new)|
+        transitions[k] =  [content_digest(old), content_digest(new)]
+        new_content[content_digest(new)]=new
+      end
+
+      send_to_server ClientTransactionMessage.new tx_id, transitions, new_content
+
+      outcome=outcome_future.pop
+
+
+      if ClientTransactionSuccessfulMessage === outcome
+        @mutex.synchronize do
+          while @state.current_transaction_sequence < outcome.transaction_sequence
+            @transaction_id_condition_variable.wait(@mutex)
+          end
+        end
+      end
+
+
+      result
+
+    end
+
+
+    def content_digest content
+      unless content == nil
+        Digest::SHA2.hexdigest(content)
+      else
+        nil
+      end
+    end
+
+    def atomic_read
+      @mutex.synchronize do
+        yield AtomicReadView.new @state
+      end
+    end
+
+
+
+    # private
+
+    def send_to_server message
+      # puts "about to send #{message}"
+      @outgoing_queue << message
+    end
+
+
+  end
+
+
+end

data/lib/dp_stm_map/ClientLocalStore.rb

@@ -0,0 +1,119 @@
+# dp_stm_map - Distributed and Persistent Software Transaction Map
+# Copyright (C) 2013  Dragan Milic
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+require 'threadsafe-lru'
+
+module DpStmMap
+  class ClientLocalStore
+    def initialize store_dir
+
+      @store_dir=store_dir
+
+      @mapping_dir="%s/mapping" % store_dir
+      FileUtils.mkdir_p(@mapping_dir) unless File.exist? @mapping_dir
+
+      @content_dir="%s/content" % store_dir
+      FileUtils.mkdir_p(@content_dir) unless File.exist? @content_dir
+
+
+      transaction_sequence_file_name="%s/transaction_sequence.txt" % @store_dir
+
+      File.open(transaction_sequence_file_name,"w") {|f| f.write(0)} unless File.exist? transaction_sequence_file_name
+
+      @content_cache=ThreadSafeLru::LruCache.new 9000
+      @mapping_cache=ThreadSafeLru::LruCache.new 9000
+
+    end
+
+    def update transaction_sequence, new_content, updates, to_delete
+
+
+
+      File.open("%s/transaction_sequence.txt" % @store_dir,"w") {|f| f.write(transaction_sequence)}
+
+
+      new_content.each_pair do |k,v|
+        File.open("%s/%s" % [@content_dir,k],"w") {|f| f.write(v)}
+      end
+
+
+      changes=updates.inject({}) do |c, (k, new_hash)|
+        c[k]=[self[k],get_content(new_hash)]
+        c
+      end
+
+      to_delete.each do |hash|
+        File.delete("%s/%s" % [@content_dir,hash])
+      end
+
+      updates.each_pair do |k,v|
+        @mapping_cache.drop(k)
+        if v == nil
+          File.delete("%s/%s" % [@mapping_dir,k])
+        else
+          raise StandardError, "unknown content #{v} for key #{k}" unless has_content?(v)
+          File.open("%s/%s" % [@mapping_dir,k],"w") {|f| f.write(v)}
+        end
+      end
+
+
+
+      changes
+
+    end
+
+    def current_transaction_sequence
+      File.open("%s/transaction_sequence.txt" % @store_dir,"r") {|f| f.read().to_i}
+    end
+
+
+    def has_content? hash
+      File.exist?("%s/%s" % [@content_dir,hash])
+    end
+
+    def get_content h
+      @content_cache.get(h) do |hash|
+        if hash == nil
+          nil
+        else
+          File.open("%s/%s" % [@content_dir,hash],"r") {|f| f.read }
+        end
+      end
+    end
+
+    def get_mapping k
+      @mapping_cache.get(k) do |key|
+        if key == nil
+          nil
+        else
+          if File.exist? "%s/%s" % [@mapping_dir,key]
+            File.open("%s/%s" % [@mapping_dir,key],"r") {|f| f.read }
+          else
+            nil
+          end
+        end
+      end
+    end
+
+
+
+    def [] key
+      get_content(get_mapping(key))
+    end
+
+    def has_key? key
+      File.exist?("%s/%s" % [@mapping_dir,key])
+    end
+
+  end
+end

data/lib/dp_stm_map/InMemoryStmMap.rb

@@ -0,0 +1,147 @@
+# dp_stm_map - Distributed and Persistent Software Transaction Map
+# Copyright (C) 2013  Dragan Milic
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+require 'thread'
+require 'set'
+
+module DpStmMap
+
+  class AtomicView
+
+    def initialize global_state
+      @global_state=global_state
+      @local_state={}
+      @to_delete=Set.new
+    end
+
+    def []= key, value
+      if value == nil
+        delete key
+      else
+        @local_state[key]=value
+      end
+    end
+
+    def [] key
+      if @local_state.has_key? key
+        @local_state[key]
+      else
+        @local_state[key]=@global_state[key]
+      end
+    end
+
+    def has_key? key
+      if @local_state.has_key?(key)
+        @local_state[key] != @global_state[key]
+      else        
+        (not @to_delete.include?(key)) && @global_state.has_key?(key)
+      end
+    end
+
+    def delete key
+      if @local_state.has_key? key
+        @local_state.delete key
+      else
+        @to_delete << key
+      end
+    end
+
+    def changes
+      changes={}
+      @local_state.each do |k,v|
+        changes[k]=[@global_state[k],v]
+      end
+      @to_delete.each do |k|
+        changes[k]=[@global_state[k],nil]
+      end
+      changes
+    end
+
+    def commit
+      @to_delete.each do |key|
+        @global_state.delete key
+      end
+      @global_state.merge!(@local_state)
+    end
+
+  end
+
+  class AtomicReadView
+    def initialize state
+      @state=state
+    end
+
+    def [] key
+      @state[key]
+    end
+
+    def has_key? key
+      @state.has_key? key
+    end
+  end
+
+
+  class InMemoryStmMap
+
+    def initialize
+      @mutex=Mutex.new
+      @state={}
+      @validators=[]
+      @listeners=[]
+    end
+
+
+    def on_atomic &block
+      @listeners << block
+    end
+
+
+    def validate_atomic &block
+      @validators << block
+    end
+
+
+    def atomic timeout=nil
+      @mutex.synchronize do
+        view=AtomicView.new @state
+        result=yield view
+
+        changes=view.changes
+
+        @validators.each do |validator|
+          validator.call changes
+        end
+
+        view.commit
+
+        @listeners.each do |listener|
+          begin
+            listener.call changes
+          rescue
+          end
+        end
+
+        result
+      end
+    end
+
+    def atomic_read
+      @mutex.synchronize do
+        yield AtomicReadView.new @state
+      end
+    end
+
+
+  end
+
+end