delfos 0.0.2.pre.rc2 → 0.0.2.pre.rc3

data/lib/delfos/neo4j/batch/execution.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require "delfos/neo4j/query_execution/transactional"
-
-module Delfos
-  module Neo4j
-    module Batch
-      class Execution
-        attr_reader :size, :current_transaction_url, :commit_url, :expires, :query_count
-
-        def initialize(size:, clock: Time)
-          @size               = size
-          @clock              = clock
-          reset!
-        end
-
-        def execute!(query, params: {})
-          check_for_expiry!
-
-          perform_query(query, params)
-          flush_if_required!
-        end
-
-        def flush!
-          return unless query_count.positive?
-          return unless @commit_url
-          QueryExecution::Transactional.commit!(@commit_url)
-
-          reset!
-        end
-
-        private
-
-        def perform_query(query, params)
-          transactional_query = QueryExecution::Transactional.new(query, params, url)
-          @total_query_length += transactional_query.query_length
-          transaction_url, @commit_url, @expires = transactional_query.perform
-          @current_transaction_url ||= transaction_url # the transaction_url is only returned with the first request
-          @query_count += 1
-        end
-
-        def url
-          return @commit_url if @commit_url && batch_full? || expires_soon?
-
-          current_transaction_url || new_transaction_url
-        end
-
-        def new_transaction_url
-          Delfos.neo4j.uri_for("/db/data/transaction")
-        end
-
-        def flush_if_required!
-          check_for_expiry!
-
-          if batch_full? || expires_soon? || large_query?
-            flush!
-            return true
-          end
-
-          false
-        end
-
-        def check_for_expiry!
-          return if @expires.nil? || (@clock.now <= @expires)
-
-          raise QueryExecution::ExpiredTransaction.new(@commit_url, "")
-        end
-
-        def batch_full?
-          query_count >= size
-        end
-
-        def expires_soon?
-          @expires && (@clock.now + 10 > @expires)
-        end
-
-        def large_query?
-          @total_query_length >= Delfos.max_query_size
-        end
-
-        def reset!
-          @query_count             = 0
-          @total_query_length      = 0
-          @current_transaction_url = nil
-          @commit_url              = nil
-          @expires                 = nil
-        end
-      end
-    end
-  end
-end

data/lib/delfos/neo4j/batch/retryable.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "execution"
-
-module Delfos
-  module Neo4j
-    module Batch
-      class Retryable
-        class << self
-          MUTEX = Mutex.new
-
-          def reset!
-            MUTEX.synchronize do
-              Thread.current[:_delfos__retryable_batch] = nil
-            end
-          end
-
-          def ensure_instance(size: nil)
-            MUTEX.synchronize do
-              Thread.current[:_delfos__retryable_batch] ||= new(size: size || 1_000)
-            end
-          end
-
-          def execute!(query, params: {}, size: nil)
-            ensure_instance(size: size).execute!(query, params: params)
-          end
-
-          def flush!
-            ensure_instance&.flush!
-            reset!
-          end
-        end
-
-        attr_reader :size, :queries, :execution
-        attr_accessor :retry_count
-
-        def initialize(size:)
-          @size = size
-          reset!
-        end
-
-        def execute!(query, params: {}, retrying: false)
-          queries.push([query, params]) unless retrying
-
-          with_retry(retrying) do
-            flushed = execution.execute!(query, params: params)
-
-            reset! if flushed
-          end
-        end
-
-        def flush!
-          execution.flush!
-          reset!
-        end
-
-        private
-
-        def with_retry(already_retrying)
-          yield
-        rescue QueryExecution::ExpiredTransaction
-          check_retry_limit! if already_retrying
-
-          retry_batch!
-        end
-
-        def check_retry_limit!
-          self.retry_count += 1
-
-          return if self.retry_count <= 5
-
-          self.retry_count = 0
-          Delfos.logger.error "Transaction expired - 5 retries failed aborting"
-          raise
-        end
-
-        def retry_batch!
-          Delfos.logger.error do
-            "Transaction expired - retrying batch. #{queries.count} queries retry_count: #{retry_count}"
-          end
-
-          new_execution
-
-          queries.each { |q, p| execute!(q, params: p, retrying: true) }
-
-          Delfos.logger.error { "Batch retry successful" }
-        end
-
-        def reset!
-          @queries = []
-          new_execution
-          @retry_count = 0
-        end
-
-        def new_execution
-          @execution = Execution.new(size: size)
-        end
-      end
-    end
-  end
-end

