class Quark::Mdk::MDKImpl

# File output/rb/mdk-2.0/lib/mdk.rb, line 591
def initialize(runtime)
    
    self.__init_fields__
    @_reflection_hack = ::Hash.new()
    @_runtime = runtime
    @_environment = ::Quark.mdk._parseEnvironment(runtime.getEnvVarsService().var("MDK_ENVIRONMENT").orElseGet("sandbox"))
    if (!((runtime).dependencies.hasService("failurepolicy_factory")))
        (runtime).dependencies.registerService("failurepolicy_factory", self.getFailurePolicy(runtime))
    end
    if ((runtime).dependencies.hasService("tracer"))
        @_tracer = ::DatawireQuarkCore.cast((@_runtime).dependencies.getService("tracer")) { ::Quark.mdk_tracing.Tracer }
    end
    @_disco = ::Quark.mdk_discovery.Discovery.new(runtime)
    @_wsclient = self.getWSClient(runtime)
    if ((@_wsclient) != (nil))
        @_openclose = ::Quark.mdk_protocol.OpenCloseSubscriber.new(@_wsclient, @procUUID, @_environment)
    end
    env = runtime.getEnvVarsService()
    discoFactory = self.getDiscoveryFactory(env)
    @_discoSource = discoFactory.create(@_disco, runtime)
    if (discoFactory.isRegistrar())
        (runtime).dependencies.registerService("discovery_registrar", @_discoSource)
    end
    if ((@_wsclient) != (nil))
        if ((@_tracer) == (nil))
            @_tracer = ::Quark.mdk_tracing.Tracer.new(runtime, @_wsclient)
        end
        @_metrics = ::Quark.mdk_metrics.MetricsClient.new(@_wsclient)
    end

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 895
def __init_fields__()
    
    self.logger = ::Quark.quark._getLogger("mdk")
    self._reflection_hack = nil
    self._runtime = nil
    self._wsclient = nil
    self._openclose = nil
    self._disco = nil
    self._discoSource = nil
    self._tracer = nil
    self._metrics = nil
    self.procUUID = ::Quark.quark.concurrent.Context.runtime().uuid()
    self._running = false
    self._defaultTimeout = nil
    self._environment = nil

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 794
def _getClass()
    
    return "mdk.MDKImpl"

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 801
def _getField(name)
    
    if ((name) == ("CONTEXT_HEADER"))
        return ::Quark.mdk.MDK.CONTEXT_HEADER
    end
    if ((name) == ("logger"))
        return (self).logger
    end
    if ((name) == ("_reflection_hack"))
        return (self)._reflection_hack
    end
    if ((name) == ("_runtime"))
        return (self)._runtime
    end
    if ((name) == ("_wsclient"))
        return (self)._wsclient
    end
    if ((name) == ("_openclose"))
        return (self)._openclose
    end
    if ((name) == ("_disco"))
        return (self)._disco
    end
    if ((name) == ("_discoSource"))
        return (self)._discoSource
    end
    if ((name) == ("_tracer"))
        return (self)._tracer
    end
    if ((name) == ("_metrics"))
        return (self)._metrics
    end
    if ((name) == ("procUUID"))
        return (self).procUUID
    end
    if ((name) == ("_running"))
        return (self)._running
    end
    if ((name) == ("_defaultTimeout"))
        return (self)._defaultTimeout
    end
    if ((name) == ("_environment"))
        return (self)._environment
    end
    return nil

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 850
def _setField(name, value)
    
    if ((name) == ("logger"))
        (self).logger = value
    end
    if ((name) == ("_reflection_hack"))
        (self)._reflection_hack = ::DatawireQuarkCore.cast(value) { ::Hash }
    end
    if ((name) == ("_runtime"))
        (self)._runtime = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.MDKRuntime }
    end
    if ((name) == ("_wsclient"))
        (self)._wsclient = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.WSClient }
    end
    if ((name) == ("_openclose"))
        (self)._openclose = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.OpenCloseSubscriber }
    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) == ("_metrics"))
        (self)._metrics = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_metrics.MetricsClient }
    end
    if ((name) == ("procUUID"))
        (self).procUUID = ::DatawireQuarkCore.cast(value) { ::String }
    end
    if ((name) == ("_running"))
        (self)._running = ::DatawireQuarkCore.cast(value) { ::Object }
    end
    if ((name) == ("_defaultTimeout"))
        (self)._defaultTimeout = ::DatawireQuarkCore.cast(value) { ::Float }
    end
    if ((name) == ("_environment"))
        (self)._environment = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_protocol.OperationalEnvironment }
    end

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 693
def _timeout()
    
    return 10.0

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 769
def derive(encodedContext)
    
    session = ::DatawireQuarkCore.cast(self.session()) { ::Quark.mdk.SessionImpl }
    parent = ::Quark.mdk_protocol.SharedContext.decode(encodedContext)
    ((session)._context).properties = (parent).properties
    if ((((session)._context).properties).key?("timeout"))
        (((session)._context).properties).delete("timeout")
    end
    session.info("mdk", ((("This session is derived from trace ") + ((parent).traceId)) + (" ")) + ((((parent).clock).clocks).to_s))
    return session

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 630
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(@_wsclient)
    else
        if ((config).start_with?("synapse:path="))
            result = ::Quark.mdk_discovery.synapse.Synapse.new((config)[(13)...((config).size)], (self)._environment)
        else
            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

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 659
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

