datawire_mdk 2.0.15 → 2.0.16

data/lib/mdk.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk; Mdk; end
@@ -8,12 +8,13 @@ require_relative 'quark/reflect' # 0 ('quark',) ()
 require_relative 'mdk_runtime' # 0 () ()
 require_relative 'mdk_discovery' # 0 () ()
 require_relative 'quark' # 0 () ()
+require_relative 'mdk_protocol' # 0 () ()
 require_relative 'mdk_tracing' # 0 () ()
 require_relative 'quark/concurrent' # 0 ('quark',) ()
 require_relative 'mdk_introspection' # 0 () ()
 require_relative 'mdk_discovery/protocol' # 0 ('mdk_discovery',) ()
 require_relative 'mdk_discovery/synapse' # 0 ('mdk_discovery',) ()
-require_relative 'mdk_protocol' # 0 () ()
+require_relative 'mdk_rtp' # 0 () ()
 require_relative 'mdk_runtime/promise' # 0 ('mdk_runtime',) ()
 require_relative 'mdk_util' # 0 () ()
 
@@ -123,6 +124,19 @@ class MDK < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    ##
+    # Set the default timeout for MDK sessions.
+    #
+    # This is the maximum timeout; if a joined session has a lower
+    # timeout that will be used.
+    #
+
+    def setDefaultTimeout(seconds)
+        raise NotImplementedError, '`MDK.setDefaultTimeout` is an abstract method'
+
+        nil
+    end
+
     ##
     # Creates a new Session. A Session created in this way will
     # result in a new distributed trace. This should therefore
@@ -312,6 +326,8 @@ class Session < ::DatawireQuarkCore::QuarkObject
     ##
     # Locate a compatible service instance.
     #
+    # Uses a minimum of 10 seconds and the timeout set on the session.
+    #
 
     def resolve(service, version)
         raise NotImplementedError, '`Session.resolve` is an abstract method'
@@ -402,6 +418,40 @@ class Session < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    ##
+    # Set how many seconds the session is expected to live from this point.
+    #
+    # If a timeout has previously been set the new timeout will only be
+    # used if it is lower than the existing timeout.
+    #
+    # The MDK will not enforce the timeout. Rather, it provides the
+    # information to any process or server in the same session (even if
+    # they are on different machines). By passing this timeout to
+    # blocking APIs you can ensure timeouts are enforced across a whole
+    # distributed session.
+    #
+
+    def setTimeout(seconds)
+        raise NotImplementedError, '`Session.setTimeout` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Return how many seconds until the session ought to end.
+    #
+    # This will only be accurate across multiple servers insofar as their
+    # clocks are in sync.
+    #
+    # If a timeout has not been set the result will be null.
+    #
+
+    def getRemainingTime()
+        raise NotImplementedError, '`Session.getRemainingTime` is an abstract method'
+
+        nil
+    end
+
     def __init_fields__()
         
 
@@ -414,7 +464,7 @@ Session.unlazy_statics
 
 def self.MDKImpl; MDKImpl; end
 class MDKImpl < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :logger, :_reflection_hack, :_runtime, :_disco, :_discoSource, :_tracer, :procUUID, :_running
+    attr_accessor :logger, :_reflection_hack, :_runtime, :_wsclient, :_openclose, :_disco, :_discoSource, :_tracer, :procUUID, :_running, :_defaultTimeout
     extend ::DatawireQuarkCore::Static
 
     static mdk_MDKImpl_ref: -> { nil }
@@ -432,20 +482,18 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
             (runtime).dependencies.registerService("failurepolicy_factory", self.getFailurePolicy(runtime))
         end
         @_disco = ::Quark.mdk_discovery.Discovery.new(runtime)
+        @_wsclient = self.getWSClient(runtime)
+        if ((@_wsclient) != (nil))
+            @_openclose = ::Quark.mdk_protocol.OpenCloseSubscriber.new(@_wsclient)
+        end
         env = runtime.getEnvVarsService()
