grumlin 0.1.0 → 0.3.0

data/lib/grumlin/client.rb

@@ -1,172 +1,102 @@
 # frozen_string_literal: true
 
 module Grumlin
-  class Client # rubocop:disable Metrics/ClassLength
-    SUCCESS_STATUS = 200
-    NO_CONTENT_STATUS = 204
-    PARTIAL_CONTENT_STATUS = 206
-
-    ERRORS = {
-      499 => InvalidRequestArgumentsError,
-      500 => ServerError,
-      597 => ScriptEvaluationError,
-      599 => ServerSerializationError,
-      598 => ServerTimeoutError,
-
-      401 => ClientSideError,
-      407 => ClientSideError,
-      498 => ClientSideError
-    }.freeze
-
-    def initialize(url, task: Async::Task.current, autoconnect: true, mode: :bytecode)
-      @task = task
-      @endpoint = Async::HTTP::Endpoint.parse(url)
-      @mode = mode
-
-      @requests = {}
-      @query_queue = Async::Queue.new
-
-      connect if autoconnect
-    end
-
-    def connect # rubocop:disable Metrics/MethodLength
-      raise AlreadyConnectedError unless @connection_task.nil?
+  class Client
+    class PoolResource < self
+      attr :concurrency, :count
 
-      @connection_task = @task.async do |subtask|
-        Async::WebSocket::Client.connect(@endpoint) do |connection|
-          subtask.async { query_task(connection) }
-          response_task(connection)
-        end
-      rescue StandardError => e
-        @requests.each_value do |queue|
-          queue << [:error, e]
-        end
-        disconnect
+      def self.call
+        new(Grumlin.config.url, concurrency: Grumlin.config.client_concurrency).tap(&:connect)
       end
-    end
-
-    def disconnect
-      raise NotConnectedError if @connection_task.nil?
-
-      @connection_task&.stop
-      @connection_task&.wait
-      @connection_task = nil
-      @requests = {}
-    end
 
-    def query(*args) # rubocop:disable Metrics/MethodLength
-      response_queue, request_id = schedule_query(args)
-      result = []
-
-      response_queue.each do |status, response|
-        reraise_error!(response) if status == :error
+      def initialize(url, concurrency: 1, parent: Async::Task.current)
+        super(url, parent: parent)
+        @concurrency = concurrency
+        @count = 0
+      end
 
-        status = response[:status]
+      def viable?
+        connected?
+      end
 
-        if status[:code] == NO_CONTENT_STATUS
-          close_request(request_id)
-          return []
-        end
+      def closed?
+        connected?
+      end
 
-        check_errors!(status, request_id)
+      def reusable?
+        true
+      end
+    end
 
-        page = Typing.cast(response.dig(:result, :data))
+    def initialize(url, parent: Async::Task.current)
+      @parent = parent
+      @transport = Transport.new(url)
+      reset!
+    end
 
-        case status[:code]
-        when SUCCESS_STATUS
-          close_request(request_id)
-          return result + page
-        when PARTIAL_CONTENT_STATUS
-          result += page
-        else
-          raise UnknownResponseStatus, status
+    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
     end
 
-    private
-
-    def schedule_query(args)
-      uuid = SecureRandom.uuid
-      queue = Async::Queue.new
-      @requests[uuid] = queue
-      @query_queue << to_query(uuid, args)
+    def close
+      @transport.close
+      raise ResourceLeakError, "Request list is not empty: #{requests}" if @request_dispatcher.requests.any?
 
-      [queue, uuid]
+      reset!
     end
 
-    def to_query(uuid, message)
-      case message.first
-      when String
-        string_query_message(uuid, *message)
-      when Grumlin::Step
-        build_query(uuid, message)
-      end
+    def connected?
+      @transport.connected?
     end
 
-    def check_errors!(status, request_id)
-      error = ERRORS[status[:code]]
-      close_request(request_id)
-      raise(error, status) if error
-    end
+    # 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)
 
-    def close_request(request_id)
-      @requests.delete(request_id)
-    end
+      begin
+        msg, response = queue.dequeue
+        raise response if msg == :error
 
-    def reraise_error!(error)
-      raise error
-    rescue StandardError
-      raise ConnectionError
-    end
+        return response.flat_map { |item| Typing.cast(item) } if msg == :result
 
-    def query_task(connection)
-      loop do
-        connection.write @query_queue.dequeue
-        connection.flush
+        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 response_task(connection)
-      loop do
-        response = connection.read
-        response_queue = @requests[response[:requestId]]
-        response_queue << [:response, response]
-      end
+    def inspect
+      "<#{self.class} url=#{@transport.url}>"
     end
 