data/lib/delfos/setup.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-module Delfos
-  module Setup
-    extend self
-    attr_accessor :neo4j
-
-    def perform!(call_site_logger: nil,
-      application_directories: nil,
-      offline_query_saving: nil)
-      self.application_directories = application_directories if application_directories
-      self.call_site_logger = call_site_logger if call_site_logger
-
-      assign_offline_attributes(offline_query_saving)
-
-      require "delfos/method_trace"
-      ::Delfos::MethodTrace.trace!
-    end
-
-    def application_directories=(dirs)
-      dirs ||= %w[app lib]
-      require "pathname"
-      Delfos.application_directories = Array(dirs).map { |f| Pathname.new(f.to_s).expand_path }
-    end
-
-    def call_site_logger=(call_site_logger)
-      Delfos.call_site_logger = call_site_logger || default_call_site_logger
-    end
-
-    def default_call_site_logger
-      if Delfos.offline_query_saving
-        require "delfos/neo4j/offline/call_site_logger"
-        Delfos:: Neo4j::Offline::CallSiteLogger.new
-      else
-        Delfos.setup_neo4j!
-
-        require "delfos/neo4j/live/call_site_logger"
-        Delfos:: Neo4j::Live::CallSiteLogger.new
-      end
-    end
-
-    def disable!
-      disable_tracepoint!
-
-      reset_call_stack!
-      reset_batch!
-
-      reset_top_level_variables!
-      reset_app_directories!
-    end
-
-    def disable_tracepoint!
-      require "delfos/method_trace"
-      ::Delfos::MethodTrace.disable!
-    end
-
-    def reset_call_stack!
-      ignoring_undefined("Delfos::CallStack") do |k|
-        k.pop_until_top!
-        k.reset!
-      end
-    end
-
-    def reset_batch!
-      Delfos.batch_size = nil
-
-      ignoring_undefined "Delfos::Neo4j::Batch::Retryable" do |b|
-        begin
-          with_rescue { b.flush! }
-        ensure
-          b.instance = nil
-        end
-      end
-    end
-
-    def reset_app_directories!
-      ignoring_undefined("Delfos::FileSystem::AppDirectories", &:reset!)
-    end
-
-    def reset_top_level_variables!
-      Delfos.offline_query_saving    = nil
-      Delfos.offline_query_filename  = nil
-      Delfos.neo4j                   = nil
-      Delfos.logger                  = nil
-      Delfos.application_directories = nil
-      Delfos.call_site_logger        = nil
-      Delfos.max_query_size          = nil
-      Delfos.neo4j                   = nil
-    end
-
-    # This method allows resetting in between every spec.  So we avoid load
-    # order issues in cases where we have not run particular specs that require
-    # and define these constants
-    def ignoring_undefined(k)
-      o = Object.const_get(k)
-      yield(o)
-    rescue NameError => e
-      raise unless e.message[k]
-    end
-
-    def with_rescue
-      yield
-    rescue Delfos::Neo4j::QueryExecution::ExpiredTransaction
-      puts # no-op
-    end
-
-    def assign_offline_attributes(offline_query_saving)
-      return unless offline_query_saving
-      Delfos.offline_query_saving = offline_query_saving
-
-      Delfos.offline_query_filename = filename_from(offline_query_saving)
-    end
-
-    def filename_from(offline_query_saving)
-      return offline_query_saving if offline_query_saving.is_a?(String)
-
-      "delfos_query_parameters.json"
-    end
-  end
-end