-        token = env.var("DATAWIRE_TOKEN").orElseGet("")
         discoFactory = self.getDiscoveryFactory(env)
         @_discoSource = discoFactory.create(@_disco, runtime)
         if (discoFactory.isRegistrar())
             (runtime).dependencies.registerService("discovery_registrar", @_discoSource)
         end
-        if ((token) != (""))
-            tracingURL = ::Quark.mdk._get(env, "MDK_TRACING_URL", "wss://tracing.datawire.io/ws/v1")
-            tracingQueryURL = ::Quark.mdk._get(env, "MDK_TRACING_API_URL", "https://tracing.datawire.io/api/v1/logs")
-            @_tracer = ::Quark.mdk_tracing.Tracer.new(runtime)
-            (@_tracer).url = tracingURL
-            (@_tracer).queryURL = tracingQueryURL
-            (@_tracer).token = token
+        if ((@_wsclient) != (nil))
+            @_tracer = ::Quark.mdk_tracing.Tracer.new(runtime, @_wsclient)
             @_tracer.initContext()
         end
 
@@ -466,7 +514,7 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         end
         result = ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_discovery.DiscoverySourceFactory }
         if ((config).start_with?("datawire:"))
-            result = ::Quark.mdk_discovery.protocol.DiscoClientFactory.new((config)[(9)...((config).size)])
+            result = ::Quark.mdk_discovery.protocol.DiscoClientFactory.new(@_wsclient)
         else
             if ((config).start_with?("synapse:path="))
                 result = ::Quark.mdk_discovery.synapse.Synapse.new((config)[(13)...((config).size)])
@@ -499,6 +547,28 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    ##
+    # Get a WSClient, unless env variables suggest the user doesn't want one.
+
+    def getWSClient(runtime)
+        
+        env = runtime.getEnvVarsService()
+        token = env.var("DATAWIRE_TOKEN").orElseGet("")
+        disco_config = env.var("MDK_DISCOVERY_SOURCE").orElseGet("")
+        if ((token) == (""))
+            if ((disco_config).start_with?("datawire:"))
+                token = (disco_config)[(9)...((disco_config).size)]
+            else
+                return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.WSClient }
+            end
+        end
+        ddu = env.var("MDK_SERVER_URL")
+        url = ddu.orElseGet("wss://mcp.datawire.io/rtp")
+        return ::Quark.mdk_protocol.WSClient.new(runtime, ::Quark.mdk_rtp.getRTPParser(), url, token)
+
+        nil
+    end
+
     def _timeout()
         
         return 10.0
@@ -509,12 +579,13 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
     def start()
         
         (self)._running = true
+        if ((@_wsclient) != (nil))
+            (@_runtime).dispatcher.startActor(@_wsclient)
+            (@_runtime).dispatcher.startActor(@_openclose)
+            (@_runtime).dispatcher.startActor(@_tracer)
+        end
         (@_runtime).dispatcher.startActor(@_disco)
         (@_runtime).dispatcher.startActor(@_discoSource)
-        if ((@_tracer) != (nil))
-            @_tracer._openIfNeeded()
-            (@_tracer)._client._startIfNeeded()
-        end
 
         nil
     end
@@ -522,9 +593,13 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
     def stop()
         
         (self)._running = false
-        (@_runtime).dispatcher.stopActor(@_disco)
         (@_runtime).dispatcher.stopActor(@_discoSource)
-        @_tracer.stop()
+        (@_runtime).dispatcher.stopActor(@_disco)
+        if ((@_wsclient) != (nil))
+            (@_runtime).dispatcher.stopActor(@_tracer)
+            (@_runtime).dispatcher.stopActor(@_openclose)
+            (@_runtime).dispatcher.stopActor(@_wsclient)
+        end
         @_runtime.stop()
 
         nil
@@ -542,16 +617,31 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    def setDefaultTimeout(seconds)
+        
+        (self)._defaultTimeout = seconds
+
+        nil
+    end
+
     def session()
         
