datawire_mdk 2.0.29 → 2.0.30

data/lib/mdk.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk; Mdk; end
@@ -16,6 +16,7 @@ require_relative 'mdk_introspection' # 0 () ()
 require_relative 'mdk_discovery/protocol' # 0 ('mdk_discovery',) ()
 require_relative 'mdk_discovery/synapse' # 0 ('mdk_discovery',) ()
 require_relative 'mdk_rtp' # 0 () ()
+require_relative 'mdk_tracing/protocol' # 0 ('mdk_tracing',) ()
 require_relative 'mdk_runtime/promise' # 0 ('mdk_runtime',) ()
 require_relative 'mdk_util' # 0 () ()
 
@@ -969,6 +970,92 @@ class TLSInit < ::DatawireQuarkCore::QuarkObject
 end
 TLSInit.unlazy_statics
 
+def self.LoggedMessageId; LoggedMessageId; end
+##
+# Information about the message that was just logged.
+#
+
+class LoggedMessageId < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :traceId, :causalLevel, :environment, :environmentFallback
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_LoggedMessageId_ref: -> { nil }
+    static quark_List_quark_int__ref: -> { nil }
+
+
+
+    def initialize(traceId, causalLevel, environment, environmentFallback)
+        
+        self.__init_fields__
+        (self).traceId = traceId
+        (self).causalLevel = causalLevel
+        (self).environment = environment
+        (self).environmentFallback = environmentFallback
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk.LoggedMessageId"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("traceId"))
+            return (self).traceId
+        end
+        if ((name) == ("causalLevel"))
+            return (self).causalLevel
+        end
+        if ((name) == ("environment"))
+            return (self).environment
+        end
+        if ((name) == ("environmentFallback"))
+            return (self).environmentFallback
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("traceId"))
+            (self).traceId = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("causalLevel"))
+            (self).causalLevel = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("environment"))
+            (self).environment = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("environmentFallback"))
+            (self).environmentFallback = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.traceId = nil
+        self.causalLevel = nil
+        self.environment = nil
+        self.environmentFallback = nil
+
+        nil
+    end
+
+
+end
+LoggedMessageId.unlazy_statics
+
 def self.SessionImpl; SessionImpl; end
 class SessionImpl < ::DatawireQuarkCore::QuarkObject
     attr_accessor :_mdk, :_resolved, :_interactionReports, :_context, :_experimental
@@ -1121,59 +1208,51 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
 
     def _log(level, category, text)
         
-        if (((@_mdk)._tracer) != (nil))
-            if (::Quark.mdk.SessionImpl._inLogging.getValue())
-                return
-            end
-            ::Quark.mdk.SessionImpl._inLogging.setValue(true)
-            (@_mdk)._tracer.log(@_context, (@_mdk).procUUID, level, category, text)
-            ::Quark.mdk.SessionImpl._inLogging.setValue(false)
+        if (::Quark.mdk.SessionImpl._inLogging.getValue())
+            return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk.LoggedMessageId }
+        end
+        ::Quark.mdk.SessionImpl._inLogging.setValue(true)
+        evt = ::Quark.mdk_tracing.createLogEvent(@_context, (@_mdk).procUUID, level, category, text)
+        if ((((@_mdk)._tracer) != (nil)) && (self._enabled(level)))
+            (@_mdk)._tracer.log(evt)
         end
+        ::Quark.mdk.SessionImpl._inLogging.setValue(false)
+        return ::Quark.mdk.LoggedMessageId.new((@_context).traceId, (((evt).context).clock).clocks, ((@_context).environment).name, ((@_context).environment).fallbackName)
 
         nil
     end
 
     def critical(category, text)
         
-        if (self._enabled("CRITICAL"))
-            self._log("CRITICAL", category, text)
-        end
+        return self._log("CRITICAL", category, text)
 
         nil
     end
 
     def error(category, text)
         
