grumlin 0.2.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0290e4d77bd50f701a803390ff2a0489b039f4beb231e8883ced690180c7abc
-  data.tar.gz: b4948d687c09ffea5bf9da26eda8644fc3fcffa1954e4e61fe2d628192984e7e
+  metadata.gz: 5fb5b809483aeed3b56aeafc11e0f08919a68ce420a14ae918e3aecab791e266
+  data.tar.gz: e42c886a034faeb5ca512882811e78a39f1f5f386b697b0f4061c5be5d5a5f0b
 SHA512:
-  metadata.gz: 3846fe491a606989f51f0f609e8c7ae2049b8a1005272ea531f085402e7d998a7f8723ccdafae01ce7d913f9ad9272f9da1e86a307cb7aeb5066ef4ad4024e4b
-  data.tar.gz: 1b20d251d16c95cb12657c6becbbb4592b8e206e9e83a7defee42281bbdd7c3f84d04785b2cc89bcc1328d05d11aa14b865b6bc6832899d3a73ce7b86283be5b
+  metadata.gz: 2bd8e23cd4e6ab7526e2e4aaf92dddfa2b1e0dc51fd2e15e9e0a09541e9716c741673a8e6f85b077e5fd1a3a5f16519ae533748347b1aff0ba5de47a8394ed47
+  data.tar.gz: 673985aeb319810c061234e1d0964cf6e40b95363288423d7cda4e0932a7e271d51b957dccc5605a160e54e680d2a869bfa32769b393d19387e61e0ad15b7794

data/.github/workflows/main.yml

@@ -1,6 +1,6 @@
 name: Ruby
 
-on: [push, pull_request]
+on: [push]
 
 jobs:
   lint:

data/.rubocop.yml

@@ -7,24 +7,44 @@ require:
   - rubocop-performance
   - rubocop-rspec
 
-Style/StringLiterals:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  Enabled: true
-  EnforcedStyle: double_quotes
-
-Style/Documentation:
-  Enabled: false
-
 Layout/LineLength:
   Max: 120
+  Exclude:
+    - spec/**/*_spec.rb
 
 Metrics/BlockLength:
   Exclude:
     - spec/**/*_spec.rb
 
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/ParameterLists:
+  Max: 6
+
+Naming/MethodName:
+  IgnoredPatterns:
+    - toList
+    - inVLabel
+    - outVLabel
+    - inV
+    - outV
+
+Naming/VariableName:
+  AllowedIdentifiers:
+    - inV
+    - outV
+    - inVLabel
+    - outVLabel
+
+Naming/MethodParameterName:
+  AllowedNames:
+    - id
+    - inV
+    - outV
+    - inVLabel
+    - outVLabel
+
 RSpec/NamedSubject:
   Enabled: false
 
@@ -34,5 +54,26 @@ RSpec/NestedGroups:
 RSpec/ExampleLength:
   Enabled: false
 
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/DescribeClass:
+  Enabled: false
+
+Style/WordArray:
+  Exclude:
+    - spec/**/*_spec.rb
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
 Style/MultilineBlockChain:
-  Enabled: false
+  Enabled: false

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    grumlin (0.2.0)
+    grumlin (0.5.1)
+      async-pool (~> 0.3)
       async-websocket (~> 0.19)
 
 GEM
@@ -14,7 +15,7 @@ GEM
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
     ast (2.4.2)
-    async (1.30.0)
+    async (1.30.1)
       console (~> 1.10)
       nio4r (~> 2.3)
       timers (~> 4.1)
@@ -58,7 +59,7 @@ GEM
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
     minitest (5.14.4)
-    nio4r (2.5.7)
+    nio4r (2.5.8)
     nokogiri (1.11.7-x86_64-linux)
       racc (~> 1.4)
     overcommit (0.57.0)
@@ -124,7 +125,7 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.3)
-    solargraph (0.42.4)
+    solargraph (0.43.0)
       backport (~> 1.2)
       benchmark
       bundler (>= 1.17.2)

data/bin/console

@@ -19,5 +19,5 @@ Async do
 rescue StandardError
   raise
 ensure
-  Grumlin.config.default_client&.disconnect
+  Grumlin.config.default_pool.close
 end

data/grumlin.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "async-pool", "~> 0.3"
   spec.add_dependency "async-websocket", "~> 0.19"
 end