-        return ::Quark.mdk.SessionImpl.new(self, nil)
+        session = ::Quark.mdk.SessionImpl.new(self, nil)
+        if ((@_defaultTimeout) != (nil))
+            session.setTimeout(@_defaultTimeout)
+        end
+        return session
 
         nil
     end
 
     def join(encodedContext)
         
-        return ::Quark.mdk.SessionImpl.new(self, encodedContext)
+        session = ::Quark.mdk.SessionImpl.new(self, encodedContext)
+        if ((@_defaultTimeout) != (nil))
+            session.setTimeout(@_defaultTimeout)
+        end
+        return session
 
         nil
     end
@@ -577,6 +667,12 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_runtime"))
             return (self)._runtime
         end
+        if ((name) == ("_wsclient"))
+            return (self)._wsclient
+        end
+        if ((name) == ("_openclose"))
+            return (self)._openclose
+        end
         if ((name) == ("_disco"))
             return (self)._disco
         end
@@ -592,6 +688,9 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_running"))
             return (self)._running
         end
+        if ((name) == ("_defaultTimeout"))
+            return (self)._defaultTimeout
+        end
         return nil
 
         nil
@@ -608,6 +707,12 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_runtime"))
             (self)._runtime = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.MDKRuntime }
         end
+        if ((name) == ("_wsclient"))
+            (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
+        end
+        if ((name) == ("_openclose"))
+            (self)._openclose = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.OpenCloseSubscriber }
+        end
         if ((name) == ("_disco"))
             (self)._disco = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Discovery }
         end
@@ -623,6 +728,9 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_running"))
             (self)._running = ::DatawireQuarkCore.cast(value) { ::Object }
         end
+        if ((name) == ("_defaultTimeout"))
+            (self)._defaultTimeout = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
 
         nil
     end
@@ -632,11 +740,14 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         self.logger = ::Quark.quark._getLogger("mdk")
         self._reflection_hack = nil
         self._runtime = nil
+        self._wsclient = nil
+        self._openclose = nil
         self._disco = nil
         self._discoSource = nil
         self._tracer = nil
         self.procUUID = ::Quark.quark.concurrent.Context.runtime().uuid()
         self._running = false
+        self._defaultTimeout = nil
 
         nil
     end
@@ -758,6 +869,31 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    def setTimeout(timeout)
+        
+        current = self.getRemainingTime()
+        if ((current) == (nil))
+            current = timeout
+        end
+        if ((timeout) > (current))
+            timeout = current
+        end
+        self.set("timeout", ((@_mdk)._runtime.getTimeService().time()) + (timeout))
+
+        nil
+    end
+
+    def getRemainingTime()
+        
+        deadline = ::DatawireQuarkCore.cast(self.get("timeout")) { ::Float }
+        if ((deadline) == (nil))
+            return ::DatawireQuarkCore.cast(nil) { ::Float }
+        end
+        return (deadline) - ((@_mdk)._runtime.getTimeService().time())
+
+        nil
+    end
+
     def route(service, version, target, targetVersion)
         
         routes = nil
@@ -900,7 +1036,12 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
 
     def resolve(service, version)
         
-        return self.resolve_until(service, version, @_mdk._timeout())
+        timeout = @_mdk._timeout()
+        session_timeout = self.getRemainingTime()
+        if (((session_timeout) != (nil)) && ((session_timeout) < (timeout)))
+            timeout = session_timeout
+        end
+        return self.resolve_until(service, version, timeout)
 
         nil
     end

data/lib/mdk_discovery.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end

data/lib/mdk_discovery/protocol.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-10-05 18:08:41.189562
+# Quark 1.0.452 run at 2016-10-13 16:26:58.627837
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end
@@ -8,9 +8,9 @@ module Protocol
 require "datawire-quark-core"
 require_relative '../quark/reflect' # 0 ('quark',) ('mdk_discovery',)
 require_relative '../mdk_discovery' # 0 () ('mdk_discovery',)
+require_relative '../mdk_protocol' # 0 () ('mdk_discovery',)
 require_relative '../mdk_runtime/actors' # 0 ('mdk_runtime',) ('mdk_discovery',)
 require_relative '../mdk_runtime' # 0 () ('mdk_discovery',)
