datawire_mdk 2.0.5

data/lib/mdk.rb

@@ -0,0 +1,962 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk; Mdk; end
+module Mdk
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'mdk_runtime' # 0 () ()
+require_relative 'datawire_mdk_md' # 0 () ()
+require_relative 'mdk_discovery' # 0 () ()
+require_relative 'quark' # 0 () ()
+require_relative 'mdk_tracing' # 0 () ()
+require_relative 'quark/concurrent' # 0 ('quark',) ()
+require_relative 'mdk_introspection' # 0 () ()
+require_relative 'mdk_discovery/protocol' # 0 ('mdk_discovery',) ()
+require_relative 'mdk_discovery/synapse' # 0 ('mdk_discovery',) ()
+require_relative 'mdk_protocol' # 0 () ()
+require_relative 'mdk_runtime/promise' # 0 ('mdk_runtime',) ()
+require_relative 'mdk_util' # 0 () ()
+
+
+def self._get(env, name, value)
+    
+    return env.var(name).orElseGet(value)
+
+
+    nil
+end
+
+##
+# Create an unstarted instance of the MDK.
+
+def self.init()
+    
+    return ::Quark.mdk.MDKImpl.new(::Quark.mdk_runtime.defaultRuntime())
+
+
+    nil
+end
+
+##
+# Create a started instance of the MDK. This is equivalent to
+# calling init() followed by start() on the resulting instance.
+#
+
+def self.start()
+    
+    m = ::Quark.mdk.init()
+    m.start()
+    return m
+
+
+    nil
+end
+
+def self.MDK; MDK; end
+##
+# The MDK API consists of two interfaces: MDK and Session. The
+# MDK interface holds globally scoped APIs and state associated
+# with the microservice. The Session interface holds locally
+# scoped APIs and state. A Session must be used sequentially.
+#
+# The MDK instance is responsible for communicating with
+# foundational services like discovery and tracing.
+#
+# There will typically be one MDK instance for the entire
+# process, and one instance of the Session object per
+# thread/channel/request depending on how the MDK is integrated
+# and used within the application framework of choice.
+#
+
+class MDK < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static CONTEXT_HEADER: -> { "X-MDK-Context" }
+    static mdk_MDK_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Start the MDK. An MDK instance will not communicate with
+    # foundational services unless it is started.
+    #
+
+    def start()
+        raise NotImplementedError, '`MDK.start` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Stop the MDK. When the MDK stops unregisters any service
+    # endpoints from the discovery system. This should always
+    # be done prior to process exit in order to propogate node
+    # shutdowns in realtime rather than waiting for heartbeats
+    # to detect node departures.
+    #
+
+    def stop()
+        raise NotImplementedError, '`MDK.stop` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Registers a service endpoint with the discovery
+    # system. This can be called at any point, however
+    # registered endpoints will not be advertised to the
+    # discovery system until the MDK is started.
+    #
+
+    def register(service, version, address)
+        raise NotImplementedError, '`MDK.register` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Creates a new Session. A Session created in this way will
+    # result in a new distributed trace. This should therefore
+    # be used primarily by edge services. Intermediary and
+    # foundational services should make use of
+    # join(encodedContext) in order to preserve distributed
+    # traces.
+    #
+
+    def session()
+        raise NotImplementedError, '`MDK.session` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Create a new Session and join it to a distributed trace.
+    #
+
+    def join(encodedContext)
+        raise NotImplementedError, '`MDK.join` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+MDK.unlazy_statics
+
+def self.Session; Session; end
+##
+# A session provides a lightweight sequential context that a
+# microservice can use in the context of any application
+# framework in order to manage its interactions with other
+# microservices. It provides simple APIs for service
+# resolution, distributed tracing, and circuit breakers.
+#
+# A microservices architecture enables small self contained
+# units of business logic to be implemented by separate teams
+# working on isolated services based on the languages and
+# frameworks best suited for their problem domain.
+#
+# Any given microservice will contain sequential business logic
+# implemented in a variety of ways depending on the application
+# framework chosen. For example it may be a long running
+# thread, a simple blocking request handler, or a chained
+# series of reactive handlers in an async environment.
+#
+# For the most part this business logic can be implemented
+# exactly as prescribed by the application framework of choice,
+# however in a microservices architecture, some special care
+# needs to be taken when this business logic interacts with
+# other microservices.
+#
+# Because microservices are updated with much higher frequency
+# than normal web applications, the interactions between them
+# form key points that require extra care beyond normal web
+# interactions in order to avoid creating a system that is both
+# extremely fragile, unreliable, and opaque.
+#
+# Realtime service resolution, distributed tracing, and
+# resilience heuristics such as circuit breakers provide the
+# foundational behavior required at these interaction
+# points. These capabilites must be combined with the defensive
+# coding practice of intelligent fallback behavior when remote
+# services are unavailable or misbehaving, in order to build a
+# robust microservice application.
+#
+# Because of this, a session is expected to be created and made
+# available to all business logic within a given microservice,
+# e.g. on a per request basis, as a thread local, part of a
+# context object, etc depending on the application framework of
+# choice.
+#
+
+class Session < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_Session_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Grabs the encoded context.
+
+    def inject()
+        raise NotImplementedError, '`Session.inject` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Returns an externalized representation of the distributed session.
+
+    def externalize()
+        raise NotImplementedError, '`Session.externalize` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Record a log entry at the CRITICAL logging level.
+
+    def critical(category, text)
+        raise NotImplementedError, '`Session.critical` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Record a log entry at the ERROR logging level.
+
+    def error(category, text)
+        raise NotImplementedError, '`Session.error` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Record a log entry at the WARN logging level.
+
+    def warn(category, text)
+        raise NotImplementedError, '`Session.warn` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Record a log entry at the INFO logging level.
+
+    def info(category, text)
+        raise NotImplementedError, '`Session.info` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Record a log entry at the DEBUG logging level.
+
+    def debug(category, text)
+        raise NotImplementedError, '`Session.debug` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # EXPERIMENTAL: Set the logging level for the session.
+
+    def trace(level)
+        raise NotImplementedError, '`Session.trace` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # EXPERIMENTAL; requires MDK_EXPERIMENTAL=1 environment variable to
+    # function.
+    #
+    # Override service resolution for the current distributed
+    # session. All attempts to resolve *service*, *version*
+    # will be replaced with an attempt to resolve *target*,
+    # *targetVersion*. This effect will be propogated to any
+    # downstream services involved in the distributed session.
+    #
+
+    def route(service, version, target, targetVersion)
+        raise NotImplementedError, '`Session.route` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Locate a compatible service instance.
+    #
+
+    def resolve(service, version)
+        raise NotImplementedError, '`Session.resolve` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Locate a compatible service instance with a non-default timeout.
+    #
+
+    def resolve_until(service, version, timeout)
+        raise NotImplementedError, '`Session.resolve_until` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Locate a compatible service instance asynchronously. The result is returned as a promise.
+    #
+
+    def resolve_async(service, version)
+        raise NotImplementedError, '`Session.resolve_async` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Start an interaction with a remote service.
+    #
+    # The session tracks any nodes resolved during an
+    # interactin with a remote service.
+    #
+    # The service resolution API permits a compatible instance
+    # of the service to be located. In addition, it tracks
+    # which exact instances are in use during any
+    # interaction. Should the interaction fail, circuit breaker
+    # state is updated for those nodes, and all involved
+    # instances involved are reported to the tracing services.
+    #
+    # This permits realtime reporting of integration issues
+    # when services are updated, and also allows circuit
+    # breakers to mitigate the impact of any such issues.
+    #
+
+    def start_interaction()
+        raise NotImplementedError, '`Session.start_interaction` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Record an interaction as failed.
+    #
+    # This will update circuit breaker state for the remote
+    # nodes, as well as reporting all nodes involved to the
+    # tracing system.
+    #
+
+    def fail_interaction(message)
+        raise NotImplementedError, '`Session.fail_interaction` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # Finish an interaction.
+    #
+    # This marks an interaction as completed.
+    #
+
+    def finish_interaction()
+        raise NotImplementedError, '`Session.finish_interaction` is an abstract method'
+
+        nil
+    end
+
+    ##
+    # This is a convenience API that will perform
+    # start_interaction() followed by callable(ssn) followed by
+    # finish_interaction().
+    #
+    #
+
+    def interact(callable)
+        raise NotImplementedError, '`Session.interact` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Session.unlazy_statics
+
+def self.MDKImpl; MDKImpl; end
+class MDKImpl < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :logger, :_runtime, :_disco, :_discoSource, :_tracer, :procUUID, :_running
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_MDKImpl_ref: -> { nil }
+    static CONTEXT_HEADER: -> { "X-MDK-Context" }
+
+
+
+    def initialize(runtime)
+        
+        self.__init_fields__
+        @_runtime = runtime
+        if (!((runtime).dependencies.hasService("failurepolicy_factory")))
+            (runtime).dependencies.registerService("failurepolicy_factory", ::Quark.mdk_discovery.CircuitBreakerFactory.new(runtime))
+        end
+        @_disco = ::Quark.mdk_discovery.Discovery.new(runtime)
+        env = runtime.getEnvVarsService()
+        token = env.var("DATAWIRE_TOKEN").orElseGet("")
+        discoFactory = self.getDiscoveryFactory(env)
+        @_discoSource = discoFactory.create(@_disco, runtime)
+        if (discoFactory.isRegistrar())
+            (runtime).dependencies.registerService("discovery_registrar", @_discoSource)
+        end
+        if ((token) != (""))
+            tracingURL = ::Quark.mdk._get(env, "MDK_TRACING_URL", "wss://tracing.datawire.io/ws/v1")
+            tracingQueryURL = ::Quark.mdk._get(env, "MDK_TRACING_API_URL", "https://tracing.datawire.io/api/v1/logs")
+            @_tracer = ::Quark.mdk_tracing.Tracer.new(runtime)
+            (@_tracer).url = tracingURL
+            (@_tracer).queryURL = tracingQueryURL
+            (@_tracer).token = token
+            @_tracer.initContext()
+        end
+
+        nil
+    end
+
+
+
+
+    ##
+    # Choose DiscoverySource based on environment variables.
+
+    def getDiscoveryFactory(env)
+        
+        config = env.var("MDK_DISCOVERY_SOURCE").orElseGet("")
+        if ((config) == (""))
+            config = ("datawire:") + (::Quark.mdk_introspection.DatawireToken.getToken(env))
+        end
+        result = ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_discovery.DiscoverySourceFactory }
+        if ((config).start_with?("datawire:"))
+            result = ::Quark.mdk_discovery.protocol.DiscoClientFactory.new((config)[(9)...((config).size)])
+        else
+            if ((config).start_with?("synapse:path="))
+                result = ::Quark.mdk_discovery.synapse.Synapse.new((config)[(13)...((config).size)])
+            else
+                raise (("Unknown MDK discovery source: ") + (config))
+            end
+        end
+        return result
+
+        nil
+    end
+
+    def _timeout()
+        
+        return 10.0
+
+        nil
+    end
+
+    def start()
+        
+        (self)._running = true
+        (@_runtime).dispatcher.startActor(@_disco)
+        (@_runtime).dispatcher.startActor(@_discoSource)
+
+        nil
+    end
+
+    def stop()
+        
+        (self)._running = false
+        (@_runtime).dispatcher.stopActor(@_disco)
+        (@_runtime).dispatcher.stopActor(@_discoSource)
+        @_tracer.stop()
+        @_runtime.stop()
+
+        nil
+    end
+
+    def register(service, version, address)
+        
+        node = ::Quark.mdk_discovery.Node.new()
+        (node).service = service
+        (node).version = version
+        (node).address = address
+        (node).properties = {"datawire_nodeId" => @procUUID}
+        @_disco.register(node)
+
+        nil
+    end
+
+    def session()
+        
+        return ::Quark.mdk.SessionImpl.new(self, nil)
+
+        nil
+    end
+
+    def join(encodedContext)
+        
+        return ::Quark.mdk.SessionImpl.new(self, encodedContext)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk.MDKImpl"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("CONTEXT_HEADER"))
+            return ::Quark.mdk.MDK.CONTEXT_HEADER
+        end
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("_runtime"))
+            return (self)._runtime
+        end
+        if ((name) == ("_disco"))
+            return (self)._disco
+        end
+        if ((name) == ("_discoSource"))
+            return (self)._discoSource
+        end
+        if ((name) == ("_tracer"))
+            return (self)._tracer
+        end
+        if ((name) == ("procUUID"))
+            return (self).procUUID
+        end
+        if ((name) == ("_running"))
+            return (self)._running
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("_runtime"))
+            (self)._runtime = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.MDKRuntime }
+        end
+        if ((name) == ("_disco"))
+            (self)._disco = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.Discovery }
+        end
+        if ((name) == ("_discoSource"))
+            (self)._discoSource = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_discovery.DiscoverySource }
+        end
+        if ((name) == ("_tracer"))
+            (self)._tracer = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_tracing.Tracer }
+        end
+        if ((name) == ("procUUID"))
+            (self).procUUID = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("_running"))
+            (self)._running = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.logger = ::Quark.quark._getLogger("mdk")
+        self._runtime = nil
+        self._disco = nil
+        self._discoSource = nil
+        self._tracer = nil
+        self.procUUID = ::Quark.quark.concurrent.Context.runtime().uuid()
+        self._running = false
+
+        nil
+    end
+
+
+end
+MDKImpl.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 mdk_SessionImpl_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 }
+    static quark_Map_quark_String_quark_int__ref: -> { nil }
+    static quark_Map_quark_String_quark_List_quark_Map_quark_String_quark_String____ref: -> { nil }
+    static quark_Map_quark_String_quark_String__ref: -> { nil }
+
+
+
+    def initialize(mdk, encodedContext)
+        
+        self.__init_fields__
+        @_experimental = ((mdk)._runtime.getEnvVarsService().var("MDK_EXPERIMENTAL").orElseGet("")) != ("")
+        @_mdk = mdk
+        encodedContext = ::DatawireQuarkCore.cast(encodedContext) { ::String }
+        if (((encodedContext) == (nil)) || ((encodedContext) == ("")))
+            @_context = ::Quark.mdk_protocol.SharedContext.new()
+        else
+            ctx = ::Quark.mdk_protocol.SharedContext.decode(encodedContext)
+            @_context = ctx.start_span()
+        end
+
+        nil
+    end
+
+
+
+
+    def get(property)
+        
+        return ((@_context).properties)[property]
+
+        nil
+    end
+
+    def set(property, value)
+        
+        ((@_context).properties)[property] = (value)
+
+        nil
+    end
+
+    def has(property)
+        
+        return ((@_context).properties).key?(property)
+
+        nil
+    end
+
+    def route(service, version, target, targetVersion)
+        
+        routes = nil
+        if (!(self.has("routes")))
+            routes = {}
+            self.set("routes", routes)
+        else
+            routes = ::DatawireQuarkCore.cast(self.get("routes")) { ::Hash }
+        end
+        targets = nil
+        if ((routes).key?(service))
+            targets = (routes)[service]
+        else
+            targets = ::DatawireQuarkCore::List.new([])
+            (routes)[service] = (targets)
+        end
+        (targets) << ({"version" => version, "target" => target, "targetVersion" => targetVersion})
+
+        nil
+    end
+
+    def trace(level)
+        
+        self.set("trace", level)
+
+        nil
+    end
+
+    def self._level(level)
+        
+        if ((::Quark.mdk.SessionImpl._levels).key?(level))
+            return (::Quark.mdk.SessionImpl._levels)[level]
+        else
+            return 0
+        end
+
+        nil
+    end
+
+    def _enabled(level)
+        
+        ilevel = ::Quark.mdk.SessionImpl._level("INFO")
+        if (self.has("trace"))
+            ilevel = ::Quark.mdk.SessionImpl._level(::DatawireQuarkCore.cast(self.get("trace")) { ::String })
+        end
+        return (::Quark.mdk.SessionImpl._level(level)) <= (ilevel)
+
+        nil
+    end
+
+    def _log(level, category, text)
+        
+        if (((@_mdk)._tracer) != (nil))
+            (@_mdk)._tracer.setContext(@_context)
+            (@_mdk)._tracer.log((@_mdk).procUUID, level, category, text)
+        end
+
+        nil
+    end
+
+    def critical(category, text)
+        
+        if (self._enabled("CRITICAL"))
+            (@_mdk).logger.error(((category) + (": ")) + (text))
+            self._log("CRITICAL", category, text)
+        end
+
+        nil
+    end
+
+    def error(category, text)
+        
+        if (self._enabled("ERROR"))
+            (@_mdk).logger.error(((category) + (": ")) + (text))
+            self._log("ERROR", category, text)
+        end
+
+        nil
+    end
+
+    def warn(category, text)
+        
+        if (self._enabled("WARN"))
+            (@_mdk).logger.warn(((category) + (": ")) + (text))
+            self._log("WARN", category, text)
+        end
+
+        nil
+    end
+
+    def info(category, text)
+        
+        if (self._enabled("INFO"))
+            (@_mdk).logger.info(((category) + (": ")) + (text))
+            self._log("INFO", category, text)
+        end
+
+        nil
+    end
+
+    def debug(category, text)
+        
+        if (self._enabled("DEBUG"))
+            (@_mdk).logger.debug(((category) + (": ")) + (text))
+            self._log("DEBUG", category, text)
+        end
+
+        nil
+    end
+
+    def _resolve(service, version)
+        
+        if (@_experimental)
+            routes = ::DatawireQuarkCore.cast(self.get("routes")) { ::Hash }
+            if (((routes) != (nil)) && ((routes).key?(service)))
+                targets = (routes)[service]
+                idx = 0
+                while ((idx) < ((targets).size)) do
+                    target = (targets)[idx]
+                    if (::Quark.mdk_util.versionMatch((target)["version"], version))
+                        service = (target)["target"]
+                        version = (target)["targetVersion"]
+                        break
+                    end
+                    idx = (idx) + (1)
+                end
+            end
+        end
+        return (@_mdk)._disco._resolve(service, version).andThen(::Quark.quark._BoundMethod.new(self, "_resolvedCallback", ::DatawireQuarkCore::List.new([])))
+
+        nil
+    end
+
+    def resolve_async(service, version)
+        
+        return ::Quark.mdk_util.toNativePromise(self._resolve(service, version))
+
+        nil
+    end
+
+    def resolve(service, version)
+        
+        return self.resolve_until(service, version, @_mdk._timeout())
+
+        nil
+    end
+
+    def resolve_until(service, version, timeout)
+        
+        return ::DatawireQuarkCore.cast(::Quark.mdk_util.WaitForPromise.wait(self._resolve(service, version), timeout, (((("service ") + (service)) + ("(")) + (version)) + (")"))) { ::Quark.mdk_discovery.Node }
+
+        nil
+    end
+
+    def _resolvedCallback(result)
+        
+        (@_resolved) << (result)
+        return result
+
+        nil
+    end
+
+    def start_interaction()
+        
+        @_resolved = ::DatawireQuarkCore::List.new([])
+
+        nil
+    end
+
+    def inject()
+        
+        return self.externalize()
+
+        nil
+    end
+
+    def externalize()
+        
+        result = @_context.encode()
+        @_context.tick()
+        return result
+
+        nil
+    end
+
+    def fail_interaction(message)
+        
+        suspects = @_resolved
+        @_resolved = ::DatawireQuarkCore::List.new([])
+        involved = ::DatawireQuarkCore::List.new([])
+        idx = 0
+        while ((idx) < ((suspects).size)) do
+            node = (suspects)[idx]
+            idx = (idx) + (1)
+            (involved) << (node.toString())
+            node.failure()
+        end
+        text = ((("involved: ") + ((involved).join(", "))) + ("\n\n")) + (message)
+        self.error("interaction failure", text)
+
+        nil
+    end
+
+    def finish_interaction()
+        
+        nodes = @_resolved
+        @_resolved = ::DatawireQuarkCore::List.new([])
+        idx = 0
+        while ((idx) < ((nodes).size)) do
+            node = (nodes)[idx]
+            node.success()
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    def interact(cmd)
+        
+        self.start_interaction()
+        (cmd).call(self)
+        self.finish_interaction()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk.SessionImpl"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_levels"))
+            return ::Quark.mdk.SessionImpl._levels
+        end
+        if ((name) == ("_mdk"))
+            return (self)._mdk
+        end
+        if ((name) == ("_resolved"))
+            return (self)._resolved
+        end
+        if ((name) == ("_context"))
+            return (self)._context
+        end
+        if ((name) == ("_experimental"))
+            return (self)._experimental
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_levels"))
+            ::Quark.mdk.SessionImpl._levels = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("_mdk"))
+            (self)._mdk = ::DatawireQuarkCore.cast(value) { ::Quark.mdk.MDKImpl }
+        end
+        if ((name) == ("_resolved"))
+            (self)._resolved = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_context"))
+            (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.SharedContext }
+        end
+        if ((name) == ("_experimental"))
+            (self)._experimental = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._mdk = nil
+        self._resolved = ::DatawireQuarkCore::List.new([])
+        self._context = nil
+        self._experimental = false
+
+        nil
+    end
+
+
+end
+SessionImpl.unlazy_statics
+end # module Mdk
+end # module Quark