datawire_mdk 2.0.12 → 2.0.13

data/lib/mdk.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-09-12 17:46:24.827506
+# Quark 1.0.443 run at 2016-09-21 13:32:20.805015
 module Quark
 require "quark"
 def self.mdk; Mdk; end
@@ -429,7 +429,7 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         @_reflection_hack = ::Hash.new()
         @_runtime = runtime
         if (!((runtime).dependencies.hasService("failurepolicy_factory")))
-            (runtime).dependencies.registerService("failurepolicy_factory", ::Quark.mdk_discovery.CircuitBreakerFactory.new(runtime))
+            (runtime).dependencies.registerService("failurepolicy_factory", self.getFailurePolicy(runtime))
         end
         @_disco = ::Quark.mdk_discovery.Discovery.new(runtime)
         env = runtime.getEnvVarsService()
@@ -471,7 +471,12 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
             if ((config).start_with?("synapse:path="))
                 result = ::Quark.mdk_discovery.synapse.Synapse.new((config)[(13)...((config).size)])
             else
-                raise (("Unknown MDK discovery source: ") + (config))
+                if ((config).start_with?("static:nodes="))
+                    json = (config)[(13)...((config).size)]
+                    result = ::Quark.mdk_discovery.StaticRoutes.parseJSON(json)
+                else
+                    raise (("Unknown MDK discovery source: ") + (config))
+                end
             end
         end
         return result
@@ -479,6 +484,21 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
         nil
     end
 
+    ##
+    # Choose FailurePolicy based on environment variables.
+
+    def getFailurePolicy(runtime)
+        
+        config = runtime.getEnvVarsService().var("MDK_FAILURE_POLICY").orElseGet("")
+        if ((config) == ("recording"))
+            return ::Quark.mdk_discovery.RecordingFailurePolicyFactory.new()
+        else
+            return ::Quark.mdk_discovery.CircuitBreakerFactory.new(runtime)
+        end
+
+        nil
+    end
+
     def _timeout()
         
         return 10.0
@@ -621,13 +641,70 @@ class MDKImpl < ::DatawireQuarkCore::QuarkObject
 end
 MDKImpl.unlazy_statics
 
+def self._TLSInit; TLSInit; end
+class TLSInit < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk__TLSInit_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getValue()
+        
+        return false
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk._TLSInit"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+TLSInit.unlazy_statics
+
 def self.SessionImpl; SessionImpl; end
 class SessionImpl < ::DatawireQuarkCore::QuarkObject
     attr_accessor :_mdk, :_resolved, :_context, :_experimental
     extend ::DatawireQuarkCore::Static
 
     static _levels: -> { {"CRITICAL" => 0, "ERROR" => 1, "WARN" => 2, "INFO" => 3, "DEBUG" => 4} }
+    static _inLogging: -> { ::DatawireQuarkCore::TLS.new(::Quark.mdk._TLSInit.new()) }
     static mdk_SessionImpl_ref: -> { nil }
+    static quark_List_quark_List_mdk_discovery_Node___ref: -> { nil }
     static quark_List_mdk_discovery_Node__ref: -> { nil }
     static quark_List_quark_Map_quark_String_quark_String___ref: -> { nil }
     static quark_List_quark_String__ref: -> { nil }
@@ -730,8 +807,13 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def _log(level, category, text)
         
         if (((@_mdk)._tracer) != (nil))
+            if (::Quark.mdk.SessionImpl._inLogging.getValue())
+                return
+            end
+            ::Quark.mdk.SessionImpl._inLogging.setValue(true)
             (@_mdk)._tracer.setContext(@_context)
             (@_mdk)._tracer.log((@_mdk).procUUID, level, category, text)
+            ::Quark.mdk.SessionImpl._inLogging.setValue(false)
         end
 
         nil
@@ -740,7 +822,6 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def critical(category, text)
         
         if (self._enabled("CRITICAL"))
-            (@_mdk).logger.error(((category) + (": ")) + (text))
             self._log("CRITICAL", category, text)
         end
 
@@ -750,7 +831,6 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def error(category, text)
         
         if (self._enabled("ERROR"))
-            (@_mdk).logger.error(((category) + (": ")) + (text))
             self._log("ERROR", category, text)
         end
 
@@ -760,7 +840,6 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def warn(category, text)
         
         if (self._enabled("WARN"))
