datawire_mdk 2.0.5

data/lib/mdk_tracing/protocol.rb

@@ -0,0 +1,850 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_tracing; MdkTracing; end
+module MdkTracing
+def self.protocol; Protocol; end
+module Protocol
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_tracing',)
+require_relative '../mdk_protocol' # 0 () ('mdk_tracing',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_tracing',)
+require_relative '../mdk_tracing' # 0 () ('mdk_tracing',)
+require_relative '../quark' # 0 () ('mdk_tracing',)
+require_relative '../mdk_runtime/actors' # 0 ('mdk_runtime',) ('mdk_tracing',)
+require_relative '../mdk_runtime' # 0 () ('mdk_tracing',)
+
+
+def self.TracingHandler; TracingHandler; end
+class TracingHandler < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_tracing_protocol_TracingHandler_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onLogEvent(event)
+        
+        nil
+
+        nil
+    end
+
+    def onLogAck(ack)
+        
+        nil
+
+        nil
+    end
+
+    def onSubscribe(sub)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+TracingHandler.unlazy_statics
+
+def self.TracingEvent; TracingEvent; end
+##
+# A single event in the stream that Tracing has to manage.
+
+class TracingEvent < ::Quark.mdk_protocol.ProtocolEvent
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_tracing_protocol_TracingEvent_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def self.construct(type)
+        
+        result = ::Quark.mdk_protocol.ProtocolEvent.construct(type)
+        if ((result) != (nil))
+            return result
+        end
+        if (::Quark.mdk_tracing.protocol.LogEvent._discriminator.matches(type))
+            return ::Quark.mdk_tracing.protocol.LogEvent.new()
+        end
+        if (::Quark.mdk_tracing.protocol.LogAck._discriminator.matches(type))
+            return ::Quark.mdk_tracing.protocol.LogAck.new()
+        end
+        if (::Quark.mdk_tracing.protocol.Subscribe._discriminator.matches(type))
+            return ::Quark.mdk_tracing.protocol.Subscribe.new()
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.ProtocolEvent }
+
+        nil
+    end
+
+    def self.decode(encoded)
+        
+        return ::DatawireQuarkCore.cast(::Quark.mdk_protocol.Serializable.decodeClassName("mdk_tracing.protocol.TracingEvent", encoded)) { ::Quark.mdk_protocol.ProtocolEvent }
+
+        nil
+    end
+
+    def dispatch(handler)
+        
+        self.dispatchTracingEvent(::DatawireQuarkCore.cast(handler) { ::Quark.mdk_tracing.protocol.TracingHandler })
+
+        nil
+    end
+
+    def dispatchTracingEvent(handler)
+        raise NotImplementedError, '`TracingEvent.dispatchTracingEvent` is an abstract method'
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.protocol.TracingEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+TracingEvent.unlazy_statics
+
+def self.LogEvent; LogEvent; end
+class LogEvent < ::Quark.mdk_tracing.protocol.TracingEvent
+    attr_accessor :context, :timestamp, :node, :level, :category, :contentType, :text, :sequence, :sync
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["log"])) }
+    static mdk_tracing_protocol_LogEvent_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatchTracingEvent(handler)
+        
+        handler.onLogEvent(self)
+
+        nil
+    end
+
+    def toString()
+        
+        return (((((((((((((((("<LogEvent ") + ((@sequence).to_s)) + (" @")) + ((@timestamp).to_s)) + (" ")) + (@context.toString())) + (", ")) + (@node)) + (", ")) + (@level)) + (", ")) + (@category)) + (", ")) + (@contentType)) + (", ")) + (@text)) + (">")
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.protocol.LogEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_tracing.protocol.LogEvent._discriminator
+        end
+        if ((name) == ("context"))
+            return (self).context
+        end
+        if ((name) == ("timestamp"))
+            return (self).timestamp
+        end
+        if ((name) == ("node"))
+            return (self).node
+        end
+        if ((name) == ("level"))
+            return (self).level
+        end
+        if ((name) == ("category"))
+            return (self).category
+        end
+        if ((name) == ("contentType"))
+            return (self).contentType
+        end
+        if ((name) == ("text"))
+            return (self).text
+        end
+        if ((name) == ("sequence"))
+            return (self).sequence
+        end
+        if ((name) == ("sync"))
+            return (self).sync
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_tracing.protocol.LogEvent._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+        if ((name) == ("context"))
+            (self).context = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.SharedContext }
+        end
+        if ((name) == ("timestamp"))
+            (self).timestamp = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("node"))
+            (self).node = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("level"))
+            (self).level = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("category"))
+            (self).category = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("contentType"))
+            (self).contentType = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("text"))
+            (self).text = ::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
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.context = nil
+        self.timestamp = nil
+        self.node = nil
+        self.level = nil
+        self.category = nil
+        self.contentType = nil
+        self.text = nil
+        self.sequence = nil
+        self.sync = nil
+
+        nil
+    end
+
+
+end
+LogEvent.unlazy_statics
+
+def self.Subscribe; Subscribe; end
+class Subscribe < ::Quark.mdk_tracing.protocol.TracingEvent
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["subscribe"])) }
+    static mdk_tracing_protocol_Subscribe_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatchTracingEvent(handler)
+        
+        handler.onSubscribe(self)
+
+        nil
+    end
+
+    def toString()
+        
+        return "<Subscribe>"
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.protocol.Subscribe"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_tracing.protocol.Subscribe._discriminator
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_tracing.protocol.Subscribe._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+Subscribe.unlazy_statics
+
+def self.LogAck; LogAck; end
+class LogAck < ::Quark.mdk_tracing.protocol.TracingEvent
+    attr_accessor :sequence
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["logack", "mdk_tracing.protocol.LogAckEvent"])) }
+    static mdk_tracing_protocol_LogAck_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatchTracingEvent(handler)
+        
+        handler.onLogAck(self)
+
+        nil
+    end
+
+    def toString()
+        
+        return (("<LogAck ") + ((@sequence).to_s)) + (">")
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.protocol.LogAck"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_tracing.protocol.LogAck._discriminator
+        end
+        if ((name) == ("sequence"))
+            return (self).sequence
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_tracing.protocol.LogAck._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+        if ((name) == ("sequence"))
+            (self).sequence = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.sequence = nil
+
+        nil
+    end
+
+
+end
+LogAck.unlazy_statics
+
+def self.TracingClient; TracingClient; end
+class TracingClient < ::Quark.mdk_protocol.WSClient
+    attr_accessor :_tracer, :_started, :_mutex, :_handler, :_dispatcher, :_syncRequestPeriod, :_syncInFlightMax, :_buffered, :_inFlight, :_logged, :_sent, :_failedSends, :_recorded, :_lastSyncTime, :_myLog
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_tracing_protocol_TracingClient_ref: -> { nil }
+
+
+
+    def initialize(tracer, runtime)
+        
+        super(runtime)
+        (self)._dispatcher = (runtime).dispatcher
+        @_tracer = tracer
+
+        nil
+    end
+
+
+
+
+    def _debug(message)
+        
+        s = (((("[") + (((@_buffered).size).to_s)) + (" buf, ")) + (((@_inFlight).size).to_s)) + (" inf] ")
+        @_myLog.debug((s) + (message))
+
+        nil
+    end
+
+    def url()
+        
+        return (@_tracer).url
+
+        nil
+    end
+
+    def token()
+        
+        return (@_tracer).token
+
+        nil
+    end
+
+    def isStarted()
+        
+        @_mutex.acquire()
+        result = ((@_started) || (((@_buffered).size) > (0))) || ((@_handler) != (nil))
+        @_mutex.release()
+        return result
+
+        nil
+    end
+
+    def _startIfNeeded()
+        
+        if (!(@_started))
+            (self)._dispatcher.startActor(self)
+            @_started = true
+        end
+
+        nil
+    end
+
+    def subscribe(handler)
+        
+        @_mutex.acquire()
+        @_handler = handler
+        self._startIfNeeded()
+        @_mutex.release()
+
+        nil
+    end
+
+    def onStart(dispatcher)
+        
+        method(:onStart).super_method.call(dispatcher)
+
+        nil
+    end
+
+    def onStop()
+        
+        @_started = false
+        method(:onStop).super_method.call()
+
+        nil
+    end
+
+    def startup()
+        
+        @_mutex.acquire()
+        while (((@_inFlight).size) > (0)) do
+            evt = (@_inFlight).delete_at(((@_inFlight).size) - (1))
+            (@_buffered).insert((0), (evt))
+            @_failedSends = (@_failedSends) + ((1))
+            self._debug(("no ack for #") + (((evt).sequence).to_s))
+        end
+        self._debug(("Starting up! with connection ") + (((self).sock).to_s))
+        if ((@_handler) != (nil))
+            (self).dispatcher.tell(self, ::Quark.mdk_tracing.protocol.Subscribe.new().encode(), (self).sock)
+        end
+        @_mutex.release()
+
+        nil
+    end
+
+    def pump()
+        
+        @_mutex.acquire()
+        while (((@_buffered).size) > (0)) do
+            debugSuffix = ""
+            evt = (@_buffered).delete_at(0)
+            (@_inFlight) << (evt)
+            if ((((evt).timestamp) > ((@_lastSyncTime) + (@_syncRequestPeriod))) || (((@_inFlight).size) == (@_syncInFlightMax)))
+                (evt).sync = 1
+                @_lastSyncTime = (evt).timestamp
+                debugSuffix = " with sync set"
+            end
+            (self).dispatcher.tell(self, evt.encode(), (self).sock)
+            (evt).sync = 0
+            @_sent = (@_sent) + ((1))
+            self._debug((((("sent #") + (((evt).sequence).to_s)) + (debugSuffix)) + (" to ")) + (((self).sock).to_s))
+        end
+        @_mutex.release()
+
+        nil
+    end
+
+    def onWSMessage(message)
+        
+        event = ::Quark.mdk_tracing.protocol.TracingEvent.decode(message)
+        if ((event) == (nil))
+            return
+        end
+        event.dispatch(self)
+
+        nil
+    end
+
+    def onLogEvent(evt)
+        
+        @_mutex.acquire()
+        if ((@_handler) != (nil))
+            (@_handler).call(evt)
+        end
+        @_mutex.release()
+
+        nil
+    end
+
+    def onLogAck(ack)
+        
+        @_mutex.acquire()
+        while (((@_inFlight).size) > (0)) do
+            if ((((@_inFlight)[0]).sequence) <= ((ack).sequence))
+                evt = (@_inFlight).delete_at(0)
+                @_recorded = (@_recorded) + ((1))
+                self._debug(((("ack #") + (((ack).sequence).to_s)) + (", discarding #")) + (((evt).sequence).to_s))
+            else
+                break
+            end
+        end
+        @_mutex.release()
+
+        nil
+    end
+
+    def log(evt)
+        
+        @_mutex.acquire()
+        (evt).sequence = @_logged
+        (evt).sync = 0
+        @_logged = (@_logged) + ((1))
+        (@_buffered) << (evt)
+        self._debug(("logged #") + (((evt).sequence).to_s))
+        self._startIfNeeded()
+        @_mutex.release()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_tracing.protocol.TracingClient"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("firstDelay"))
+            return (self).firstDelay
+        end
+        if ((name) == ("maxDelay"))
+            return (self).maxDelay
+        end
+        if ((name) == ("reconnectDelay"))
+            return (self).reconnectDelay
+        end
+        if ((name) == ("ttl"))
+            return (self).ttl
+        end
+        if ((name) == ("tick"))
+            return (self).tick
+        end
+        if ((name) == ("sock"))
+            return (self).sock
+        end
+        if ((name) == ("sockUrl"))
+            return (self).sockUrl
+        end
+        if ((name) == ("lastConnectAttempt"))
+            return (self).lastConnectAttempt
+        end
+        if ((name) == ("lastHeartbeat"))
+            return (self).lastHeartbeat
+        end
+        if ((name) == ("timeService"))
+            return (self).timeService
+        end
+        if ((name) == ("schedulingActor"))
+            return (self).schedulingActor
+        end
+        if ((name) == ("websockets"))
+            return (self).websockets
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("_tracer"))
+            return (self)._tracer
+        end
+        if ((name) == ("_started"))
+            return (self)._started
+        end
+        if ((name) == ("_mutex"))
+            return (self)._mutex
+        end
+        if ((name) == ("_handler"))
+            return (self)._handler
+        end
+        if ((name) == ("_dispatcher"))
+            return (self)._dispatcher
+        end
+        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) == ("_logged"))
+            return (self)._logged
+        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) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("firstDelay"))
+            (self).firstDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("maxDelay"))
+            (self).maxDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("reconnectDelay"))
+            (self).reconnectDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("ttl"))
+            (self).ttl = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("tick"))
+            (self).tick = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("sock"))
+            (self).sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.WSActor }
+        end
+        if ((name) == ("sockUrl"))
+            (self).sockUrl = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("lastConnectAttempt"))
+            (self).lastConnectAttempt = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("lastHeartbeat"))
+            (self).lastHeartbeat = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("timeService"))
+            (self).timeService = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.Time }
+        end
+        if ((name) == ("schedulingActor"))
+            (self).schedulingActor = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("websockets"))
+            (self).websockets = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.WebSockets }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("_tracer"))
+            (self)._tracer = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_tracing.Tracer }
+        end
+        if ((name) == ("_started"))
+            (self)._started = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("_mutex"))
+            (self)._mutex = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("_handler"))
+            (self)._handler = ::DatawireQuarkCore.cast(value) { ::Quark.quark.UnaryCallable }
+        end
+        if ((name) == ("_dispatcher"))
+            (self)._dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        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) == ("_logged"))
+            (self)._logged = ::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 onSubscribe(sub)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self._tracer = nil
+        self._started = false
+        self._mutex = ::DatawireQuarkCore::Lock.new()
+        self._handler = nil
+        self._dispatcher = nil
+        self._syncRequestPeriod = 5000
+        self._syncInFlightMax = 50
+        self._buffered = ::DatawireQuarkCore::List.new([])
+        self._inFlight = ::DatawireQuarkCore::List.new([])
+        self._logged = 0
+        self._sent = 0
+        self._failedSends = 0
+        self._recorded = 0
+        self._lastSyncTime = 0
+        self._myLog = ::Quark.quark._getLogger("TracingClient")
+
+        nil
+    end
+
+
+end
+TracingClient.unlazy_statics
+end # module Protocol
+end # module MdkTracing
+end # module Quark