grumlin 0.21.0 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb67bbe2eff3a7fd02cce19c6052fa70e3f54f3ec2cb06102667f69e43d07e8d
-  data.tar.gz: 1ecf0285f60fab6fd93bd0b36bfe58c39b94eebf0ead055f6f3cc4f2e9f8b19d
+  metadata.gz: 8f91cc8f8b58fc3d72726e876dabac6a8f167e81bd524907eef4df7d72802e79
+  data.tar.gz: 892fa89f75c999899ff0869c7c6f74c26526b9eb5a6da0b43bd4df8a1b64504a
 SHA512:
-  metadata.gz: '05263993fc271810fd493ae3d5fdd8d84b6b698a8d9a4e4a4c336b09858571b156971b6f3def4bdb2d9c3743b07bebeb40eb1c426e4c316a8aa4a87b264f15b5'
-  data.tar.gz: 78fc706c4694146ff2b5fedc75b1d0186dca152fc9f2731c1b6936ea906e6410077c95871fba8b4c302f375cc8b28afffa37ccb59097a88470e266c4f26e6c51
+  metadata.gz: 5d50c9b36f4a69a431620404b333b71c8fd9ca2fd8a6b2689c6ece3da57198de4cfa294adaf631238ca1186581eaa3b74a9ec8dea6e6f50f69a977a78ea71a79
+  data.tar.gz: 3f201c437eee80beac09bb76f121542f7c611b68ce513545fb46d6c44790cf061527564e5f9c03e4f55e51c70c67e355802d0e63e64004d4db36de135f110750

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grumlin (0.21.0)
+    grumlin (0.22.1)
       async-pool (~> 0.3)
       async-websocket (~> 0.19)
       oj (~> 3.13)
@@ -21,14 +21,14 @@ GEM
       console (~> 1.10)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-http (0.56.6)
+    async-http (0.58.0)
       async (>= 1.25)
       async-io (>= 1.28)
       async-pool (>= 0.2)
-      protocol-http (~> 0.22.0)
+      protocol-http (~> 0.23.1)
       protocol-http1 (~> 0.14.0)
       protocol-http2 (~> 0.14.0)
-      traces (~> 0.4.0)
+      traces (>= 0.4.0)
     async-io (1.33.0)
       async
     async-pool (0.3.10)
@@ -37,7 +37,7 @@ GEM
       rspec (~> 3.0)
       rspec-files (~> 1.0)
       rspec-memory (~> 1.0)
-    async-websocket (0.19.0)
+    async-websocket (0.19.2)
       async-http (~> 0.54)
       async-io (~> 1.23)
       protocol-websocket (~> 0.7.0)
@@ -72,7 +72,7 @@ GEM
       racc (~> 1.4)
     nokogiri (1.13.6-x86_64-linux)
       racc (~> 1.4)
-    oj (3.13.18)
+    oj (3.13.20)
     overcommit (0.59.1)
       childprocess (>= 0.6.3, < 5)
       iniparse (~> 1.4)
@@ -81,7 +81,7 @@ GEM
     parser (3.1.2.0)
       ast (~> 2.4.1)
     protocol-hpack (1.4.2)
-    protocol-http (0.22.6)
+    protocol-http (0.23.4)
     protocol-http1 (0.14.4)
       protocol-http (~> 0.22)
     protocol-http2 (0.14.2)
@@ -157,7 +157,7 @@ GEM
     thor (1.2.1)
     tilt (2.0.10)
     timers (4.3.3)
-    traces (0.4.1)
+    traces (0.6.0)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.1.0)

data/README.md

@@ -46,9 +46,38 @@ Or install it yourself as:
 ```ruby
 Grumlin.configure do |config|
   config.url = "ws://localhost:8182/gremlin"
+
+  # make sure you select right provider for better compatibility
+  config.provider = :tinkergraph
 end
 ```
 
