datawire_mdk 2.0.15 → 2.0.16

data/lib/mdk_discovery/synapse.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_introspection.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_introspection; MdkIntrospection; end

data/lib/mdk_introspection/aws.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_introspection; MdkIntrospection; end

data/lib/mdk_introspection/kubernetes.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_introspection; MdkIntrospection; end

data/lib/mdk_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_protocol; MdkProtocol; end
@@ -12,86 +12,32 @@ require_relative 'mdk_runtime' # 0 () ()
 require_relative 'quark/error' # 0 ('quark',) ()
 
 
-def self.Discriminator; Discriminator; end
-class Discriminator < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :values
-    extend ::DatawireQuarkCore::Static
-
-    static mdk_protocol_Discriminator_ref: -> { nil }
-
-
-
-    def initialize(values)
-        
-        self.__init_fields__
-        (self).values = values
-
-        nil
-    end
-
-
-
-
-    def matches(value)
-        
-        idx = 0
-        while ((idx) < ((@values).size)) do
-            if ((value) == ((@values)[idx]))
-                return true
-            end
-            idx = (idx) + (1)
-        end
-        return false
-
-        nil
-    end
-
-    def _getClass()
-        
-        return "mdk_protocol.Discriminator"
-
-        nil
-    end
-
-    def _getField(name)
-        
-        if ((name) == ("values"))
-            return (self).values
-        end
-        return nil
-
-        nil
-    end
+##
+# Returns whether a list contains a given value.
 
-    def _setField(name, value)
-        
-        if ((name) == ("values"))
-            (self).values = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+def self.contains(values, value)
+    
+    idx = 0
+    while ((idx) < ((values).size)) do
+        if ((value) == ((values)[idx]))
+            return true
         end
-
-        nil
-    end
-
-    def __init_fields__()
-        
-        self.values = nil
-
-        nil
+        idx = (idx) + (1)
     end
-
-
-end
-Discriminator.unlazy_statics
-
-def self.anyof(values)
-    
-    return ::Quark.mdk_protocol.Discriminator.new(values)
+    return false
 
 
     nil
 end
 
 def self.Serializable; Serializable; end
+##
+# JSON serializable object.
+#
+# If it has have a String field called _json_type, that will be set as the
+# 'type' field in serialized JSON.
+#
+
 class Serializable < ::DatawireQuarkCore::QuarkObject
     extend ::DatawireQuarkCore::Static
 
@@ -109,29 +55,15 @@ class Serializable < ::DatawireQuarkCore::QuarkObject
 
 
     ##
-    # The given class must have a construct() static method that takes the JSON-encoded type,
-    # or a constructor that takes no arguments.
-    #
+    # Decode JSON into a particular class. XXX TURN INTO FUNCTION
 
-    def self.decodeClass(clazz, encoded)
+    def self.decodeClassName(name, encoded)
         
         json = ::DatawireQuarkCore::JSONObject.parse(encoded)
-        type = (json).getObjectItem("type").getString()
-        meth = clazz.getMethod("construct")
-        obj = nil
-        if ((meth) != (nil))
-            obj = ::DatawireQuarkCore.cast(meth.invoke(nil, ::DatawireQuarkCore::List.new([type]))) { ::Quark.mdk_protocol.Serializable }
-            if ((obj) == (nil))
-                logger = ::Quark.quark._getLogger("protocol")
-                logger.warn(((((clazz.getName()) + (".")) + (meth.getName())) + (" could not understand this json: ")) + (encoded))
-                return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.Serializable }
-            end
-            clazz = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(obj))
-        else
-            obj = ::DatawireQuarkCore.cast(clazz.construct(::DatawireQuarkCore::List.new([]))) { ::Quark.mdk_protocol.Serializable }
-            if ((obj) == (nil))
-                raise (((("could not construct ") + (clazz.getName())) + (" from this json: ")) + (encoded))
-            end
+        clazz = ::Quark.quark.reflect.QuarkClass.get(name)
+        obj = ::DatawireQuarkCore.cast(clazz.construct(::DatawireQuarkCore::List.new([]))) { ::Quark.mdk_protocol.Serializable }
+        if ((obj) == (nil))
+            raise (((("could not construct ") + (clazz.getName())) + (" from this json: ")) + (encoded))
         end
         ::Quark.quark.fromJSON(clazz, obj, json)
         return obj
