grumlin 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0290e4d77bd50f701a803390ff2a0489b039f4beb231e8883ced690180c7abc
-  data.tar.gz: b4948d687c09ffea5bf9da26eda8644fc3fcffa1954e4e61fe2d628192984e7e
+  metadata.gz: e532964db5d5afd11d89978a132a5f4f7d1a4d98c740f639acadac260c93be89
+  data.tar.gz: 9015cb71bbab17895d8809dc7ff514b90e9d1ceb81ed6a9eec446a0db7ec0994
 SHA512:
-  metadata.gz: 3846fe491a606989f51f0f609e8c7ae2049b8a1005272ea531f085402e7d998a7f8723ccdafae01ce7d913f9ad9272f9da1e86a307cb7aeb5066ef4ad4024e4b
-  data.tar.gz: 1b20d251d16c95cb12657c6becbbb4592b8e206e9e83a7defee42281bbdd7c3f84d04785b2cc89bcc1328d05d11aa14b865b6bc6832899d3a73ce7b86283be5b
+  metadata.gz: a4295b9e6041726c36c05cc0aed94a645e8d7103c99351dfadef7077f14037b81daf87a4ffb1fd48105d8c1fa888e96ce173aa3be42c9b35ec58de3e289c01ed
+  data.tar.gz: 51824ca159be63be91fc798b40777a25d55f0ce423b07a9ce4ce9880002e94b4e4196bc0d92b4ca84bee86356f17fd90f3cc2dd9daa594f906fc2e93f11be422

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    grumlin (0.2.0)
+    grumlin (0.3.0)
+      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)
@@ -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/grumlin.rb

@@ -4,6 +4,9 @@ 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"
@@ -12,19 +15,20 @@ require "async/websocket/client"
 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 +38,20 @@ require_relative "grumlin/sugar"
 
 module Grumlin
   class Config
-    attr_accessor :url
+    attr_accessor :url, :pool_size, :client_concurrency
+
+    # For some reason, client_concurrency must be greather pool_size
+    def initialize
+      @pool_size = 10
+      @client_concurrency = 20
+    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
 

data/lib/grumlin/client.rb

@@ -2,120 +2,101 @@
 
 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 < self
+      attr :concurrency, :count
 
-    def_delegators :@transport, :connect, :disconnect, :requests
+      def self.call
+        new(Grumlin.config.url, concurrency: Grumlin.config.client_concurrency).tap(&:connect)
+      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, concurrency: 1, parent: Async::Task.current)
+        super(url, parent: parent)
+        @concurrency = concurrency
+        @count = 0
+      end
 
-    def inspect
-      "<#{self.class} @url=#{@url}>"
-    end
+      def viable?
+        connected?
+      end
 
-    alias to_s inspect
+      def closed?
+        connected?
+      end
 
-    private
+      def reusable?
+        true
+      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)
+      @parent = parent
+      @transport = Transport.new(url)
+      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
+      response_queue = @transport.connect
+      @request_dispatcher = RequestDispatcher.new
+      @parent.async do
+        response_queue.each do |response|
+          @request_dispatcher.add_response(response)
         end
       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?
+    end
 
-      status = response[:status]
+    # TODO: support yielding
+    def write(*args) # rubocop:disable Metrics/MethodLength
+      request_id = SecureRandom.uuid
+      request = to_query(request_id, args)
+      queue = @request_dispatcher.add_request(request)
+      @transport.write(request)
 
-      if (error = ERRORS[status[:code]])
-        raise(error, status)
-      end
+      begin
+        msg, response = queue.dequeue
+        raise response if msg == :error
 
-      return unless SUCCESS[status[:code]].nil?
+        return response.flat_map { |item| Typing.cast(item) } if msg == :result
 
-      raise(UnknownResponseStatus, status)
+        raise "ERROR"
+      rescue Async::Stop
+        retry if @request_dispatcher.ongoing_request?(request_id)
+        raise UnknownRequestStopped, "#{request_id} is not in the ongoing requests list"
+      end
     end
 
-    def reraise_error!(error)
-      raise error
-    rescue StandardError
-      raise UnknownError
+    def inspect
+      "<#{self.class} url=#{@transport.url}>"
     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
 
-    def bytecode_query_message(request_id, bytecode)
+    private
+
+    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
+    end
   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::Queue.new.tap do |queue|
+        @requests[request[:requestId]] = { request: request, result: [], queue: queue }
+      end
+    end
+
+    # builds a response object, when it's ready sends it to the client via a queue
+    # TODO: sometimes response does not include requestID, no idea how to handle it so far.
+    def add_response(response) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      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[:queue] << [:result, request[:result] + [response.dig(:result, :data)]]
+        close_request(request_id)
+      when :partial_content then request[:result] << response.dig(:result, :data)
+      when :no_content
+        request[:queue] << [:result, []]
+        close_request(request_id)
+      end
+    rescue StandardError => e
+      request[:queue] << [:error, e]
+      close_request(request_id)
+    end
+
+    def close_request(request_id)
+      raise "ERROR" unless ongoing_request?(request_id)
+
+      request = @requests.delete(request_id)
+      request[:queue] << nil
+    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
@@ -15,17 +15,21 @@ module Grumlin
     end
 
     def toList # rubocop:disable Naming/MethodName
-      @toList ||= @client.submit(*steps) # rubocop:disable Naming/VariableName
+      @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/test/rspec/gremlin_context.rb

@@ -12,8 +12,7 @@ module Grumlin
         let(:g) { Grumlin::Traversal.new }
 
         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,78 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Transport
+    # A transport based on https://github.com/socketry/async
+    # and https://github.com/socketry/async-websocket
+    def initialize(url, parent: Async::Task.current)
+      @endpoint = Async::HTTP::Endpoint.parse(url)
+      @parent = parent
+      @request_queue = Async::Queue.new
+      @response_queue = Async::Queue.new
+      reset!
+    end
+
+    def url
+      @endpoint.url
+    end
+
+    def connected?
+      @connected
+    end
+
+    def connect # rubocop:disable Metrics/MethodLength
+      raise AlreadyConnectedError if connected?
+
+      @connection = Async::WebSocket::Client.connect(@endpoint)
+
+      @response_task = @parent.async do
+        loop do
+          data = @connection.read
+          @response_queue << data
+        end
+      rescue Async::Stop
+        @response_queue << nil
+      end
+
+      @request_task = @parent.async do
+        @request_queue.each do |message|
+          @connection.write(message)
+          @connection.flush
+        end
+      end
+
+      @connected = true
+
+      @response_queue
+    end
+
+    def write(message)
+      raise NotConnectedError unless connected?
+
+      @request_queue << message
+    end
+
+    def close
+      raise NotConnectedError unless connected?
+
+      @request_queue << nil
+      @request_task.wait
+
+      @response_task.stop
+      @response_task.wait
+
+      @connection.close
+
+      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/version.rb

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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-26 00:00:00.000000000 Z
+date: 2021-07-29 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
@@ -57,6 +71,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 +79,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