-require_relative '../mdk_protocol' # 0 () ('mdk_discovery',)
 require_relative '../quark' # 0 () ('mdk_discovery',)
 
 
@@ -21,17 +21,17 @@ def self.DiscoClientFactory; DiscoClientFactory; end
 #
 
 class DiscoClientFactory < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :token
+    attr_accessor :wsclient
     extend ::DatawireQuarkCore::Static
 
     static mdk_discovery_protocol_DiscoClientFactory_ref: -> { nil }
 
 
 
-    def initialize(token)
+    def initialize(wsclient)
         
         self.__init_fields__
-        (self).token = token
+        (self).wsclient = wsclient
 
         nil
     end
@@ -41,9 +41,7 @@ class DiscoClientFactory < ::DatawireQuarkCore::QuarkObject
 
     def create(subscriber, runtime)
         
-        ddu = runtime.getEnvVarsService().var("MDK_DISCOVERY_URL")
-        url = ddu.orElseGet("wss://discovery.datawire.io/ws/v1")
-        return ::Quark.mdk_discovery.protocol.DiscoClient.new(subscriber, @token, url, runtime)
+        return ::Quark.mdk_discovery.protocol.DiscoClient.new(subscriber, @wsclient, runtime)
 
         nil
     end
@@ -64,8 +62,8 @@ class DiscoClientFactory < ::DatawireQuarkCore::QuarkObject
 
     def _getField(name)
         
-        if ((name) == ("token"))
-            return (self).token
+        if ((name) == ("wsclient"))
+            return (self).wsclient
         end
         return nil
 
@@ -74,8 +72,8 @@ class DiscoClientFactory < ::DatawireQuarkCore::QuarkObject
 
     def _setField(name, value)
         
-        if ((name) == ("token"))
-            (self).token = ::DatawireQuarkCore.cast(value) { ::String }
+        if ((name) == ("wsclient"))
+            (self).wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
         end
 
         nil
@@ -83,7 +81,7 @@ class DiscoClientFactory < ::DatawireQuarkCore::QuarkObject
 
     def __init_fields__()
         
-        self.token = nil
+        self.wsclient = nil
 
         nil
     end
@@ -99,21 +97,22 @@ def self.DiscoClient; DiscoClient; end
 # Also supports registering discovery information with the server.
 #
 
-class DiscoClient < ::Quark.mdk_protocol.WSClient
-    attr_accessor :_started, :_token, :_url, :_failurePolicyFactory, :_dispatcher, :_subscriber, :registered, :dlog
+class DiscoClient < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_failurePolicyFactory, :_dispatcher, :_timeService, :_subscriber, :_wsclient, :registered, :dlog, :lastHeartbeat, :sock
     extend ::DatawireQuarkCore::Static
 
     static mdk_discovery_protocol_DiscoClient_ref: -> { nil }
 
 
 
-    def initialize(subscriber, token, url, runtime)
+    def initialize(disco_subscriber, wsclient, runtime)
         
-        super(runtime)
-        (self)._subscriber = subscriber
+        self.__init_fields__
+        (self)._subscriber = disco_subscriber
+        (self)._wsclient = wsclient
+        (self)._wsclient.subscribe(self)
         (self)._failurePolicyFactory = ::DatawireQuarkCore.cast((runtime).dependencies.getService("failurepolicy_factory")) { ::Quark.mdk_discovery.FailurePolicyFactory }
-        (self)._token = token
-        (self)._url = url
+        (self)._timeService = runtime.getTimeService()
 
         nil
     end
@@ -124,49 +123,63 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
     def onStart(dispatcher)
         
         (self)._dispatcher = dispatcher
-        (self)._started = true
-        method(:onStart).super_method.call(dispatcher)
 
         nil
     end
 
     def onStop()
         
-        (self)._started = false
-        method(:onStop).super_method.call()
+        self.shutdown()
 
         nil
     end
 
     def onMessage(origin, message)
         