@@ -139,20 +71,13 @@ class Serializable < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
-    def self.decodeClassName(name, encoded)
-        
-        return ::Quark.mdk_protocol.Serializable.decodeClass(::Quark.quark.reflect.QuarkClass.get(name), encoded)
-
-        nil
-    end
-
     def encode()
         
         clazz = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(self))
         json = ::Quark.quark.toJSON(self, clazz)
-        desc = ::DatawireQuarkCore.cast((self)._getField("_discriminator")) { ::Quark.mdk_protocol.Discriminator }
-        if ((desc) != (nil))
-            (json).setObjectItem(("type"), (::DatawireQuarkCore::JSONObject.new.setString(((desc).values)[0])))
+        jsonType = ::DatawireQuarkCore.cast((self)._getField("_json_type")) { ::String }
+        if ((jsonType) != (nil))
+            (json).setObjectItem(("type"), (::DatawireQuarkCore::JSONObject.new.setString(jsonType)))
         end
         encoded = json.toString()
         return encoded
@@ -535,120 +460,15 @@ class SharedContext < ::Quark.mdk_protocol.Serializable
 end
 SharedContext.unlazy_statics
 
-def self.ProtocolHandler; ProtocolHandler; end
-class ProtocolHandler < ::DatawireQuarkCore::QuarkObject
-    extend ::DatawireQuarkCore::Static
-
-    static mdk_protocol_ProtocolHandler_ref: -> { nil }
-
-
-
-    def initialize()
-        self.__init_fields__
-
-        nil
-    end
-
-
-
-
-    def onOpen(open)
-        raise NotImplementedError, '`ProtocolHandler.onOpen` is an abstract method'
-
-        nil
-    end
-
-    def onClose(close)
-        raise NotImplementedError, '`ProtocolHandler.onClose` is an abstract method'
-
-        nil
-    end
-
-    def __init_fields__()
-        
-
-        nil
-    end
-
-
-end
-ProtocolHandler.unlazy_statics
-
-def self.ProtocolEvent; ProtocolEvent; end
-class ProtocolEvent < ::Quark.mdk_protocol.Serializable
-    extend ::DatawireQuarkCore::Static
-
-    static mdk_protocol_ProtocolEvent_ref: -> { nil }
-
-
-
-    def initialize()
-        
-        super()
-
-        nil
-    end
-
-
-
-
-    def self.construct(type)
-        
-        if (::Quark.mdk_protocol.Open._discriminator.matches(type))
-            return ::Quark.mdk_protocol.Open.new()
-        end
-        if (::Quark.mdk_protocol.Close._discriminator.matches(type))
-            return ::Quark.mdk_protocol.Close.new()
-        end
-        return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.ProtocolEvent }
-
-        nil
-    end
-
-    def dispatch(handler)
-        raise NotImplementedError, '`ProtocolEvent.dispatch` is an abstract method'
-
-        nil
-    end
-
-    def _getClass()
-        
-        return "mdk_protocol.ProtocolEvent"
-
-        nil
-    end
-
-    def _getField(name)
-        
-        return nil
-
-        nil
-    end
-
-    def _setField(name, value)
-        
-        nil
-
-        nil
-    end
-
-    def __init_fields__()
-        
-        super
-
-        nil
-    end
-
-
-end
-ProtocolEvent.unlazy_statics
-
 def self.Open; Open; end
-class Open < ::Quark.mdk_protocol.ProtocolEvent
+##
+# A message sent whenever a new connection is opened, by both sides.
+
+class Open < ::Quark.mdk_protocol.Serializable
     attr_accessor :version, :properties
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["open", "mdk.protocol.Open", "discovery.protocol.Open"])) }
+    static _json_type: -> { "open" }
     static mdk_protocol_Open_ref: -> { nil }
 
 
@@ -663,13 +483,6 @@ class Open < ::Quark.mdk_protocol.ProtocolEvent
 
 
 
-    def dispatch(handler)
-        
-        handler.onOpen(self)
-
-        nil
-    end
-
     def _getClass()
         
         return "mdk_protocol.Open"
@@ -679,8 +492,8 @@ class Open < ::Quark.mdk_protocol.ProtocolEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_protocol.Open._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_protocol.Open._json_type
         end
         if ((name) == ("version"))
             return (self).version
