datawire_mdk 2.0.5

data/lib/mdk_discovery.rb

@@ -0,0 +1,1518 @@
+# 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
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'datawire_mdk_md' # 0 () ()
+require_relative 'mdk_runtime/actors' # 0 ('mdk_runtime',) ()
+require_relative 'mdk_runtime' # 0 () ()
+require_relative 'mdk_runtime/promise' # 0 ('mdk_runtime',) ()
+require_relative 'quark' # 0 () ()
+require_relative 'mdk_util' # 0 () ()
+require_relative 'mdk_discovery/protocol' # 0 ('mdk_discovery',) ()
+require_relative 'mdk_discovery/synapse' # 0 ('mdk_discovery',) ()
+
+
+def self.NodeActive; NodeActive; end
+##
+# Message from DiscoverySource: a node has become active.
+
+class NodeActive < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :node
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_NodeActive_ref: -> { nil }
+
+
+
+    def initialize(node)
+        
+        self.__init_fields__
+        (self).node = node
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_discovery.NodeActive"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("node"))
+            return (self).node
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("node"))
+            (self).node = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Node }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.node = nil
+
+        nil
+    end
+
+
+end
+NodeActive.unlazy_statics
+
+def self.NodeExpired; NodeExpired; end
+##
+# Message from DiscoverySource: a node has expired.
+
+class NodeExpired < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :node
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_NodeExpired_ref: -> { nil }
+
+
+
+    def initialize(node)
+        
+        self.__init_fields__
+        (self).node = node
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_discovery.NodeExpired"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("node"))
+            return (self).node
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("node"))
+            (self).node = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Node }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.node = nil
+
+        nil
+    end
+
+
+end
+NodeExpired.unlazy_statics
+
+def self.ReplaceCluster; ReplaceCluster; end
+##
+# Message from DiscoverySource: replace all nodes in a particular Cluster.
+
+class ReplaceCluster < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :nodes, :cluster
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_ReplaceCluster_ref: -> { nil }
+
+
+
+    def initialize(cluster, nodes)
+        
+        self.__init_fields__
+        (self).nodes = nodes
+        (self).cluster = cluster
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_discovery.ReplaceCluster"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("nodes"))
+            return (self).nodes
+        end
+        if ((name) == ("cluster"))
+            return (self).cluster
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("nodes"))
+            (self).nodes = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("cluster"))
+            (self).cluster = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.nodes = nil
+        self.cluster = nil
+
+        nil
+    end
+
+
+end
+ReplaceCluster.unlazy_statics
+
+def self.DiscoverySource; DiscoverySource; end
+##
+# A source of discovery information.
+#
+# Sends ReplaceCluster, NodeActive and NodeExpired messages to a
+# subscriber.
+#
+
+class DiscoverySource < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_DiscoverySource_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+DiscoverySource.unlazy_statics
+
+def self.DiscoverySourceFactory; DiscoverySourceFactory; end
+##
+# A factory for DiscoverySource instances.
+
+class DiscoverySourceFactory < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_DiscoverySourceFactory_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Create a new instance
+
+    def create(subscriber, runtime)
+        raise NotImplementedError, '`DiscoverySourceFactory.create` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # If true, the returned DiscoverySource is also a DiscoveryRegistrar.
+    #
+
+    def isRegistrar()
+        raise NotImplementedError, '`DiscoverySourceFactory.isRegistrar` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+DiscoverySourceFactory.unlazy_statics
+
+def self.RegisterNode; RegisterNode; end
+##
+# Message sent to DiscoveryRegistrar Actor to register a node.
+
+class RegisterNode < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :node
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_RegisterNode_ref: -> { nil }
+
+
+
+    def initialize(node)
+        
+        self.__init_fields__
+        (self).node = node
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_discovery.RegisterNode"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("node"))
+            return (self).node
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("node"))
+            (self).node = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Node }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.node = nil
+
+        nil
+    end
+
+
+end
+RegisterNode.unlazy_statics
+
+def self.DiscoveryRegistrar; DiscoveryRegistrar; end
+##
+# Allow registration of services.
+#
+# Send this an actor a RegisterNode message to do so.
+#
+
+class DiscoveryRegistrar < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_DiscoveryRegistrar_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+DiscoveryRegistrar.unlazy_statics
+
+def self._Request; Request; end
+class Request < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :version, :factory
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery__Request_ref: -> { nil }
+
+
+
+    def initialize(version, factory)
+        
+        self.__init_fields__
+        (self).version = version
+        (self).factory = factory
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_discovery._Request"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("version"))
+            return (self).version
+        end
+        if ((name) == ("factory"))
+            return (self).factory
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("version"))
+            (self).version = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("factory"))
+            (self).factory = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.promise.PromiseResolver }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.version = nil
+        self.factory = nil
+
+        nil
+    end
+
+
+end
+Request.unlazy_statics
+
+def self.FailurePolicy; FailurePolicy; end
+##
+# A policy for choosing how to deal with failures.
+
+class FailurePolicy < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_FailurePolicy_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Record a success for the Node this policy is managing.
+
+    def success()
+        raise NotImplementedError, '`FailurePolicy.success` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Record a failure for the Node this policy is managing.
+
+    def failure()
+        raise NotImplementedError, '`FailurePolicy.failure` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Return whether the Node should be accessed.
+
+    def available()
+        raise NotImplementedError, '`FailurePolicy.available` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+FailurePolicy.unlazy_statics
+
+def self.FailurePolicyFactory; FailurePolicyFactory; end
+##
+# A factory for FailurePolicy.
+
+class FailurePolicyFactory < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_FailurePolicyFactory_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Create a new FailurePolicy.
+
+    def create()
+        raise NotImplementedError, '`FailurePolicyFactory.create` is an abstract method'
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.FailurePolicyFactory"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+FailurePolicyFactory.unlazy_statics
+
+def self.CircuitBreaker; CircuitBreaker; end
+##
+# Default circuit breaker policy.
+
+class CircuitBreaker < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_log, :_threshold, :_delay, :_time, :_mutex, :_failed, :_failures, :_lastFailure
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_CircuitBreaker_ref: -> { nil }
+
+
+
+    def initialize(time, threshold, retestDelay)
+        
+        self.__init_fields__
+        @_threshold = threshold
+        @_delay = retestDelay
+        @_time = time
+
+        nil
+    end
+
+
+
+
+    def success()
+        
+        @_mutex.acquire()
+        @_failed = false
+        @_failures = 0
+        @_lastFailure = 0.0
+        @_mutex.release()
+
+        nil
+    end
+
+    def failure()
+        
+        @_mutex.acquire()
+        @_failures = (@_failures) + (1)
+        @_lastFailure = @_time.time()
+        if (((@_threshold) != (0)) && ((@_failures) >= (@_threshold)))
+            @_log.info("BREAKER TRIPPED.")
+            @_failed = true
+        end
+        @_mutex.release()
+
+        nil
+    end
+
+    def available()
+        
+        if (@_failed)
+            @_mutex.acquire()
+            result = ((@_time.time()) - (@_lastFailure)) > (@_delay)
+            @_mutex.release()
+            if (result)
+                @_log.info("BREAKER RETEST.")
+            end
+            return result
+        else
+            return true
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.CircuitBreaker"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_log"))
+            return (self)._log
+        end
+        if ((name) == ("_threshold"))
+            return (self)._threshold
+        end
+        if ((name) == ("_delay"))
+            return (self)._delay
+        end
+        if ((name) == ("_time"))
+            return (self)._time
+        end
+        if ((name) == ("_mutex"))
+            return (self)._mutex
+        end
+        if ((name) == ("_failed"))
+            return (self)._failed
+        end
+        if ((name) == ("_failures"))
+            return (self)._failures
+        end
+        if ((name) == ("_lastFailure"))
+            return (self)._lastFailure
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_log"))
+            (self)._log = value
+        end
+        if ((name) == ("_threshold"))
+            (self)._threshold = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_delay"))
+            (self)._delay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("_time"))
+            (self)._time = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.Time }
+        end
+        if ((name) == ("_mutex"))
+            (self)._mutex = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("_failed"))
+            (self)._failed = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("_failures"))
+            (self)._failures = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_lastFailure"))
+            (self)._lastFailure = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._log = ::Quark.quark._getLogger("mdk.breaker")
+        self._threshold = nil
+        self._delay = nil
+        self._time = nil
+        self._mutex = ::DatawireQuarkCore::Lock.new()
+        self._failed = false
+        self._failures = 0
+        self._lastFailure = 0.0
+
+        nil
+    end
+
+
+end
+CircuitBreaker.unlazy_statics
+
+def self.CircuitBreakerFactory; CircuitBreakerFactory; end
+##
+# Create CircuitBreaker instances.
+
+class CircuitBreakerFactory < ::Quark.mdk_discovery.FailurePolicyFactory
+    attr_accessor :threshold, :retestDelay, :time
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_CircuitBreakerFactory_ref: -> { nil }
+
+
+
+    def initialize(runtime)
+        
+        super()
+        (self).time = runtime.getTimeService()
+
+        nil
+    end
+
+
+
+
+    def create()
+        
+        return ::Quark.mdk_discovery.CircuitBreaker.new(@time, @threshold, @retestDelay)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.CircuitBreakerFactory"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("threshold"))
+            return (self).threshold
+        end
+        if ((name) == ("retestDelay"))
+            return (self).retestDelay
+        end
+        if ((name) == ("time"))
+            return (self).time
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("threshold"))
+            (self).threshold = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("retestDelay"))
+            (self).retestDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("time"))
+            (self).time = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.Time }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.threshold = 3
+        self.retestDelay = 30.0
+        self.time = nil
+
+        nil
+    end
+
+
+end
+CircuitBreakerFactory.unlazy_statics
+
+def self.Cluster; Cluster; end
+##
+# A Cluster is a group of providers of (possibly different versions of)
+# a single service. Each service provider is represented by a Node.
+
+class Cluster < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :nodes, :_waiting, :_failurepolicies, :_counter, :_fpfactory
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_discovery__Request__ref: -> { nil }
+    static quark_Map_quark_String_mdk_discovery_FailurePolicy__ref: -> { nil }
+    static mdk_discovery_Cluster_ref: -> { nil }
+
+
+
+    def initialize(fpfactory)
+        
+        self.__init_fields__
+        (self)._fpfactory = fpfactory
+
+        nil
+    end
+
+
+
+
+    ##
+    # Choose a single Node to talk to. At present this is a simple round
+    # robin.
+
+    def choose()
+        
+        return self.chooseVersion(nil)
+
+        nil
+    end
+
+    ##
+    # Create a Node for external use.
+
+    def _copyNode(node)
+        
+        result = ::Quark.mdk_discovery.Node.new()
+        (result).address = (node).address
+        (result).version = (node).version
+        (result).service = (node).service
+        (result).properties = (node).properties
+        (result)._policy = self.failurePolicy(node)
+        return result
+
+        nil
+    end
+
+    ##
+    # Get the FailurePolicy for a Node.
+
+    def failurePolicy(node)
+        
+        return ((self)._failurepolicies)[(node).address]
+
+        nil
+    end
+
+    ##
+    # Choose a compatible version of a service to talk to.
+
+    def chooseVersion(version)
+        
+        if (((@nodes).size) == (0))
+            return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_discovery.Node }
+        end
+        start = (@_counter) % ((@nodes).size)
+        @_counter = (@_counter) + (1)
+        count = 0
+        while ((count) < ((@nodes).size)) do
+            choice = ((start) + (count)) % ((@nodes).size)
+            candidate = (@nodes)[choice]
+            policy = ((self)._failurepolicies)[(candidate).address]
+            if ((::Quark.mdk_util.versionMatch(version, (candidate).version)) && (policy.available()))
+                return self._copyNode(candidate)
+            end
+            count = (count) + (1)
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_discovery.Node }
+
+        nil
+    end
+
+    ##
+    # Add a Node to the cluster (or, if it's already present in the cluster,
+    # update its properties).  At present, this involves a linear search, so
+    # very large Clusters are unlikely to perform well.
+
+    def add(node)
+        
+        if (!((@_failurepolicies).key?((node).address)))
+            (@_failurepolicies)[(node).address] = ((self)._fpfactory.create())
+        end
+        if ((((self)._waiting).size) > (0))
+            waiting = (self)._waiting
+            (self)._waiting = ::DatawireQuarkCore::List.new([])
+            jdx = 0
+            while ((jdx) < ((waiting).size)) do
+                req = (waiting)[jdx]
+                if (::Quark.mdk_util.versionMatch((req).version, (node).version))
+                    (req).factory.resolve(self._copyNode(node))
+                else
+                    ((self)._waiting) << (req)
+                end
+                jdx = (jdx) + (1)
+            end
+        end
+        idx = 0
+        while ((idx) < ((@nodes).size)) do
+            if ((((@nodes)[idx]).address) == ((node).address))
+                (@nodes)[idx] = (node)
+                return
+            end
+            idx = (idx) + (1)
+        end
+        (@nodes) << (node)
+
+        nil
+    end
+
+    def _addRequest(version, factory)
+        
+        (@_waiting) << (::Quark.mdk_discovery._Request.new(version, factory))
+
+        nil
+    end
+
+    ##
+    # Remove a Node from the cluster, if it's present. If it's not present, do
+    # nothing. Note that it is possible to remove all the Nodes and be left with
+    # an empty cluster.
+
+    def remove(node)
+        
+        idx = 0
+        while ((idx) < ((@nodes).size)) do
+            ep = (@nodes)[idx]
+            if ((((ep).address) == (nil)) || (((ep).address) == ((node).address)))
+                (@nodes).delete_at(idx)
+                return
+            end
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    ##
+    # Returns true if and only if this Cluster contains no Nodes.
+
+    def isEmpty()
+        
+        return ((@nodes).size) <= (0)
+
+        nil
+    end
+
+    ##
+    # Return a string representation of the Cluster.
+    #
+    # WARNING: every Node is represented in the string. Large Clusters will
+    # produce unusably large strings.
+
+    def toString()
+        
+        result = "Cluster("
+        idx = 0
+        while ((idx) < ((@nodes).size)) do
+            if ((idx) > (0))
+                result = (result) + (", ")
+            end
+            result = (result) + ((@nodes)[idx].toString())
+            idx = (idx) + (1)
+        end
+        result = (result) + (")")
+        return result
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.Cluster"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("nodes"))
+            return (self).nodes
+        end
+        if ((name) == ("_waiting"))
+            return (self)._waiting
+        end
+        if ((name) == ("_failurepolicies"))
+            return (self)._failurepolicies
+        end
+        if ((name) == ("_counter"))
+            return (self)._counter
+        end
+        if ((name) == ("_fpfactory"))
+            return (self)._fpfactory
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("nodes"))
+            (self).nodes = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_waiting"))
+            (self)._waiting = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_failurepolicies"))
+            (self)._failurepolicies = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("_counter"))
+            (self)._counter = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_fpfactory"))
+            (self)._fpfactory = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.FailurePolicyFactory }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.nodes = ::DatawireQuarkCore::List.new([])
+        self._waiting = ::DatawireQuarkCore::List.new([])
+        self._failurepolicies = {}
+        self._counter = 0
+        self._fpfactory = nil
+
+        nil
+    end
+
+
+end
+Cluster.unlazy_statics
+
+def self.Node; Node; end
+##
+# The Node class captures address and metadata information about a
+# server functioning as a service instance.
+
+class Node < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :service, :version, :address, :properties, :_policy
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_Node_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def success()
+        
+        @_policy.success()
+
+        nil
+    end
+
+    def failure()
+        
+        @_policy.failure()
+
+        nil
+    end
+
+    def available()
+        
+        return @_policy.available()
+
+        nil
+    end
+
+    ##
+    # Return a string representation of the Node.
+
+    def toString()
+        
+        result = "Node("
+        if ((@service) == (nil))
+            result = (result) + ("<unnamed>")
+        else
+            result = (result) + (@service)
+        end
+        result = (result) + (": ")
+        if ((@address) == (nil))
+            result = (result) + ("<unlocated>")
+        else
+            result = (result) + (@address)
+        end
+        if ((@version) != (nil))
+            result = ((result) + (", ")) + (@version)
+        end
+        result = (result) + (")")
+        if ((@properties) != (nil))
+            result = ((result) + (" ")) + ((@properties).to_s)
+        end
+        return result
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.Node"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("service"))
+            return (self).service
+        end
+        if ((name) == ("version"))
+            return (self).version
+        end
+        if ((name) == ("address"))
+            return (self).address
+        end
+        if ((name) == ("properties"))
+            return (self).properties
+        end
+        if ((name) == ("_policy"))
+            return (self)._policy
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("service"))
+            (self).service = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("version"))
+            (self).version = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("address"))
+            (self).address = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("properties"))
+            (self).properties = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("_policy"))
+            (self)._policy = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.FailurePolicy }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.service = nil
+        self.version = nil
+        self.address = nil
+        self.properties = {}
+        self._policy = nil
+
+        nil
+    end
+
+
+end
+Node.unlazy_statics
+
+def self.Discovery; Discovery; end
+##
+# The Discovery class functions as a conduit to a source of discovery information.
+# Using it, a provider can register itself as providing a particular service
+# (see the register method) and a consumer can locate a provider for a
+# particular service (see the resolve method).
+
+class Discovery < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :logger, :services, :started, :mutex, :runtime, :_fpfactory
+    extend ::DatawireQuarkCore::Static
+
+    static quark_ListUtil_mdk_discovery_Node__ref: -> { nil }
+    static quark_Map_quark_String_mdk_discovery_Cluster__ref: -> { nil }
+    static mdk_discovery_Discovery_ref: -> { nil }
+
+
+
+    ##
+    # Construct a Discovery object. You must set the token before doing
+    # anything else; see the withToken() method.
+
+    def initialize(runtime)
+        
+        self.__init_fields__
+        @logger.info("Discovery created!")
+        (self).runtime = runtime
+        (self)._fpfactory = ::DatawireQuarkCore.cast((runtime).dependencies.getService("failurepolicy_factory")) { ::Quark.mdk_discovery.FailurePolicyFactory }
+
+        nil
+    end
+
+
+
+
+    ##
+    # Lock.
+
+    def _lock()
+        
+        @mutex.acquire()
+
+        nil
+    end
+
+    def _release()
+        
+        @mutex.release()
+
+        nil
+    end
+
+    ##
+    # Start the uplink to the discovery service.
+
+    def onStart(dispatcher)
+        
+        self._lock()
+        if (!(@started))
+            @started = true
+        end
+        self._release()
+
+        nil
+    end
+
+    ##
+    # Stop the uplink to the discovery service.
+
+    def onStop()
+        
+        self._lock()
+        if (@started)
+            @started = false
+        end
+        self._release()
+
+        nil
+    end
+
+    ##
+    # Register info about a service node with a discovery source of truth. You must
+    # usually start the uplink before this will do much; see start().
+
+    def register(node)
+        
+        registrar = nil
+        if ((@runtime).dependencies.hasService("discovery_registrar"))
+            registrar = ::DatawireQuarkCore.cast((@runtime).dependencies.getService("discovery_registrar")) { ::Quark.mdk_discovery.DiscoveryRegistrar }
+        else
+            raise ("Registration not supported as no Discovery Registrar was setup.")
+        end
+        ((self).runtime).dispatcher.tell(self, ::Quark.mdk_discovery.RegisterNode.new(node), registrar)
+        return self
+
+        nil
+    end
+
+    ##
+    # Register info about a service node with the discovery service. You must
+    # usually start the uplink before this will do much; see start().
+
+    def register_service(service, address, version)
+        
+        node = ::Quark.mdk_discovery.Node.new()
+        (node).service = service
+        (node).address = address
+        (node).version = version
+        return self.register(node)
+
+        nil
+    end
+
+    ##
+    # Return the current known Nodes for a service, if any.
+
+    def knownNodes(service)
+        
+        if (!((@services).key?(service)))
+            return ::DatawireQuarkCore::List.new([])
+        end
+        return ((@services)[service]).nodes
+
+        nil
+    end
+
+    ##
+    # Get the FailurePolicy for a Node.
+
+    def failurePolicy(node)
+        
+        return (@services)[(node).service].failurePolicy(node)
+
+        nil
+    end
+
+    ##
+    # Resolve a service name into an available service node. You must
+    # usually start the uplink before this will do much; see start().
+    # The returned Promise will end up with a Node as its value.
+
+    def _resolve(service, version)
+        
+        factory = ::Quark.mdk_runtime.promise.PromiseResolver.new((@runtime).dispatcher)
+        self._lock()
+        if (!((@services).key?(service)))
+            (@services)[service] = (::Quark.mdk_discovery.Cluster.new((self)._fpfactory))
+        end
+        result = (@services)[service].chooseVersion(version)
+        if ((result) == (nil))
+            (@services)[service]._addRequest(version, factory)
+            self._release()
+        else
+            self._release()
+            factory.resolve(result)
+        end
+        return (factory).promise
+
+        nil
+    end
+
+    ##
+    # Resolve a service; return a (Bluebird) Promise on Javascript. Does not work elsewhere.
+
+    def resolve(service, version)
+        
+        return ::Quark.mdk_util.toNativePromise(self._resolve(service, version))
+
+        nil
+    end
+
+    ##
+    # Wait for service name to resolve into an available service node, or fail
+    # appropriately (typically by raising an exception if the language
+    # supports it). This should only be used in blocking runtimes (e.g.
+    # you do not want to use this in Javascript).
+
+    def resolve_until(service, version, timeout)
+        
+        return ::DatawireQuarkCore.cast(::Quark.mdk_util.WaitForPromise.wait(self._resolve(service, version), timeout, ("service ") + (service))) { ::Quark.mdk_discovery.Node }
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        klass = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        if ((klass) == ("mdk_discovery.NodeActive"))
+            active = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.NodeActive }
+            self._active((active).node)
+            return
+        end
+        if ((klass) == ("mdk_discovery.NodeExpired"))
+            expire = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.NodeExpired }
+            self._expire((expire).node)
+            return
+        end
+        if ((klass) == ("mdk_discovery.ReplaceCluster"))
+            replace = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_discovery.ReplaceCluster }
+            self._replace((replace).cluster, (replace).nodes)
+            return
+        end
+
+        nil
+    end
+
+    def _replace(service, nodes)
+        
+        self._lock()
+        @logger.info(((("replacing all nodes for ") + (service)) + (" with ")) + ((nodes).to_s))
+        if (!((@services).key?(service)))
+            (@services)[service] = (::Quark.mdk_discovery.Cluster.new((self)._fpfactory))
+        end
+        cluster = (@services)[service]
+        currentNodes = ::Quark.quark.ListUtil.new().slice((cluster).nodes, 0, ((cluster).nodes).size)
+        idx = 0
+        while ((idx) < ((currentNodes).size)) do
+            cluster.remove((currentNodes)[idx])
+            idx = (idx) + (1)
+        end
+        idx = 0
+        while ((idx) < ((nodes).size)) do
+            cluster.add((nodes)[idx])
+            idx = (idx) + (1)
+        end
+        self._release()
+
+        nil
+    end
+
+    def _active(node)
+        
+        self._lock()
+        service = (node).service
+        @logger.info(("adding ") + (node.toString()))
+        if (!((@services).key?(service)))
+            (@services)[service] = (::Quark.mdk_discovery.Cluster.new((self)._fpfactory))
+        end
+        cluster = (@services)[service]
+        cluster.add(node)
+        self._release()
+
+        nil
+    end
+
+    def _expire(node)
+        
+        self._lock()
+        service = (node).service
+        if ((@services).key?(service))
+            cluster = (@services)[service]
+            @logger.info((("removing ") + (node.toString())) + (" from cluster"))
+            cluster.remove(node)
+        end
+        self._release()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.Discovery"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("services"))
+            return (self).services
+        end
+        if ((name) == ("started"))
+            return (self).started
+        end
+        if ((name) == ("mutex"))
+            return (self).mutex
+        end
+        if ((name) == ("runtime"))
+            return (self).runtime
+        end
+        if ((name) == ("_fpfactory"))
+            return (self)._fpfactory
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("services"))
+            (self).services = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("started"))
+            (self).started = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("mutex"))
+            (self).mutex = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("runtime"))
+            (self).runtime = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.MDKRuntime }
+        end
+        if ((name) == ("_fpfactory"))
+            (self)._fpfactory = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.FailurePolicyFactory }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.logger = ::Quark.quark._getLogger("discovery")
+        self.services = ::Hash.new()
+        self.started = false
+        self.mutex = ::DatawireQuarkCore::Lock.new()
+        self.runtime = nil
+        self._fpfactory = nil
+
+        nil
+    end
+
+
+end
+Discovery.unlazy_statics
+
+
+end # module MdkDiscovery
+end # module Quark