data/lib/async/channel.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Async
+  # Channel is a wrapper around Async::Queue that provides
+  # a protocol and handy tools for passing data, exceptions and closing.
+  # It is designed to be used with only one publisher and one subscriber
+  class Channel
+    class ChannelError < StandardError; end
+
+    class ChannelClosedError < ChannelError; end
+
+    def initialize
+      @queue = Async::Queue.new
+      @closed = false
+    end
+
+    def closed?
+      @closed
+    end
+
+    # Methods for a publisher
+    def <<(payload)
+      raise(ChannelClosedError, "Cannot send to a closed channel") if @closed
+
+      @queue << [:payload, payload]
+    end
+
+    def exception(exception)
+      raise(ChannelClosedError, "Cannot send to a closed channel") if closed?
+
+      @queue << [:exception, exception]
+    end
+
+    def close
+      raise(ChannelClosedError, "Cannot close a closed channel") if closed?
+
+      @queue << [:close]
+      @closed = true
+    end
+
+    # Methods for a subscriber
+    def dequeue
+      each do |payload| # rubocop:disable Lint/UnreachableLoop this is intended
+        return payload
+      end
+    end
+
+    def each
+      raise(ChannelClosedError, "Cannot receive from a closed channel") if closed?
+
+      @queue.each do |type, payload|
+        case type
+        when :exception
+          payload.set_backtrace(caller + (payload.backtrace || [])) # A hack to preserve full backtrace
+          raise payload
+        when :payload
+          yield payload
+        when :close
+          break
+        end
+      end
+    end
+  end
+end

data/lib/grumlin/client.rb

@@ -2,120 +2,107 @@
 
 module Grumlin
   class Client
-    extend Forwardable
-
-    SUCCESS = {
-      200 => :success,
-      204 => :no_content,
-      206 => :partial_content
-    }.freeze
-
-    ERRORS = {
-      499 => InvalidRequestArgumentsError,
-      500 => ServerError,
-      597 => ScriptEvaluationError,
-      599 => ServerSerializationError,
-      598 => ServerTimeoutError,
-
-      401 => ClientSideError,
-      407 => ClientSideError,
-      498 => ClientSideError
-    }.freeze
-
-    def initialize(url, autoconnect: true)
-      @url = url
-      @transport = Transport::Async.new(url)
-      connect if autoconnect
-    end
+    class PoolResource < Async::Pool::Resource
+      attr_reader :client
 
-    def_delegators :@transport, :connect, :disconnect, :requests
+      def self.call
+        config = Grumlin.config
+        new(config.url, client_factory: config.client_factory, concurrency: config.client_concurrency)
+      end
 
-    # TODO: support yielding
-    def submit(*args)
-      request_id = SecureRandom.uuid
-      queue = @transport.submit(to_query(request_id, args))
-      wait_for_response(request_id, queue)
-    ensure
-      @transport.close_request(request_id)
-    end
+      def initialize(url, client_factory:, concurrency: 1, parent: Async::Task.current)
+        super(concurrency)
+        @client = client_factory.call(url, parent).tap(&:connect)
+      end
 
-    def inspect
-      "<#{self.class} @url=#{@url}>"
-    end
+      def closed?
+        !@client.connected?
+      end
 
-    alias to_s inspect
+      def close
+        @client.close
+      end
 
-    private
+      def write(*args)
+        @client.write(*args)
+      end
+    end
 
-    def wait_for_response(request_id, queue, result: []) # rubocop:disable Metrics/MethodLength
-      queue.each do |status, response|
-        check_errors!(request_id, status, response)
+    def initialize(url, parent: Async::Task.current, **client_options)
+      @url = url
+      @client_options = client_options
+      @parent = parent
+      reset!
+    end
 
-        case SUCCESS[response.dig(:status, :code)]
-        when :success
-          return result + Typing.cast(response.dig(:result, :data))
-        when :partial_content then result += Typing.cast(response.dig(:result, :data))
-        when :no_content
-          return []
+    def connect
+      @transport = build_transport
+      response_channel = @transport.connect
+      @request_dispatcher = RequestDispatcher.new
+      @parent.async do
+        response_channel.each do |response|
+          @request_dispatcher.add_response(response)
         end
+      rescue StandardError
+        close
       end
-    rescue ::Async::Stop
-      retry if @transport.ongoing_request?(request_id)
-      raise UnknownRequestStopped, "#{request_id} is not in the ongoing requests list"
     end
 