@@ -695,8 +508,8 @@ class Open < ::Quark.mdk_protocol.ProtocolEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_protocol.Open._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_protocol.Open._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
         if ((name) == ("version"))
             (self).version = ::DatawireQuarkCore.cast(value) { ::String }
@@ -804,11 +617,11 @@ def self.Close; Close; end
 ##
 # Close the event stream.
 
-class Close < ::Quark.mdk_protocol.ProtocolEvent
+class Close < ::Quark.mdk_protocol.Serializable
     attr_accessor :error
     extend ::DatawireQuarkCore::Static
 
-    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["close", "mdk.protocol.Close", "discovery.protocol.Close"])) }
+    static _json_type: -> { "close" }
     static mdk_protocol_Close_ref: -> { nil }
 
 
@@ -823,13 +636,6 @@ class Close < ::Quark.mdk_protocol.ProtocolEvent
 
 
 
-    def dispatch(handler)
-        
-        handler.onClose(self)
-
-        nil
-    end
-
     def _getClass()
         
         return "mdk_protocol.Close"
@@ -839,8 +645,8 @@ class Close < ::Quark.mdk_protocol.ProtocolEvent
 
     def _getField(name)
         
-        if ((name) == ("_discriminator"))
-            return ::Quark.mdk_protocol.Close._discriminator
+        if ((name) == ("_json_type"))
+            return ::Quark.mdk_protocol.Close._json_type
         end
         if ((name) == ("error"))
             return (self).error
@@ -852,8 +658,8 @@ class Close < ::Quark.mdk_protocol.ProtocolEvent
 
     def _setField(name, value)
         
-        if ((name) == ("_discriminator"))
-            ::Quark.mdk_protocol.Close._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        if ((name) == ("_json_type"))
+            ::Quark.mdk_protocol.Close._json_type = ::DatawireQuarkCore.cast(value) { ::String }
         end
         if ((name) == ("error"))
             (self).error = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.ProtocolError }
@@ -874,25 +680,19 @@ class Close < ::Quark.mdk_protocol.ProtocolEvent
 end
 Close.unlazy_statics
 
-def self.WSClient; WSClient; end
+def self.Pump; Pump; end
 ##
-# Common protocol machinery for web socket based protocol clients.
+# Sent to a subscriber every once in a while, to tell subscribers they can send data.
 
-class WSClient < ::DatawireQuarkCore::QuarkObject
-    attr_accessor :logger, :firstDelay, :maxDelay, :reconnectDelay, :ttl, :tick, :sock, :sockUrl, :lastConnectAttempt, :lastHeartbeat, :timeService, :schedulingActor, :websockets, :dispatcher
+class Pump < ::DatawireQuarkCore::QuarkObject
     extend ::DatawireQuarkCore::Static
 
-    static mdk_protocol_WSClient_ref: -> { nil }
+    static mdk_protocol_Pump_ref: -> { nil }
 
 
 
-    def initialize(runtime)
-        
+    def initialize()
         self.__init_fields__
-        (self).dispatcher = (runtime).dispatcher
-        (self).timeService = runtime.getTimeService()
-        (self).schedulingActor = runtime.getScheduleService()
-        (self).websockets = runtime.getWebSocketsService()
 
         nil
     end
@@ -900,207 +700,671 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
 
 
 
-    def url()
-        raise NotImplementedError, '`WSClient.url` is an abstract method'
+    def _getClass()
+        
+        return "mdk_protocol.Pump"
 
         nil
     end
 
-    def token()
-        raise NotImplementedError, '`WSClient.token` is an abstract method'
+    def _getField(name)
+        
+        return nil
 
         nil
     end
 
-    def isStarted()
-        raise NotImplementedError, '`WSClient.isStarted` is an abstract method'
+    def _setField(name, value)
+        
+        nil
 
         nil
     end
 
-    def isConnected()
+    def __init_fields__()
         
-        return (@sock) != (nil)
 
         nil
     end
 
-    def schedule(time)
+
+end
+Pump.unlazy_statics
+
+def self.WSConnected; WSConnected; end
+##
+# Sent to a subscriber when connection happens.
+
+class WSConnected < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :websock
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_WSConnected_ref: -> { nil }
+
+
+
+    def initialize(websock)
         