-            (@_mdk).logger.warn(((category) + (": ")) + (text))
             self._log("WARN", category, text)
         end
 
@@ -770,7 +849,6 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def info(category, text)
         
         if (self._enabled("INFO"))
-            (@_mdk).logger.info(((category) + (": ")) + (text))
             self._log("INFO", category, text)
         end
 
@@ -780,7 +858,6 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def debug(category, text)
         
         if (self._enabled("DEBUG"))
-            (@_mdk).logger.debug(((category) + (": ")) + (text))
             self._log("DEBUG", category, text)
         end
 
@@ -833,15 +910,22 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
 
     def _resolvedCallback(result)
         
-        (@_resolved) << (result)
+        (self._current_interaction()) << (result)
         return result
 
         nil
     end
 
+    def _current_interaction()
+        
+        return (@_resolved)[((@_resolved).size) - (1)]
+
+        nil
+    end
+
     def start_interaction()
         
-        @_resolved = ::DatawireQuarkCore::List.new([])
+        (@_resolved) << (::DatawireQuarkCore::List.new([]))
 
         nil
     end
@@ -864,8 +948,8 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
 
     def fail_interaction(message)
         
-        suspects = @_resolved
-        @_resolved = ::DatawireQuarkCore::List.new([])
+        suspects = self._current_interaction()
+        (@_resolved)[((@_resolved).size) - (1)] = (::DatawireQuarkCore::List.new([]))
         involved = ::DatawireQuarkCore::List.new([])
         idx = 0
         while ((idx) < ((suspects).size)) do
@@ -882,8 +966,8 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
 
     def finish_interaction()
         
-        nodes = @_resolved
-        @_resolved = ::DatawireQuarkCore::List.new([])
+        nodes = self._current_interaction()
+        (@_resolved).delete_at(((@_resolved).size) - (1))
         idx = 0
         while ((idx) < ((nodes).size)) do
             node = (nodes)[idx]
@@ -915,6 +999,9 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_levels"))
             return ::Quark.mdk.SessionImpl._levels
         end
+        if ((name) == ("_inLogging"))
+            return ::Quark.mdk.SessionImpl._inLogging
+        end
         if ((name) == ("_mdk"))
             return (self)._mdk
         end
@@ -937,6 +1024,9 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
         if ((name) == ("_levels"))
             ::Quark.mdk.SessionImpl._levels = ::DatawireQuarkCore.cast(value) { ::Hash }
         end
+        if ((name) == ("_inLogging"))
+            ::Quark.mdk.SessionImpl._inLogging = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::TLS }
+        end
         if ((name) == ("_mdk"))
             (self)._mdk = ::DatawireQuarkCore.cast(value) { ::Quark.mdk.MDKImpl }
         end
@@ -956,7 +1046,7 @@ class SessionImpl < ::DatawireQuarkCore::QuarkObject
     def __init_fields__()
         
         self._mdk = nil
-        self._resolved = ::DatawireQuarkCore::List.new([])
+        self._resolved = ::DatawireQuarkCore::List.new([::DatawireQuarkCore::List.new([])])
         self._context = nil
         self._experimental = false
 

data/lib/mdk_discovery/protocol.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-09-12 17:46:24.827506
+# Quark 1.0.443 run at 2016-09-21 13:32:20.805015
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end

data/lib/mdk_discovery/synapse.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-09-12 17:46:24.827506
+# Quark 1.0.443 run at 2016-09-21 13:32:20.805015
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end

data/lib/mdk_discovery.rb

@@ -1,4 +1,4 @@
-# Quark 1.0.443 run at 2016-09-12 17:46:24.827506
+# Quark 1.0.443 run at 2016-09-21 13:32:20.805015
 module Quark
 require "quark"
 def self.mdk_discovery; MdkDiscovery; end
@@ -7,8 +7,8 @@ require "datawire-quark-core"
 require_relative 'quark/reflect' # 0 ('quark',) ()
 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_runtime/promise' # 0 ('mdk_runtime',) ()
 require_relative 'mdk_util' # 0 () ()
 require_relative 'mdk_discovery/protocol' # 0 ('mdk_discovery',) ()
 require_relative 'mdk_discovery/synapse' # 0 ('mdk_discovery',) ()
@@ -285,6 +285,182 @@ class DiscoverySourceFactory < ::DatawireQuarkCore::QuarkObject
 end
 DiscoverySourceFactory.unlazy_statics
 
