datawire_mdk 2.0.5

data/lib/mdk_discovery/synapse.rb

@@ -0,0 +1,267 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_discovery; MdkDiscovery; end
+module MdkDiscovery
+def self.synapse; Synapse; end
+module Synapse
+require "datawire-quark-core"
+require_relative '../quark/reflect' # 0 ('quark',) ('mdk_discovery',)
+require_relative '../mdk_discovery' # 0 () ('mdk_discovery',)
+require_relative '../mdk_runtime/actors' # 0 ('mdk_runtime',) ('mdk_discovery',)
+require_relative '../mdk_runtime' # 0 () ('mdk_discovery',)
+require_relative '../datawire_mdk_md' # 0 () ('mdk_discovery',)
+require_relative '../mdk_runtime/files' # 0 ('mdk_runtime',) ('mdk_discovery',)
+
+
+def self.Synapse; Synapse; end
+##
+# AirBnB Synapse discovery source.
+#
+# Reads Synapse-generated files (https://github.com/airbnb/synapse#file) and
+# generates discovery events.
+#
+# Usage:
+#
+# m = mdk.init()
+# m.registerDiscoverySource(Synapse('/path/to/synapse/files'))
+# m.start()
+#
+# All resulting Node instances will have version '1.0' hardcoded, and an
+# address of the form '<host>:<port>'.
+#
+# The original object from Synpase will be attached as the Node's properties.
+#
+
+class Synapse < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :_directory_path
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_synapse_Synapse_ref: -> { nil }
+
+
+
+    def initialize(directory_path)
+        
+        self.__init_fields__
+        (self)._directory_path = directory_path
+
+        nil
+    end
+
+
+
+
+    def create(subscriber, runtime)
+        
+        return ::Quark.mdk_discovery.synapse._SynapseSource.new(subscriber, (self)._directory_path, runtime)
+
+        nil
+    end
+
+    def isRegistrar()
+        
+        return false
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.synapse.Synapse"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_directory_path"))
+            return (self)._directory_path
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_directory_path"))
+            (self)._directory_path = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self._directory_path = nil
+
+        nil
+    end
+
+
+end
+Synapse.unlazy_statics
+
+def self._SynapseSource; SynapseSource; end
+##
+# Implementation of the Synapse discovery source.
+
+class SynapseSource < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :subscriber, :directory_path, :files, :dispatcher
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_discovery_synapse__SynapseSource_ref: -> { nil }
+
+
+
+    def initialize(subscriber, directory_path, runtime)
+        
+        self.__init_fields__
+        (self).subscriber = subscriber
+        (self).directory_path = directory_path
+        (self).files = runtime.getFileService()
+
+        nil
+    end
+
+
+
+
+    def onStart(dispatcher)
+        
+        (self).dispatcher = dispatcher
+        (self).dispatcher.tell(self, ::Quark.mdk_runtime.files.SubscribeChanges.new((self).directory_path), (self).files)
+
+        nil
+    end
+
+    ##
+    # Convert '/path/to/service_name.json' to 'service_name'.
+
+    def _pathToServiceName(filename)
+        
+        parts = ::DatawireQuarkCore.split(filename, "/")
+        service = (parts)[((parts).size) - (1)]
+        return (service)[(0)...(((service).size) - (5))]
+
+        nil
+    end
+
+    ##
+    # Send an appropriate update to the subscriber for this DiscoverySource.
+
+    def _update(service, nodes)
+        
+        (self).dispatcher.tell(self, ::Quark.mdk_discovery.ReplaceCluster.new(service, nodes), (self).subscriber)
+
+        nil
+    end
+
+    def onMessage(origin, message)
+        
+        typeId = (::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(message))).id
+        service = nil
+        if ((typeId) == ("mdk_runtime.files.FileContents"))
+            contents = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_runtime.files.FileContents }
+            if (!(((contents).path).end_with?(".json")))
+                return
+            end
+            service = self._pathToServiceName((contents).path)
+            json = ::DatawireQuarkCore::JSONObject.parse((contents).contents)
+            nodes = ::DatawireQuarkCore::List.new([])
+            idx = 0
+            while ((idx) < (json.size())) do
+                entry = json.getListItem(idx)
+                node = ::Quark.mdk_discovery.Node.new()
+                (node).service = service
+                (node).version = "1.0"
+                host = entry.getObjectItem("host").getString()
+                port = ((entry.getObjectItem("port").getNumber()).round()).to_s
+                (node).address = ((host) + (":")) + (port)
+                (nodes) << (node)
+                idx = (idx) + (1)
+            end
+            self._update(service, nodes)
+            return
+        end
+        if ((typeId) == ("mdk_runtime.files.FileDeleted"))
+            deleted = ::DatawireQuarkCore.cast(message) { ::Quark.mdk_runtime.files.FileDeleted }
+            service = self._pathToServiceName((deleted).path)
+            self._update(service, ::DatawireQuarkCore::List.new([]))
+            return
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_discovery.synapse._SynapseSource"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("subscriber"))
+            return (self).subscriber
+        end
+        if ((name) == ("directory_path"))
+            return (self).directory_path
+        end
+        if ((name) == ("files"))
+            return (self).files
+        end
+        if ((name) == ("dispatcher"))
+            return (self).dispatcher
+        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) == ("directory_path"))
+            (self).directory_path = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("files"))
+            (self).files = ::DatawireQuarkCore.cast(value) { ::Quark.mdk_runtime.files.FileActor }
+        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.subscriber = nil
+        self.directory_path = nil
+        self.files = nil
+        self.dispatcher = nil
+
+        nil
+    end
+
+
+end
+SynapseSource.unlazy_statics
+end # module Synapse
+end # module MdkDiscovery
+end # module Quark

