ducts-client 0.2.0 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4c3b4b409de5782a0a17ff6be86f8a2a567508f7c6ac3c0baf6f4c0808301c2
-  data.tar.gz: 628e413f6fe4399fb51c288850a36503b62e9ce810114bbf93d6cea8b9c479f9
+  metadata.gz: 74c85c4fbbb4e225d647251a22a526545a3f4921b88921fb6fb779705b1fe4f1
+  data.tar.gz: f5396e8363fb5c31159be810b0631d45bfaca068143f136beb8a52e82f54ba93
 SHA512:
-  metadata.gz: caa94df4e3324917d66e1186dd158c8acf964eb5325f485e158ed5b1eee597d57ff5faef95dde812fe7a1d40a758a077f2cd8852c2f784657c9e9562861eced3
-  data.tar.gz: 06111104f2f3a82de9586f57551de285f810a06b54034642638822087b3044edfc3db69cb5d89be420a0272a95da5c8aed53939f571f5febdb8d26b18f79e001
+  metadata.gz: 2627825a0174c77e7070ae62a57bd6a74563fc35fb2882bc53fcee11434cb3341145c4735fc2deb7c2fc88bb5f624a776bff7e3110d0ca273b3fc93784882fb3
+  data.tar.gz: 040e53690914465287f0f59e275f9711454c46994cef7aaa68c9687c9e2d87e6d53bb31500aff28fa73aee1315581738dab025bc80ac06519838b24bdd72217e

data/lib/ducts/client.rb

@@ -6,6 +6,7 @@ require 'timeout'
 require 'uri'
 require 'net/http'
 require 'json'
+require 'stringio'
 require 'faye/websocket'
 require 'faye/websocket/api/event'
 require 'msgpack'
@@ -56,6 +57,8 @@ module Ducts
       end
     end
 
+    DuctEventHandlerReturnValue = Struct.new(:source_rid, :source_eid, :source_data)
+
     class ConnectionEventListener < DuctEventListener
       attr_writer :onopen, :onclose, :onerror, :onmessage
       def onopen(event)
@@ -118,7 +121,10 @@ module Ducts
 
       @_last_rid = nil
       @_ws = nil
-      @_waiting_completion = Hash.new
+      @_waiting_message_completion = Hash.new
+      @_waiting_closed_completion = Array.new
+      @_loop_queues = Hash.new
+      @_divided_buffers = Hash.new
     end
 
     def next_rid
@@ -130,29 +136,13 @@ module Ducts
       next_id
     end
 
-    def open(wsd_url, uuid = nil, **params)
-      _open(wsd_url, uuid, **params)
-    end
-
-    def reconnect
-      _reconnect
-    end
-
-    def event_send(rid, eid, data)
-      _send(rid, eid, data)
-    end
-
-    def event_call(eid, data)
-      _call(eid, data)
-    end
-
-    def close
-      _close
-    end
-
     def set_event_handler(event_id, &handler)
       @_event_handler ||= {}
-      @_event_handler[event_id] = handler
+      if handler
+        @_event_handler.store(event_id, handler)
+      else
+        @_event_handler.delete(event_id)
+      end
     end
 
     def state
@@ -163,16 +153,16 @@ module Ducts
       end
     end
 
-    private
-    def _reconnect(wsd)
-      if wsd
-        @WSD = wsd
-        @EVENT = @WSD['EVENT']
+    def reconnect
+      completion = EM::Completion.new
+      if @_ws
+        completion.succeed(self)
+        return completion;
       end
-      return if @_ws
       Faye::WebSocket::Client.new(@WSD['websocket_url_reconnect']).tap do |ws|
         ws.on(:open) do |event|
           @_ws = ws
+          completion.succeed(self)
           connection_event = DuctConnectionEvent.new('onopen', event)
           _onreconnect(connection_event)
           @connection_listener.onopen(connection_event)
@@ -192,10 +182,15 @@ module Ducts
           @connection_listener.onerror(connection_event)
         end
       end
+      completion
     end
 
-    def _open(wsd_url, uuid, **params)
-      return if @_ws
+    def open(wsd_url, uuid = nil, **params)
+      completion = EM::Completion.new
+      if @_ws
+        completion.succeed(self)
+        return completion;
+      end
       begin
         query = '?uuid=' + (uuid || 'dummy') + params.map{ |k, v| "&#{k}=#{v}" }.join
         uri = URI.parse(wsd_url + query)