# File output/rb/mdk-2.0/lib/mdk.rb, line 674
def getWSClient(runtime)
    
    env = runtime.getEnvVarsService()
    token = env.var("DATAWIRE_TOKEN").orElseGet("")
    disco_config = env.var("MDK_DISCOVERY_SOURCE").orElseGet("")
    if ((token) == (""))
        if ((disco_config).start_with?("datawire:"))
            token = (disco_config)[(9)...((disco_config).size)]
        else
            return ::DatawireQuarkCore.cast(nil) { ::Quark.mdk_protocol.WSClient }
        end
    end
    ddu = env.var("MDK_SERVER_URL")
    url = ddu.orElseGet("wss://mcp.datawire.io/rtp")
    return ::Quark.mdk_protocol.WSClient.new(runtime, ::Quark.mdk_rtp.getRTPParser(), url, token)

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 783
def join(encodedContext)
    
    session = ::Quark.mdk.SessionImpl.new(self, encodedContext, (self)._environment)
    if ((@_defaultTimeout) != (nil))
        session.setDeadline(@_defaultTimeout)
    end
    return session

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 730
def register(service, version, address)
    
    node = ::Quark.mdk_discovery.Node.new()
    (node).id = @procUUID
    (node).service = service
    (node).version = version
    (node).address = address
    (node).environment = (self)._environment
    (node).properties = {"datawire_nodeId" => @procUUID}
    @_disco.register(node)

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 758
def session()
    
    session = ::Quark.mdk.SessionImpl.new(self, nil, (self)._environment)
    if ((@_defaultTimeout) != (nil))
        session.setDeadline(@_defaultTimeout)
    end
    return session

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 744
def setDefaultDeadline(seconds)
    
    (self)._defaultTimeout = seconds

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 751
def setDefaultTimeout(seconds)
    
    self.setDefaultDeadline(seconds)

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 700
def start()
    
    (self)._running = true
    if ((@_wsclient) != (nil))
        (@_runtime).dispatcher.startActor(@_wsclient)
        (@_runtime).dispatcher.startActor(@_openclose)
        (@_runtime).dispatcher.startActor(@_tracer)
        (@_runtime).dispatcher.startActor(@_metrics)
    end
    (@_runtime).dispatcher.startActor(@_disco)
    (@_runtime).dispatcher.startActor(@_discoSource)

    nil
end

# File output/rb/mdk-2.0/lib/mdk.rb, line 715
def stop()
    
    (self)._running = false
    (@_runtime).dispatcher.stopActor(@_discoSource)
    (@_runtime).dispatcher.stopActor(@_disco)
    if ((@_wsclient) != (nil))
        (@_runtime).dispatcher.stopActor(@_tracer)
        (@_runtime).dispatcher.stopActor(@_openclose)
        (@_runtime).dispatcher.stopActor(@_wsclient)
    end
    @_runtime.stop()

    nil
end