+#### Providers
+
+Currently `Grumlin` supports 2 providers:
+- tinkergraph (default)
+- neptune
+
+As different providers may have or may have not support for specific features it's recommended to
+explicitly specify the provider you use.
+
+#### Provider features
+
+Every provider is described by a set of features. In the future `Grumlin` may decide to disable or enable 
+some parts of it's functionality to comply provider's supported features.
+
+To check current providers supported features use
+
+```ruby
+Grumlin.features
+```
+
+Current differences between providers:
+
+| Feature      | TinkerGraph                                                                                                                                               |AWS Neptune|
+|--------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------|
+| Transactions | Transaction semantic is ignoroed, data is always writen, `tx.rollback` does nothing, an info is printed every time transactions are used with TinkerGraph |Full support
+
 ### Traversing graphs
 
 **Warning**: Not all steps and expressions defined in the reference documentation are supported.
@@ -216,21 +245,29 @@ Each `return_mode` is mapped to a particular termination step:
 - `:traversal` - do not execute the query and return the traversal as is
 
 `Grumlin::Repository` also provides a set of generic CRUD operations:
-- `add_vertex(label, id = nil, **properties)`
-- `add_edge(label, id = nil, from:, to:, **properties)`
-- `drop_vertex(id)`
-- `drop_edge(id = nil, from: nil, to: nil, label: nil)`
+- `add_vertex(label, id = nil, start: g, **properties)`
+- `add_edge(label, id = nil, from:, to:, start: g, **properties)`
+- `drop_vertex(id, start: g)`
+- `drop_edge(id = nil, from: nil, to: nil, label: nil, start: g)`
+- `drop_in_batches(traversal, batch_size: 10_000)`
 
 and a few methods that emulate upserts:
-- `upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, **params)` 
-- `upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}, on_failure: :retry, **params)`
-- `upsert_edges(edges, batch_size: 100, on_failure: :retry, **params)`
-- `upsert_vertices(edges, batch_size: 100, on_failure: :retry, **params)`
+- `upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, start: g, **params)` 
+- `upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}, on_failure: :retry, start: g, **params)`
+- `upsert_edges(edges, batch_size: 100, on_failure: :retry, start: g, **params)`
+- `upsert_vertices(edges, batch_size: 100, on_failure: :retry, start: g, **params)`
 
 All of them support 3 different modes for error handling: `:retry`, `:ignore` and `:raise`. Retry mode is implemented
 with [retryable](https://github.com/nfedyashev/retryable). **params will be merged to the default config for upserts 
 and passed to `Retryable.retryable`. In case if you want to modify retryable behaviour you are to do so.
 
+If you want to use these methods inside a transaction simply pass your `gtx` as `start` parameter:
+```ruby
+g.tx do |gtx|
+  add_vertex(:vertex, start: gtx)
+end
+```
+
 If you don't want to define you own repository, simply use
 
 `Grumlin::Repository.new` returns an instance of an anonymous class extending `Grumlin::Repository`. 
@@ -258,6 +295,24 @@ it may be useful for debugging. Note that one needs to call a termination step m
 
 method will return profiling data of the results.
 
+#### Transactions
+
+Since 0.22.0 `Grumlin` supports transactions when working with providers that supports them:
+```ruby
+# Using Transaction directly
+tx = g.tx
+gtx = tx.begin
+gtx.addV(:vertex).iterate
+tx.commit # or tx.rollback
+
+# Using with a block
+g.tx do |gtx|
+  gtx.addV(:vertex).iterate
+  # raise Grumlin::Rollback to manually rollback
+  # any other exception will also rollback the transaction and will be reraised 
+end # commits automatically
+```
+
 #### IRB
 
 An example of how to start an IRB session with support for executing gremlin queries:

data/lib/grumlin/action.rb

@@ -4,18 +4,19 @@ module Grumlin
   class Action < Steppable
     attr_reader :name, :args, :params, :next_step, :configuration_steps, :previous_step, :shortcut
 
-    def initialize(name, args: [], params: {}, previous_step: nil, pool: nil)
-      super()
+    # client is only used when a traversal is a part of transaction
+    def initialize(name, args: [], params: {}, previous_step: nil, pool: Grumlin.default_pool, session_id: nil)
+      super(pool: pool, session_id: session_id)
+
       @name = name.to_sym
       @args = args # TODO: add recursive validation: only json types or Action
       @params = params # TODO: add recursive validation: only json types
       @previous_step = previous_step
       @shortcut = shortcuts[@name]
-      @pool = pool || Grumlin.default_pool
     end
 
     def configuration_step?
-      CONFIGURATION_STEPS.include?(@name)
+      CONFIGURATION_STEPS.include?(@name) || name.to_sym == :tx
     end
 
     def start_step?
@@ -73,14 +74,18 @@ module Grumlin
     end
 
     def toList
-      @pool.acquire do |client|
-        client.write(bytecode)
-      end
+      client_write(bytecode)
     end
 
     def iterate
+      client_write(bytecode(no_return: true))
+    end
+
+    private
+
+    def client_write(payload)
       @pool.acquire do |client|
-        client.write(bytecode(no_return: true))
+        client.write(payload, session_id: @session_id)
       end
     end
   end

data/lib/grumlin/client.rb

@@ -24,8 +24,8 @@ module Grumlin
         @client.close
       end
 
-      def write(bytecode)
-        @client.write(bytecode)
+      def write(bytecode, session_id: nil)
+        @client.write(bytecode, session_id: session_id)
       ensure
         @count += 1
       end
@@ -94,14 +94,14 @@ module Grumlin
     end
 
     # TODO: support yielding
-    def write(bytecode)
+    def write(bytecode, session_id: nil)
       raise NotConnectedError unless connected?
 
-      request = to_query(bytecode)
-      channel = @request_dispatcher.add_request(request)
-      @transport.write(request)
+      request = to_query(bytecode, session_id: session_id)
 
+      channel = @request_dispatcher.add_request(request)
       begin
+        @transport.write(request)
         channel.dequeue.flat_map { |item| Typing.cast(item) }
       rescue Async::Stop, Async::TimeoutError
         close(check_requests: false)
@@ -124,15 +124,19 @@ module Grumlin
       Transport.new(@url, parent: @parent, **@client_options)
     end
 
-    def to_query(bytecode)
+    def to_query(bytecode, session_id:)
       {
         requestId: SecureRandom.uuid,
-        op: "bytecode",
-        processor: "traversal",
+        op: :bytecode,
+        processor: session_id ? :session : :traversal,
         args: {
-          gremlin: { :@type => "g:Bytecode", :@value => bytecode.serialize },
-          aliases: { g: :g }
-        }
+          gremlin: {
+            :@type => "g:Bytecode",
+            :@value => bytecode.serialize
+          },
+          aliases: { g: :g },
+          session: session_id
+        }.compact
       }
     end
   end