-        if (((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id) == ("mdk_discovery.RegisterNode"))
+        klass = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        if ((klass) == ("mdk_discovery.RegisterNode"))
             register = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.RegisterNode }
             self._register((register).node)
             return
         end
-        method(:onMessage).super_method.call(origin, message)
+        ::Quark.mdk_protocol._subscriberDispatch(self, message)
 
         nil
     end
 
-    def url()
+    def onMessageFromServer(message)
         
-        return (self)._url
+        type = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        if ((type) == ("mdk_discovery.protocol.Active"))
+            active = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.protocol.Active }
+            self.onActive(active)
+            return
+        end
+        if ((type) == ("mdk_discovery.protocol.Expire"))
+            expire = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.protocol.Expire }
+            self.onExpire(expire)
+            return
+        end
 
         nil
     end
 
-    def token()
+    def onWSConnected(websocket)
         
-        return (self)._token
+        (self).sock = websocket
+        self.heartbeat()
 
         nil
     end
 
-    def isStarted()
+    def onPump()
         
-        return (self)._started
+        rightNow = (((self)._timeService.time()) * (1000.0)).round()
+        heartbeatInterval = (((((self)._wsclient).ttl) / (2.0)) * (1000.0)).round()
+        if (((rightNow) - ((self).lastHeartbeat)) >= (heartbeatInterval))
+            (self).lastHeartbeat = rightNow
+            self.heartbeat()
+        end
 
         nil
     end
@@ -181,7 +194,7 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
             (@registered)[service] = (::Quark.mdk_discovery.Cluster.new((self)._failurePolicyFactory))
         end
         (@registered)[service].add(node)
-        if (self.isConnected())
+        if ((self)._wsclient.isConnected())
             self.active(node)
         end
 
@@ -192,8 +205,8 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
         
         active = ::Quark.mdk_discovery.protocol.Active.new()
         (active).node = node
-        (active).ttl = (self).ttl
-        (self).dispatcher.tell(self, active.encode(), (self).sock)
+        (active).ttl = ((self)._wsclient).ttl
+        (self)._dispatcher.tell(self, active.encode(), (self).sock)
         @dlog.info(("active ") + (node.toString()))
 
         nil
@@ -203,7 +216,7 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
         
         expire = ::Quark.mdk_discovery.protocol.Expire.new()
         (expire).node = node
-        (self).dispatcher.tell(self, expire.encode(), (self).sock)
+        (self)._dispatcher.tell(self, expire.encode(), (self).sock)
         @dlog.info(("expire ") + (node.toString()))
 
         nil
@@ -230,19 +243,8 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
         nil
     end
 
-    def onClear(reset)
-        
-        nil
-
-        nil
-    end
-
-    def startup()
-        
-        self.heartbeat()
-
-        nil
-    end
+    ##
+    # Send all registered services.
 
     def heartbeat()
         
@@ -278,17 +280,6 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
         nil
     end
 
-    def onWSMessage(message)
-        
-        event = ::Quark.mdk_discovery.protocol.DiscoveryEvent.decode(message)
-        if ((event) == (nil))
-            return
-        end
-        event.dispatch(self)
-
-        nil
-    end
-
     def _getClass()
         
         return "mdk_discovery.protocol.DiscoClient"
@@ -298,72 +289,33 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
 
     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) == ("_started"))
-            return (self)._started
-        end
-        if ((name) == ("_token"))
-            return (self)._token
-        end
-        if ((name) == ("_url"))
-            return (self)._url
-        end
         if ((name) == ("_failurePolicyFactory"))
             return (self)._failurePolicyFactory
         end
         if ((name) == ("_dispatcher"))
             return (self)._dispatcher
         end
+        if ((name) == ("_timeService"))
+            return (self)._timeService
+        end
         if ((name) == ("_subscriber"))
             return (self)._subscriber
         end
+        if ((name) == ("_wsclient"))
+            return (self)._wsclient
+        end
         if ((name) == ("registered"))
             return (self).registered
         end
         if ((name) == ("dlog"))
             return (self).dlog
         end
