datawire_mdk 2.0.5

data/lib/quark/behaviors.rb

@@ -0,0 +1,494 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.behaviors; Behaviors; end
+module Behaviors
+require "datawire-quark-core"
+require_relative 'reflect' # 1 () ()
+require_relative 'error' # 1 () ()
+require_relative '../datawire_mdk_md' # 0 () ('quark',)
+require_relative '../quark' # 0 () ('quark',)
+require_relative 'concurrent' # 1 () ()
+
+
+def self.RPCError; RPCError; end
+class RPCError < ::Quark.quark.error.Error
+    extend ::DatawireQuarkCore::Static
+
+    static quark_behaviors_RPCError_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super(message)
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.behaviors.RPCError"
+
+        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
+RPCError.unlazy_statics
+
+def self.RPC; RPC; end
+class RPC < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :service, :returned, :timeout, :methodName, :instance
+    extend ::DatawireQuarkCore::Static
+
+    static quark_behaviors_RPC_ref: -> { nil }
+
+
+
+    def initialize(service, methodName)
+        
+        self.__init_fields__
+        timeout = ::DatawireQuarkCore.cast((service)._getField("timeout")) { ::Float }
+        if (((timeout) == (nil)) || ((timeout) <= (0.0)))
+            timeout = 10.0
+        end
+        override = service.getTimeout()
+        if (((override) != (nil)) && ((override) > (0.0)))
+            timeout = override
+        end
+        (self).returned = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(service)).getMethod(methodName).getType()
+        (self).timeout = timeout
+        (self).methodName = methodName
+        (self).service = service
+
+        nil
+    end
+
+
+
+
+    def call(args)
+        
+        result = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.concurrent.Future }
+        (self).instance = (self).service.getInstance()
+        if (((self).instance) != (nil))
+            request = ::DatawireQuarkCore::HTTP::Request.new((self).instance.getURL())
+            json = ::Quark.quark.toJSON(args, nil)
+            envelope = ::DatawireQuarkCore::JSONObject.new
+            (envelope).setObjectItem(("$method"), (::DatawireQuarkCore::JSONObject.new.setString((self).methodName)))
+            (envelope).setObjectItem(("$context"), (::DatawireQuarkCore::JSONObject.new.setString("TBD")))
+            (envelope).setObjectItem(("rpc"), (json))
+            body = envelope.toString()
+            request.setBody(body)
+            request.setMethod("POST")
+            rpc = ::Quark.quark.behaviors.RPCRequest.new(args, self)
+            result = rpc.call(request)
+        else
+            result = ::DatawireQuarkCore.cast(@returned.construct(::DatawireQuarkCore::List.new([]))) { ::Quark.quark.concurrent.Future }
+            result.finish(::Quark.quark.behaviors.RPCError.new("all services are down"))
+        end
+        ::Quark.quark.concurrent.FutureWait.waitFor(result, 10.0)
+        return result
+
+        nil
+    end
+
+    def succeed(info)
+        
+        (self).instance.succeed(info)
+
+        nil
+    end
+
+    def fail(info)
+        
+        (self).instance.fail(info)
+
+        nil
+    end
+
+    def toString()
+        
+        return (((((("RPC ") + ((self).service.getName())) + (" at ")) + ((self).instance.getURL())) + (": ")) + ((self).methodName)) + ("(...)")
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.behaviors.RPC"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("service"))
+            return (self).service
+        end
+        if ((name) == ("returned"))
+            return (self).returned
+        end
+        if ((name) == ("timeout"))
+            return (self).timeout
+        end
+        if ((name) == ("methodName"))
+            return (self).methodName
+        end
+        if ((name) == ("instance"))
+            return (self).instance
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("service"))
+            (self).service = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Service }
+        end
+        if ((name) == ("returned"))
+            (self).returned = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("timeout"))
+            (self).timeout = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("methodName"))
+            (self).methodName = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("instance"))
+            (self).instance = ::DatawireQuarkCore.cast(value) { ::Quark.quark.ServiceInstance }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.service = nil
+        self.returned = nil
+        self.timeout = nil
+        self.methodName = nil
+        self.instance = nil
+
+        nil
+    end
+
+
+end
+RPC.unlazy_statics
+
+def self.RPCRequest; RPCRequest; end
+class RPCRequest < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :rpc, :retval, :args, :timeout
+    extend ::DatawireQuarkCore::Static
+
+    static quark_behaviors_RPCRequest_ref: -> { nil }
+
+
+
+    def initialize(args, rpc)
+        
+        self.__init_fields__
+        (self).retval = ::DatawireQuarkCore.cast((rpc).returned.construct(::DatawireQuarkCore::List.new([]))) { ::Quark.quark.concurrent.Future }
+        (self).args = args
+        (self).timeout = ::Quark.quark.concurrent.Timeout.new((rpc).timeout)
+        (self).rpc = rpc
+
+        nil
+    end
+
+
+
+
+    def call(request)
+        
+        (self).timeout.start(self)
+        ::Quark.quark.concurrent.Context.runtime().request(request, self)
+        return (self).retval
+
+        nil
+    end
+
+    def onHTTPResponse(rq, response)
+        
+        info = nil
+        (self).timeout.cancel()
+        if ((response.getCode()) != (200))
+            info = (((self).rpc.toString()) + (" failed: Server returned error ")) + ((response.getCode()).to_s)
+            (self).retval.finish(::Quark.quark.behaviors.RPCError.new(info))
+            (self).rpc.fail(info)
+            return
+        end
+        body = response.getBody()
+        obj = ::DatawireQuarkCore::JSONObject.parse(body)
+        classname = (obj).getObjectItem("$class").getString()
+        if ((classname) == (nil))
+            info = ((self).rpc.toString()) + (" failed: Server returned unrecognizable content")
+            (self).retval.finish(::Quark.quark.behaviors.RPCError.new(info))
+            (self).rpc.fail(info)
+            return
+        else
+            ::Quark.quark.fromJSON(((self).rpc).returned, (self).retval, obj)
+            (self).retval.finish(nil)
+            (self).rpc.succeed("Success in the future...")
+        end
+
+        nil
+    end
+
+    def onTimeout(timeout)
+        
+        (self).retval.finish(::Quark.quark.behaviors.RPCError.new("request timed out"))
+        (self).rpc.fail("request timed out")
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.behaviors.RPCRequest"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("rpc"))
+            return (self).rpc
+        end
+        if ((name) == ("retval"))
+            return (self).retval
+        end
+        if ((name) == ("args"))
+            return (self).args
+        end
+        if ((name) == ("timeout"))
+            return (self).timeout
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("rpc"))
+            (self).rpc = ::DatawireQuarkCore.cast(value) { ::Quark.quark.behaviors.RPC }
+        end
+        if ((name) == ("retval"))
+            (self).retval = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Future }
+        end
+        if ((name) == ("args"))
+            (self).args = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("timeout"))
+            (self).timeout = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Timeout }
+        end
+
+        nil
+    end
+
+    def onHTTPInit(request)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPError(request, message)
+        
+        nil
+
+        nil
+    end
+
+    def onHTTPFinal(request)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.rpc = nil
+        self.retval = nil
+        self.args = nil
+        self.timeout = nil
+
+        nil
+    end
+
+
+end
+RPCRequest.unlazy_statics
+
+def self.CircuitBreaker; CircuitBreaker; end
+class CircuitBreaker < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :id, :failureLimit, :retestDelay, :active, :failureCount, :mutex
+    extend ::DatawireQuarkCore::Static
+
+    static quark_behaviors_CircuitBreaker_ref: -> { nil }
+
+
+
+    def initialize(id, failureLimit, retestDelay)
+        
+        self.__init_fields__
+        (self).id = id
+        (self).failureLimit = failureLimit
+        (self).retestDelay = retestDelay
+
+        nil
+    end
+
+
+
+
+    def succeed()
+        
+        (self).mutex.acquire()
+        if (((self).failureCount) > (0))
+            ::Quark.quark.Client.logger.info(("- CLOSE breaker on ") + ((self).id))
+        end
+        (self).failureCount = 0
+        (self).mutex.release()
+
+        nil
+    end
+
+    def fail()
+        
+        doSchedule = false
+        (self).mutex.acquire()
+        (self).failureCount = ((self).failureCount) + (1)
+        if (((self).failureCount) >= ((self).failureLimit))
+            (self).active = false
+            doSchedule = true
+            ::Quark.quark.Client.logger.warn(("- OPEN breaker on ") + ((self).id))
+        end
+        (self).mutex.release()
+        if (doSchedule)
+            ::Quark.quark.concurrent.Context.runtime().schedule(self, (self).retestDelay)
+        end
+
+        nil
+    end
+
+    def onExecute(runtime)
+        
+        (self).mutex.acquire()
+        (self).active = true
+        ::Quark.quark.Client.logger.warn(("- RETEST breaker on ") + ((self).id))
+        (self).mutex.release()
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.behaviors.CircuitBreaker"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("id"))
+            return (self).id
+        end
+        if ((name) == ("failureLimit"))
+            return (self).failureLimit
+        end
+        if ((name) == ("retestDelay"))
+            return (self).retestDelay
+        end
+        if ((name) == ("active"))
+            return (self).active
+        end
+        if ((name) == ("failureCount"))
+            return (self).failureCount
+        end
+        if ((name) == ("mutex"))
+            return (self).mutex
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("id"))
+            (self).id = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("failureLimit"))
+            (self).failureLimit = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("retestDelay"))
+            (self).retestDelay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("active"))
+            (self).active = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("failureCount"))
+            (self).failureCount = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("mutex"))
+            (self).mutex = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.id = nil
+        self.failureLimit = nil
+        self.retestDelay = nil
+        self.active = true
+        self.failureCount = 0
+        self.mutex = ::DatawireQuarkCore::Lock.new()
+
+        nil
+    end
+
+
+end
+CircuitBreaker.unlazy_statics
+end # module Behaviors
+end # module Quark
+end # module Quark