data/lib/grumlin/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Config
+    attr_accessor :url, :pool_size, :client_concurrency, :client_factory, :provider
+
+    SUPPORTED_PROVIDERS = %i[neptune tinkergraph].freeze
+
+    class ConfigurationError < Grumlin::Error; end
+
+    class UnknownProviderError < ConfigurationError; end
+
+    def initialize
+      @pool_size = 10
+      @client_concurrency = 5
+      @provider = :tinkergraph
+      @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
+    end
+
+    def validate!
+      return if SUPPORTED_PROVIDERS.include?(provider.to_sym)
+
+      raise UnknownProviderError, "provider '#{provider}' is unknown. Supported providers: #{SUPPORTED_PROVIDERS}"
+    end
+  end
+end

data/lib/grumlin/dummy_transaction.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class DummyTransaction < Transaction
+    attr_reader :uuid
+
+    include Console
+
+    def initialize(traversal_start_class, pool: Grumlin.default_pool) # rubocop:disable Lint/MissingSuper, Lint/UnusedMethodArgument
+      @traversal_start_class = traversal_start_class
+
+      logger.info(self) do
+        "#{Grumlin.config.provider} does not support transactions. commit and rollback are ignored, data will be saved"
+      end
+    end
+
+    def commit
+      nil
+    end
+
+    def rollback
+      nil
+    end
+  end
+end

data/lib/grumlin/features/feature_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Features
+    class FeatureList
+      def user_supplied_ids?
+        raise(NotImplementedError) if @user_supplied_ids.nil?
+
+        @user_supplied_ids
+      end
+
+      def supports_transactions?
+        raise(NotImplementedError) if @supports_transactions.nil?
+
+        @supports_transactions
+      end
+    end
+  end
+end