data/lib/mdk_introspection.rb

@@ -0,0 +1,281 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+require "quark"
+def self.mdk_introspection; MdkIntrospection; end
+module MdkIntrospection
+require "datawire-quark-core"
+require_relative 'quark/reflect' # 0 ('quark',) ()
+require_relative 'datawire_mdk_md' # 0 () ()
+require_relative 'mdk_runtime' # 0 () ()
+require_relative 'quark' # 0 () ()
+require_relative 'quark/concurrent' # 0 ('quark',) ()
+require_relative 'mdk_introspection/aws' # 0 ('mdk_introspection',) ()
+require_relative 'mdk_introspection/kubernetes' # 0 ('mdk_introspection',) ()
+
+
+def self.Supplier; Supplier; end
+##
+# A Supplier has a 'get' method that can return a value to anyone who needs it.
+
+class Supplier < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static mdk_introspection_Supplier_quark_Object__ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Gets a value
+
+    def get()
+        raise NotImplementedError, '`Supplier.get` is an abstract method'
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Supplier.unlazy_statics
+
+def self.DatawireToken; DatawireToken; end
+class DatawireToken < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static TOKEN_VARIABLE_NAME: -> { "DATAWIRE_TOKEN" }
+    static mdk_introspection_DatawireToken_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Returns the Datawire Access Token by reading the environment variable DATAWIRE_TOKEN.
+
+    def self.getToken(env)
+        
+        token = env.var(::Quark.mdk_introspection.DatawireToken.TOKEN_VARIABLE_NAME).get()
+        if ((token) == (nil))
+            raise ("Neither 'MDK_DISCOVERY_SOURCE' nor 'DATAWIRE_TOKEN' are set. Either set the former to an existing discovery source (e.g. 'synapse:path=/synapse/output_files/'), or use the Datawire cloud services. For the latter please visit https://app.datawire.io/#/signup to create a free account and get a token.")
+        end
+        return token
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_introspection.DatawireToken"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("TOKEN_VARIABLE_NAME"))
+            return ::Quark.mdk_introspection.DatawireToken.TOKEN_VARIABLE_NAME
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("TOKEN_VARIABLE_NAME"))
+            ::Quark.mdk_introspection.DatawireToken.TOKEN_VARIABLE_NAME = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+DatawireToken.unlazy_statics
+
+def self.Platform; Platform; end
+class Platform < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static PLATFORM_TYPE_VARIABLE_NAME: -> { "DATAWIRE_PLATFORM_TYPE" }
+    static PLATFORM_TYPE_EC2: -> { "EC2" }
+    static PLATFORM_TYPE_GOOGLE_COMPUTE: -> { "GOOGLE_COMPUTE" }
+    static PLATFORM_TYPE_GOOGLE_CONTAINER: -> { "GOOGLE_CONTAINER" }
+    static PLATFORM_TYPE_KUBERNETES: -> { "Kubernetes" }
+    static ROUTABLE_HOST_VARIABLE_NAME: -> { "DATAWIRE_ROUTABLE_HOST" }
+    static ROUTABLE_PORT_VARIABLE_NAME: -> { "DATAWIRE_ROUTABLE_PORT" }
+    static mdk_introspection_Platform_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def self.platformType(env)
+        
+        result = env.var(::Quark.mdk_introspection.Platform.PLATFORM_TYPE_VARIABLE_NAME).get()
+        if ((result) != (nil))
+            result = (result).upcase
+        end
+        return result
+
+        nil
+    end
+
+    ##
+    # Returns the routable hostname or IP for this service instance.
+    # This method always returns the value of the environment variable DATAWIRE_ROUTABLE_HOST if it is defined.
+
+    def self.getRoutableHost(env)
+        
+        result = ::DatawireQuarkCore.cast(nil) { ::String }
+        logger = ::Quark.quark._getLogger("Platform")
+        if (env.var(::Quark.mdk_introspection.Platform.ROUTABLE_HOST_VARIABLE_NAME).isDefined())
+            logger.debug((("Using value in environment variable '") + (::Quark.mdk_introspection.Platform.ROUTABLE_HOST_VARIABLE_NAME)) + ("'"))
+            result = env.var(::Quark.mdk_introspection.Platform.ROUTABLE_HOST_VARIABLE_NAME).get()
+        else
+            if ((::Quark.mdk_introspection.Platform.platformType(env)) == (nil))
+                logger.error((("Platform type not specified in environment variable '") + (::Quark.mdk_introspection.Platform.PLATFORM_TYPE_VARIABLE_NAME)) + ("'"))
+                ::Quark.quark.concurrent.Context.runtime().fail("Environment variable 'DATAWIRE_PLATFORM_TYPE' is not set.")
+            end
+            if ((::Quark.mdk_introspection.Platform.platformType(env)).start_with?(::Quark.mdk_introspection.Platform.PLATFORM_TYPE_EC2))
+                logger.debug((::Quark.mdk_introspection.Platform.PLATFORM_TYPE_VARIABLE_NAME) + (" = EC2"))
+                parts = ::DatawireQuarkCore.split(::Quark.mdk_introspection.Platform.platformType(env), ":")
+                logger.debug(("Platform Scope = ") + ((parts)[1]))
+                if (((parts).size) == (2))
+                    return ::Quark.mdk_introspection.aws.Ec2Host.new(env, (parts)[1]).get()
+                else
+                    logger.error((("Invalid format for '") + (::Quark.mdk_introspection.Platform.PLATFORM_TYPE_VARIABLE_NAME)) + ("' starting with 'ec2'. Expected (ec2:<scope>)"))
+                    ::Quark.quark.concurrent.Context.runtime().fail("Invalid format for DATAWIRE_PLATFORM_TYPE == EC2. Expected EC2:<scope>.")
+                end
+            end
+        end
+        return result
+
+        nil
+    end
+
+    ##
+    # Returns the routable port number for this service instance or uses the provided port if a value cannot be resolved.
+    # This method always returns the value of the environment variable DATAWIRE_ROUTABLE_PORT if it is defined.
+
+    def self.getRoutablePort(env, servicePort)
+        
+        if (env.var(::Quark.mdk_introspection.Platform.ROUTABLE_PORT_VARIABLE_NAME).isDefined())
+            return Integer(env.var(::Quark.mdk_introspection.Platform.ROUTABLE_PORT_VARIABLE_NAME).get())
+        end
+        if ((::Quark.mdk_introspection.Platform.platformType(env)) == (::Quark.mdk_introspection.Platform.PLATFORM_TYPE_KUBERNETES))
+            return ::Quark.mdk_introspection.kubernetes.KubernetesPort.new().get()
+        end
+        return servicePort
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "mdk_introspection.Platform"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("PLATFORM_TYPE_VARIABLE_NAME"))
+            return ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_VARIABLE_NAME
+        end
+        if ((name) == ("PLATFORM_TYPE_EC2"))
+            return ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_EC2
+        end
+        if ((name) == ("PLATFORM_TYPE_GOOGLE_COMPUTE"))
+            return ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_GOOGLE_COMPUTE
+        end
+        if ((name) == ("PLATFORM_TYPE_GOOGLE_CONTAINER"))
+            return ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_GOOGLE_CONTAINER
+        end
+        if ((name) == ("PLATFORM_TYPE_KUBERNETES"))
+            return ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_KUBERNETES
+        end
+        if ((name) == ("ROUTABLE_HOST_VARIABLE_NAME"))
+            return ::Quark.mdk_introspection.Platform.ROUTABLE_HOST_VARIABLE_NAME
+        end
+        if ((name) == ("ROUTABLE_PORT_VARIABLE_NAME"))
+            return ::Quark.mdk_introspection.Platform.ROUTABLE_PORT_VARIABLE_NAME
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("PLATFORM_TYPE_VARIABLE_NAME"))
+            ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_VARIABLE_NAME = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("PLATFORM_TYPE_EC2"))
+            ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_EC2 = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("PLATFORM_TYPE_GOOGLE_COMPUTE"))
+            ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_GOOGLE_COMPUTE = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("PLATFORM_TYPE_GOOGLE_CONTAINER"))
+            ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_GOOGLE_CONTAINER = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("PLATFORM_TYPE_KUBERNETES"))
+            ::Quark.mdk_introspection.Platform.PLATFORM_TYPE_KUBERNETES = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("ROUTABLE_HOST_VARIABLE_NAME"))
+            ::Quark.mdk_introspection.Platform.ROUTABLE_HOST_VARIABLE_NAME = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("ROUTABLE_PORT_VARIABLE_NAME"))
+            ::Quark.mdk_introspection.Platform.ROUTABLE_PORT_VARIABLE_NAME = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Platform.unlazy_statics
+
+end # module MdkIntrospection
+end # module Quark