-        (self).dispatcher.tell(self, ::Quark.mdk_runtime.Schedule.new("wakeup", time), (self).schedulingActor)
+        self.__init_fields__
+        (self).websock = websock
 
         nil
     end
 
-    def scheduleReconnect()
+
+
+
+    def _getClass()
         
-        self.schedule(@reconnectDelay)
+        return "mdk_protocol.WSConnected"
 
         nil
     end
 
-    def onOpen(open)
+    def _getField(name)
         
-        nil
+        if ((name) == ("websock"))
+            return (self).websock
+        end
+        return nil
 
         nil
     end
 
-    def doBackoff()
+    def _setField(name, value)
         
-        @reconnectDelay = (2.0) * (@reconnectDelay)
-        if ((@reconnectDelay) > (@maxDelay))
-            @reconnectDelay = @maxDelay
+        if ((name) == ("websock"))
+            (self).websock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
         end
-        @logger.info((("backing off, reconnecting in ") + ((@reconnectDelay).to_s)) + (" seconds"))
 
         nil
     end
 
-    def onClose(close)
+    def __init_fields__()
         
-        @logger.info(("close: ") + ((close).to_s))
-        if (((close).error) == (nil))
-            @reconnectDelay = @firstDelay
-        else
-            self.doBackoff()
-        end
+        self.websock = nil
 
         nil
     end
 
-    def onStart(dispatcher)
+
+end
+WSConnected.unlazy_statics
+
+def self.DecodedMessage; DecodedMessage; end
+##
+# Sent to a subscriber when a message is received.
+
+class DecodedMessage < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :message
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_DecodedMessage_ref: -> { nil }
+
+
+
+    def initialize(message)
         
-        self.schedule(0.0)
+        self.__init_fields__
+        (self).message = message
 
         nil
     end
 
-    def onStop()
+
+
+
+    def _getClass()
         
-        if (self.isConnected())
-            self.shutdown()
-            (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSClose.new(), @sock)
-            @sock = ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_runtime.WSActor }
-        end
+        return "mdk_protocol.DecodedMessage"
 
         nil
     end
 
-    def onMessage(origin, message)
+    def _getField(name)
         
-        typeId = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
-        if ((typeId) == ("mdk_runtime.Happening"))
-            self.onScheduledEvent()
-            return
+        if ((name) == ("message"))
+            return (self).message
         end
-        if ((typeId) == ("mdk_runtime.WSClosed"))
-            self.onWSClosed()
-            return
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("message"))
+            (self).message = value
         end
-        if ((typeId) == ("mdk_runtime.WSMessage"))
-            wsmessage = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_runtime.WSMessage }
-            self.onWSMessage((wsmessage).body)
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.message = nil
+
+        nil
+    end
+
+
+end
+DecodedMessage.unlazy_statics
+
+def self.WSClientSubscriber; WSClientSubscriber; end
+##
+# Higher-level interface for subscribers, to be utilized with _subscriberDispatch.
+
+class WSClientSubscriber < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_WSClientSubscriber_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Handle an incoming decoded JSON message received from the server.
+
+    def onMessageFromServer(message)
+        raise NotImplementedError, '`WSClientSubscriber.onMessageFromServer` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Called with WebSocket actor when the WSClient connects to the server.
+
+    def onWSConnected(websocket)
+        raise NotImplementedError, '`WSClientSubscriber.onWSConnected` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Called when the WSClient notifies the subscriber it can send data.
+
+    def onPump()
+        raise NotImplementedError, '`WSClientSubscriber.onPump` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WSClientSubscriber.unlazy_statics
+
+##
+# Dispatch actor messages to a WSClientSubscriber.
+#
+# Call this in onMessage to handle DecodedMessage, WSConnected and Pump messages
+# from the WSClient.
+#
+
+def self._subscriberDispatch(subscriber, message)
+    
+    klass = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+    if ((klass) == ("mdk_protocol.WSConnected"))
+        connected = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_protocol.WSConnected }
+        subscriber.onWSConnected((connected).websock)
+        return
+    end
+    if ((klass) == ("mdk_protocol.Pump"))
+        subscriber.onPump()
+        return
+    end
+    if ((klass) == ("mdk_protocol.DecodedMessage"))
+        decoded = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_protocol.DecodedMessage }
+        subscriber.onMessageFromServer((decoded).message)
+        return
+    end
+
+
+    nil
+end
+
+def self.OpenCloseSubscriber; OpenCloseSubscriber; end
+##
+# Handle Open and Close messages.
+
+class OpenCloseSubscriber < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_dispatcher, :_wsclient
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_OpenCloseSubscriber_ref: -> { nil }
+
+
+
+    def initialize(client)
+        
+        self.__init_fields__
+        (self)._wsclient = client
+        (self)._wsclient.subscribe(self)
+
+        nil
+    end
+
+
+
+
+    def onStart(dispatcher)
+        
+        (self)._dispatcher = dispatcher
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        ::Quark.mdk_protocol._subscriberDispatch(self, message)
+
+        nil
+    end
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    def onMessageFromServer(message)
+        
+        type = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        if ((type) == ("mdk_protocol.Open"))
+            self.onOpen()
+            return
+        end
+        if ((type) == ("mdk_protocol.Close"))
+            close = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_protocol.Close }
+            self.onClose(close)
             return
         end
 
         nil
     end
 