data/lib/grumlin/features/neptune_features.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Features
+    class NeptuneFeatures < FeatureList
+      def initialize
+        super
+        @user_supplied_ids = true
+        @supports_transactions = true
+      end
+    end
+  end
+end

data/lib/grumlin/features/tinkergraph_features.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Features
+    class TinkergraphFeatures < FeatureList
+      def initialize
+        super
+        @user_supplied_ids = true
+        @supports_transactions = false
+      end
+    end
+  end
+end

data/lib/grumlin/features.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Features
+    class << self
+      FEATURES = {
+        neptune: NeptuneFeatures.new,
+        tinkergraph: TinkergraphFeatures.new
+      }.freeze
+
+      def for(provider)
+        FEATURES[provider]
+      end
+    end
+  end
+end

data/lib/grumlin/repository/instance_methods.rb

@@ -2,13 +2,13 @@
 
 module Grumlin
   module Repository
-    module InstanceMethods
+    module InstanceMethods # rubocop:disable Metrics/ModuleLength
       include Grumlin::Expressions
 
       extend Forwardable
 
       UPSERT_RETRY_PARAMS = {
-        on: [Grumlin::AlreadyExistsError, Grumlin::ConcurrentInsertFailedError],
+        on: [Grumlin::AlreadyExistsError, Grumlin::ConcurrentModificationError],
         sleep_method: ->(n) { Async::Task.current.sleep(n) },
         tries: 3,
         sleep: ->(n) { (n**2) + 1 + rand }
@@ -22,51 +22,73 @@ module Grumlin
         self.class.shortcuts
       end
 
-      def drop_vertex(id)
-        g.V(id).drop.iterate
+      def drop_vertex(id, start: g)
+        start.V(id).drop.iterate
       end
 
-      def drop_edge(id = nil, from: nil, to: nil, label: nil) # rubocop:disable Metrics/AbcSize
+      def drop_in_batches(traversal, batch_size: 10_000) # rubocop:disable Metrics/AbcSize
+        total_count = traversal.count.next
+
+        batches = (total_count / batch_size) + 1
+
+        Console.logger.info(self) do
+          "drop_in_batches: total_count: #{total_count}, batch_size: #{batch_size}, batches: #{batches}"
+        end
+
+        batches.times do |batch|
+          Console.logger.info(self) { "drop_in_batches: deleting batch #{batch + 1}/#{batches}..." }
+          traversal.limit(batch_size).drop.iterate
+          Console.logger.info(self) { "drop_in_batches: batch #{batch + 1}/#{batches} deleted" }
+        end
+
+        return if traversal.count.next.zero?
+
+        drop_in_batches(traversal, batch_size: batch_size)
+
+        Console.logger.info(self) { "drop_in_batches: finished." }
+      end
+
+      def drop_edge(id = nil, from: nil, to: nil, label: nil, start: g) # rubocop:disable Metrics/AbcSize
         raise ArgumentError, "either id or from:, to: and label: must be passed" if [id, from, to, label].all?(&:nil?)
-        return g.E(id).drop.iterate unless id.nil?
+        return start.E(id).drop.iterate unless id.nil?
 
         raise ArgumentError, "from:, to: and label: must be passed" if [from, to, label].any?(&:nil?)
 
-        g.V(from).outE(label).where(__.inV.hasId(to)).limit(1).drop.iterate
+        start.V(from).outE(label).where(__.inV.hasId(to)).limit(1).drop.iterate
       end
 
-      def add_vertex(label, id = nil, **properties)
+      def add_vertex(label, id = nil, start: g, **properties)
         id ||= properties[T.id]
         properties = except(properties, T.id)
 
-        t = g.addV(label)
+        t = start.addV(label)
         t = t.props(T.id => id) unless id.nil?
         t.props(**properties).next
       end
 
-      def add_edge(label, id = nil, from:, to:, **properties)
+      def add_edge(label, id = nil, from:, to:, start: g, **properties)
         id ||= properties[T.id]
         properties = except(properties, T.label)
         properties[T.id] = id
 
-        g.addE(label).from(__.V(from)).to(__.V(to)).props(**properties).next
+        start.addE(label).from(__.V(from)).to(__.V(to)).props(**properties).next
       end
 
-      def upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, **params)
+      def upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, start: g, **params) # rubocop:disable Metrics/ParameterLists
         with_upsert_error_handling(on_failure, params) do
           create_properties, update_properties = cleanup_properties(create_properties, update_properties)
 
