datawire_mdk 2.0.22 → 2.0.23

data/lib/mdk_protocol.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_protocol; MdkProtocol; end
@@ -942,17 +942,18 @@ def self.OpenCloseSubscriber; OpenCloseSubscriber; end
 # Handle Open and Close messages.
 
 class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :_dispatcher, :_wsclient
+    attr_accessor :_dispatcher, :_wsclient, :_node_id
     extend ::DatawireQuarkCore::Static
 
     static mdk_protocol_OpenCloseSubscriber_ref: -> { nil }
 
 
 
-    def initialize(client)
+    def initialize(client, node_id)
         
         self.__init_fields__
         (self)._wsclient = client
+        (self)._node_id = node_id
         (self)._wsclient.subscribe(self)
 
         nil
@@ -1000,7 +1001,9 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
 
     def onWSConnected(websocket)
         
-        (self)._dispatcher.tell(self, ::Quark.mdk_protocol.Open.new().encode(), websocket)
+        open = ::Quark.mdk_protocol.Open.new()
+        ((open).properties)["datawire_nodeId"] = ((self)._node_id)
+        (self)._dispatcher.tell(self, open.encode(), websocket)
 
         nil
     end
@@ -1041,6 +1044,9 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_wsclient"))
             return (self)._wsclient
         end
+        if ((name) == ("_node_id"))
+            return (self)._node_id
+        end
         return nil
 
         nil
