datawire_mdk 2.0.5

data/lib/mdk_runtime.rb

@@ -0,0 +1,2135 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_runtime; MdkRuntime; end
+module MdkRuntime
+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/files' # 0 ('mdk_runtime',) ()
+require_relative 'mdk_runtime/promise' # 0 ('mdk_runtime',) ()
+require_relative 'quark/error' # 0 ('quark',) ()
+require_relative 'quark' # 0 () ()
+require_relative 'quark/concurrent' # 0 ('quark',) ()
+require_relative 'quark/os' # 0 ('quark',) ()
+
+
+def self.Dependencies; Dependencies; end
+##
+# Trivial dependency injection setup.
+
+class Dependencies < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_services
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_Dependencies_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Register a service object.
+
+    def registerService(name, service)
+        
+        if (((self)._services).key?(name))
+            raise ((("Can't register service '") + (name)) + ("' twice."))
+        end
+        ((self)._services)[name] = (service)
+
+        nil
+    end
+
+    ##
+    # Look up a service by name.
+
+    def getService(name)
+        
+        if (!(((self)._services).key?(name)))
+            raise ((("Service '") + (name)) + ("' not found!"))
+        end
+        return ((self)._services)[name]
+
+        nil
+    end
+
+    ##
+    # Return whether the service exists.
+
+    def hasService(name)
+        
+        return ((self)._services).key?(name)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.Dependencies"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_services"))
+            return (self)._services
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_services"))
+            (self)._services = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._services = {}
+
+        nil
+    end
+
+
+end
+Dependencies.unlazy_statics
+
+def self.MDKRuntime; MDKRuntime; end
+##
+# Runtime environment for a particular MDK instance.
+#
+# Required registered services:
+# - 'time': A provider of mdk_runtime.Time;
+# - 'schedule': Implements the mdk_runtime.ScheduleActor actor protocol.
+# - 'websockets': A provider of mdk_runtime.WebSockets.
+#
+
+class MDKRuntime < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :dependencies, :dispatcher
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_MDKRuntime_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Return Time service.
+
+    def getTimeService()
+        
+        return ::DatawireQuarkCore.cast((self).dependencies.getService("time")) { ::Quark.mdk_runtime.Time }
+
+        nil
+    end
+
+    ##
+    # Return Schedule service.
+
+    def getScheduleService()
+        
+        return ::DatawireQuarkCore.cast((self).dependencies.getService("schedule")) { ::Quark.mdk_runtime.actors.Actor }
+
+        nil
+    end
+
+    ##
+    # Return WebSockets service.
+
+    def getWebSocketsService()
+        
+        return ::DatawireQuarkCore.cast((self).dependencies.getService("websockets")) { ::Quark.mdk_runtime.WebSockets }
+
+        nil
+    end
+
+    ##
+    # Return File service.
+
+    def getFileService()
+        
+        return ::DatawireQuarkCore.cast((self).dependencies.getService("files")) { ::Quark.mdk_runtime.files.FileActor }
+
+        nil
+    end
+
+    ##
+    # Return EnvironmentVariables service.
+
+    def getEnvVarsService()
+        
+        return ::DatawireQuarkCore.cast((self).dependencies.getService("envvar")) { ::Quark.mdk_runtime.EnvironmentVariables }
+
+        nil
+    end
+
+    ##
+    # Stop all Actors that are started by default (i.e. files, schedule).
+
+    def stop()
+        
+        (self).dispatcher.stopActor(self.getFileService())
+        (self).dispatcher.stopActor(self.getScheduleService())
+        (self).dispatcher.stopActor(self.getWebSocketsService())
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.MDKRuntime"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("dependencies"))
+            return (self).dependencies
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("dependencies"))
+            (self).dependencies = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.Dependencies }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.dependencies = ::Quark.mdk_runtime.Dependencies.new()
+        self.dispatcher = ::Quark.mdk_runtime.actors.MessageDispatcher.new()
+
+        nil
+    end
+
+
+end
+MDKRuntime.unlazy_statics
+
+def self.Time; Time; end
+##
+# Return current time.
+#
+
+class Time < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_Time_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Return the current time in seconds since the Unix epoch.
+    #
+
+    def time()
+        raise NotImplementedError, '`Time.time` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Time.unlazy_statics
+
+def self.SchedulingActor; SchedulingActor; end
+##
+# An actor that can schedule events.
+#
+# Accepts Schedule messages and send Happening events to originator at the
+# appropriate time.
+#
+
+class SchedulingActor < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_SchedulingActor_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+SchedulingActor.unlazy_statics
+
+def self.WebSockets; WebSockets; end
+##
+# Service that can open new WebSocket connections.
+#
+# When stopped it should close all connections.
+#
+
+class WebSockets < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_WebSockets_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # The Promise resolves to a WSActor or WSConnectError. The originator will
+    # receive messages.
+    #
+
+    def connect(url, originator)
+        raise NotImplementedError, '`WebSockets.connect` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WebSockets.unlazy_statics
+
+def self.WSConnectError; WSConnectError; end
+##
+# Connection failed.
+
+class WSConnectError < ::Quark.quark.error.Error
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_WSConnectError_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super(message)
+
+        nil
+    end
+
+
+
+
+    def toString()
+        
+        return (("<WSConnectionError: ") + (method(:toString).super_method.call())) + (">")
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.WSConnectError"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("message"))
+            return (self).message
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("message"))
+            (self).message = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+WSConnectError.unlazy_statics
+
+def self.WSActor; WSActor; end
+##
+# Actor representing a specific WebSocket connection.
+#
+# Accepts String and WSClose messages, sends WSMessage and WSClosed
+# messages to the originator of the connection (Actor passed to
+# WebSockets.connect()).
+#
+
+class WSActor < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_WSActor_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WSActor.unlazy_statics
+
+def self.WSMessage; WSMessage; end
+##
+# A message was received from the server.
+
+class WSMessage < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :body
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_WSMessage_ref: -> { nil }
+
+
+
+    def initialize(body)
+        
+        self.__init_fields__
+        (self).body = body
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_runtime.WSMessage"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("body"))
+            return (self).body
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("body"))
+            (self).body = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.body = nil
+
+        nil
+    end
+
+
+end
+WSMessage.unlazy_statics
+
+def self.WSClose; WSClose; end
+##
+# Tell WSActor to close the connection.
+
+class WSClose < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_WSClose_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_runtime.WSClose"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WSClose.unlazy_statics
+
+def self.WSClosed; WSClosed; end
+##
+# Notify of WebSocket connection having closed.
+
+class WSClosed < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_WSClosed_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_runtime.WSClosed"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+WSClosed.unlazy_statics
+
+def self.QuarkRuntimeWSActor; QuarkRuntimeWSActor; end
+##
+# WSActor that uses current Quark runtime as temporary expedient.
+#
+# State can be 'ERROR', 'CONNECTING', 'CONNECTED', 'DISCONNECTING',
+# 'DISCONNECTED'.
+#
+
+class QuarkRuntimeWSActor < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :logger, :socket, :factory, :originator, :dispatcher, :state
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_QuarkRuntimeWSActor_ref: -> { nil }
+
+
+
+    def initialize(originator, factory)
+        
+        self.__init_fields__
+        (self).originator = originator
+        (self).factory = factory
+
+        nil
+    end
+
+
+
+
+    def onStart(dispatcher)
+        
+        (self).dispatcher = dispatcher
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        if ((((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id) == ("quark.String")) && (((self).state) == ("CONNECTED")))
+            (self).socket.send(::DatawireQuarkCore.cast(message) { ::String })
+            return
+        end
+        if ((((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id) == ("mdk_runtime.WSClose")) && (((self).state) == ("CONNECTED")))
+            (self).state = "DISCONNECTING"
+            (self).socket.close()
+            return
+        end
+
+        nil
+    end
+
+    def onWSConnected(socket)
+        
+        @logger.debug(((((("onWSConnected, current state ") + ((self).state)) + ("originator: ")) + (((self).originator).to_s)) + (" and I am ")) + ((self).to_s))
+        if (((self).state) == ("ERROR"))
+            @logger.debug("Connection event after error event!")
+            return
+        end
+        (self).state = "CONNECTED"
+        (self).socket = socket
+        (self).factory.resolve(self)
+
+        nil
+    end
+
+    def onWSError(socket, error)
+        
+        @logger.debug(((("onWSError, current state ") + ((self).state)) + ("originator: ")) + (((self).originator).to_s))
+        if (((self).state) == ("CONNECTING"))
+            @logger.error(("Error connecting to WebSocket: ") + (error.toString()))
+            (self).state = "ERROR"
+            (self).factory.reject(::Quark.mdk_runtime.WSConnectError.new(error.toString()))
+            return
+        end
+        @logger.error(("WebSocket error: ") + (error.toString()))
+
+        nil
+    end
+
+    def onWSMessage(socket, message)
+        
+        @logger.debug(((("onWSMessage, current state: ") + ((self).state)) + ("originator: ")) + (((self).originator).to_s))
+        (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSMessage.new(message), (self).originator)
+
+        nil
+    end
+
+    def onWSFinal(socket)
+        
+        @logger.debug(((("onWSFinal, current state ") + ((self).state)) + ("originator: ")) + (((self).originator).to_s))
+        if ((((self).state) == ("DISCONNECTING")) || (((self).state) == ("CONNECTED")))
+            (self).state = "DISCONNECTED"
+            (self).socket = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.WebSocket }
+            (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSClosed.new(), (self).originator)
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.QuarkRuntimeWSActor"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("socket"))
+            return (self).socket
+        end
+        if ((name) == ("factory"))
+            return (self).factory
+        end
+        if ((name) == ("originator"))
+            return (self).originator
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("state"))
+            return (self).state
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("socket"))
+            (self).socket = ::DatawireQuarkCore.cast(value) { ::Quark.quark.WebSocket }
+        end
+        if ((name) == ("factory"))
+            (self).factory = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.promise.PromiseResolver }
+        end
+        if ((name) == ("originator"))
+            (self).originator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("state"))
+            (self).state = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    ##
+    # The Actor should begin shutting down.
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket is first created.
+
+    def onWSInit(socket)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket receives a binary message.
+
+    def onWSBinary(socket, message)
+        
+        nil
+
+        nil
+    end
+
+    ##
+    # Called when the WebSocket disconnects cleanly.
+
+    def onWSClosed(socket)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.logger = ::Quark.quark._getLogger("protocol")
+        self.socket = nil
+        self.factory = nil
+        self.originator = nil
+        self.dispatcher = nil
+        self.state = "CONNECTING"
+
+        nil
+    end
+
+
+end
+QuarkRuntimeWSActor.unlazy_statics
+
+def self.QuarkRuntimeWebSockets; QuarkRuntimeWebSockets; end
+##
+# WebSocket that uses current Quark runtime as temporary expedient.
+#
+
+class QuarkRuntimeWebSockets < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :logger, :dispatcher, :connections
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_runtime_WSActor__ref: -> { nil }
+    static mdk_runtime_QuarkRuntimeWebSockets_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def connect(url, originator)
+        
+        @logger.debug((((originator).to_s) + ("requested connection to ")) + (url))
+        factory = ::Quark.mdk_runtime.promise.PromiseResolver.new((self).dispatcher)
+        actor = ::Quark.mdk_runtime.QuarkRuntimeWSActor.new(originator, factory)
+        (@connections) << (actor)
+        (self).dispatcher.startActor(actor)
+        ::Quark.quark.concurrent.Context.runtime().open(url, actor)
+        return (factory).promise
+
+        nil
+    end
+
+    def onStart(dispatcher)
+        
+        (self).dispatcher = dispatcher
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        nil
+
+        nil
+    end
+
+    def onStop()
+        
+        idx = 0
+        while ((idx) < ((@connections).size)) do
+            (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSClose.new(), ((self).connections)[idx])
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.QuarkRuntimeWebSockets"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("logger"))
+            return (self).logger
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("connections"))
+            return (self).connections
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("logger"))
+            (self).logger = value
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("connections"))
+            (self).connections = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.logger = ::Quark.quark._getLogger("protocol")
+        self.dispatcher = nil
+        self.connections = ::DatawireQuarkCore::List.new([])
+
+        nil
+    end
+
+
+end
+QuarkRuntimeWebSockets.unlazy_statics
+
+def self.FakeWSActor; FakeWSActor; end
+##
+# WSActor implementation for testing purposes.
+
+class FakeWSActor < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :url, :resolver, :resolved, :dispatcher, :originator, :sent, :state, :expectIdx
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_FakeWSActor_ref: -> { nil }
+
+
+
+    def initialize(originator, resolver, url)
+        
+        self.__init_fields__
+        (self).url = url
+        (self).originator = originator
+        (self).resolver = resolver
+
+        nil
+    end
+
+
+
+
+    def onStart(dispatcher)
+        
+        (self).dispatcher = dispatcher
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        if ((((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id) == ("quark.String")) && (((self).state) == ("CONNECTED")))
+            ((self).sent) << (::DatawireQuarkCore.cast(message) { ::String })
+            return
+        end
+        if ((((::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id) == ("mdk_runtime.WSClose")) && (((self).state) == ("CONNECTED")))
+            self.close()
+            return
+        end
+
+        nil
+    end
+
+    ##
+    # Simulate the remote peer accepting the socket connect.
+    #
+
+    def accept()
+        
+        if (@resolved)
+            ::Quark.quark.concurrent.Context.runtime().fail("Test bug. already accepted")
+        else
+            @resolved = true
+            (self).state = "CONNECTED"
+            (self).resolver.resolve(self)
+        end
+
+        nil
+    end
+
+    ##
+    # Simulate the remote peer rejecting the socket connect.
+
+    def reject()
+        
+        if (@resolved)
+            ::Quark.quark.concurrent.Context.runtime().fail("Test bug. already accepted")
+        else
+            @resolved = true
+            (self).resolver.reject(::Quark.mdk_runtime.WSConnectError.new("connection refused"))
+        end
+
+        nil
+    end
+
+    ##
+    # Simulate the remote peer sending a text message to the client.
+    #
+
+    def send(message)
+        
+        if (((self).state) != ("CONNECTED"))
+            ::Quark.quark.concurrent.Context.runtime().fail("Test bug. Can't send when not connected.")
+        end
+        (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSMessage.new(message), @originator)
+
+        nil
+    end
+
+    ##
+    # Simulate the remote peer closing the socket.
+    #
+
+    def close()
+        
+        if (((self).state) == ("CONNECTED"))
+            (self).state = "DISCONNECTED"
+            (self).dispatcher.tell(self, ::Quark.mdk_runtime.WSClosed.new(), @originator)
+        else
+            ::Quark.quark.concurrent.Context.runtime().fail("Test bug. Can't close already closed socket.")
+        end
+
+        nil
+    end
+
+    ##
+    # Check that a message has been sent via this actor.
+    #
+
+    def expectTextMessage()
+        
+        if (!(@resolved))
+            ::Quark.quark.concurrent.Context.runtime().fail("not connected yet")
+            return "unreachable"
+        end
+        if ((@expectIdx) < (((self).sent).size))
+            msg = ((self).sent)[@expectIdx]
+            @expectIdx = (@expectIdx) + (1)
+            return msg
+        end
+        ::Quark.quark.concurrent.Context.runtime().fail("no remaining message found")
+        return "unreachable"
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.FakeWSActor"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("url"))
+            return (self).url
+        end
+        if ((name) == ("resolver"))
+            return (self).resolver
+        end
+        if ((name) == ("resolved"))
+            return (self).resolved
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("originator"))
+            return (self).originator
+        end
+        if ((name) == ("sent"))
+            return (self).sent
+        end
+        if ((name) == ("state"))
+            return (self).state
+        end
+        if ((name) == ("expectIdx"))
+            return (self).expectIdx
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("url"))
+            (self).url = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("resolver"))
+            (self).resolver = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.promise.PromiseResolver }
+        end
+        if ((name) == ("resolved"))
+            (self).resolved = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("originator"))
+            (self).originator = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("sent"))
+            (self).sent = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("state"))
+            (self).state = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("expectIdx"))
+            (self).expectIdx = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    ##
+    # The Actor should begin shutting down.
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.url = nil
+        self.resolver = nil
+        self.resolved = false
+        self.dispatcher = nil
+        self.originator = nil
+        self.sent = ::DatawireQuarkCore::List.new([])
+        self.state = "CONNECTING"
+        self.expectIdx = 0
+
+        nil
+    end
+
+
+end
+FakeWSActor.unlazy_statics
+
+def self.FakeWebSockets; FakeWebSockets; end
+##
+# WebSocket implementation for testing purposes.
+#
+
+class FakeWebSockets < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :dispatcher, :fakeActors
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_mdk_runtime_FakeWSActor__ref: -> { nil }
+    static mdk_runtime_FakeWebSockets_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def connect(url, originator)
+        
+        factory = ::Quark.mdk_runtime.promise.PromiseResolver.new((self).dispatcher)
+        actor = ::Quark.mdk_runtime.FakeWSActor.new(originator, factory, url)
+        (self).dispatcher.startActor(actor)
+        ((self).fakeActors) << (actor)
+        return (factory).promise
+
+        nil
+    end
+
+    def lastConnection()
+        
+        return ((self).fakeActors)[(((self).fakeActors).size) - (1)]
+
+        nil
+    end
+
+    def onStart(dispatcher)
+        
+        (self).dispatcher = dispatcher
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        nil
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.FakeWebSockets"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("fakeActors"))
+            return (self).fakeActors
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("fakeActors"))
+            (self).fakeActors = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    ##
+    # The Actor should begin shutting down.
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.dispatcher = nil
+        self.fakeActors = ::DatawireQuarkCore::List.new([])
+
+        nil
+    end
+
+
+end
+FakeWebSockets.unlazy_statics
+
+def self.Schedule; Schedule; end
+##
+# Please send me a Happening message with given event name in given number of
+# seconds.
+#
+
+class Schedule < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :event, :seconds
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_Schedule_ref: -> { nil }
+
+
+
+    def initialize(event, seconds)
+        
+        self.__init_fields__
+        (self).event = event
+        (self).seconds = seconds
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_runtime.Schedule"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("event"))
+            return (self).event
+        end
+        if ((name) == ("seconds"))
+            return (self).seconds
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("event"))
+            (self).event = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("seconds"))
+            (self).seconds = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.event = nil
+        self.seconds = nil
+
+        nil
+    end
+
+
+end
+Schedule.unlazy_statics
+
+def self.Happening; Happening; end
+##
+# A scheduled event is now happening.
+
+class Happening < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :event, :currentTime
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_Happening_ref: -> { nil }
+
+
+
+    def initialize(event, currentTime)
+        
+        self.__init_fields__
+        (self).event = event
+        (self).currentTime = currentTime
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_runtime.Happening"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("event"))
+            return (self).event
+        end
+        if ((name) == ("currentTime"))
+            return (self).currentTime
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("event"))
+            (self).event = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("currentTime"))
+            (self).currentTime = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.event = nil
+        self.currentTime = nil
+
+        nil
+    end
+
+
+end
+Happening.unlazy_statics
+
+def self._ScheduleTask; ScheduleTask; end
+class ScheduleTask < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :timeService, :requester, :event
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime__ScheduleTask_ref: -> { nil }
+
+
+
+    def initialize(timeService, requester, event)
+        
+        self.__init_fields__
+        (self).timeService = timeService
+        (self).requester = requester
+        (self).event = event
+
+        nil
+    end
+
+
+
+
+    def onExecute(runtime)
+        
+        (@timeService).dispatcher.tell((self).timeService, ::Quark.mdk_runtime.Happening.new((self).event, (self).timeService.time()), (self).requester)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime._ScheduleTask"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("timeService"))
+            return (self).timeService
+        end
+        if ((name) == ("requester"))
+            return (self).requester
+        end
+        if ((name) == ("event"))
+            return (self).event
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("timeService"))
+            (self).timeService = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.QuarkRuntimeTime }
+        end
+        if ((name) == ("requester"))
+            (self).requester = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("event"))
+            (self).event = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.timeService = nil
+        self.requester = nil
+        self.event = nil
+
+        nil
+    end
+
+
+end
+ScheduleTask.unlazy_statics
+
+def self.QuarkRuntimeTime; QuarkRuntimeTime; end
+##
+# Temporary implementation based on Quark runtime, until we have native
+# implementation.
+#
+
+class QuarkRuntimeTime < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :dispatcher, :stopped
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_QuarkRuntimeTime_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onStart(dispatcher)
+        
+        (self).dispatcher = dispatcher
+
+        nil
+    end
+
+    def onStop()
+        
+        (self).stopped = true
+
+        nil
+    end
+
+    def onMessage(origin, msg)
+        
+        if ((self).stopped)
+            return
+        end
+        sched = ::DatawireQuarkCore.cast(msg) { ::Quark.mdk_runtime.Schedule }
+        seconds = (sched).seconds
+        if ((seconds) == (0.0))
+            seconds = 0.001
+        end
+        ::Quark.quark.concurrent.Context.runtime().schedule(::Quark.mdk_runtime._ScheduleTask.new(self, origin, (sched).event), seconds)
+
+        nil
+    end
+
+    def time()
+        
+        milliseconds = (::Quark.quark.concurrent.Context.runtime().now()).to_f
+        return (milliseconds) / (1000.0)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.QuarkRuntimeTime"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        if ((name) == ("stopped"))
+            return (self).stopped
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+        if ((name) == ("stopped"))
+            (self).stopped = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.dispatcher = nil
+        self.stopped = false
+
+        nil
+    end
+
+
+end
+QuarkRuntimeTime.unlazy_statics
+
+def self._FakeTimeRequest; FakeTimeRequest; end
+class FakeTimeRequest < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :requester, :event, :happensAt
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime__FakeTimeRequest_ref: -> { nil }
+
+
+
+    def initialize(requester, event, happensAt)
+        
+        self.__init_fields__
+        (self).requester = requester
+        (self).event = event
+        (self).happensAt = happensAt
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "mdk_runtime._FakeTimeRequest"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("requester"))
+            return (self).requester
+        end
+        if ((name) == ("event"))
+            return (self).event
+        end
+        if ((name) == ("happensAt"))
+            return (self).happensAt
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("requester"))
+            (self).requester = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.Actor }
+        end
+        if ((name) == ("event"))
+            (self).event = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("happensAt"))
+            (self).happensAt = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.requester = nil
+        self.event = nil
+        self.happensAt = nil
+
+        nil
+    end
+
+
+end
+FakeTimeRequest.unlazy_statics
+
+def self.FakeTime; FakeTime; end
+##
+# Testing fake.
+
+class FakeTime < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_now, :_scheduled, :dispatcher
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_quark_long__ref: -> { nil }
+    static quark_Map_quark_long_mdk_runtime__FakeTimeRequest__ref: -> { nil }
+    static mdk_runtime_FakeTime_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def onStart(dispatcher)
+        
+        (self).dispatcher = dispatcher
+
+        nil
+    end
+
+    def onMessage(origin, msg)
+        
+        sched = ::DatawireQuarkCore.cast(msg) { ::Quark.mdk_runtime.Schedule }
+        (@_scheduled)[((::DatawireQuarkCore::List.new((@_scheduled).keys)).size)] = (::Quark.mdk_runtime._FakeTimeRequest.new(origin, (sched).event, ((self)._now) + ((sched).seconds)))
+
+        nil
+    end
+
+    def time()
+        
+        return (self)._now
+
+        nil
+    end
+
+    ##
+    # Run scheduled events whose time has come.
+
+    def pump()
+        
+        idx = 0
+        keys = ::DatawireQuarkCore::List.new(((self)._scheduled).keys)
+        while ((idx) < ((keys).size)) do
+            request = (@_scheduled)[(keys)[idx]]
+            if (((request).happensAt) <= ((self)._now))
+                ((self)._scheduled).delete((keys)[idx])
+                (self).dispatcher.tell(self, ::Quark.mdk_runtime.Happening.new((request).event, self.time()), (request).requester)
+            end
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    ##
+    # Move time forward.
+
+    def advance(seconds)
+        
+        (self)._now = ((self)._now) + (seconds)
+
+        nil
+    end
+
+    ##
+    # Number of scheduled events.
+
+    def scheduled()
+        
+        return (::DatawireQuarkCore::List.new(((self)._scheduled).keys)).size
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.FakeTime"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_now"))
+            return (self)._now
+        end
+        if ((name) == ("_scheduled"))
+            return (self)._scheduled
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_now"))
+            (self)._now = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("_scheduled"))
+            (self)._scheduled = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("dispatcher"))
+            (self).dispatcher = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.actors.MessageDispatcher }
+        end
+
+        nil
+    end
+
+    ##
+    # The Actor should begin shutting down.
+
+    def onStop()
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._now = 1000.0
+        self._scheduled = {}
+        self.dispatcher = nil
+
+        nil
+    end
+
+
+end
+FakeTime.unlazy_statics
+
+def self.EnvironmentVariable; EnvironmentVariable; end
+##
+# EnvironmentVariable is a Supplier of Strings that come from the environment.
+
+class EnvironmentVariable < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :variableName, :_value
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_EnvironmentVariable_ref: -> { nil }
+
+
+
+    def initialize(variableName, value)
+        
+        self.__init_fields__
+        (self).variableName = variableName
+        (self)._value = value
+
+        nil
+    end
+
+
+
+
+    def isDefined()
+        
+        return (self.get()) != (nil)
+
+        nil
+    end
+
+    def get()
+        
+        return (self)._value
+
+        nil
+    end
+
+    def orElseGet(alternative)
+        
+        result = self.get()
+        if ((result) != (nil))
+            return result
+        else
+            return alternative
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.EnvironmentVariable"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("variableName"))
+            return (self).variableName
+        end
+        if ((name) == ("_value"))
+            return (self)._value
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("variableName"))
+            (self).variableName = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("_value"))
+            (self)._value = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.variableName = nil
+        self._value = nil
+
+        nil
+    end
+
+
+end
+EnvironmentVariable.unlazy_statics
+
+def self.EnvironmentVariables; EnvironmentVariables; end
+##
+# Inspect process environment variables.
+
+class EnvironmentVariables < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_EnvironmentVariables_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Return an EnvironmentVariable instance for the given var.
+
+    def var(name)
+        raise NotImplementedError, '`EnvironmentVariables.var` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+EnvironmentVariables.unlazy_statics
+
+def self.RealEnvVars; RealEnvVars; end
+##
+# Use real environment variables.
+
+class RealEnvVars < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_RealEnvVars_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def var(name)
+        
+        return ::Quark.mdk_runtime.EnvironmentVariable.new(name, ::Quark.quark.os.Environment.getEnvironment().__get__(name))
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.RealEnvVars"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+RealEnvVars.unlazy_statics
+
+def self.FakeEnvVars; FakeEnvVars; end
+##
+# Testing fake for EnvironmentVariables.
+
+class FakeEnvVars < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :env
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_runtime_FakeEnvVars_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def set(name, value)
+        
+        ((self).env)[name] = (value)
+
+        nil
+    end
+
+    def var(name)
+        
+        value = ::DatawireQuarkCore.cast(nil) { ::String }
+        if (((self).env).key?(name))
+            value = ((self).env)[name]
+        end
+        return ::Quark.mdk_runtime.EnvironmentVariable.new(name, value)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_runtime.FakeEnvVars"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("env"))
+            return (self).env
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("env"))
+            (self).env = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.env = {}
+
+        nil
+    end
+
+
+end
+FakeEnvVars.unlazy_statics
+
+##
+# Create a MDKRuntime with the default configuration and start its actors.
+
+def self.defaultRuntime()
+    
+    runtime = ::Quark.mdk_runtime.MDKRuntime.new()
+    (runtime).dependencies.registerService("envvar", ::Quark.mdk_runtime.RealEnvVars.new())
+    timeService = ::Quark.mdk_runtime.QuarkRuntimeTime.new()
+    websockets = ::Quark.mdk_runtime.QuarkRuntimeWebSockets.new()
+    (runtime).dependencies.registerService("time", timeService)
+    (runtime).dependencies.registerService("schedule", timeService)
+    (runtime).dependencies.registerService("websockets", websockets)
+    fileActor = ::Quark.mdk_runtime.files.FileActorImpl.new(runtime)
+    (runtime).dependencies.registerService("files", fileActor)
+    (runtime).dispatcher.startActor(timeService)
+    (runtime).dispatcher.startActor(websockets)
+    (runtime).dispatcher.startActor(fileActor)
+    return runtime
+
+
+    nil
+end
+
+def self.fakeRuntime()
+    
+    runtime = ::Quark.mdk_runtime.MDKRuntime.new()
+    (runtime).dependencies.registerService("envvar", ::Quark.mdk_runtime.FakeEnvVars.new())
+    timeService = ::Quark.mdk_runtime.FakeTime.new()
+    websockets = ::Quark.mdk_runtime.FakeWebSockets.new()
+    (runtime).dependencies.registerService("time", timeService)
+    (runtime).dependencies.registerService("schedule", timeService)
+    (runtime).dependencies.registerService("websockets", websockets)
+    fileActor = ::Quark.mdk_runtime.files.FileActorImpl.new(runtime)
+    (runtime).dependencies.registerService("files", fileActor)
+    (runtime).dispatcher.startActor(timeService)
+    (runtime).dispatcher.startActor(websockets)
+    (runtime).dispatcher.startActor(fileActor)
+    return runtime
+
+
+    nil
+end
+
+
+
+end # module MdkRuntime
+end # module Quark