-    def onScheduledEvent()
+    def onWSConnected(websocket)
         
-        rightNow = (((self).timeService.time()) * (1000.0)).round()
-        heartbeatInterval = (((@ttl) / (2.0)) * (1000.0)).round()
-        reconnectInterval = ((@reconnectDelay) * (1000.0)).round()
-        if (self.isConnected())
-            if (self.isStarted())
-                self.pump()
-                if (((rightNow) - (@lastHeartbeat)) >= (heartbeatInterval))
-                    self.doHeartbeat()
-                end
-            end
-        else
-            if ((self.isStarted()) && (((rightNow) - (@lastConnectAttempt)) >= (reconnectInterval)))
-                self.doOpen()
-            end
+        (self)._dispatcher.tell(self, ::Quark.mdk_protocol.Open.new().encode(), websocket)
+
+        nil
+    end
+
+    def onPump()
+        
+        nil
+
+        nil
+    end
+
+    def onOpen()
+        
+        nil
+
+        nil
+    end
+
+    def onClose(close)
+        
+        (self)._wsclient.onClose(((close).error) != (nil))
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.OpenCloseSubscriber"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_dispatcher"))
+            return (self)._dispatcher
         end
-        if (self.isStarted())
-            self.schedule(@tick)
+        if ((name) == ("_wsclient"))
+            return (self)._wsclient
         end
+        return nil
 
         nil
     end
 
-    def doOpen()
+    def _setField(name, value)
         