@@ -1054,6 +1060,9 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_wsclient"))
             (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
         end
+        if ((name) == ("_node_id"))
+            (self)._node_id = ::DatawireQuarkCore.cast(value) { ::String }
+        end
 
         nil
     end
@@ -1062,6 +1071,7 @@ class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
         
         self._dispatcher = nil
         self._wsclient = nil
+        self._node_id = nil
 
         nil
     end
@@ -1536,6 +1546,356 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
 end
 WSClient.unlazy_statics
 
+def self.AckablePayload; AckablePayload; end
+##
+# The payload for an ackable event.
+
+class AckablePayload < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_AckablePayload_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # When did this happen? Milliseconds since Unix epoch.
+
+    def getTimestamp()
+        raise NotImplementedError, '`AckablePayload.getTimestamp` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+AckablePayload.unlazy_statics
+
+def self.AckableEvent; AckableEvent; end
+##
+# An event that can be acknowledged.
+
+class AckableEvent < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :json_type, :sequence, :sync, :payload
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_AckableEvent_ref: -> { nil }
+
+
+
+    def initialize(json_type, payload, sequence)
+        
+        self.__init_fields__
+        (self).json_type = json_type
+        (self).payload = payload
+        (self).sequence = sequence
+
+        nil
+    end
+
+
+
+
+    def getTimestamp()
+        
+        return @payload.getTimestamp()
+
+        nil
+    end
+
+    def encode()
+        
+        clazz = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass((self).payload))
+        json = ::Quark.quark.toJSON((self).payload, clazz)
+        (json).setObjectItem(("type"), (::DatawireQuarkCore::JSONObject.new.setString((self).json_type)))
+        (json).setObjectItem(("sequence"), (::DatawireQuarkCore::JSONObject.new.setNumber((self).sequence)))
+        (json).setObjectItem(("sync"), (::DatawireQuarkCore::JSONObject.new.setNumber((self).sync)))
+        encoded = json.toString()
+        return encoded
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.AckableEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("json_type"))
+            return (self).json_type
+        end
+        if ((name) == ("sequence"))
+            return (self).sequence
+        end
+        if ((name) == ("sync"))
+            return (self).sync
+        end
+        if ((name) == ("payload"))
+            return (self).payload
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("json_type"))
+            (self).json_type = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("sequence"))
+            (self).sequence = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("sync"))
+            (self).sync = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("payload"))
+            (self).payload = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.AckablePayload }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.json_type = nil
+        self.sequence = nil
+        self.sync = 0
+        self.payload = nil
+
+        nil
+    end
+
+
+end
+AckableEvent.unlazy_statics
+
+def self.SendWithAcks; SendWithAcks; end
+##
+# Utility class for sending messages with a protocol that sends back acks.
+#
+
+class SendWithAcks < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_syncRequestPeriod, :_syncInFlightMax, :_buffered, :_inFlight, :_added, :_sent, :_failedSends, :_recorded, :_lastSyncTime, :_myLog
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_protocol_AckableEvent__ref: -> { nil }
+    static mdk_protocol_SendWithAcks_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def _debug(message)
+        
+        s = (((("[") + (((@_buffered).size).to_s)) + (" buf, ")) + (((@_inFlight).size).to_s)) + (" inf] ")
+        @_myLog.debug((s) + (message))
+
+        nil
+    end
+
+    ##
+    # Call when (re)connected to other side.
+
+    def onConnected(origin, dispatcher, sock)
+        
+        while (((@_buffered).size) > (0)) do
+            debugSuffix = ""
+            evt = (@_buffered).delete_at(0)
+            (@_inFlight) << (evt)
+            if (((evt.getTimestamp()) > ((@_lastSyncTime) + (@_syncRequestPeriod))) || (((@_inFlight).size) == (@_syncInFlightMax)))
+                (evt).sync = 1
+                @_lastSyncTime = evt.getTimestamp()
+                debugSuffix = " with sync set"
+            end
+            dispatcher.tell(origin, evt.encode(), sock)
+            (evt).sync = 0
+            @_sent = (@_sent) + ((1))
+            self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + ((sock).to_s))
+        end
+
+        nil
+    end
+
+    ##
+    # Call to send buffered messages.
+
+    def onPump(origin, dispatcher, sock)
+        
+        while (((@_buffered).size) > (0)) do
+            debugSuffix = ""
+            evt = (@_buffered).delete_at(0)
+            (@_inFlight) << (evt)
+            if (((evt.getTimestamp()) > ((@_lastSyncTime) + (@_syncRequestPeriod))) || (((@_inFlight).size) == (@_syncInFlightMax)))
+                (evt).sync = 1
+                @_lastSyncTime = evt.getTimestamp()
+                debugSuffix = " with sync set"
+            end
+            dispatcher.tell(origin, evt.encode(), sock)
+            (evt).sync = 0
+            @_sent = (@_sent) + ((1))
+            self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + ((sock).to_s))
+        end
+
+        nil
+    end
+
+    ##
+    # Called when receiving acknowledgement from other side.
+
+    def onAck(sequence)
+        
+        while (((@_inFlight).size) > (0)) do
+            if ((((@_inFlight)[0]).sequence) <= (sequence))
+                evt = (@_inFlight).delete_at(0)
+                @_recorded = (@_recorded) + ((1))
+                self._debug(((("ack #") + ((sequence).to_s)) + (", discarding #")) + (((evt).sequence).to_s))
+            else
+                break
+            end
+        end
+
+        nil
+    end
+
+    ##
+    # Send an event.
+
+    def send(json_type, event)
+        
+        wrapper = ::Quark.mdk_protocol.AckableEvent.new(json_type, event, @_added)
+        @_added = (@_added) + ((1))
+        (@_buffered) << (wrapper)
+        self._debug(("logged #") + (((wrapper).sequence).to_s))
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.SendWithAcks"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_syncRequestPeriod"))
+            return (self)._syncRequestPeriod
+        end
+        if ((name) == ("_syncInFlightMax"))
+            return (self)._syncInFlightMax
+        end
+        if ((name) == ("_buffered"))
+            return (self)._buffered
+        end
+        if ((name) == ("_inFlight"))
+            return (self)._inFlight
+        end
+        if ((name) == ("_added"))
+            return (self)._added
+        end
+        if ((name) == ("_sent"))
+            return (self)._sent
+        end
+        if ((name) == ("_failedSends"))
+            return (self)._failedSends
+        end
+        if ((name) == ("_recorded"))
+            return (self)._recorded
+        end
+        if ((name) == ("_lastSyncTime"))
+            return (self)._lastSyncTime
+        end
+        if ((name) == ("_myLog"))
+            return (self)._myLog
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_syncRequestPeriod"))
+            (self)._syncRequestPeriod = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_syncInFlightMax"))
+            (self)._syncInFlightMax = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_buffered"))
+            (self)._buffered = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_inFlight"))
+            (self)._inFlight = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_added"))
+            (self)._added = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_sent"))
+            (self)._sent = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_failedSends"))
+            (self)._failedSends = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_recorded"))
+            (self)._recorded = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_lastSyncTime"))
+            (self)._lastSyncTime = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_myLog"))
+            (self)._myLog = value
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._syncRequestPeriod = 5000
+        self._syncInFlightMax = 50
+        self._buffered = ::DatawireQuarkCore::List.new([])
+        self._inFlight = ::DatawireQuarkCore::List.new([])
+        self._added = 0
+        self._sent = 0
+        self._failedSends = 0
+        self._recorded = 0
+        self._lastSyncTime = 0
+        self._myLog = ::Quark.quark._getLogger("SendWithAcks")
+
+        nil
+    end
+
+
+end
+SendWithAcks.unlazy_statics
+
 
 require_relative 'datawire_mdk_md' # 0 () ()
 