-        if (self._enabled("ERROR"))
-            self._log("ERROR", category, text)
-        end
+        return self._log("ERROR", category, text)
 
         nil
     end
 
     def warn(category, text)
         
-        if (self._enabled("WARN"))
-            self._log("WARN", category, text)
-        end
+        return self._log("WARN", category, text)
 
         nil
     end
 
     def info(category, text)
         
-        if (self._enabled("INFO"))
-            self._log("INFO", category, text)
-        end
+        return self._log("INFO", category, text)
 
         nil
     end
 
     def debug(category, text)
         
-        if (self._enabled("DEBUG"))
-            self._log("DEBUG", category, text)
-        end
+        return self._log("DEBUG", category, text)
 
         nil
     end
@@ -1248,6 +1327,7 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
         (interactionReport).node = (@_mdk).procUUID
         (interactionReport).timestamp = ((1000.0) * ((@_mdk)._runtime.getTimeService().time())).round()
         (interactionReport).session = (@_context).traceId
+        (interactionReport).environment = (@_context).environment
         (@_interactionReports) << (interactionReport)
         (@_resolved) << (::DatawireQuarkCore::List.new([]))
 

data/lib/mdk_discovery.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end
@@ -1262,7 +1262,9 @@ class Cluster < ::DatawireQuarkCore::QuarkObject
             while ((jdx) < ((waiting).size)) do
                 req = (waiting)[jdx]
                 if (::Quark.mdk_util.versionMatch((req).version, (node).version))
-                    (req).factory.resolve(self._copyNode(node))
+                    if (!(((req).factory).promise.value().hasValue()))
+                        (req).factory.resolve(self._copyNode(node))
+                    end
                 else
                     ((self)._waiting) << (req)
                 end
@@ -1718,8 +1720,13 @@ class Discovery < ::DatawireQuarkCore::QuarkObject
         if (!(cluster.matchingVersionRegistered(version)))
             fallback = environment.getFallback()
             if ((fallback) != (nil))
-                self._release()
-                return self.resolve(service, version, fallback)
+                fallbackCluster = self._getCluster(service, fallback)
+                if (!(fallbackCluster.matchingVersionRegistered(version)))
+                    fallbackCluster._addRequest(version, factory)
+                else
+                    self._release()
+                    return self.resolve(service, version, fallback)
+                end
             end
         end
         result = cluster.chooseVersion(version)

data/lib/mdk_discovery/protocol.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end
@@ -167,6 +167,7 @@ class DiscoClient < ::DatawireQuarkCore::QuarkObject
     def onWSConnected(websocket)
         
         (self).sock = websocket
+        (self).lastHeartbeat = (((self)._timeService.time()) * (1000.0)).round()
         self.heartbeat()
 
         nil

data/lib/mdk_discovery/synapse.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end

data/lib/mdk_introspection.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_introspection; MdkIntrospection; end

data/lib/mdk_introspection/aws.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_introspection; MdkIntrospection; end

data/lib/mdk_introspection/kubernetes.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_introspection; MdkIntrospection; end

data/lib/mdk_metrics.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_metrics; MdkMetrics; end
@@ -16,7 +16,7 @@ def self.InteractionEvent; InteractionEvent; end
 # Wire protocol message for reporting interaction results to MCP.
 
 class InteractionEvent < ::Quark.mdk_protocol.Serializable
-    attr_accessor :timestamp, :uuid, :session, :node, :results
+    attr_accessor :timestamp, :environment, :uuid, :session, :node, :results
     extend ::DatawireQuarkCore::Static
 
     static _json_type: -> { "interaction_event" }
@@ -70,6 +70,9 @@ class InteractionEvent < ::Quark.mdk_protocol.Serializable
         if ((name) == ("timestamp"))
             return (self).timestamp
         end
+        if ((name) == ("environment"))
+            return (self).environment
+        end
         if ((name) == ("uuid"))
             return (self).uuid
         end
