datawire_mdk 2.0.5

data/lib/mdk_introspection/aws.rb

@@ -0,0 +1,101 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_introspection; MdkIntrospection; end
+module MdkIntrospection
+def self.aws; Aws; end
+module Aws
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_introspection',)
+require_relative '../mdk_introspection' # 0 () ('mdk_introspection',)
+require_relative '../mdk_runtime' # 0 () ('mdk_introspection',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_introspection',)
+
+
+def self.Ec2Host; Ec2Host; end
+class Ec2Host < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :scope, :env
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_introspection_aws_Ec2Host_ref: -> { nil }
+
+
+
+    def initialize(env, scope)
+        
+        self.__init_fields__
+        (self).scope = (scope).upcase
+        (self).env = env
+
+        nil
+    end
+
+
+
+
+    def self.metadataHost(env)
+        
+        return env.var("DATAWIRE_METADATA_HOST_OVERRIDE").orElseGet("169.254.169.254")
+
+        nil
+    end
+
+    def get()
+        
+        if ((@scope) == ("INTERNAL"))
+            return ::DatawireQuarkCore.url_get((("http://") + (::Quark.mdk_introspection.aws.Ec2Host.metadataHost(@env))) + ("/latest/meta-data/local-hostname"))
+        end
+        if ((@scope) == ("PUBLIC"))
+            return ::DatawireQuarkCore.url_get((("http://") + (::Quark.mdk_introspection.aws.Ec2Host.metadataHost(@env))) + ("/latest/meta-data/public-hostname"))
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::String }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_introspection.aws.Ec2Host"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("scope"))
+            return (self).scope
+        end
+        if ((name) == ("env"))
+            return (self).env
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("scope"))
+            (self).scope = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("env"))
+            (self).env = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.EnvironmentVariables }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.scope = nil
+        self.env = nil
+
+        nil
+    end
+
+
+end
+Ec2Host.unlazy_statics
+end # module Aws
+end # module MdkIntrospection
+end # module Quark

data/lib/mdk_introspection/kubernetes.rb

@@ -0,0 +1,125 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_introspection; MdkIntrospection; end
+module MdkIntrospection
+def self.kubernetes; Kubernetes; end
+module Kubernetes
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_introspection',)
+require_relative '../mdk_introspection' # 0 () ('mdk_introspection',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_introspection',)
+
+
+def self.KubernetesHost; KubernetesHost; end
+class KubernetesHost < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_introspection_kubernetes_KubernetesHost_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def get()
+        
+        return ::DatawireQuarkCore.cast(nil) { ::String }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_introspection.kubernetes.KubernetesHost"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+KubernetesHost.unlazy_statics
+
+def self.KubernetesPort; KubernetesPort; end
+class KubernetesPort < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_introspection_kubernetes_KubernetesPort_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def get()
+        
+        return ::DatawireQuarkCore.cast(nil) { ::Integer }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_introspection.kubernetes.KubernetesPort"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+KubernetesPort.unlazy_statics
+end # module Kubernetes
+end # module MdkIntrospection
+end # module Quark

data/lib/mdk_protocol.rb