data/lib/mdk_rtp.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_rtp; MdkRtp; end
@@ -29,6 +29,8 @@ def self.getRTPParser()
     parser.register("logack", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.LogAck"))
     parser.register("mdk_tracing.protocol.LogAckEvent", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.LogAck"))
     parser.register("subscribe", ::Quark.quark.reflect.QuarkClass.get("mdk_tracing.protocol.Subscribe"))
+    parser.register("interaction_event", ::Quark.quark.reflect.QuarkClass.get("mdk_metrics.InteractionEvent"))
+    parser.register("interaction_ack", ::Quark.quark.reflect.QuarkClass.get("mdk_metrics.InteractionAck"))
     return parser
 
 

data/lib/mdk_runtime.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-10-24 14:33:24.783025
+# Quark 1.0.452 run at 2016-10-26 12:53:21.596699
 module Quark
 require "quark"
 def self.mdk_runtime; MdkRuntime; end
@@ -1122,6 +1122,21 @@ class FakeWSActor < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    ##
+    # Skip over any logged messages for purposes of expectTextMessage().
+
+    def swallowLogMessages()
+        
+        if (!(@resolved))
+            ::Quark.quark.concurrent.Context.runtime().fail("not connected yet")
+        end
+        while (((@expectIdx) < (((self).sent).size)) && ((((((self).sent)[@expectIdx]).index("mdk_tracing.protocol.LogEvent") or -1)) != (-(1)))) do
+            @expectIdx = (@expectIdx) + (1)
+        end
+
+        nil
+    end
+
     ##
     # Check that a message has been sent via this actor.
     #
@@ -1748,7 +1763,7 @@ def self.FakeTime; FakeTime; end
 # Testing fake.
 
 class FakeTime < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :_now, :_scheduled, :dispatcher
+    attr_accessor :_now, :_scheduled, :dispatcher, :_counter
     extend ::DatawireQuarkCore::Static
 
     static quark_List_quark_long__ref: -> { nil }
@@ -1776,7 +1791,8 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
     def onMessage(origin, msg)
         
         sched = ::DatawireQuarkCore.cast(msg) { ::Quark.mdk_runtime.Schedule }
-        (@_scheduled)[((::DatawireQuarkCore::List.new((@_scheduled).keys)).size)] = (::Quark.mdk_runtime._FakeTimeRequest.new(origin, (sched).event, ((self)._now) + ((sched).seconds)))
+        (self)._counter = ((self)._counter) + (1)
+        (@_scheduled)[(@_counter)] = (::Quark.mdk_runtime._FakeTimeRequest.new(origin, (sched).event, ((self)._now) + ((sched).seconds)))
 
         nil
     end
@@ -1845,6 +1861,9 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("dispatcher"))
             return (self).dispatcher
         end
+        if ((name) == ("_counter"))
+            return (self)._counter
+        end
         return nil
 
         nil
@@ -1861,6 +1880,9 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("dispatcher"))
             (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
         end
+        if ((name) == ("_counter"))
+            (self)._counter = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
 
         nil
     end
@@ -1880,6 +1902,7 @@ class FakeTime < ::DatawireQuarkCore::QuarkObject
         self._now = 1000.0
         self._scheduled = {}
         self.dispatcher = nil
+        self._counter = 0
 
         nil
     end