-    def string_query_message(uuid, query, bindings)
-      {
-        requestId: uuid,
-        op: "eval",
-        processor: "",
-        args: {
-          gremlin: query,
-          bindings: bindings,
-          language: "gremlin-groovy"
-        }
-      }
-    end
+    alias to_s inspect
 
-    def bytecode_query_message(uuid, bytecode)
+    private
+
+    def to_query(request_id, message)
       {
-        requestId: uuid,
+        requestId: request_id,
         op: "bytecode",
         processor: "traversal",
         args: {
-          gremlin: { "@type": "g:Bytecode", "@value": { step: bytecode } },
+          gremlin: Typing.to_bytecode(Translator.to_bytecode_query(message)),
           aliases: { g: :g }
         }
       }
     end
 
-    def build_query(uuid, steps)
-      case @mode
-      when :string
-        string_query_message(uuid, *Translator.to_string_query(steps))
-      else
-        bytecode_query_message(uuid, Translator.to_bytecode_query(steps))
-      end
+    def reset!
+      @request_dispatcher = nil
     end
   end
 end

data/lib/grumlin/edge.rb

@@ -15,11 +15,11 @@ module Grumlin
     end
 
     def ==(other)
-      @label == other.label && @id == other.id
+      self.class == other.class && @label == other.label && @id == other.id
     end
 
     def inspect
-      "<E #{@label}(#{@id})>"
+      "e[#{@id}][#{@inV}-#{@label}->#{@outV}]"
     end
     alias to_s inspect
   end

data/lib/grumlin/exceptions.rb

@@ -3,8 +3,14 @@
 module Grumlin
   class Error < StandardError; end
 
+  class UnknownError < Error; end
+
   class ConnectionError < Error; end
 
+  class CannotConnectError < ConnectionError; end
+
+  class DisconnectError < ConnectionError; end
+
   class ConnectionStatusError < Error; end
 
   class NotConnectedError < ConnectionStatusError; end
@@ -24,8 +30,6 @@ module Grumlin
 
   class UnknownTypeError < ProtocolError; end
 
-  class ConnectionClosedError < Error; end
-
   class StatusError < Error
     attr_reader :status
 
@@ -48,4 +52,20 @@ module Grumlin
   class ServerSerializationError < ServerSideError; end
 
   class ServerTimeoutError < ServerSideError; end
+
+  class InternalClientError < Error; end
+
+  class UnknownRequestStoppedError < InternalClientError; end
+
+  class ResourceLeakError < InternalClientError; end
+
+  class UnknownMapKey < InternalClientError
+    attr_reader :key, :map
+
+    def initialize(key, map)
+      @key = key
+      @map = map
+      super("Cannot cast key #{key} in map #{map}")
+    end
+  end
 end

data/lib/grumlin/order.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Order
+    module Order
+      DESC = { "@type": "g:Order", "@value": "desc" }.freeze
+      ASC = { "@type": "g:Order", "@value": "desc" }.freeze
+
+      extend self # rubocop:disable Style/ModuleFunction
+
+      def asc
+        ASC
+      end
+
+      def desc
+        DESC
+      end
+    end
+
+    extend Order
+  end
+end

data/lib/grumlin/p.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module P
+    module P
+      %w[within].each do |step|
+        define_method step do |*args|
+          { # TODO: replace with a class?
+            "@type": "g:P",
+            "@value": { predicate: "within", value: { "@type": "g:List", "@value": args } }
+          }
+        end
+      end
+    end
+
+    extend P
+  end
+end

data/lib/grumlin/path.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grumlin
+  class Path
+    def initialize(path)
+      @labels = Typing.cast(path[:labels])
+      @objects = Typing.cast(path[:objects])
+    end
+
+    def inspect
+      "p[#{@objects}]"
+    end
+    alias to_s inspect
+  end
+end

data/lib/grumlin/pop.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Pop
+    module Pop
+      extend self # rubocop:disable Style/ModuleFunction
+
+      FIRST = { "@type": "g:Pop", "@value": "first" }.freeze
+      LAST = { "@type": "g:Pop", "@value": "last" }.freeze
+      ALL = { "@type": "g:Pop", "@value": "all" }.freeze
+      MIXED = { "@type": "g:Pop", "@value": "mixed" }.freeze
+
+      def first
+        FIRST
+      end
+
+      def last
+        LAST
+      end
+
+      def all
+        ALL
+      end
+
+      def mixed
+        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::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