datawire_mdk 2.0.5

data/lib/mdk_discovery/protocol.rb

@@ -0,0 +1,818 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_discovery; MdkDiscovery; end
+module MdkDiscovery
+def self.protocol; Protocol; end
+module Protocol
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_discovery',)
+require_relative '../mdk_discovery' # 0 () ('mdk_discovery',)
+require_relative '../mdk_runtime/actors' # 0 ('mdk_runtime',) ('mdk_discovery',)
+require_relative '../mdk_runtime' # 0 () ('mdk_discovery',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_discovery',)
+require_relative '../mdk_protocol' # 0 () ('mdk_discovery',)
+require_relative '../quark' # 0 () ('mdk_discovery',)
+
+
+def self.DiscoClientFactory; DiscoClientFactory; end
+##
+# Create a Discovery service client using standard MDK env variables and
+# register it with the MDK.
+#
+
+class DiscoClientFactory < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :token
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_protocol_DiscoClientFactory_ref: -> { nil }
+
+
+
+    def initialize(token)
+        
+        self.__init_fields__
+        (self).token = token
+
+        nil
+    end
+
+
+
+
+    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)
+
+        nil
+    end
+
+    def isRegistrar()
+        
+        return true
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.protocol.DiscoClientFactory"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("token"))
+            return (self).token
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("token"))
+            (self).token = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.token = nil
+
+        nil
+    end
+
+
+end
+DiscoClientFactory.unlazy_statics
+
+def self.DiscoClient; DiscoClient; end
+##
+# A source of discovery information that talks to Datawire Discovery server.
+#
+# Also supports registering discovery information with the server.
+#
+
+class DiscoClient < ::Quark.mdk_protocol.WSClient
+    attr_accessor :_started, :_token, :_url, :_failurePolicyFactory, :_dispatcher, :_subscriber, :registered, :dlog
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_protocol_DiscoClient_ref: -> { nil }
+
+
+
+    def initialize(subscriber, token, url, runtime)
+        
+        super(runtime)
+        (self)._subscriber = subscriber
+        (self)._failurePolicyFactory = ::DatawireQuarkCore.cast((runtime).dependencies.getService("failurepolicy_factory")) { ::Quark.mdk_discovery.FailurePolicyFactory }
+        (self)._token = token
+        (self)._url = url
+
+        nil
+    end
+
+
+
+
+    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()
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        if (((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id) == ("mdk_discovery.RegisterNode"))
+            register = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.RegisterNode }
+            self._register((register).node)
+            return
+        end
+        method(:onMessage).super_method.call(origin, message)
+
+        nil
+    end
+
+    def url()
+        
+        return (self)._url
+
+        nil
+    end
+
+    def token()
+        
+        return (self)._token
+
+        nil
+    end
+
+    def isStarted()
+        
+        return (self)._started
+
+        nil
+    end
+
+    ##
+    # Register a node with the remote Discovery server.
+
+    def _register(node)
+        
+        service = (node).service
+        if (!((@registered).key?(service)))
+            (@registered)[service] = (::Quark.mdk_discovery.Cluster.new((self)._failurePolicyFactory))
+        end
+        (@registered)[service].add(node)
+        if (self.isConnected())
+            self.active(node)
+        end
+
+        nil
+    end
+
+    def active(node)
+        
+        active = ::Quark.mdk_discovery.protocol.Active.new()
+        (active).node = node
+        (active).ttl = (self).ttl
+        (self).dispatcher.tell(self, active.encode(), (self).sock)
+        @dlog.info(("active ") + (node.toString()))
+
+        nil
+    end
+
+    def expire(node)
+        
+        expire = ::Quark.mdk_discovery.protocol.Expire.new()
+        (expire).node = node
+        (self).dispatcher.tell(self, expire.encode(), (self).sock)
+        @dlog.info(("expire ") + (node.toString()))
+
+        nil
+    end
+
+    def resolve(node)
+        
+        nil
+
+        nil
+    end
+
+    def onActive(active)
+        
+        (self)._dispatcher.tell(self, ::Quark.mdk_discovery.NodeActive.new((active).node), (self)._subscriber)
+
+        nil
+    end
+
+    def onExpire(expire)
+        
+        (self)._dispatcher.tell(self, ::Quark.mdk_discovery.NodeExpired.new((expire).node), (self)._subscriber)
+
+        nil
+    end
+
+    def onClear(reset)
+        
+        nil
+
+        nil
+    end
+
+    def startup()
+        
+        self.heartbeat()
+
+        nil
+    end
+
+    def heartbeat()
+        
+        services = ::DatawireQuarkCore::List.new(((self).registered).keys)
+        idx = 0
+        while ((idx) < ((services).size)) do
+            jdx = 0
+            nodes = (((self).registered)[(services)[idx]]).nodes
+            while ((jdx) < ((nodes).size)) do
+                self.active((nodes)[jdx])
+                jdx = (jdx) + (1)
+            end
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    def shutdown()
+        
+        services = ::DatawireQuarkCore::List.new(((self).registered).keys)
+        idx = 0
+        while ((idx) < ((services).size)) do
+            jdx = 0
+            nodes = (((self).registered)[(services)[idx]]).nodes
+            while ((jdx) < ((nodes).size)) do
+                self.expire((nodes)[jdx])
+                jdx = (jdx) + (1)
+            end
+            idx = (idx) + (1)
+        end
+
+        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"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("firstDelay"))
+            return (self).firstDelay
+        end
+        if ((name) == ("maxDelay"))
+            return (self).maxDelay
+        end
+        if ((name) == ("reconnectDelay"))
+            return (self).reconnectDelay
+        end
+        if ((name) == ("ttl"))
+            return (self).ttl
+        end
+        if ((name) == ("tick"))
+            return (self).tick
+        end
+        if ((name) == ("sock"))
+            return (self).sock
+        end
+        if ((name) == ("sockUrl"))
+            return (self).sockUrl
+        end
+        if ((name) == ("lastConnectAttempt"))
+            return (self).lastConnectAttempt
+        end
+        if ((name) == ("lastHeartbeat"))
+            return (self).lastHeartbeat
+        end
+        if ((name) == ("timeService"))
+            return (self).timeService
+        end
+        if ((name) == ("schedulingActor"))
+            return (self).schedulingActor
+        end
+        if ((name) == ("websockets"))
+            return (self).websockets
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("_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) == ("_subscriber"))
+            return (self)._subscriber
+        end
+        if ((name) == ("registered"))
+            return (self).registered
+        end
+        if ((name) == ("dlog"))
+            return (self).dlog
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("firstDelay"))
+            (self).firstDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("maxDelay"))
+            (self).maxDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("reconnectDelay"))
+            (self).reconnectDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("ttl"))
+            (self).ttl = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("tick"))
+            (self).tick = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("sock"))
+            (self).sock = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.WSActor }
+        end
+        if ((name) == ("sockUrl"))
+            (self).sockUrl = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("lastConnectAttempt"))
+            (self).lastConnectAttempt = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("lastHeartbeat"))
+            (self).lastHeartbeat = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("timeService"))
+            (self).timeService = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.Time }
+        end
+        if ((name) == ("schedulingActor"))
+            (self).schedulingActor = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("websockets"))
+            (self).websockets = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.WebSockets }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("_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) == ("_subscriber"))
+            (self)._subscriber = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("registered"))
+            (self).registered = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("dlog"))
+            (self).dlog = value
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self._started = false
+        self._token = nil
+        self._url = nil
+        self._failurePolicyFactory = nil
+        self._dispatcher = nil
+        self._subscriber = nil
+        self.registered = ::Hash.new()
+        self.dlog = ::Quark.quark._getLogger("discovery")
+
+        nil
+    end
+
+
+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
+    attr_accessor :node, :ttl
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["active", "discovery.protocol.Active"])) }
+    static mdk_discovery_protocol_Active_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatchDiscoveryEvent(handler)
+        
+        handler.onActive(self)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.protocol.Active"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_discovery.protocol.Active._discriminator
+        end
+        if ((name) == ("node"))
+            return (self).node
+        end
+        if ((name) == ("ttl"))
+            return (self).ttl
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_discovery.protocol.Active._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+        if ((name) == ("node"))
+            (self).node = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Node }
+        end
+        if ((name) == ("ttl"))
+            (self).ttl = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.node = nil
+        self.ttl = nil
+
+        nil
+    end
+
+
+end
+Active.unlazy_statics
+
+def self.Expire; Expire; end
+##
+# Expire a node.
+
+class Expire < ::Quark.mdk_discovery.protocol.DiscoveryEvent
+    attr_accessor :node
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["expire", "discovery.protocol.Expire"])) }
+    static mdk_discovery_protocol_Expire_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatchDiscoveryEvent(handler)
+        
+        handler.onExpire(self)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.protocol.Expire"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_discovery.protocol.Expire._discriminator
+        end
+        if ((name) == ("node"))
+            return (self).node
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_discovery.protocol.Expire._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+        if ((name) == ("node"))
+            (self).node = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Node }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.node = nil
+
+        nil
+    end
+
+
+end
+Expire.unlazy_statics
+
+def self.Clear; Clear; end
+##
+# Expire all nodes.
+
+class Clear < ::Quark.mdk_discovery.protocol.DiscoveryEvent
+    extend ::DatawireQuarkCore::Static
+
+    static _discriminator: -> { ::Quark.mdk_protocol.anyof(::DatawireQuarkCore::List.new(["clear", "discovery.protocol.Clear"])) }
+    static mdk_discovery_protocol_Clear_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def dispatchDiscoveryEvent(handler)
+        
+        handler.onClear(self)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.protocol.Clear"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_discriminator"))
+            return ::Quark.mdk_discovery.protocol.Clear._discriminator
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_discriminator"))
+            ::Quark.mdk_discovery.protocol.Clear._discriminator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.Discriminator }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+Clear.unlazy_statics
+end # module Protocol
+end # module MdkDiscovery
+end # module Quark