-    def to_query(request_id, message)
-      case message.first # TODO: properly handle unknown type of message
-      when String
-        string_query_message(request_id, *message)
-      when Grumlin::Step
-        bytecode_query_message(request_id, Translator.to_bytecode_query(message))
-      end
+    def close
+      @transport.close
+      raise ResourceLeakError, "Request list is not empty: #{requests}" if @request_dispatcher.requests.any?
+
+      reset!
     end
 
-    def check_errors!(_request_id, status, response)
-      reraise_error!(response) if status == :error
+    def connected?
+      @transport&.connected? || false
+    end
 
-      status = response[:status]
+    # TODO: support yielding
+    def write(*args)
+      raise NotConnectedError unless connected?
 
-      if (error = ERRORS[status[:code]])
-        raise(error, status)
+      request_id = SecureRandom.uuid
+      request = to_query(request_id, args)
+      channel = @request_dispatcher.add_request(request)
+      @transport.write(request)
+
+      begin
+        channel.dequeue.flat_map { |item| Typing.cast(item) }
+      rescue Async::Stop
+        retry if @request_dispatcher.ongoing_request?(request_id)
+        raise Grumlin::UnknownRequestStoppedError, "#{request_id} is not in the ongoing requests list"
       end
-
-      return unless SUCCESS[status[:code]].nil?
-
-      raise(UnknownResponseStatus, status)
     end
 
-    def reraise_error!(error)
-      raise error
-    rescue StandardError
-      raise UnknownError
+    def inspect
+      "<#{self.class} url=#{@url} connected=#{connected?}>"
     end
 
-    def string_query_message(request_id, query, bindings)
-      {
-        requestId: request_id,
-        op: "eval",
-        processor: "",
-        args: {
-          gremlin: query,
-          bindings: bindings,
-          language: "gremlin-groovy"
-        }
-      }
-    end
+    alias to_s inspect
+
+    private
 
-    def bytecode_query_message(request_id, bytecode)
+    def to_query(request_id, message)
       {
         requestId: request_id,
         op: "bytecode",
         processor: "traversal",
         args: {
-          gremlin: Typing.to_bytecode(bytecode),
+          gremlin: Typing.to_bytecode(Translator.to_bytecode_query(message)),
           aliases: { g: :g }
         }
       }
     end
+
+    def reset!
+      @request_dispatcher = nil
+      @transport = nil
+    end
+
+    def build_transport
+      Transport.new(@url, parent: @parent, **@client_options)
+    end
   end
 end

data/lib/grumlin/edge.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-# rubocop:disable Naming/VariableName,Naming/MethodParameterName,Naming/MethodName
 module Grumlin
   class Edge
     attr_reader :label, :id, :inVLabel, :outVLabel, :inV, :outV
 
-    def initialize(label:, id:, inVLabel:, outVLabel:, inV:, outV:) # rubocop:disable Metrics/ParameterLists
+    def initialize(label:, id:, inVLabel:, outVLabel:, inV:, outV:)
       @label = label
       @id = Typing.cast(id)
       @inVLabel = inVLabel
@@ -24,4 +23,3 @@ module Grumlin
     alias to_s inspect
   end
 end
-# rubocop:enable Naming/MethodParameterName,Naming/VariableName,Naming/MethodName

data/lib/grumlin/order.rb

@@ -2,11 +2,9 @@
 
 module Grumlin
   module Order
-    module Order
+    class << self
       DESC = { "@type": "g:Order", "@value": "desc" }.freeze
-      ASC = { "@type": "g:Order", "@value": "desc" }.freeze
-
-      extend self # rubocop:disable Style/ModuleFunction
+      ASC = { "@type": "g:Order", "@value": "asc" }.freeze
 
       def asc
         ASC
@@ -16,7 +14,5 @@ module Grumlin
         DESC
       end
     end
-
-    extend Order
   end
 end

data/lib/grumlin/pop.rb

@@ -2,9 +2,7 @@
 
 module Grumlin
   module Pop
-    module Pop
-      extend self # rubocop:disable Style/ModuleFunction
-
+    class << self
       FIRST = { "@type": "g:Pop", "@value": "first" }.freeze
       LAST = { "@type": "g:Pop", "@value": "last" }.freeze
       ALL = { "@type": "g:Pop", "@value": "all" }.freeze
@@ -26,7 +24,5 @@ module Grumlin
         MIXED
       end
     end
-
-    extend Pop
   end
 end