-        self.open(self.url())
-        @lastConnectAttempt = (((self).timeService.time()) * (1000.0)).round()
+        if ((name) == ("_dispatcher"))
+            (self)._dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("_wsclient"))
+            (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
+        end
 
         nil
     end
 
-    def doHeartbeat()
+    def __init_fields__()
         
-        self.heartbeat()
-        @lastHeartbeat = (((self).timeService.time()) * (1000.0)).round()
+        self._dispatcher = nil
+        self._wsclient = nil
 
         nil
     end
 
-    def open(url)
+
+end
+OpenCloseSubscriber.unlazy_statics
+
+def self.JSONParser; JSONParser; end
+##
+# Convert JSON-encoded strings into objects.
+
+class JSONParser < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_typeToClass
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_JSONParser_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Register a type field and the corresponding class.
+
+    def register(type, cls)
         
-        @sockUrl = url
-        tok = self.token()
-        if ((tok) != (nil))
-            url = ((url) + ("?token=")) + (tok)
+        ((self)._typeToClass)[type] = (cls)
+
+        nil
+    end
+
+    ##
+    # Decode a String into an Object.
+
+    def decode(message)
+        
+        json = ::DatawireQuarkCore::JSONObject.parse(message)
+        cls = ((self)._typeToClass)[json.getObjectItem("type").getString()]
+        if ((cls) == (nil))
+            return nil
         end
-        @logger.info(("opening ") + (@sockUrl))
-        (self).websockets.connect(url, self).andEither(::Quark.quark._BoundMethod.new(self, "onWSConnected", ::DatawireQuarkCore::List.new([])), ::Quark.quark._BoundMethod.new(self, "onWSError", ::DatawireQuarkCore::List.new([])))
+        instance = cls.construct(::DatawireQuarkCore::List.new([]))
+        ::Quark.quark.fromJSON(cls, instance, json)
+        return instance
 
         nil
     end
 
-    def startup()
+    def _getClass()
+        
+        return "mdk_protocol.JSONParser"
+
+        nil
+    end
+
+    def _getField(name)
         
+        if ((name) == ("_typeToClass"))
+            return (self)._typeToClass
+        end
+        return nil
+
         nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_typeToClass"))
+            (self)._typeToClass = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
 
         nil
     end
 
-    def pump()
+    def __init_fields__()
+        
+        self._typeToClass = {}
+
+        nil
+    end
+
+
+end
+JSONParser.unlazy_statics
+
+def self.WSClient; WSClient; end
+##
+# Common protocol machinery for web socket based protocol clients.
+
+class WSClient < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :logger, :firstDelay, :maxDelay, :reconnectDelay, :ttl, :tick, :sock, :lastConnectAttempt, :timeService, :schedulingActor, :websockets, :dispatcher, :url, :token, :subscribers, :_started, :_parser
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_runtime_actors_Actor__ref: -> { nil }
+    static mdk_protocol_WSClient_ref: -> { nil }
+
+
+
+    def initialize(runtime, parser, url, token)
+        
+        self.__init_fields__
+        (self).dispatcher = (runtime).dispatcher
+        (self).timeService = runtime.getTimeService()
+        (self).schedulingActor = runtime.getScheduleService()
+        (self).websockets = runtime.getWebSocketsService()
+        (self).url = url
+        (self).token = token
+        (self)._parser = parser
+
+        nil
+    end
+
+
+
+
+    ##
+    # Subscribe to messages from the server.
+    #
+    # Do this before starting the WSClient.
+    #
+    # The given Actor subscribes to WSConnected, all WSMessage received by the
+    # WSClient, as well as a periodic Pump message.
+    #
+
+    def subscribe(subscriber)
+        
+        ((self).subscribers) << (subscriber)
+
+        nil
+    end
+
+    def isStarted()
+        
+        return @_started
+
+        nil
+    end
+
+    def isConnected()
+        
+        return (@sock) != (nil)
+
+        nil
+    end
+
+    def schedule(time)
+        
+        (self).dispatcher.tell(self, ::Quark.mdk_runtime.Schedule.new("wakeup", time), (self).schedulingActor)
+
+        nil
+    end
+
+    def scheduleReconnect()
+        
+        self.schedule(@reconnectDelay)
+
+        nil
+    end
+
+    ##
+    # Called when the connection is closed via message by the server.
+
+    def onClose(error)
         
+        @logger.info("close!")
+        if (error)
+            self.doBackoff()
+        else
+            @reconnectDelay = @firstDelay
+        end
+
         nil
+    end
+
+    def doBackoff()
+        
+        @reconnectDelay = (2.0) * (@reconnectDelay)
+        if ((@reconnectDelay) > (@maxDelay))
+            @reconnectDelay = @maxDelay
+        end
+        @logger.info((("backing off, reconnecting in ") + ((@reconnectDelay).to_s)) + (" seconds"))
 
         nil
     end
 
-    def heartbeat()
+    def onStart(dispatcher)
         
+        (self)._started = true
+        self.schedule(0.0)
+
         nil
+    end
+
+    def onStop()
+        
+        (self)._started = false
+        if (self.isConnected())
+            (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSClose.new(), @sock)
+            @sock = ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_runtime.WSActor }
+        end
 
         nil
     end
 
-    def shutdown()
+    def onMessage(origin, message)
+        
+        typeId = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        if ((typeId) == ("mdk_runtime.Happening"))
+            self.onScheduledEvent()
+            return
+        end
+        if ((typeId) == ("mdk_runtime.WSClosed"))
+            self.onWSClosed()
+            return
+        end
+        if ((typeId) == ("mdk_runtime.WSMessage"))
+            wsmessage = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_runtime.WSMessage }
+            parsed = (self)._parser.decode((wsmessage).body)
+            if ((parsed) == (nil))
+                return
+            end
+            decoded = ::Quark.mdk_protocol.DecodedMessage.new(parsed)
+            idx = 0
+            while ((idx) < (((self).subscribers).size)) do
+                (self).dispatcher.tell(self, decoded, ((self).subscribers)[idx])
+                idx = (idx) + (1)
+            end
+            return
+        end
+
+        nil
+    end
+
+    def onScheduledEvent()
         