-          g.upsertV(label, id, create_properties, update_properties).id.next
+          start.upsertV(label, id, create_properties, update_properties).id.next
         end
       end
 
       # vertices:
       # [["label", "id", {create: :properties}, {update: properties}]]
       # params can override Retryable config from UPSERT_RETRY_PARAMS
-      def upsert_vertices(vertices, batch_size: 100, on_failure: :retry, **params)
+      def upsert_vertices(vertices, batch_size: 100, on_failure: :retry, start: g, **params)
         vertices.each_slice(batch_size) do |slice|
           with_upsert_error_handling(on_failure, params) do
-            slice.reduce(g) do |t, (label, id, create_properties, update_properties)|
+            slice.reduce(start) do |t, (label, id, create_properties, update_properties)|
               create_properties, update_properties = cleanup_properties(create_properties, update_properties)
 
               t.upsertV(label, id, create_properties, update_properties)
@@ -77,20 +99,21 @@ module Grumlin
 
       # Only from and to are used to find the existing edge, if one wants to assign an id to a created edge,
       # it must be passed as T.id in create_properties.
-      def upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}, on_failure: :retry, **params) # rubocop:disable Metrics/ParameterLists
+      def upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}, # rubocop:disable Metrics/ParameterLists
+                      on_failure: :retry, start: g, **params)
         with_upsert_error_handling(on_failure, params) do
           create_properties, update_properties = cleanup_properties(create_properties, update_properties, T.label)
-          g.upsertE(label, from, to, create_properties, update_properties).id.next
+          start.upsertE(label, from, to, create_properties, update_properties).id.next
         end
       end
 
       # edges:
       # [["label", "from", "to", {create: :properties}, {update: properties}]]
       # params can override Retryable config from UPSERT_RETRY_PARAMS
-      def upsert_edges(edges, batch_size: 100, on_failure: :retry, **params)
+      def upsert_edges(edges, batch_size: 100, on_failure: :retry, start: g, **params)
         edges.each_slice(batch_size) do |slice|
           with_upsert_error_handling(on_failure, params) do
-            slice.reduce(g) do |t, (label, from, to, create_properties, update_properties)|
+            slice.reduce(start) do |t, (label, from, to, create_properties, update_properties)|
               create_properties, update_properties = cleanup_properties(create_properties, update_properties, T.label)
 
               t.upsertE(label, from, to, create_properties, update_properties)

data/lib/grumlin/request_dispatcher.rb

@@ -10,23 +10,6 @@ module Grumlin
       206 => :partial_content
     }.freeze
 
-    ERRORS = {
-      499 => InvalidRequestArgumentsError,
-      500 => ServerError,
-      597 => ScriptEvaluationError,
-      599 => ServerSerializationError,
-      598 => ServerTimeoutError,
-
-      401 => ClientSideError,
-      407 => ClientSideError,
-      498 => ClientSideError
-    }.freeze
-
-    VERTEX_ALREADY_EXISTS = "Vertex with id already exists:"
-    EDGE_ALREADY_EXISTS = "Edge with id already exists:"
-    CONCURRENT_VERTEX_INSERT_FAILED = "Failed to complete Insert operation for a Vertex due to conflicting concurrent"
-    CONCURRENT_EDGE_INSERT_FAILED = "Failed to complete Insert operation for an Edge due to conflicting concurrent"
-
     class DispatcherError < Grumlin::Error; end
 
     class RequestAlreadyAddedError < DispatcherError; end
@@ -47,14 +30,16 @@ module Grumlin
 
     # builds a response object, when it's ready sends it to the client via a channel
     # TODO: sometimes response does not include requestID, no idea how to handle it so far.
-    def add_response(response) # rubocop:disable Metrics/AbcSize
+    def add_response(response) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       request_id = response[:requestId]
       raise UnknownRequestError unless ongoing_request?(request_id)
 
       begin
         request = @requests[request_id]
 