+def self._StaticRoutesActor; StaticRoutesActor; end
+##
+# Discovery actor for hard-coded static routes.
+
+class StaticRoutesActor < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_subscriber, :_knownNodes
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery__StaticRoutesActor_ref: -> { nil }
+
+
+
+    def initialize(subscriber, knownNodes)
+        
+        self.__init_fields__
+        (self)._subscriber = subscriber
+        (self)._knownNodes = knownNodes
+
+        nil
+    end
+
+
+
+
+    def onStart(dispatcher)
+        
+        idx = 0
+        while ((idx) < (((self)._knownNodes).size)) do
+            dispatcher.tell(self, ::Quark.mdk_discovery.NodeActive.new(((self)._knownNodes)[idx]), (self)._subscriber)
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        nil
+
+        nil
+    end
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery._StaticRoutesActor"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_subscriber"))
+            return (self)._subscriber
+        end
+        if ((name) == ("_knownNodes"))
+            return (self)._knownNodes
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_subscriber"))
+            (self)._subscriber = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("_knownNodes"))
+            (self)._knownNodes = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._subscriber = nil
+        self._knownNodes = nil
+
+        nil
+    end
+
+
+end
+StaticRoutesActor.unlazy_statics
+
+def self.StaticRoutes; StaticRoutes; end
+##
+# Create a DiscoverySource with hard-coded static routes.
+
+class StaticRoutes < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_knownNodes
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_StaticRoutes_ref: -> { nil }
+
+
+
+    def initialize(knowNodes)
+        
+        self.__init_fields__
+        (self)._knownNodes = knowNodes
+
+        nil
+    end
+
+
+
+
+    def self.parseJSON(json_encoded)
+        
+        nodes = ::DatawireQuarkCore::List.new([])
+        ::Quark.quark.fromJSON(::Quark.quark.reflect.QuarkClass.get("quark.List<mdk_discovery.Node>"), nodes, ::DatawireQuarkCore::JSONObject.parse(json_encoded))
+        return ::Quark.mdk_discovery.StaticRoutes.new(nodes)
+
+        nil
+    end
+
+    def isRegistrar()
+        
+        return false
+
+        nil
+    end
+
+    def create(subscriber, runtime)
+        
+        return ::Quark.mdk_discovery._StaticRoutesActor.new(subscriber, (self)._knownNodes)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.StaticRoutes"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_knownNodes"))
+            return (self)._knownNodes
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_knownNodes"))
+            (self)._knownNodes = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._knownNodes = nil
+
+        nil
+    end
+
+
+end
+StaticRoutes.unlazy_statics
+
 def self.RegisterNode; RegisterNode; end
 ##
 # Message sent to DiscoveryRegistrar Actor to register a node.
@@ -795,6 +971,152 @@ class CircuitBreakerFactory < ::Quark.mdk_discovery.FailurePolicyFactory
 end
 CircuitBreakerFactory.unlazy_statics
 
+def self.RecordingFailurePolicy; RecordingFailurePolicy; end
+##
+# FailurePolicy that records failures and successes.
+
+class RecordingFailurePolicy < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :successes, :failures
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_RecordingFailurePolicy_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def success()
+        
+        (self).successes = ((self).successes) + (1)
+
+        nil
+    end
+
+    def failure()
+        
+        (self).failures = ((self).failures) + (1)
+
+        nil
+    end
+
+    def available()
+        
+        return true
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.RecordingFailurePolicy"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("successes"))
+            return (self).successes
+        end
+        if ((name) == ("failures"))
+            return (self).failures
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("successes"))
+            (self).successes = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("failures"))
+            (self).failures = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.successes = 0
+        self.failures = 0
+
+        nil
+    end
+
+
+end
+RecordingFailurePolicy.unlazy_statics
+
+def self.RecordingFailurePolicyFactory; RecordingFailurePolicyFactory; end
+##
+# Factory for FailurePolicy useful for testing.
+
+class RecordingFailurePolicyFactory < ::Quark.mdk_discovery.FailurePolicyFactory
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_RecordingFailurePolicyFactory_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def create()
+        
+        return ::Quark.mdk_discovery.RecordingFailurePolicy.new()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.RecordingFailurePolicyFactory"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+RecordingFailurePolicyFactory.unlazy_statics
+
 def self.Cluster; Cluster; end
 ##
 # A Cluster is a group of providers of (possibly different versions of)