data/lib/grumlin/request_dispatcher.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class RequestDispatcher
+    attr_reader :requests
+
+    SUCCESS = {
+      200 => :success,
+      204 => :no_content,
+      206 => :partial_content
+    }.freeze
+
+    ERRORS = {
+      499 => InvalidRequestArgumentsError,
+      500 => ServerError,
+      597 => ScriptEvaluationError,
+      599 => ServerSerializationError,
+      598 => ServerTimeoutError,
+
+      401 => ClientSideError,
+      407 => ClientSideError,
+      498 => ClientSideError
+    }.freeze
+
+    def initialize
+      @requests = {}
+    end
+
+    def add_request(request)
+      raise "ERROR" if @requests.key?(request[:requestId])
+
+      Async::Channel.new.tap do |channel|
+        @requests[request[:requestId]] = { request: request, result: [], channel: channel }
+      end
+    end
+
+    # 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
+      request_id = response[:requestId]
+      raise "ERROR" unless ongoing_request?(request_id)
+
+      request = @requests[request_id]
+
+      check_errors!(response[:status])
+
+      case SUCCESS[response.dig(:status, :code)]
+      when :success
+        request[:channel] << request[:result] + [response.dig(:result, :data)]
+        close_request(request_id)
+      when :partial_content then request[:result] << response.dig(:result, :data)
+      when :no_content
+        request[:channel] << []
+        close_request(request_id)
+      end
+    rescue StandardError => e
+      request[:channel].exception(e)
+      close_request(request_id)
+    end
+
+    def close_request(request_id)
+      raise "ERROR" unless ongoing_request?(request_id)
+
+      request = @requests.delete(request_id)
+      request[:channel].close
+    end
+
+    def ongoing_request?(request_id)
+      @requests.key?(request_id)
+    end
+
+    private
+
+    def check_errors!(status)
+      if (error = ERRORS[status[:code]])
+        raise(error, status)
+      end
+
+      return unless SUCCESS[status[:code]].nil?
+
+      raise(UnknownResponseStatus, status)
+    end
+  end
+end

data/lib/grumlin/step.rb

@@ -4,9 +4,9 @@ module Grumlin
   class Step < AnonymousStep
     attr_reader :client
 
-    def initialize(client, name, *args, previous_steps: [])
+    def initialize(pool, name, *args, previous_steps: [])
       super(name, *args, previous_steps: previous_steps)
-      @client = client
+      @pool = pool
     end
 
     def next
@@ -14,18 +14,22 @@ module Grumlin
       @enum.next
     end
 
-    def toList # rubocop:disable Naming/MethodName
-      @toList ||= @client.submit(*steps) # rubocop:disable Naming/VariableName
+    def toList
+      @pool.acquire do |client|
+        client.write(*steps)
+      end
     end
 
     def iterate
-      @client.submit(*(steps + [nil]))
+      @pool.acquire do |client|
+        client.write(*(steps + [nil]))
+      end
     end
 
     private
 
     def add_step(step_name, args, previous_steps:)
-      self.class.new(@client, step_name, *args, previous_steps: previous_steps)
+      self.class.new(@pool, step_name, *args, previous_steps: previous_steps)
     end
   end
 end

data/lib/grumlin/sugar.rb

@@ -2,7 +2,6 @@
 
 module Grumlin
   module Sugar
-    # TODO: how to use it in specs?
     HELPERS = [
       Grumlin::U,
       Grumlin::T,
@@ -12,25 +11,12 @@ module Grumlin
     ].freeze
 
     def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def const_missing(name)
-        helper = HELPERS.find { |h| h.const_defined?(name) }
-        super if helper.nil?
-
-        const_set(name, helper)
+      HELPERS.each do |helper|
+        name = helper.name.split("::").last
+        base.const_set(name, helper)
       end
     end
 
-    def const_missing(name)
-      helper = HELPERS.find { |h| h.const_defined?(name) }
-      super if helper.nil?
-
-      const_set(name, helper)
-    end
-
     def __
       Grumlin::U
     end

data/lib/grumlin/t.rb

@@ -2,12 +2,10 @@
 
 module Grumlin
   module T
-    module T
+    class << self
       T_ID = { :@type => "g:T", :@value => "id" }.freeze # TODO: replace with a class?
       T_LABEL = { :@type => "g:T", :@value => "label" }.freeze # TODO: replace with a class?
 
-      extend self # rubocop:disable Style/ModuleFunction
-
       def id
         T_ID
       end
@@ -16,7 +14,5 @@ module Grumlin
         T_LABEL
       end
     end
-
-    extend T
   end
 end

data/lib/grumlin/test/rspec/gremlin_context.rb