@@ -95,6 +98,9 @@ class InteractionEvent < ::Quark.mdk_protocol.Serializable
         if ((name) == ("timestamp"))
             (self).timestamp = ::DatawireQuarkCore.cast(value) { ::Integer }
         end
+        if ((name) == ("environment"))
+            (self).environment = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.OperationalEnvironment }
+        end
         if ((name) == ("uuid"))
             (self).uuid = ::DatawireQuarkCore.cast(value) { ::String }
         end
@@ -115,6 +121,7 @@ class InteractionEvent < ::Quark.mdk_protocol.Serializable
         
         super
         self.timestamp = nil
+        self.environment = nil
         self.uuid = ::Quark.quark.concurrent.Context.runtime().uuid()
         self.session = nil
         self.node = nil
@@ -251,14 +258,14 @@ class MetricsClient < ::DatawireQuarkCore::QuarkObject
     def onWSConnected(websock)
         
         (self)._sock = websock
-        (self)._sendWithAcks.onConnected(self, (self)._dispatcher, websock)
+        (self)._sendWithAcks.onConnected(::Quark.mdk_protocol.WSSend.new(self, (self)._dispatcher, (self)._sock))
 
         nil
     end
 
     def onPump()
         
-        (self)._sendWithAcks.onPump(self, (self)._dispatcher, (self)._sock)
+        (self)._sendWithAcks.onPump(::Quark.mdk_protocol.WSSend.new(self, (self)._dispatcher, (self)._sock))
 
         nil
     end

data/lib/mdk_protocol.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.452 run at 2016-11-04 17:24:33.914374
+# Quark 1.0.452 run at 2016-11-10 18:39:58.222591
 module Quark
 require "quark"
 def self.mdk_protocol; MdkProtocol; end
@@ -135,7 +135,6 @@ class LamportClock < ::Quark.mdk_protocol.Serializable
     attr_accessor :_mutex, :clocks
     extend ::DatawireQuarkCore::Static
 
-    static quark_List_quark_int__ref: -> { nil }
     static mdk_protocol_LamportClock_ref: -> { nil }
 
 
@@ -1794,7 +1793,7 @@ class AckableEvent < ::DatawireQuarkCore::QuarkObject
         
         self.json_type = nil
         self.sequence = nil
-        self.sync = 0
+        self.sync = 1
         self.payload = nil
 
         nil
@@ -1804,16 +1803,142 @@ class AckableEvent < ::DatawireQuarkCore::QuarkObject
 end
 AckableEvent.unlazy_statics
 
+def self.SendAckableEvent; SendAckableEvent; end
+##
+# Send a message to the other side.
+
+class SendAckableEvent < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_SendAckableEvent_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def send(event)
+        raise NotImplementedError, '`SendAckableEvent.send` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+SendAckableEvent.unlazy_statics
+
+def self.WSSend; WSSend; end
+##
+# Send using a WebSocket actor.
+
+class WSSend < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :origin, :dispatcher, :sock
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_WSSend_ref: -> { nil }
+
+
+
+    def initialize(origin, dispatcher, sock)
+        
+        self.__init_fields__
+        (self).origin = origin
+        (self).dispatcher = dispatcher
+        (self).sock = sock
+
+        nil
+    end
+
+
+
+
+    def send(event)
+        
+        @dispatcher.tell(@origin, event.encode(), @sock)
+
+        nil
+    end
+
+    def toString()
+        
+        return ((self).sock).to_s
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.WSSend"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("origin"))
+            return (self).origin
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("sock"))
+            return (self).sock
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("origin"))
+            (self).origin = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("sock"))
+            (self).sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.origin = nil
+        self.dispatcher = nil
+        self.sock = nil
+
+        nil
+    end
+
+
+end
+WSSend.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
+    attr_accessor :_buffered, :_inFlight, :_added, :_sent, :_recorded, :_myLog
     extend ::DatawireQuarkCore::Static
 