-        check_errors!(response[:status], request[:request])
+        RequestErrorFactory.build(request, response).tap do |err|
+          raise err unless err.nil?
+        end
 
         case SUCCESS[response.dig(:status, :code)]
         when :success
@@ -91,29 +76,5 @@ module Grumlin
       request = @requests.delete(request_id)
       request[:channel].close
     end
-
-    def check_errors!(status, query)
-      if (error = ERRORS[status[:code]])
-        raise (
-          already_exists_error(status) ||
-          concurrent_insert_error(status) ||
-          error
-        ).new(status, query)
-      end
-
-      return unless SUCCESS[status[:code]].nil?
-
-      raise(UnknownResponseStatus, status)
-    end
-
-    def already_exists_error(status)
-      return VertexAlreadyExistsError if status[:message]&.include?(VERTEX_ALREADY_EXISTS)
-      return EdgeAlreadyExistsError if status[:message]&.include?(EDGE_ALREADY_EXISTS)
-    end
-
-    def concurrent_insert_error(status)
-      return ConcurrentVertexInsertFailedError if status[:message]&.include?(CONCURRENT_VERTEX_INSERT_FAILED)
-      return ConcurrentEdgeInsertFailedError if status[:message]&.include?(CONCURRENT_EDGE_INSERT_FAILED)
-    end
   end
 end

data/lib/grumlin/request_error_factory.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class RequestErrorFactory
+    ERRORS = {
+      499 => InvalidRequestArgumentsError,
+      500 => ServerError,
+      597 => ScriptEvaluationError,
+      599 => ServerSerializationError,
+      598 => ServerTimeoutError,
+
+      401 => ClientSideError,
+      407 => ClientSideError,
+      498 => ClientSideError
+    }.freeze
+
+    # Neptune presumably returns message as a JSON string of format
+    # {"detailedMessage":"",
+    #  "requestId":"UUID",
+    #  "code":"ConcurrentModificationException"}
+    # Currencly we simply search for substings to identify the exact error
+    # TODO: parse json and use `code` instead
+    VERTEX_ALREADY_EXISTS = "Vertex with id already exists:"
+    EDGE_ALREADY_EXISTS = "Edge with id already exists:"
+    CONCURRENT_VERTEX_INSERT_FAILED = "Failed to complete Insert operation for a Vertex due to conflicting concurrent"
+    CONCURRENT_EDGE_INSERT_FAILED = "Failed to complete Insert operation for an Edge due to conflicting concurrent"
+    CONCURRENCT_MODIFICATION_FAILED = "Failed to complete operation due to conflicting concurrent"
+
+    class << self
+      def build(request, response)
+        status = response[:status]
+        query = request[:request]
+
+        if (error = ERRORS[status[:code]])
+          return (
+            already_exists_error(status) ||
+            concurrent_modification_error(status) ||
+            error
+          ).new(status, query)
+        end
+
+        return unless RequestDispatcher::SUCCESS[status[:code]].nil?
+
+        UnknownResponseStatus.new(status)
+      end
+
+      def already_exists_error(status)
+        return VertexAlreadyExistsError if status[:message]&.include?(VERTEX_ALREADY_EXISTS)
+        return EdgeAlreadyExistsError if status[:message]&.include?(EDGE_ALREADY_EXISTS)
+      end
+
+      def concurrent_modification_error(status)
+        return ConcurrentVertexInsertFailedError if status[:message]&.include?(CONCURRENT_VERTEX_INSERT_FAILED)
+        return ConcurrentEdgeInsertFailedError if status[:message]&.include?(CONCURRENT_EDGE_INSERT_FAILED)
+        return ConcurrentModificationError if status[:message]&.include?(CONCURRENCT_MODIFICATION_FAILED)
+      end
+    end
+  end
+end

data/lib/grumlin/steppable.rb

@@ -4,13 +4,18 @@ module Grumlin
   class Steppable
     extend Forwardable
 