@@ -8,12 +8,17 @@ module Grumlin
 
       ::RSpec.shared_context GremlinContext do
         include GremlinContext
+        include Grumlin::Sugar
 
-        let(:g) { Grumlin::Traversal.new }
+        before do
+          Grumlin::Sugar::HELPERS.each do |helper|
+            name = helper.name.split("::").last
+            stub_const(name, helper)
+          end
+        end
 
         after do
-          expect(Grumlin.config.default_client.requests).to be_empty
-          Grumlin.config.default_client.disconnect
+          Grumlin.config.default_pool.close
           Grumlin.config.reset!
         end
       end

data/lib/grumlin/transport.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Transport
+    # A transport based on https://github.com/socketry/async
+    # and https://github.com/socketry/async-websocket
+
+    attr_reader :url
+
+    def initialize(url, parent: Async::Task.current, **client_options)
+      @url = url
+      @parent = parent
+      @client_options = client_options
+      @request_channel = Async::Channel.new
+      @response_channel = Async::Channel.new
+      reset!
+    end
+
+    def connected?
+      @connected
+    end
+
+    def connect # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      raise AlreadyConnectedError if connected?
+
+      @connection = Async::WebSocket::Client.connect(Async::HTTP::Endpoint.parse(@url), **@client_options)
+
+      @response_task = @parent.async do
+        loop do
+          data = @connection.read
+          @response_channel << data
+        end
+      rescue Async::Stop
+        @response_channel.close
+      rescue StandardError => e
+        @response_channel.exception(e)
+      end
+
+      @request_task = @parent.async do
+        @request_channel.each do |message|
+          @connection.write(message)
+          @connection.flush
+        end
+      rescue StandardError => e
+        @response_channel.exception(e)
+      end
+
+      @connected = true
+
+      @response_channel
+    end
+
+    def write(message)
+      raise NotConnectedError unless connected?
+
+      @request_channel << message
+    end
+
+    def close
+      return unless connected?
+
+      @request_channel.close
+      @request_task.wait
+
+      @response_task.stop
+      @response_task.wait
+
+      begin
+        @connection.close
+      rescue Errno::EPIPE
+        nil
+      end
+
+      reset!
+    end
+
+    private
+
+    def reset!
+      @connected = false
+      @connection = nil
+      @response_task = nil
+      @request_task = nil
+    end
+  end
+end

data/lib/grumlin/traversal.rb

@@ -4,18 +4,14 @@ module Grumlin
   class Traversal
     attr_reader :connection
 
-    def initialize(client_or_url = Grumlin.config.default_client)
-      @client = if client_or_url.is_a?(String)
-                  Grumlin::Client.new(client_or_url)
-                else
-                  client_or_url
-                end
+    def initialize(pool = Grumlin.config.default_pool)
+      @pool = pool
     end
 
     # TODO: add other start steps
     %w[addV addE V E].each do |step|
       define_method step do |*args|
-        Step.new(@client, step, *args)
+        Step.new(@pool, step, *args)
       end
     end
 

data/lib/grumlin/u.rb

@@ -2,17 +2,12 @@
 
 module Grumlin
   module U
-    module U
-      extend self # rubocop:disable Style/ModuleFunction
-
+    class << self
       %w[addV V has count out values unfold].each do |step|
         define_method step do |*args|
           AnonymousStep.new(step, *args)
         end
       end
     end
-
-    # TODO: add alias __
-    extend U
   end
 end

data/lib/grumlin/version.rb

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

data/lib/grumlin.rb

@@ -4,27 +4,33 @@ require "securerandom"
 require "json"
 
 require "async"
+require "async/pool"
+require "async/pool/resource"
+require "async/pool/controller"
 require "async/queue"
 require "async/barrier"
 require "async/http/endpoint"
 require "async/websocket/client"
 
+require_relative "async/channel"
+
 require_relative "grumlin/version"
 require_relative "grumlin/exceptions"
 
-require_relative "grumlin/transport/async"
+require_relative "grumlin/transport"
+require_relative "grumlin/client"
 
 require_relative "grumlin/vertex"
 require_relative "grumlin/edge"
 require_relative "grumlin/path"
 require_relative "grumlin/typing"
-require_relative "grumlin/client"
 require_relative "grumlin/traversal"
+require_relative "grumlin/request_dispatcher"
+require_relative "grumlin/translator"
 
 require_relative "grumlin/anonymous_step"
 require_relative "grumlin/step"
 
-require_relative "grumlin/translator"
 require_relative "grumlin/t"
 require_relative "grumlin/order"
 require_relative "grumlin/u"