@@ -210,6 +205,7 @@ module Ducts
         Faye::WebSocket::Client.new(@WSD['websocket_url']).tap do |ws|
           ws.on(:open) do |event|
             @_ws = ws
+            completion.succeed(self)
             connection_event = DuctConnectionEvent.new('onopen', event)
             _onopen(connection_event)
             @connection_listener.onopen(connection_event)
@@ -225,6 +221,19 @@ module Ducts
             @connection_listener.onerror(connection_event)
           end
           ws.on(:close) do |event|
+            @_ws = nil
+            case event.code
+            when 1000
+              @_waiting_closed_completion.each do |waiting_closed_completion|
+                waiting_closed_completion.succeed(event)
+              end
+            else
+              p event.code
+              @_waiting_closed_completion.each do |waiting_closed_completion|
+                waiting_closed_completion.fail(event)
+              end
+            end
+            @_waiting_closed_completion.clear
             connection_event = DuctConnectionEvent.new('onclose', event)
             @connection_listener.onclose(connection_event)
           end
@@ -232,62 +241,70 @@ module Ducts
       rescue => error
         @connection_listener.onerror(DuctConnectionEvent.new('onerror', error))
       end
+      completion
     end
 
+    def event_send(rid, eid, data)
+      msgpack = [ rid, eid, data ].to_msgpack
+      @_ws.send(msgpack.chars.map(&:ord))
+      rid
+    end
+
+    def event_call(eid, data)
+      rid = next_rid
+      event_send(rid, eid, data)
+      warn Message.construct(Message::Level::WARNING, 'request ID is duplicated.') if @_waiting_message_completion.keys.include? rid
+      EM::Completion.new.tap { |completion| @_waiting_message_completion[rid] = completion }
+    end
+
+    def close
+      completion = EM::Completion.new
+      if @_ws
+        @_ws.close 
+        @_waiting_closed_completion.push(completion)
+      else
+        completion.succeed(nil)
+      end
+      completion
+    end
+
+    private
     def _onopen(event)
       @_send_timestamp = Time.now.to_f
       @_time_offset = 0
       @_time_latency = 0
       @_time_count = 0
-      set_event_handler(@EVENT['ALIVE_MONITORING']) do |rid, eid, data|
-        client_received = Time.now.to_f
-        server_sent, server_received = data
-        client_sent = @_send_timestamp
-        new_offset = ((server_received - client_sent) - (client_received - server_sent)) / 2
-        new_latency = ((client_received - client_sent) - (server_sent - server_received)) / 2
-        @_time_offset = (@_time_offset * @_time_count + new_offset) / (@_time_count + 1)
-        @_time_latency = (@_time_latency * @_time_count + new_latency) / (@_time_count + 1)
-        @_time_count += 1
-      end
+      set_event_handler(@EVENT['ALIVE_MONITORING'], &method(:_alive_monitoring_handler))
+      set_event_handler(@EVENT['LOOP_RESPONSE_START'], &method(:_loop_response_handler))
+      set_event_handler(@EVENT['LOOP_RESPONSE_NEXT'], &method(:_loop_response_handler))
+      set_event_handler(@EVENT['LOOP_RESPONSE_END'], &method(:_loop_response_end_handler))
+      set_event_handler(@EVENT['DIVIDED_RESPONSE_APPEND'], &method(:_divided_response_append_handler))
+      set_event_handler(@EVENT['DIVIDED_RESPONSE_END'], &method(:_divided_response_end_handler))
       rid = next_rid
       eid = @EVENT['ALIVE_MONITORING']
       value = @_send_timestamp
-      _send(rid, eid, value)
+      event_send(rid, eid, value)
     end
 
     def _onreconnect(connection_event)
     end
 
-    def _send(rid, eid, data)
-      msgpack = [ rid, eid, data ].to_msgpack
-      @_ws.send(msgpack.chars.map(&:ord))
-      rid
-    end
-
-    def _call(eid, data)
-      rid = next_rid
-      _send(rid, eid, data)
-      raise if @_waiting_completion.keys.include? rid
-      EM::Completion.new.tap { |completion| @_waiting_completion[rid] = completion }
-    end
-
-    def _close
-      begin
-        @_ws.close if @_ws
-      ensure
-        @_ws = nil
-      end
-    end
-
     def _onmessage(connection_event)
       begin
         rid, eid, data = %i(rid eid data).map{ |name| connection_event.source.public_send(name) }
         begin
           @catchall_event_handler.call(rid, eid, data)
           handle = @_event_handler[eid]