+        if ((name) == ("lastHeartbeat"))
+            return (self).lastHeartbeat
+        end
+        if ((name) == ("sock"))
+            return (self).sock
+        end
         return nil
 
         nil
@@ -371,87 +323,48 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
 
     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) == ("_started"))
-            (self)._started = ::DatawireQuarkCore.cast(value) { ::Object }
-        end
-        if ((name) == ("_token"))
-            (self)._token = ::DatawireQuarkCore.cast(value) { ::String }
-        end
-        if ((name) == ("_url"))
-            (self)._url = ::DatawireQuarkCore.cast(value) { ::String }
-        end
         if ((name) == ("_failurePolicyFactory"))
             (self)._failurePolicyFactory = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.FailurePolicyFactory }
         end
         if ((name) == ("_dispatcher"))
             (self)._dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
         end
+        if ((name) == ("_timeService"))
+            (self)._timeService = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.Time }
+        end
         if ((name) == ("_subscriber"))
             (self)._subscriber = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
         end
+        if ((name) == ("_wsclient"))
+            (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
+        end
         if ((name) == ("registered"))
             (self).registered = ::DatawireQuarkCore.cast(value) { ::Hash }
         end
         if ((name) == ("dlog"))
             (self).dlog = value
         end
+        if ((name) == ("lastHeartbeat"))
+            (self).lastHeartbeat = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("sock"))
+            (self).sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
 
         nil
     end
 
     def __init_fields__()
         
-        super
-        self._started = false
-        self._token = nil
-        self._url = nil
         self._failurePolicyFactory = nil
         self._dispatcher = nil
+        self._timeService = nil
         self._subscriber = nil
+        self._wsclient = nil
         self.registered = ::Hash.new()
         self.dlog = ::Quark.quark._getLogger("discovery")
+        self.lastHeartbeat = 0
+        self.sock = nil
 
         nil
     end
@@ -460,147 +373,12 @@ class DiscoClient < ::Quark.mdk_protocol.WSClient
 end
 DiscoClient.unlazy_statics
 
-def self.DiscoHandler; DiscoHandler; end
-class DiscoHandler < ::DatawireQuarkCore::QuarkObject
-    extend ::DatawireQuarkCore::Static
-
-    static mdk_discovery_protocol_DiscoHandler_ref: -> { nil }
-
-
-
-    def initialize()
-        self.__init_fields__
-
-        nil
-    end
-
-
-
-
-    def onActive(active)
-        raise NotImplementedError, '`DiscoHandler.onActive` is an abstract method'
-
-        nil
-    end
-
-    def onExpire(expire)
-        raise NotImplementedError, '`DiscoHandler.onExpire` is an abstract method'
-
-        nil
-    end
-
-    def onClear(reset)
-        raise NotImplementedError, '`DiscoHandler.onClear` is an abstract method'
-
-        nil
-    end
-
-    def __init_fields__()
-        
-
-        nil
-    end
-
-
-end
-DiscoHandler.unlazy_statics
-
-def self.DiscoveryEvent; DiscoveryEvent; end
-class DiscoveryEvent < ::Quark.mdk_protocol.ProtocolEvent
-    extend ::DatawireQuarkCore::Static
-
-    static mdk_discovery_protocol_DiscoveryEvent_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_discovery.protocol.Active._discriminator.matches(type))
-            return ::Quark.mdk_discovery.protocol.Active.new()
-        end
-        if (::Quark.mdk_discovery.protocol.Expire._discriminator.matches(type))
-            return ::Quark.mdk_discovery.protocol.Expire.new()
-        end
-        if (::Quark.mdk_discovery.protocol.Clear._discriminator.matches(type))
-            return ::Quark.mdk_discovery.protocol.Clear.new()
-        end
-        return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.ProtocolEvent }
-
-        nil
-    end
-
-    def self.decode(message)
-        
-        return ::DatawireQuarkCore.cast(::Quark.mdk_protocol.Serializable.decodeClassName("mdk_discovery.protocol.DiscoveryEvent", message)) { ::Quark.mdk_protocol.ProtocolEvent }
-
-        nil
-    end
-
-    def dispatch(handler)
-        
-        self.dispatchDiscoveryEvent(::DatawireQuarkCore.cast(handler) { ::Quark.mdk_discovery.protocol.DiscoHandler })
-
-        nil
-    end
-
-    def dispatchDiscoveryEvent(handler)
-        raise NotImplementedError, '`DiscoveryEvent.dispatchDiscoveryEvent` is an abstract method'
-
-        nil
-    end
-
-    def _getClass()
-        
-        return "mdk_discovery.protocol.DiscoveryEvent"
-
-        nil
-    end
-
-    def _getField(name)
-        
-        return nil
-
-        nil
-    end
-
-    def _setField(name, value)
-        
-        nil
-
-        nil
-    end
-
-    def __init_fields__()
-        
-        super
-
-        nil
-    end
-
-
-end
-DiscoveryEvent.unlazy_statics
-
 def self.Active; Active; end