@@ -34,14 +40,21 @@ require_relative "grumlin/sugar"
 
 module Grumlin
   class Config
-    attr_accessor :url
+    attr_accessor :url, :pool_size, :client_concurrency, :client_factory
+
+    # For some reason, client_concurrency must be greater than pool_size
+    def initialize
+      @pool_size = 10
+      @client_concurrency = 20
+      @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
+    end
 
-    def default_client
-      @default_client ||= Grumlin::Client.new(url)
+    def default_pool
+      @default_pool ||= Async::Pool::Controller.new(Grumlin::Client::PoolResource, limit: pool_size)
     end
 
     def reset!
-      @default_client = nil
+      @default_pool = nil
     end
   end
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-26 00:00:00.000000000 Z
+date: 2021-08-23 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: async-pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: async-websocket
   requirement: !ruby/object:Gem::Requirement
@@ -48,6 +62,7 @@ files:
 - gremlin_server/Dockerfile
 - gremlin_server/tinkergraph-empty.properties
 - grumlin.gemspec
+- lib/async/channel.rb
 - lib/grumlin.rb
 - lib/grumlin/anonymous_step.rb
 - lib/grumlin/client.rb
@@ -57,6 +72,7 @@ files:
 - lib/grumlin/p.rb
 - lib/grumlin/path.rb
 - lib/grumlin/pop.rb
+- lib/grumlin/request_dispatcher.rb
 - lib/grumlin/step.rb
 - lib/grumlin/sugar.rb
 - lib/grumlin/t.rb
@@ -64,7 +80,7 @@ files:
 - lib/grumlin/test/rspec/db_cleaner_context.rb
 - lib/grumlin/test/rspec/gremlin_context.rb
 - lib/grumlin/translator.rb
-- lib/grumlin/transport/async.rb
+- lib/grumlin/transport.rb
 - lib/grumlin/traversal.rb
 - lib/grumlin/typing.rb
 - lib/grumlin/u.rb

data/lib/grumlin/transport/async.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Grumlin
-  module Transport
-    # A transport based on https://github.com/socketry/async
-    # and https://github.com/socketry/async-websocket
-    class Async
-      attr_reader :requests
-
-      def initialize(url, task: ::Async::Task.current)
-        @task = task
-        @endpoint = ::Async::HTTP::Endpoint.parse(url)
-
-        @requests = {}
-        @query_queue = ::Async::Queue.new
-      end
-
-      def connect
-        raise AlreadyConnectedError if connected?
-
-        @client = ::Async::WebSocket::Client.open(@endpoint)
-        @connection = @client.connect(@endpoint.authority, @endpoint.path)
-
-        @tasks_barrier = ::Async::Barrier.new(parent: @task)
-
-        @tasks_barrier.async { query_task }
-        @tasks_barrier.async { response_task }
-      rescue StandardError
-        raise ConnectionError
-      end
-
-      def disconnect
-        raise NotConnectedError unless connected?
-
-        @tasks_barrier.tasks.each(&:stop)
-        @tasks_barrier.wait
-
-        @connection.close
-        @client.close
-
-        @client = nil
-        @connection = nil
-        @tasks_barrier = nil
-
-        raise ResourceLeakError, "ongoing requests list is not empty: #{@requests.count} items" unless @requests.empty?
-        raise ResourceLeakError, "query queue empty: #{@query.count} items" unless @query_queue.empty?
-      end
-
-      # Raw message
-      def submit(message)
-        raise NotConnectedError unless connected?
-
-        uuid = message[:requestId]
-        ::Async::Queue.new.tap do |queue|
-          @requests[uuid] = queue
-          @query_queue << message
-        end
-      end
-
-      def close_request(request_id)
-        @requests.delete(request_id)
-      end
-
-      def ongoing_request?(request_id)
-        @requests.key?(request_id)
-      end
-
-      def connected?
-        !@connection.nil?
-      end
-
-      private
-
-      def query_task
-        @query_queue.each do |query|
-          @connection.write(query)
-          @connection.flush
-        end
-      rescue StandardError
-        raise DisconnectError
-      end
-
-      def response_task
-        loop do
-          response = @connection.read
-          # TODO: sometimes response does not include requestID, no idea how to handle it so far.
-          response_queue = @requests[response[:requestId]]
-          response_queue << [:response, response]
-        end
-      rescue StandardError
-        raise DisconnectError
-      end
-    end
-  end
-end