+    attr_reader :session_id
+
     START_STEPS = Grumlin.definitions.dig(:steps, :start).map(&:to_sym).freeze
     REGULAR_STEPS = Grumlin.definitions.dig(:steps, :regular).map(&:to_sym).freeze
     CONFIGURATION_STEPS = Grumlin.definitions.dig(:steps, :configuration).map(&:to_sym).freeze
 
     ALL_STEPS = START_STEPS + CONFIGURATION_STEPS + REGULAR_STEPS
 
-    def initialize
+    def initialize(pool: Grumlin.default_pool, session_id: nil)
+      @pool = pool
+      @session_id = session_id
+
       return if respond_to?(:shortcuts)
 
       raise "steppable must not be initialized directly, use Grumlin::Shortcuts::Storage#g or #__ instead"
@@ -18,12 +23,12 @@ module Grumlin
 
     ALL_STEPS.each do |step|
       define_method step do |*args, **params|
-        shortcuts.action_class.new(step, args: args, params: params, previous_step: self)
+        shortcuts.action_class.new(step, args: args, params: params, previous_step: self, session_id: @session_id)
       end
     end
 
     def step(name, *args, **params)
-      shortcuts.action_class.new(name, args: args, params: params, previous_step: self)
+      shortcuts.action_class.new(name, args: args, params: params, previous_step: self, session_id: @session_id)
     end
 
     def_delegator :shortcuts, :__

data/lib/grumlin/steps.rb

@@ -32,7 +32,9 @@ module Grumlin
     end
 
     def add(name, args: [], params: {})
-      return add_configuration_step(name, args: args, params: params) if CONFIGURATION_STEPS.include?(name)
+      if CONFIGURATION_STEPS.include?(name) || name.to_sym == :tx
+        return add_configuration_step(name, args: args, params: params)
+      end
 
       StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
         @steps << step

data/lib/grumlin/steps_serializers/bytecode.rb

@@ -10,17 +10,19 @@ module Grumlin
 
       def serialize
         steps = ShortcutsApplyer.call(@steps)
-        no_return = @params[:no_return] || false
-
-        {
-          step: (steps.steps + (no_return ? [NONE_STEP] : [])).map { |s| serialize_step(s) }
-        }.tap do |v|
-          v.merge!(source: steps.configuration_steps.map { |s| serialize_step(s) }) if steps.configuration_steps.any?
+        no_return = @params.fetch(:no_return, false)
+        {}.tap do |result|
+          result[:step] = serialize_steps(steps.steps + (no_return ? [NONE_STEP] : [])) if steps.steps.any?
+          result[:source] = serialize_steps(steps.configuration_steps) if steps.configuration_steps.any?
         end
       end
 
       private
 
+      def serialize_steps(steps)
+        steps.map { |s| serialize_step(s) }
+      end
+
       def serialize_step(step)
         [step.name].tap do |result|
           step.args.each do |arg|

data/lib/grumlin/transaction.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Transaction
+    attr_reader :session_id
+
+    include Console
+
+    COMMIT = Grumlin::Repository.new.g.step(:tx, :commit).bytecode
+    ROLLBACK = Grumlin::Repository.new.g.step(:tx, :rollback).bytecode
+
+    def initialize(traversal_start_class, pool: Grumlin.default_pool)
+      @traversal_start_class = traversal_start_class
+      @pool = pool
+
+      @session_id = SecureRandom.uuid
+    end
+
+    def begin
+      @traversal_start_class.new(session_id: @session_id)
+    end
+
+    def commit
+      finalize(COMMIT)
+    end
+
+    def rollback
+      finalize(ROLLBACK)
+    end
+
+    private
+
+    def finalize(action)
+      @pool.acquire do |client|
+        client.write(action, session_id: @session_id)
+      end
+    end
+  end
+end

data/lib/grumlin/traversal_start.rb

@@ -4,6 +4,27 @@ module Grumlin
   class TraversalStart < Steppable
     include WithExtension
 
+    class TraversalError < Grumlin::Error; end
+    class AlreadyBoundToTransactionError < TraversalError; end
+
+    def tx
+      raise AlreadyBoundToTransactionError if @session_id
+
+      transaction = tx_class.new(self.class, pool: @pool)
+      return transaction unless block_given?
+
+      begin
+        yield transaction.begin
+      rescue Grumlin::Rollback
+        transaction.rollback
+      rescue StandardError
+        transaction.rollback
+        raise
+      else
+        transaction.commit
+      end
+    end
+
     def to_s(*)
       self.class.to_s
     end