+        rightNow = (((self).timeService.time()) * (1000.0)).round()
+        reconnectInterval = ((@reconnectDelay) * (1000.0)).round()
+        if (self.isConnected())
+            if (self.isStarted())
+                self.pump()
+            end
+        else
+            if ((self.isStarted()) && (((rightNow) - (@lastConnectAttempt)) >= (reconnectInterval)))
+                self.doOpen()
+            end
+        end
+        if (self.isStarted())
+            self.schedule(@tick)
+        end
+
         nil
+    end
+
+    def doOpen()
+        
+        @lastConnectAttempt = (((self).timeService.time()) * (1000.0)).round()
+        sockUrl = @url
+        if ((@token) != (nil))
+            sockUrl = ((sockUrl) + ("?token=")) + (@token)
+        end
+        @logger.info(("opening ") + (@url))
+        (self).websockets.connect(sockUrl, self).andEither(::Quark.quark._BoundMethod.new(self, "onWSConnected", ::DatawireQuarkCore::List.new([])), ::Quark.quark._BoundMethod.new(self, "onWSError", ::DatawireQuarkCore::List.new([])))
 
         nil
     end
 
-    def onWSMessage(message)
+    def startup()
         
+        message = ::Quark.mdk_protocol.WSConnected.new((self).sock)
+        idx = 0
+        while ((idx) < ((@subscribers).size)) do
+            (self).dispatcher.tell(self, message, (@subscribers)[idx])
+            idx = (idx) + (1)
+        end
+
         nil
+    end
+
+    def pump()
+        
+        message = ::Quark.mdk_protocol.Pump.new()
+        idx = 0
+        while ((idx) < ((@subscribers).size)) do
+            (self).dispatcher.tell(self, message, (@subscribers)[idx])
+            idx = (idx) + (1)
+        end
 
         nil
     end
 
     def onWSConnected(socket)
         
-        @logger.info(((("connected to ") + (@sockUrl)) + (" via ")) + ((socket).to_s))
+        @logger.info(((("connected to ") + (@url)) + (" via ")) + ((socket).to_s))
         @reconnectDelay = @firstDelay
         @sock = socket
-        (self).dispatcher.tell(self, ::Quark.mdk_protocol.Open.new().encode(), @sock)
         self.startup()
         self.pump()
 
@@ -1117,7 +1381,7 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
 
     def onWSClosed()
         
-        @logger.info(("closed ") + (@sockUrl))
+        @logger.info(("closed ") + (@url))
         @sock = ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_runtime.WSActor }
 
         nil
@@ -1153,15 +1417,9 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
         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
@@ -1174,6 +1432,21 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("dispatcher"))
             return (self).dispatcher
         end
+        if ((name) == ("url"))
+            return (self).url
+        end
+        if ((name) == ("token"))
+            return (self).token
+        end
+        if ((name) == ("subscribers"))
+            return (self).subscribers
+        end
+        if ((name) == ("_started"))
+            return (self)._started
+        end
+        if ((name) == ("_parser"))
+            return (self)._parser
+        end
         return nil
 
         nil
@@ -1202,15 +1475,9 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
         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
@@ -1223,6 +1490,21 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("dispatcher"))
             (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
         end
+        if ((name) == ("url"))
+            (self).url = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("token"))
+            (self).token = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("subscribers"))
+            (self).subscribers = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_started"))
+            (self)._started = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("_parser"))
+            (self)._parser = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.JSONParser }
+        end
 
         nil
     end
@@ -1236,13 +1518,16 @@ class WSClient < ::DatawireQuarkCore::QuarkObject
         self.ttl = 30.0
         self.tick = 1.0
         self.sock = nil
-        self.sockUrl = nil
         self.lastConnectAttempt = 0
-        self.lastHeartbeat = 0
         self.timeService = nil
         self.schedulingActor = nil
         self.websockets = nil
         self.dispatcher = nil
+        self.url = nil
+        self.token = nil
+        self.subscribers = ::DatawireQuarkCore::List.new([])
+        self._started = false
+        self._parser = nil
 
         nil
     end