-          handle = @uncaught_event_handler unless handle
-          handle.call(rid, eid, data)
-          completion = @_waiting_completion.delete(rid)
+          handle ||= @uncaught_event_handler
+          handle.call(rid, eid, data).tap do |ret|
+            if ret.instance_of? DuctEventHandlerReturnValue
+              rid = ret.source_rid 
+              eid = ret.source_eid
+              data = ret.source_data
+            end
+          end
+          return if rid.nil?
+          completion = @_waiting_message_completion.delete(rid)
           if completion
             if eid > 0
               completion.succeed(data)
@@ -302,5 +319,63 @@ module Ducts
         @event_error_handler.call(-1, -1, nil, error)
       end
     end
+
+    def _alive_monitoring_handler(rid, eid, data)
+      client_received = Time.now.to_f
+      server_sent, server_received = data
+      client_sent = @_send_timestamp
+      new_offset = ((server_received - client_sent) - (client_received - server_sent)) / 2
+      new_latency = ((client_received - client_sent) - (server_sent - server_received)) / 2
+      @_time_offset = (@_time_offset * @_time_count + new_offset) / (@_time_count + 1)
+      @_time_latency = (@_time_latency * @_time_count + new_latency) / (@_time_count + 1)
+      @_time_count += 1
+    end
+
+    def _loop_response_handler(rid, eid, data)
+      warn Message.construct(Message::Level::WARNING, 'loop response has error.') if eid.negative?
+      source_eid = data[1]
+      source_data = data[2]
+      @catchall_event_handler.call(rid, source_eid, source_data)
+      handle = @_event_handler[source_eid.abs]
+      handle ||= @uncaught_event_handler
+      ret = handle.call(rid, source_eid, source_data)
+      handled_source_data = (ret.instance_of? DuctEventHandlerReturnValue)? ret.source_data : source_data
+      @_loop_queues[rid] ||= EM::Queue.new
+      queue = @_loop_queues[rid]
+      queue.push(handled_source_data) if handled_source_data
+      DuctEventHandlerReturnValue.new(rid, source_eid, queue)
+    end
+
+    def _loop_response_end_handler(rid, eid, data)
+      warn Message.construct(Message::Level::WARNING, 'loop response end has error.') if eid.negative?
+      source_eid = data[1]
+      source_data = data[2]
+      warn Message.construct(Message::Level::WARNING, "loop response end has data: #{source_data}.") if source_data
+      @catchall_event_handler.call(rid, source_eid, source_data)
+      handle = @_event_handler[source_eid.abs]
+      handle ||= @uncaught_event_handler
+      handle.call(rid, source_eid, source_data)
+      queue = @_loop_queues.delete(rid)
+      queue.push(nil)
+      DuctEventHandlerReturnValue.new(rid, source_eid, source_eid)
+    end
+
+    def _divided_response_append_handler(rid, eid, data)
+      @_divided_buffers[rid] ||= StringIO.new('', 'wb').set_encoding(Encoding::ASCII_8BIT)
+      divided_buffer = @_divided_buffers[rid]
+      divided_buffer.write(data)
+      DuctEventHandlerReturnValue.new(nil, eid, nil)
+    end
+
+    def _divided_response_end_handler(rid, eid, data)
+      divided_buffer = @_divided_buffers.delete(rid)
+      divided_buffer.write(data)
+      source_rid, source_eid, source_data = MessagePack.unpack(divided_buffer.string)
+      @catchall_event_handler.call(source_rid, source_eid, source_data)
+      handle = @_event_handler[source_eid]
+      handle ||= @uncaught_event_handler
+      handle.call(source_rid, source_eid, source_data)
+      DuctEventHandlerReturnValue.new(source_rid, source_eid, source_data)
+    end
   end
 end

data/lib/ducts/client/version.rb

@@ -4,8 +4,8 @@ module Ducts
   class Client
     module Version
       MAJOR = 0
-      MINOR = 2
-      PATCH = 0
+      MINOR = 4
+      PATCH = 5
     end
 
     VERSION = [ Version::MAJOR, Version::MINOR, Version::PATCH ].map(&:to_s).join('.')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ducts-client
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.5
 platform: ruby
 authors:
 - Kenshiro Ueda
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-21 00:00:00.000000000 Z
+date: 2021-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faye-websocket