@@ -11,5 +32,11 @@ module Grumlin
     def inspect
       self.class.inspect
     end
+
+    private
+
+    def tx_class
+      Grumlin.features.supports_transactions? ? Transaction : DummyTransaction
+    end
   end
 end

data/lib/grumlin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.21.0"
+  VERSION = "0.22.1"
 end

data/lib/grumlin.rb

@@ -33,6 +33,9 @@ loader.do_not_eager_load(test_helpers)
 module Grumlin
   class Error < StandardError; end
 
+  class TransactionError < Error; end
+  class Rollback < TransactionError; end
+
   class UnknownError < Error; end
 
   class ConnectionError < Error; end
@@ -98,7 +101,8 @@ module Grumlin
   class VertexAlreadyExistsError < AlreadyExistsError; end
   class EdgeAlreadyExistsError < AlreadyExistsError; end
 
-  class ConcurrentInsertFailedError < ServerError; end
+  class ConcurrentModificationError < ServerError; end
+  class ConcurrentInsertFailedError < ConcurrentModificationError; end
 
   class ConcurrentVertexInsertFailedError < ConcurrentInsertFailedError; end
   class ConcurrentEdgeInsertFailedError < ConcurrentInsertFailedError; end
@@ -127,27 +131,26 @@ module Grumlin
 
   class WrongQueryResult < RepositoryError; end
 
-  class Config
-    attr_accessor :url, :pool_size, :client_concurrency, :client_factory
-
-    def initialize
-      @pool_size = 10
-      @client_concurrency = 5
-      @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
-    end
-  end
-
   @pool_mutex = Mutex.new
 
   class << self
     def configure
       yield config
+
+      config.validate!
     end
 
     def config
       @config ||= Config.new
     end
 
+    # returns a subset of features for currently configured backend.
+    # The features lists are hardcoded as there is no way to get them
+    # from the remote server.
+    def features
+      Features.for(config.provider) # no memoization as provider may be changed
+    end
+
     def default_pool
       if Thread.current.thread_variable_get(:grumlin_default_pool)
         return Thread.current.thread_variable_get(:grumlin_default_pool)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.1
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-28 00:00:00.000000000 Z
+date: 2022-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-pool
@@ -116,6 +116,8 @@ files:
 - lib/grumlin/action.rb
 - lib/grumlin/benchmark/repository.rb
 - lib/grumlin/client.rb
+- lib/grumlin/config.rb
+- lib/grumlin/dummy_transaction.rb
 - lib/grumlin/edge.rb
 - lib/grumlin/expressions/cardinality.rb
 - lib/grumlin/expressions/column.rb
@@ -128,12 +130,17 @@ files:
 - lib/grumlin/expressions/t.rb
 - lib/grumlin/expressions/text_p.rb
 - lib/grumlin/expressions/with_options.rb
+- lib/grumlin/features.rb
+- lib/grumlin/features/feature_list.rb
+- lib/grumlin/features/neptune_features.rb
+- lib/grumlin/features/tinkergraph_features.rb
 - lib/grumlin/path.rb
 - lib/grumlin/property.rb
 - lib/grumlin/repository.rb
 - lib/grumlin/repository/error_handling_strategy.rb
 - lib/grumlin/repository/instance_methods.rb
 - lib/grumlin/request_dispatcher.rb
+- lib/grumlin/request_error_factory.rb
 - lib/grumlin/shortcut.rb
 - lib/grumlin/shortcuts.rb
 - lib/grumlin/shortcuts/properties.rb
@@ -151,6 +158,7 @@ files:
 - lib/grumlin/test/rspec.rb
 - lib/grumlin/test/rspec/db_cleaner_context.rb
 - lib/grumlin/test/rspec/gremlin_context.rb
+- lib/grumlin/transaction.rb
 - lib/grumlin/transport.rb
 - lib/grumlin/traversal_start.rb
 - lib/grumlin/traversal_strategies/options_strategy.rb