-class Active < ::Quark.mdk_discovery.protocol.DiscoveryEvent
+class Active < ::Quark.mdk_protocol.Serializable
     attr_accessor :node, :ttl
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["active", "discovery.protocol.Active"])) }
+    static _json_type: -> { "active" }
     static mdk_discovery_protocol_Active_ref: -> { nil }
 
 
@@ -615,13 +393,6 @@ class Active < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
 
 
-    def dispatchDiscoveryEvent(handler)
-        
-        handler.onActive(self)
-
-        nil
-    end
-
     def _getClass()
         
         return "mdk_discovery.protocol.Active"
@@ -631,8 +402,8 @@ class Active < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_discovery.protocol.Active._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_discovery.protocol.Active._json_type
         end
         if ((name) == ("node"))
             return (self).node
@@ -647,8 +418,8 @@ class Active < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_discovery.protocol.Active._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_discovery.protocol.Active._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
         if ((name) == ("node"))
             (self).node = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Node }
@@ -677,11 +448,11 @@ def self.Expire; Expire; end
 ##
 # Expire a node.
 
-class Expire < ::Quark.mdk_discovery.protocol.DiscoveryEvent
+class Expire < ::Quark.mdk_protocol.Serializable
     attr_accessor :node
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["expire", "discovery.protocol.Expire"])) }
+    static _json_type: -> { "expire" }
     static mdk_discovery_protocol_Expire_ref: -> { nil }
 
 
@@ -696,13 +467,6 @@ class Expire < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
 
 
-    def dispatchDiscoveryEvent(handler)
-        
-        handler.onExpire(self)
-
-        nil
-    end
-
     def _getClass()
         
         return "mdk_discovery.protocol.Expire"
@@ -712,8 +476,8 @@ class Expire < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_discovery.protocol.Expire._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_discovery.protocol.Expire._json_type
         end
         if ((name) == ("node"))
             return (self).node
@@ -725,8 +489,8 @@ class Expire < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_discovery.protocol.Expire._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_discovery.protocol.Expire._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
         if ((name) == ("node"))
             (self).node = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Node }
@@ -751,10 +515,10 @@ def self.Clear; Clear; end
 ##
 # Expire all nodes.
 
-class Clear < ::Quark.mdk_discovery.protocol.DiscoveryEvent
+class Clear < ::Quark.mdk_protocol.Serializable
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["clear", "discovery.protocol.Clear"])) }
+    static _json_type: -> { "clear" }
     static mdk_discovery_protocol_Clear_ref: -> { nil }
 
 
@@ -769,13 +533,6 @@ class Clear < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
 
 
-    def dispatchDiscoveryEvent(handler)
-        
-        handler.onClear(self)
-
-        nil
-    end
-
     def _getClass()
         
         return "mdk_discovery.protocol.Clear"
@@ -785,8 +542,8 @@ class Clear < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_discovery.protocol.Clear._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_discovery.protocol.Clear._json_type
         end
         return nil
 
@@ -795,8 +552,8 @@ class Clear < ::Quark.mdk_discovery.protocol.DiscoveryEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_discovery.protocol.Clear._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_discovery.protocol.Clear._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
 
         nil