js-gei 1.0.0

package/Library/jsonrpc-2.0.js

@@ -0,0 +1,869 @@
+import axios from 'axios';
+var RpcClient = initRpcClient();
+
+function initRpcClient() {
+    let dt = new Date();
+    let _id = dt.getMilliseconds() + (1000 * dt.getSeconds()) + (60000 * dt.getMinutes()) + (3600000 * dt.getHours());
+    let _ctxid = 0;
+    let _preempted = null;
+    let _pendingAjaxCount = 0;
+
+    let _currentPath = window.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "");
+    let _currentPathTopLevel = '(unavailable)';
+    try {
+        _currentPathTopLevel = window.top.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "");
+    } catch (e) {
+        // Ignore sandbox error.
+    }
+
+    function schedulePreemptedQuery(id, ticket, processor, progressor, context, queue) {
+        let started = true;
+        if (!_preempted) {
+            _preempted = [];
+            started = false;
+        }
+
+        _preempted.push({ id: id, ticket: ticket, processor: processor, progressor: progressor, context: context, queue: queue });
+
+        let queries = 0;
+
+        function query() {
+            // Check if there is anything to query, first.
+            if (_preempted && _preempted.length === 0) {
+                _preempted = null;
+                return;
+            }
+
+            queries++;
+
+            // Configure the RPC context to automatically reschedule the query afterwards.
+            let ctx = RpcClient.context().onFinally(function () {
+                if (queries <= 2) {
+                    setTimeout(query, 2000);
+                } else if (queries <= 4) {
+                    setTimeout(query, 3000);
+                } else {
+                    setTimeout(query, 5000);
+                }
+            });
+
+            // Gather the tickets for all known preempted requests and issue a combined query.
+            let tickets = [];
+            for (let i = 0; i < _preempted.length; i++) {
+                let ticket = _preempted[i].ticket;
+                tickets.push(ticket);
+            }
+            
+            RpcClient.call('$.QueryPreemptedResponses', { 'tickets': tickets }).done(function (e) {
+                if (e.error) {
+                    // Something went wrong. Prevent future queries by removing current items
+                    // and manually invoke the callbacks with appropriate error.
+                    let items = _preempted.splice(0, tickets.length);
+                    for (let i = 0; i < items.length; i++) {
+                        let item = items[i];
+                        item.processor.process(e);
+                    }
+
+                    // Leave each item's context exactly once!
+                    for (let i = 0; i < items.length; i++) {
+                        let item = items[i];
+                        if (item.context.preempted) {
+                            item.context.preempted = null;
+                            item.context.__leave();
+                        }
+                    }
+
+                    return false; // Handled.
+                }
+
+                // Process each returned status report - there is one for each ticket that was queried.
+                for (let ticket in e.result) {
+                    let report = e.result[ticket];
+
+                    // Find the pending request that corresponds to current report.
+                    let idx = -1;
+                    for (let j = 0; j < _preempted.length; j++) {
+                        let p = _preempted[j];
+                        if (p.ticket === ticket) {
+                            idx = j;
+                            break;
+                        }
+                    }
+
+                    if (idx === -1) {
+                        // Request not found. Shouldn't happen.
+                        continue;
+                    }
+
+                    function handleTicketStatusReport(report, ticket, idx) {
+
+                        // IMPORTANT: Preserve the order of callback execution for each queue by gathering the
+                        //            ticket responses first and storing them temporarily inside the corresponding
+                        //            source queue. Execute them only after they've all been retrieved!
+                        function gather(item, rpcresult) {
+                            if (!item.queue.ready) {
+                                item.queue.ready = [];
+                            }
+                            
+                            item.queue.ready.push({
+                                ticket: ticket, handler: function () {
+                                    try {
+                                        item.processor.process(rpcresult);
+                                    } finally {
+                                        // Clean up the original context.
+                                        let idxt = item.context.preempted.indexOf(ticket);
+                                        item.context.preempted.splice(idxt, 1);
+
+                                        if (item.context.preempted.length === 0) {
+                                            item.context.preempted = null;
+                                            item.context.__leave();
+                                        }
+                                    }
+                                }
+                            });
+
+                            // Invoke deferred callbacks for item's queue when it's ready.
+                            // IMPORTANT: Do it in the same order as the tickets were originally queried, NOT the one in which
+                            //            their statuses were gathered!
+                            if (item.queue.ready.length === item.queue.preempted) {
+                                for (let i = 0; i < tickets.length; i++) {
+                                    let reqt = tickets[i];
+                                    for (let j = 0; j < item.queue.ready.length; j++) {
+                                        let rsp = item.queue.ready[j];
+                                        if (rsp.ticket !== reqt) {
+                                            continue;
+                                        }
+                                        
+                                        rsp.handler();
+                                    }
+                                }
+
+                                item.queue.ready = [];
+                            }
+                        }
+
+                        if (report.status === 'error') {
+                            // The response could not be found.
+                            let item = _preempted.splice(idx, 1)[0];
+
+                            gather(item, { id: item.id, error: { code: -1, message: report.reason } });
+                        }
+                        else if (report.status === 'ok') {
+                            // The response is ready to be retrieved.
+                            let r = _preempted.splice(idx, 1)[0];
+
+                            let retrieve = function (r) {
+                                RpcClient.call('$.RetrievePreemptedResponse', { 'ticket': r.ticket })
+                                    .done(function(realResponse) {
+                                        let response = realResponse;
+                                        if (response && response.result && response.result.code && response.result.code >= -32700 && response.result.code <= -32000) {
+                                            // This is likely a preempted error, so report it as such.
+                                            response = { id: response.id, error: response.result };
+                                        }
+
+                                        gather(r, response);
+                                    })
+                                    .post(ctx);
+                            }
+                            
+                            retrieve(r);
+                        } else {
+                            // Trigger the progress callback WITHOUT removing the item.
+                            // It will be queried again in the next round.
+                            let item = _preempted[idx];
+                            if (item.progressor) {
+                                item.progressor.progress(report);
+                            }
+                        }
+                    }
+
+                    handleTicketStatusReport(report, ticket, idx);
+                }
+
+                return false; // Handled.
+            }).post(ctx);
+        }
+
+        if (!started) {
+            setTimeout(query, 2000);
+        }
+    }
+
+    let _dispatcher = function () {
+        let _queue = [];
+        let _last = null;
+        let _delay = 700; // This is the window in ms, during which rapid requests are batched.
+        
+        function postQueue(config) {
+            let queue = _queue;
+            _queue = [];
+
+            if (queue.length === 0) {
+                return;
+            }
+
+            queue.preempted = 0;
+
+            // Combine all batches into one request.
+            let batch;
+            if (queue.length === 1) {
+                batch = queue[0].batch;
+            } else {
+                batch = [];
+                for (let i = 0; i < queue.length; i++) {
+                    let qb = queue[i].batch;
+                    for (let j = 0; j < qb.length; j++) {
+                        batch.push(qb[j]);
+                    }
+                }
+            }
+
+            let request = [];
+            if (batch.length === 1) {
+                request = batch[0].request;
+            }
+            else {
+                // Send multiple requests as sync batch so server can take advantage of caching.
+                request.push({ method: '$.BeginSynchronizedBatch', params: [] });
+                for (let i = 0; i < batch.length; i++) {
+                    let r = batch[i].request;
+                    if (i === 0 && r.method === request[0].method) {
+                        // Don't duplicate the sync batch header - use the explicitly provided one.
+                        request[0] = r;
+                        continue;
+                    }
+
+                    request.push(batch[i].request);
+                }
+            }
+            
+            // Prepare a joined fail wrapper for all queued batches.
+            let fail = function(rpc, error) {
+                for (let i = 0; i < queue.length; i++) {
+                    queue[i].fail(rpc, error);
+                }
+            }
+
+            let handler = function (data, xhr) {
+                try {
+                    if (!data) {
+                        fail(true, "Server returned an empty response. This is likely a server bug.");
+                        return;
+                    }
+
+                    if (data.ajaxCallFailed) {
+                        if (data.error.status === 'timeout') {
+                            fail(true, 'JSON-RPC call failed. Timeout.');
+                        } else if (data.error.status === 'error' && !data.error.details) {
+                            fail(true, 'JSON-RPC call failed. No connection to server.');
+                        } else {
+                            fail(true, "JSON-RPC call failed. Status: '" + data.error.status + "'" +
+                                (data.error.details ? (", Details: " + JSON.stringify(data.error.details, null, 2)) : ''));
+                        }
+                        return;
+                    }
+
+                    let responses = (typeof data === 'object' && data instanceof Array) ? data : [data];
+                    if (responses.length === 0) {
+                        fail(true, "Server returned an empty list of responses.");
+                        return;
+                    }
+
+                    // Look for known special "broadcast"-type responses that come in singles.
+                    if (responses.length === 1) {
+                        let response = responses[0];
+                        if (typeof (response.id) !== 'undefined' && response.id.indexOf && response.id.indexOf('e2-status-') === 0) {
+                            // Distribute this response to all queued requests' callbacks.
+                            responses = [];
+                            for (let b = 0; b < queue.length; b++) {
+                                let qb = queue[b];
+                                let batch = qb.batch;
+                                for (let m = 0; m < batch.length; m++) {
+                                    let copy = JSON.parse(JSON.stringify(response));
+                                    copy.id = batch[m].request.id;
+
+                                    responses.push(copy);
+                                }
+                            }
+                        }
+                    }
+
+                    for (let l = 0; l < responses.length; l++) {
+                        let response = responses[l];
+
+                        if (typeof (response.result) === 'undefined' && !response.error) {
+                            // TODO: This shouldn't go through fail - it should go through callbacks, otherwise they will hang!
+                            fail(true, "Server returned invalid JSON-RPC response: " + JSON.stringify(response, null, 2));
+                            return;
+                        }
+
+                        // Find the request to which this response belongs.
+                        let callbacks = null;
+                        let progressCallbacks = null;
+                        let context = null;
+
+                        if (typeof (response.id) !== 'undefined') {
+                            for (let b = 0; b < queue.length; b++) {
+                                let qb = queue[b];
+                                let batch = qb.batch;
+                                for (let m = 0; m < batch.length; m++) {
+                                    let item = batch[m];
+                                    if (!item.request.id || (item.request.id !== response.id)) {
+                                        continue;
+                                    }
+
+                                    callbacks = item.callbacks;
+                                    progressCallbacks = item.progressCallbacks;
+                                    context = qb.context;
+                                    break;
+                                }
+
+                                if (callbacks) {
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (!context) {
+                            // The response is not mappable to any request. Provide a default.
+                            context = RpcClient.context();
+                            callbacks = [function (m) {
+                                if (window.MessagesUI) {
+                                    window.MessagesUI.show({ message: m, json: true });
+                                } else {
+                                    console.log(m);
+                                }
+                                return true;
+                            }];
+
+                            progressCallbacks = [];
+                        }
+
+                        // Prepare a processor instance.
+                        let processor = {
+                            context: context,
+                            callbacks: callbacks,
+                            process: function(response, xhr) {
+                                // Invoke the context previewer.
+                                let doDefaultProcessing = this.context.__preview(response);
+                                if (!doDefaultProcessing) {
+                                    return;
+                                }
+
+                                // Invoke the callbacks.
+                                if (this.callbacks) {
+                                    for (let n = 0; n < this.callbacks.length; n++) {
+                                        let callback = this.callbacks[n];
+                                        if (!callback(response, xhr)) {
+                                            doDefaultProcessing = false;
+                                        }
+                                    }
+                                }
+
+                                // If none of the handlers actually handled the request, invoke our default processing.
+                                if (doDefaultProcessing) {
+                                    if (response.error) {
+                                        if (!this.context.__defaultApiFail(response.error)) {
+                                            fail(false, response.error);
+                                        }
+                                    } else if (!this.context.__defaultApiSucceed(response.result)) {
+                                        config.log(response.result);
+                                    }
+                                }
+                            }
+                        };
+
+                        // Response was preempted. Schedule processor for background waiting, unless explicitly forbidden by config.
+                        if (response.error && response.error.code === -32099 && config.autoQueryPreempted) {
+                            let ticket = response.error.data;
+
+                            if (!context.preempted) {
+                                context.preempted = [];
+                            }
+
+                            context.preempted.push(ticket);
+                            queue.preempted++;
+
+                            // Prepare a progress handler.
+                            let progressor = {
+                                callbacks: progressCallbacks,
+                                progress: function(report) {
+                                    if (!this.callbacks) {
+                                        return;
+                                    }
+
+                                    for (let c = 0; c < this.callbacks.length; c++) {
+                                        let callback = this.callbacks[c];
+                                        if (callback) {
+                                            callback(report);
+                                        }
+                                    }
+                                }
+                            };
+                            
+                            schedulePreemptedQuery(response.id, ticket, processor, progressor, context, queue);
+                            continue;
+                        }
+
+                        // Process the current response.
+                        processor.process(response, xhr);
+                    }
+                } finally {
+                    for (let i = 0; i < queue.length; i++) {
+                        // Only leave the context at this point if none of its requests were preempted!
+                        let ctx = queue[i].context;
+                        if (!ctx.preempted) {
+                            ctx.__leave();
+                        }
+                    }
+                }
+            };
+            
+            let requestConfig = {
+                timeout: 0, // config.timeout,
+                responseType: 'blob',
+                withCredentials: true
+            }
+
+            // Apply custom headers.
+            let headers = config.headers;
+            if (!headers) {
+                headers = {};
+            } else {
+                headers = JSON.parse(JSON.stringify(headers));
+            }
+
+            // Configure preemptive response support.
+            let preempt = headers["JsonRpc-Preempt-After"];
+            if (!preempt) {
+                headers["JsonRpc-Preempt-After"] = config.jsonRpcPreemptAfter;
+            }
+
+            headers["JsonRpc-Path-TopLevel"] = _currentPathTopLevel;
+            headers["JsonRpc-Path"] = _currentPath;
+
+            requestConfig["headers"] = headers;
+
+            _pendingAjaxCount++;
+            
+            axios.post(config.url, request, requestConfig)
+                .then(async function (response) {
+                    _pendingAjaxCount--;
+
+                    let length = response.headers["Content-Length"] ?? response.headers["content-length"] ?? response.headers["D3Pro-Uncompressed-Content-Length"] ?? response.headers["d3pro-uncompressed-content-length"] ?? 0;
+                    const blob = new Blob([response.data], { type: 'application/json' });
+
+                    //console.log(config);
+                    let downloadToFile = length && config.largeResponseDownloadLimitMb && config.largeResponseDownloadLimitMb > 0 && length > config.largeResponseDownloadLimitMb * 1024 * 1024;
+                    //console.log("Length: " + length);
+                    //console.log("Download to file: " + (downloadToFile ? "YES" : "NO"));
+
+                    if (downloadToFile) {
+                        let fileName = `LargeJsonRpcResponse (${new Date().toISOString().replace('T', ' ').replaceAll(':', '-',)}).json`;
+                        console.log("Response too large to load. It will be downloaded to file instead: " + fileName);
+                        const a = document.createElement("a");
+                        const url = URL.createObjectURL(blob);
+                        a.href = url;
+                        a.download = fileName;
+                        a.click();
+                        URL.revokeObjectURL(url);
+
+                        handler({ error: { status: "TOO_LARGE_REDIRECTED_TO_FILE", details: "Response was too large to load. It was saved to a file instead: '" + fileName + "'." } }, response.request);
+                    } else {
+                        let json = JSON.parse(await blob.text());
+
+                        handler(json, response.request);
+                    }
+                })
+                .catch(function (error) {
+                    console.log(error);
+
+                    _pendingAjaxCount--;
+                    handler({ error: { status: error.code, details: error.message }, ajaxCallFailed: true });
+                });
+        }
+
+        return {
+            dispatch: function(batch, context, fail, customConfig) {
+                let last = _last;
+                _last = new Date();
+
+                if (_queue.length === 0) {
+                    _queue.created = _last;
+                }
+
+                _queue.push({ batch, context, fail });
+
+                let config = customConfig ?? RpcClient.config;
+
+                // Make sure that preemption requests aren't batched. It would be a protocol violation.
+                if (batch.length === 1) {
+                    let method = batch[0].request.method;     
+                    if (method[0] === '$' && method.indexOf('Preempted') > -1) {
+                        // If a preemption request comes in a batch, we pop it from the queue and send it separately after the batch.
+                        if (_queue.length > 1) {
+                            let temp = _queue.pop();
+                            postQueue(config); 
+                            
+                            _queue = [];
+                            _queue.push(temp);                            
+                        }
+
+                        // Solo preemption requests are sent straight away.
+                        postQueue(config);
+                        return;
+                    }
+                }
+
+                if (!config.batch) {
+                    postQueue(config);
+                    return;
+                }
+
+                if (last != null) {
+                    let diff = _last - last;
+                    let span = _last - _queue.created;
+
+                    let delayExistingBatch = span < 3000 && (_pendingAjaxCount > 3 || diff < _delay);
+                    if (delayExistingBatch) {
+                        // Reschedule pending post.
+                        if (_queue.timeoutHandle) {
+                            clearTimeout(_queue.timeoutHandle);
+                            _queue.timeoutHandle = null;
+                        }
+                    }
+                }
+
+                if (_pendingAjaxCount === 0) {
+                    // There are no pending AJAX posts, so post immediately.
+                    _queue.timeoutHandle = setTimeout(function () {
+                        postQueue(config);
+                    }, 1);
+                    return;
+                }
+
+                // There are existing pending posts, so schedule a delayed one.
+                _queue.timeoutHandle = setTimeout(function () {
+                    postQueue(config);
+                }, _delay + 50);
+            }
+        }
+    }();
+
+    function preparePacket() {
+        let method = arguments[0];
+        let args = [];
+
+        const isPlainObject = value => value && [undefined, Object].includes(value.constructor);
+
+        if (arguments.length === 2 && (isPlainObject(arguments[1]) || Array.isArray(arguments[1]))) {
+            args = arguments[1];
+        } else {
+            for (let i = 1; i < arguments.length; i++) {
+                args.push(arguments[i]);
+            }
+        }
+
+        return { method: method, params: args };
+    }
+
+    function main(packet, config) {
+        let batch = [];
+        batch.push({ request: packet, callbacks: [], progressCallbacks: [] });
+
+        let context = null;
+        
+        let fail = function(rpc, e) {
+            // NOTE: Context.__rpcFail should only be called for ajax failures.
+            if (context && rpc === true && context.__rpcFail(e)) {
+                return;
+            }
+            
+            if (config && config.unhandledError) {
+                config.unhandledError(e);
+                return;
+            }
+            
+            console.log(e);
+        };
+
+        return {
+            call: function () {
+                let p = preparePacket.apply(null, arguments);
+                _id++;
+                p.id = _id;
+                batch.push({ request: p, callbacks: [], progressCallbacks: [] });
+                
+                return this;
+            },
+            notify: function () {
+                let p = preparePacket.apply(null, arguments);
+                batch.push({ request: p, callbacks: [], progressCallbacks: [] });
+                
+                return this;
+            },
+            using: function (id) {
+                let p = batch[batch.length - 1].request;
+                p.id = id;
+
+                return this;
+            },
+            done: function (c) {
+                let item = batch.length > 0 ? batch[batch.length - 1] : null;
+                if (typeof (c) == 'function') {
+                    item.callbacks.push(c);
+                }
+
+                return this;
+            },
+            progress: function (c) {
+                let item = batch.length > 0 ? batch[batch.length - 1] : null;
+                if (typeof (c) == 'function') {
+                    item.progressCallbacks.push(c);
+                }
+
+                return this;
+            },
+            post: function (ctx, customConfig) {
+                context = ctx;
+
+                if (!context) {
+                    context = RpcClient.context();
+                }
+
+                context.__enter();
+
+                let config = customConfig ?? RpcClient.config;
+                if (!config) {
+                    try {
+                        fail(true, "RpcClient was invoked without a valid config object!");
+                    } finally {
+                        context.__leave();
+                    }
+                    return;
+                }
+                
+                // Is this request supposed to go as JSONP?
+                if (config.jsonp) {
+                    let request = [];
+                    if (batch.length === 1) {
+                        request = batch[0].request;
+                    }
+                    else {
+                        for (let i = 0; i < batch.length; i++) {
+                            request.push(batch[i].request);
+                        }
+                    }
+
+                    let headers = config.headers;
+                    if (!headers) {
+                        headers = {};
+                    }
+
+                    let jsonp = "__jsonpCallback_" + _id;
+                    let url = config.url + "?callback=" + jsonp + "&jsonrpc=" + JSON.stringify(request);
+                    
+                    for (let header in headers) {
+                        if (headers.hasOwnProperty(header)) {
+                            url = url + "&" + header + "=" + config.headers[header];
+                        }
+                    }
+
+                    let script = document.createElement("script");
+                    script.setAttribute("src", url);
+                    
+                    window[jsonp] = function (data) {
+                        window[jsonp] = null;
+
+                        document.getElementsByTagName("body")[0].removeChild(script);
+                        script = null;
+
+                        handler(data);
+                    };
+
+                    // This will trigger the call to JSONP server.
+                    document.getElementsByTagName("body")[0].appendChild(script);
+                    
+                    context.__leave();
+
+                    return;
+                }
+
+                // No, dispatch it through AJAX.
+                _dispatcher.dispatch(batch, context, fail, config);
+            }
+        };
+    }
+    
+    let configTemplate = {
+        url: "json.rpc",
+        //timeout: 20000,
+        batch: true,
+        jsonRpcPreemptAfter: 7,
+        autoQueryPreempted: true,
+        log: function (obj) { console.log(obj); },
+        unhandledError: function (e) { console.log(e); }
+    }
+
+    let baseUrl = null;
+    let headElements = document.getElementsByTagName("head");
+    if (headElements && headElements.length) {
+        let baseElements = headElements[0].getElementsByTagName("base");
+        if (baseElements && baseElements.length) {
+            baseUrl = baseElements[0].getAttribute("href");
+        }
+    }
+    
+    function urlCombine(parts) {
+        return parts.map(function (part) { return part.trim().replace(/(^[\/]*|[\/]*$)/g, ""); }).join("/");
+    }
+
+    let path = window.top.location.pathname.trim().replace(/(^[\/]*|[\/]*$)/g, "");
+    if (!path || path === '') {
+        if (baseUrl) {
+            configTemplate.url = urlCombine([baseUrl, configTemplate.url]);
+        }
+    } else {
+        if (baseUrl) {
+            configTemplate.url = urlCombine([baseUrl, path, configTemplate.url]);
+        } else {
+            configTemplate.url = urlCombine([path, configTemplate.url]);
+        }
+    }
+
+    return {
+        config: configTemplate,
+        call: function() {
+            let packet = preparePacket.apply(null, arguments);
+            _id++;
+            packet.id = _id;
+            return main(packet, this.config);
+        },
+        notify: function () {
+            let packet = preparePacket.apply(null, arguments);
+            return main(packet, this.config);
+        },
+        context: function () {
+            _ctxid++;
+
+            let ctx = {
+                id: _ctxid,
+                count: 0,
+                rpcErrorHandlers: [],
+                apiErrorHandlers: [],
+                apiSuccessHandlers: [],
+                responsePreviewers: [],
+                finallyHandlers: []
+            };
+
+            return {
+                // These are meant for user code.
+                onRpcError: function (c) {
+                    if (typeof (c) == 'function') {
+                        ctx.rpcErrorHandlers.push(c);
+                    }
+
+                    return this;
+                },
+                onDefaultApiError: function (c) {
+                    if (typeof (c) == 'function') {
+                        ctx.apiErrorHandlers.push(c);
+                    }
+
+                    return this;
+                },
+                onDefaultApiSuccess: function (c) {
+                    if (typeof (c) == 'function') {
+                        ctx.apiSuccessHandlers.push(c);
+                    }
+
+                    return this;
+                },
+                onFinally: function (c) {
+                    if (typeof (c) == 'function') {
+                        ctx.finallyHandlers.push(c);
+                    }
+
+                    return this;
+                },
+                onPreviewResponse: function (c) {
+                    if (typeof (c) == 'function') {
+                        ctx.responsePreviewers.push(c);
+                    }
+
+                    return this;
+                },
+
+                // These are called internally.
+                __enter: function () {
+                    ctx.count++;
+                },
+                __preview: function () {
+                    // IMPORTANT: If this function returns true, it means it DIDN'T handle the request and other handlers should proceed.
+                    //            This is the reverse of the other function below, which return true when they DO handle it!
+                    if (ctx.responsePreviewers.length === 0) {
+                        return true; // Not handled.
+                    }
+
+                    let handled = false;
+
+                    for (let i = 0; i < ctx.responsePreviewers.length; i++) {
+                        let callback = ctx.responsePreviewers[i];
+                        if (!callback.apply(null, arguments)) {
+                            handled = true;
+                        }
+                    }
+
+                    return !handled;
+                },
+                __rpcFail: function () {
+                    if (ctx.rpcErrorHandlers.length === 0) {
+                        return false;
+                    }
+
+                    for (let i = 0; i < ctx.rpcErrorHandlers.length; i++) {
+                        let callback = ctx.rpcErrorHandlers[i];
+                        callback.apply(null, arguments);
+                    }
+
+                    return true;
+                },
+                __defaultApiFail: function () {
+                    if (ctx.apiErrorHandlers.length === 0) {
+                        return false;
+                    }
+
+                    for (let i = 0; i < ctx.apiErrorHandlers.length; i++) {
+                        let callback = ctx.apiErrorHandlers[i];
+                        callback.apply(null, arguments);
+                    }
+
+                    return true;
+                },
+                __defaultApiSucceed: function () {
+                    if (ctx.apiSuccessHandlers.length === 0) {
+                        return false;
+                    }
+
+                    for (let i = 0; i < ctx.apiSuccessHandlers.length; i++) {
+                        let callback = ctx.apiSuccessHandlers[i];
+                        callback.apply(null, arguments);
+                    }
+
+                    return true;
+                },
+                __leave: function () {
+                    ctx.count--;
+                    if (ctx.count > 0) {
+                        return;
+                    }
+
+                    for (let i = 0; i < ctx.finallyHandlers.length; i++) {
+                        let callback = ctx.finallyHandlers[i];
+                        callback.apply(null, arguments);
+                    }
+                }
+            };
+        }
+    };
+}