-    static quark_List_mdk_protocol_AckableEvent__ref: -> { nil }
+    static quark_Map_quark_long_mdk_protocol_AckableEvent__ref: -> { nil }
     static mdk_protocol_SendWithAcks_ref: -> { nil }
 
 
@@ -1829,7 +1954,7 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
 
     def _debug(message)
         
-        s = (((("[") + (((@_buffered).size).to_s)) + (" buf, ")) + (((@_inFlight).size).to_s)) + (" inf] ")
+        s = (((("[") + (((::DatawireQuarkCore::List.new((@_buffered).keys)).size).to_s)) + (" buf, ")) + (((::DatawireQuarkCore::List.new((@_inFlight).keys)).size).to_s)) + (" inf] ")
         @_myLog.debug((s) + (message))
 
         nil
@@ -1838,22 +1963,11 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
     ##
     # Call when (re)connected to other side.
 
-    def onConnected(origin, dispatcher, sock)
+    def onConnected(sender)
         
-        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
+        (@_buffered).merge!(@_inFlight)
+        @_inFlight = {}
+        self.onPump(sender)
 
         nil
     end
@@ -1861,21 +1975,16 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
     ##
     # Call to send buffered messages.
 
-    def onPump(origin, dispatcher, sock)
+    def onPump(sender)
         
-        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))
+        seqs = ::DatawireQuarkCore::List.new((@_buffered).keys)
+        (seqs).sort!
+        idx = 0
+        while (((seqs).size) > (idx)) do
+            evt = (@_buffered).delete((seqs)[idx])
+            (@_inFlight)[(evt).sequence] = (evt)
+            sender.send(evt)
+            idx = (idx) + (1)
         end
 
         nil
@@ -1886,15 +1995,9 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
 
     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
+        (@_inFlight).delete(sequence)
+        @_recorded = (@_recorded) + ((1))
+        self._debug(((("ack #") + ((sequence).to_s)) + (", discarding #")) + ((sequence).to_s))
 
         nil
     end
@@ -1906,7 +2009,7 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
         
         wrapper = ::Quark.mdk_protocol.AckableEvent.new(json_type, event, @_added)
         @_added = (@_added) + ((1))
-        (@_buffered) << (wrapper)
+        (@_buffered)[(wrapper).sequence] = (wrapper)
         self._debug(("logged #") + (((wrapper).sequence).to_s))
 
         nil
@@ -1921,12 +2024,6 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
 
     def _getField(name)
         
-        if ((name) == ("_syncRequestPeriod"))
-            return (self)._syncRequestPeriod
-        end
-        if ((name) == ("_syncInFlightMax"))
-            return (self)._syncInFlightMax
-        end
         if ((name) == ("_buffered"))
             return (self)._buffered
         end
@@ -1939,15 +2036,9 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
         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
@@ -1958,17 +2049,11 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
 
     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 }
+            (self)._buffered = ::DatawireQuarkCore.cast(value) { ::Hash }
         end
         if ((name) == ("_inFlight"))
-            (self)._inFlight = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+            (self)._inFlight = ::DatawireQuarkCore.cast(value) { ::Hash }
         end
         if ((name) == ("_added"))
             (self)._added = ::DatawireQuarkCore.cast(value) { ::Integer }
@@ -1976,15 +2061,9 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
         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
@@ -1994,15 +2073,11 @@ class SendWithAcks < ::DatawireQuarkCore::QuarkObject
 
     def __init_fields__()
         
-        self._syncRequestPeriod = 5000
-        self._syncInFlightMax = 50
-        self._buffered = ::DatawireQuarkCore::List.new([])
-        self._inFlight = ::DatawireQuarkCore::List.new([])
+        self._buffered = {}
+        self._inFlight = {}
         self._added = 0
         self._sent = 0
-        self._failedSends = 0
         self._recorded = 0
-        self._lastSyncTime = 0
         self._myLog = ::Quark.quark._getLogger("SendWithAcks")
 
         nil