@@ -0,0 +1,1255 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_protocol; MdkProtocol; end
+module MdkProtocol
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'datawire_mdk_md' # 0 () ()
+require_relative 'quark' # 0 () ()
+require_relative 'quark/concurrent' # 0 ('quark',) ()
+require_relative 'mdk_runtime/actors' # 0 ('mdk_runtime',) ()
+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
+
+    def _setField(name, value)
+        
+        if ((name) == ("values"))
+            (self).values = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.values = nil
+
+        nil
+    end
+
+
+end
+Discriminator.unlazy_statics
+
+def self.anyof(values)
+    
+    return ::Quark.mdk_protocol.Discriminator.new(values)
+
+
+    nil
+end
+
+def self.Serializable; Serializable; end
+class Serializable < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_Serializable_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # The given class must have a construct() static method that takes the JSON-encoded type,
+    # or a constructor that takes no arguments.
+    #
+
+    def self.decodeClass(clazz, 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
+        end
+        ::Quark.quark.fromJSON(clazz, obj, json)
+        return obj
+
+        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])))
+        end
+        encoded = json.toString()
+        return encoded
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.Serializable"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Serializable.unlazy_statics
+
+def self.LamportClock; LamportClock; end
+##
+# A Lamport Clock is a logical structure meant to allow partial causal ordering. Ours is a list of
+# integers such that adding an integer implies adding a new level to the causality tree.
+#
+# Within a level, time is indicated by incrementing the clock, so
+#
+# [1,2,3] comes before [1,2,4] which comes before [1,2,5]
+#
+# Adding an element to the clock implies causality, so [1,2,4,1-N] is _by definition_ a sequence that was
+# _caused by_ the sequence of [1,2,1-3].
+#
+# Note that LamportClock is lowish-level support. SharedContext puts some more structure around this, too.
+#
+
+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 }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def self.decode(encoded)
+        
+        return ::DatawireQuarkCore.cast(::Quark.mdk_protocol.Serializable.decodeClassName("mdk_protocol.LamportClock", encoded)) { ::Quark.mdk_protocol.LamportClock }
+
+        nil
+    end
+
+    ##
+    # Return a neatly-formatted list of all of our clock elements (e.g. 1,2,4,1) for use as a name or
+    # a key.
+    #
+
+    def key()
+        
+        @_mutex.acquire()
+        tmp = ::DatawireQuarkCore::List.new([])
+        i = 0
+        while ((i) < (((self).clocks).size)) do
+            (tmp) << ((((self).clocks)[i]).to_s)
+            i = (i) + (1)
+        end
+        str = (tmp).join(",")
+        @_mutex.release()
+        return str
+
+        nil
+    end
+
+    def toString()
+        
+        @_mutex.acquire()
+        str = (("<LamportClock ") + (self.key())) + (">")
+        @_mutex.release()
+        return str
+
+        nil
+    end
+
+    ##
+    # Enter a new level of causality. Returns the value to pass to later pass to leave to get back to the
+    # current level of causality.
+    #
+
+    def enter()
+        
+        @_mutex.acquire()
+        current = -(1)
+        ((self).clocks) << (0)
+        current = ((self).clocks).size
+        @_mutex.release()
+        return current
+
+        nil
+    end
+
+    ##
+    # Leave deeper levels of causality. popTo should be the value returned when you enter()d this level.
+    #
+
+    def leave(popTo)
+        
+        @_mutex.acquire()
+        current = -(1)
+        (self).clocks = ::Quark.quark.ListUtil.new().slice((self).clocks, 0, popTo)
+        current = ((self).clocks).size
+        @_mutex.release()
+        return current
+
+        nil
+    end
+
+    ##
+    # Increment the clock for our current level of causality (which is always the last element in the list).
+    # If there are no elements in our clock, do nothing.
+    #
+
+    def tick()
+        
+        @_mutex.acquire()
+        current = ((self).clocks).size
+        if ((current) > (0))
+            ((self).clocks)[(current) - (1)] = ((((self).clocks)[(current) - (1)]) + (1))
+        end
+        @_mutex.release()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.LamportClock"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_mutex"))
+            return (self)._mutex
+        end
+        if ((name) == ("clocks"))
+            return (self).clocks
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_mutex"))
+            (self)._mutex = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("clocks"))
+            (self).clocks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self._mutex = ::DatawireQuarkCore::Lock.new()
+        self.clocks = ::DatawireQuarkCore::List.new([])
+
+        nil
+    end
+
+
+end
+LamportClock.unlazy_statics
+
+def self.SharedContext; SharedContext; end
+class SharedContext < ::Quark.mdk_protocol.Serializable
+    attr_accessor :traceId, :clock, :properties, :_lastEntry
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_SharedContext_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+        (self)._lastEntry = (self).clock.enter()
+
+        nil
+    end
+
+
+
+
+    ##
+    # Set the traceId for this SharedContext.
+
+    def withTraceId(traceId)
+        
+        (self).traceId = traceId
+        return self
+
+        nil
+    end
+
+    def self.decode(encoded)
+        
+        return ::DatawireQuarkCore.cast(::Quark.mdk_protocol.Serializable.decodeClassName("mdk_protocol.SharedContext", encoded)) { ::Quark.mdk_protocol.SharedContext }
+
+        nil
+    end
+
+    def clockStr(pfx)
+        
+        cs = ""
+        if (((self).clock) != (nil))
+            cs = (pfx) + ((self).clock.key())
+        end
+        return cs
+
+        nil
+    end
+
+    def key()
+        
+        return ((self).traceId) + (self.clockStr(":"))
+
+        nil
+    end
+
+    def toString()
+        
+        return ((("<SCTX t:") + ((self).traceId)) + (self.clockStr(" c:"))) + (">")
+
+        nil
+    end
+
+    ##
+    # Tick the clock at our current causality level.
+    #
+
+    def tick()
+        
+        (self).clock.tick()
+
+        nil
+    end
+
+    ##
+    # Return a SharedContext one level deeper in causality.
+    #
+    # NOTE WELL: THIS RETURNS A NEW SharedContext RATHER THAN MODIFYING THIS ONE. It is NOT SUPPORTED
+    # to modify the causality level of a SharedContext in place.
+    #
+
+    def start_span()
+        
+        self.tick()
+        newContext = ::Quark.mdk_protocol.SharedContext.decode(self.encode())
+        (newContext)._lastEntry = (newContext).clock.enter()
+        return newContext
+
+        nil
+    end
+
+    ##
+    # Return a SharedContext one level higher in causality. In practice, most callers should probably stop
+    # using this context, and the new one, after calling this method.
+    #
+    # NOTE WELL: THIS RETURNS A NEW SharedContext RATHER THAN MODIFYING THIS ONE. It is NOT SUPPORTED
+    # to modify the causality level of a SharedContext in place.
+    #
+
+    def finish_span()
+        
+        newContext = ::Quark.mdk_protocol.SharedContext.decode(self.encode())
+        (newContext)._lastEntry = (newContext).clock.leave((newContext)._lastEntry)
+        return newContext
+
+        nil
+    end
+
+    ##
+    # Return a copy of a SharedContext.
+
+    def copy()
+        
+        return ::Quark.mdk_protocol.SharedContext.decode(self.encode())
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.SharedContext"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("traceId"))
+            return (self).traceId
+        end
+        if ((name) == ("clock"))
+            return (self).clock
+        end
+        if ((name) == ("properties"))
+            return (self).properties
+        end
+        if ((name) == ("_lastEntry"))
+            return (self)._lastEntry
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("traceId"))
+            (self).traceId = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("clock"))
+            (self).clock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.LamportClock }
+        end
+        if ((name) == ("properties"))
+            (self).properties = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("_lastEntry"))
+            (self)._lastEntry = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.traceId = ::Quark.quark.concurrent.Context.runtime().uuid()
+        self.clock = ::Quark.mdk_protocol.LamportClock.new()
+        self.properties = {}
+        self._lastEntry = 0
+
+        nil
+    end
+
+
+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
+    attr_accessor :version, :properties
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["open", "mdk.protocol.Open", "discovery.protocol.Open"])) }
+    static mdk_protocol_Open_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatch(handler)
+        
+        handler.onOpen(self)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.Open"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_protocol.Open._discriminator
+        end
+        if ((name) == ("version"))
+            return (self).version
+        end
+        if ((name) == ("properties"))
+            return (self).properties
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_protocol.Open._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+        if ((name) == ("version"))
+            (self).version = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("properties"))
+            (self).properties = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.version = "2.0.0"
+        self.properties = {}
+
+        nil
+    end
+
+
+end
+Open.unlazy_statics
+
+def self.ProtocolError; ProtocolError; end
+##
+# A value class for sending error informationto a remote peer.
+
+class ProtocolError < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :code, :title, :detail, :id
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_ProtocolError_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_protocol.ProtocolError"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("code"))
+            return (self).code
+        end
+        if ((name) == ("title"))
+            return (self).title
+        end
+        if ((name) == ("detail"))
+            return (self).detail
+        end
+        if ((name) == ("id"))
+            return (self).id
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("code"))
+            (self).code = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("title"))
+            (self).title = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("detail"))
+            (self).detail = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("id"))
+            (self).id = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.code = nil
+        self.title = nil
+        self.detail = nil
+        self.id = nil
+
+        nil
+    end
+
+
+end
+ProtocolError.unlazy_statics
+
+def self.Close; Close; end
+##
+# Close the event stream.
+
+class Close < ::Quark.mdk_protocol.ProtocolEvent
+    attr_accessor :error
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["close", "mdk.protocol.Close", "discovery.protocol.Close"])) }
+    static mdk_protocol_Close_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatch(handler)
+        
+        handler.onClose(self)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.Close"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_protocol.Close._discriminator
+        end
+        if ((name) == ("error"))
+            return (self).error
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_protocol.Close._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+        if ((name) == ("error"))
+            (self).error = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.ProtocolError }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.error = nil
+
+        nil
+    end
+
+
+end
+Close.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, :sockUrl, :lastConnectAttempt, :lastHeartbeat, :timeService, :schedulingActor, :websockets, :dispatcher
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_protocol_WSClient_ref: -> { nil }
+
+
+
+    def initialize(runtime)
+        
+        self.__init_fields__
+        (self).dispatcher = (runtime).dispatcher
+        (self).timeService = runtime.getTimeService()
+        (self).schedulingActor = runtime.getScheduleService()
+        (self).websockets = runtime.getWebSocketsService()
+
+        nil
+    end
+
+
+
+
+    def url()
+        raise NotImplementedError, '`WSClient.url` is an abstract method'
+
+        nil
+    end
+
+    def token()
+        raise NotImplementedError, '`WSClient.token` is an abstract method'
+
+        nil
+    end
+
+    def isStarted()
+        raise NotImplementedError, '`WSClient.isStarted` is an abstract method'
+
+        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
+
+    def onOpen(open)
+        
+        nil
+
+        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 onClose(close)
+        
+        @logger.info(("close: ") + ((close).to_s))
+        if (((close).error) == (nil))
+            @reconnectDelay = @firstDelay
+        else
+            self.doBackoff()
+        end
+
+        nil
+    end
+
+    def onStart(dispatcher)
+        
+        self.schedule(0.0)
+
+        nil
+    end
+
+    def onStop()
+        
+        if (self.isConnected())
+            self.shutdown()
+            (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSClose.new(), @sock)
+            @sock = ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_runtime.WSActor }
+        end
+
+        nil
+    end
+
+    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 }
+            self.onWSMessage((wsmessage).body)
+            return
+        end
+
+        nil
+    end
+
+    def onScheduledEvent()
+        
+        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
+        end
+        if (self.isStarted())
+            self.schedule(@tick)
+        end
+
+        nil
+    end
+
+    def doOpen()
+        
+        self.open(self.url())
+        @lastConnectAttempt = (((self).timeService.time()) * (1000.0)).round()
+
+        nil
+    end
+
+    def doHeartbeat()
+        
+        self.heartbeat()
+        @lastHeartbeat = (((self).timeService.time()) * (1000.0)).round()
+
+        nil
+    end
+
+    def open(url)
+        
+        @sockUrl = url
+        tok = self.token()
+        if ((tok) != (nil))
+            url = ((url) + ("?token=")) + (tok)
+        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([])))
+
+        nil
+    end
+
+    def startup()
+        
+        nil
+
+        nil
+    end
+
+    def pump()
+        
+        nil
+
+        nil
+    end
+
+    def heartbeat()
+        
+        nil
+
+        nil
+    end
+
+    def shutdown()
+        
+        nil
+
+        nil
+    end
+
+    def onWSMessage(message)
+        
+        nil
+
+        nil
+    end
+
+    def onWSConnected(socket)
+        
+        @logger.info(((("connected to ") + (@sockUrl)) + (" via ")) + ((socket).to_s))
+        @reconnectDelay = @firstDelay
+        @sock = socket
+        (self).dispatcher.tell(self, ::Quark.mdk_protocol.Open.new().encode(), @sock)
+        self.startup()
+        self.pump()
+
+        nil
+    end
+
+    def onWSError(error)
+        
+        @logger.error(("onWSError in protocol! ") + (error.toString()))
+        self.doBackoff()
+
+        nil
+    end
+
+    def onWSClosed()
+        
+        @logger.info(("closed ") + (@sockUrl))
+        @sock = ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_runtime.WSActor }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_protocol.WSClient"
+
+        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
+        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
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.logger = ::Quark.quark._getLogger("protocol")
+        self.firstDelay = 1.0
+        self.maxDelay = 16.0
+        self.reconnectDelay = @firstDelay
+        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
+
+        nil
+    end
+
+
+end
+WSClient.unlazy_statics
+end # module MdkProtocol
+end # module Quark