@hpcc-js/comms
Version:
hpcc-js - Communications
1,325 lines (1,219 loc) • 202 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@hpcc-js/util')) :
typeof define === 'function' && define.amd ? define(['exports', '@hpcc-js/util'], factory) :
(factory((global['@hpcc-js/comms'] = {}),global['@hpcc-js/util']));
}(this, (function (exports,util) { 'use strict';
(function(self) {
if (self.fetch) {
return
}
var support = {
searchParams: 'URLSearchParams' in self,
iterable: 'Symbol' in self && 'iterator' in Symbol,
blob: 'FileReader' in self && 'Blob' in self && (function() {
try {
new Blob();
return true
} catch(e) {
return false
}
})(),
formData: 'FormData' in self,
arrayBuffer: 'ArrayBuffer' in self
};
if (support.arrayBuffer) {
var viewClasses = [
'[object Int8Array]',
'[object Uint8Array]',
'[object Uint8ClampedArray]',
'[object Int16Array]',
'[object Uint16Array]',
'[object Int32Array]',
'[object Uint32Array]',
'[object Float32Array]',
'[object Float64Array]'
];
var isDataView = function(obj) {
return obj && DataView.prototype.isPrototypeOf(obj)
};
var isArrayBufferView = ArrayBuffer.isView || function(obj) {
return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
};
}
function normalizeName(name) {
if (typeof name !== 'string') {
name = String(name);
}
if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
throw new TypeError('Invalid character in header field name')
}
return name.toLowerCase()
}
function normalizeValue(value) {
if (typeof value !== 'string') {
value = String(value);
}
return value
}
// Build a destructive iterator for the value list
function iteratorFor(items) {
var iterator = {
next: function() {
var value = items.shift();
return {done: value === undefined, value: value}
}
};
if (support.iterable) {
iterator[Symbol.iterator] = function() {
return iterator
};
}
return iterator
}
function Headers(headers) {
this.map = {};
if (headers instanceof Headers) {
headers.forEach(function(value, name) {
this.append(name, value);
}, this);
} else if (Array.isArray(headers)) {
headers.forEach(function(header) {
this.append(header[0], header[1]);
}, this);
} else if (headers) {
Object.getOwnPropertyNames(headers).forEach(function(name) {
this.append(name, headers[name]);
}, this);
}
}
Headers.prototype.append = function(name, value) {
name = normalizeName(name);
value = normalizeValue(value);
var oldValue = this.map[name];
this.map[name] = oldValue ? oldValue+','+value : value;
};
Headers.prototype['delete'] = function(name) {
delete this.map[normalizeName(name)];
};
Headers.prototype.get = function(name) {
name = normalizeName(name);
return this.has(name) ? this.map[name] : null
};
Headers.prototype.has = function(name) {
return this.map.hasOwnProperty(normalizeName(name))
};
Headers.prototype.set = function(name, value) {
this.map[normalizeName(name)] = normalizeValue(value);
};
Headers.prototype.forEach = function(callback, thisArg) {
for (var name in this.map) {
if (this.map.hasOwnProperty(name)) {
callback.call(thisArg, this.map[name], name, this);
}
}
};
Headers.prototype.keys = function() {
var items = [];
this.forEach(function(value, name) { items.push(name); });
return iteratorFor(items)
};
Headers.prototype.values = function() {
var items = [];
this.forEach(function(value) { items.push(value); });
return iteratorFor(items)
};
Headers.prototype.entries = function() {
var items = [];
this.forEach(function(value, name) { items.push([name, value]); });
return iteratorFor(items)
};
if (support.iterable) {
Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
}
function consumed(body) {
if (body.bodyUsed) {
return Promise.reject(new TypeError('Already read'))
}
body.bodyUsed = true;
}
function fileReaderReady(reader) {
return new Promise(function(resolve, reject) {
reader.onload = function() {
resolve(reader.result);
};
reader.onerror = function() {
reject(reader.error);
};
})
}
function readBlobAsArrayBuffer(blob) {
var reader = new FileReader();
var promise = fileReaderReady(reader);
reader.readAsArrayBuffer(blob);
return promise
}
function readBlobAsText(blob) {
var reader = new FileReader();
var promise = fileReaderReady(reader);
reader.readAsText(blob);
return promise
}
function readArrayBufferAsText(buf) {
var view = new Uint8Array(buf);
var chars = new Array(view.length);
for (var i = 0; i < view.length; i++) {
chars[i] = String.fromCharCode(view[i]);
}
return chars.join('')
}
function bufferClone(buf) {
if (buf.slice) {
return buf.slice(0)
} else {
var view = new Uint8Array(buf.byteLength);
view.set(new Uint8Array(buf));
return view.buffer
}
}
function Body() {
this.bodyUsed = false;
this._initBody = function(body) {
this._bodyInit = body;
if (!body) {
this._bodyText = '';
} else if (typeof body === 'string') {
this._bodyText = body;
} else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
this._bodyBlob = body;
} else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
this._bodyFormData = body;
} else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
this._bodyText = body.toString();
} else if (support.arrayBuffer && support.blob && isDataView(body)) {
this._bodyArrayBuffer = bufferClone(body.buffer);
// IE 10-11 can't handle a DataView body.
this._bodyInit = new Blob([this._bodyArrayBuffer]);
} else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
this._bodyArrayBuffer = bufferClone(body);
} else {
throw new Error('unsupported BodyInit type')
}
if (!this.headers.get('content-type')) {
if (typeof body === 'string') {
this.headers.set('content-type', 'text/plain;charset=UTF-8');
} else if (this._bodyBlob && this._bodyBlob.type) {
this.headers.set('content-type', this._bodyBlob.type);
} else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
}
}
};
if (support.blob) {
this.blob = function() {
var rejected = consumed(this);
if (rejected) {
return rejected
}
if (this._bodyBlob) {
return Promise.resolve(this._bodyBlob)
} else if (this._bodyArrayBuffer) {
return Promise.resolve(new Blob([this._bodyArrayBuffer]))
} else if (this._bodyFormData) {
throw new Error('could not read FormData body as blob')
} else {
return Promise.resolve(new Blob([this._bodyText]))
}
};
this.arrayBuffer = function() {
if (this._bodyArrayBuffer) {
return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
} else {
return this.blob().then(readBlobAsArrayBuffer)
}
};
}
this.text = function() {
var rejected = consumed(this);
if (rejected) {
return rejected
}
if (this._bodyBlob) {
return readBlobAsText(this._bodyBlob)
} else if (this._bodyArrayBuffer) {
return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
} else if (this._bodyFormData) {
throw new Error('could not read FormData body as text')
} else {
return Promise.resolve(this._bodyText)
}
};
if (support.formData) {
this.formData = function() {
return this.text().then(decode)
};
}
this.json = function() {
return this.text().then(JSON.parse)
};
return this
}
// HTTP methods whose capitalization should be normalized
var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
function normalizeMethod(method) {
var upcased = method.toUpperCase();
return (methods.indexOf(upcased) > -1) ? upcased : method
}
function Request(input, options) {
options = options || {};
var body = options.body;
if (input instanceof Request) {
if (input.bodyUsed) {
throw new TypeError('Already read')
}
this.url = input.url;
this.credentials = input.credentials;
if (!options.headers) {
this.headers = new Headers(input.headers);
}
this.method = input.method;
this.mode = input.mode;
if (!body && input._bodyInit != null) {
body = input._bodyInit;
input.bodyUsed = true;
}
} else {
this.url = String(input);
}
this.credentials = options.credentials || this.credentials || 'omit';
if (options.headers || !this.headers) {
this.headers = new Headers(options.headers);
}
this.method = normalizeMethod(options.method || this.method || 'GET');
this.mode = options.mode || this.mode || null;
this.referrer = null;
if ((this.method === 'GET' || this.method === 'HEAD') && body) {
throw new TypeError('Body not allowed for GET or HEAD requests')
}
this._initBody(body);
}
Request.prototype.clone = function() {
return new Request(this, { body: this._bodyInit })
};
function decode(body) {
var form = new FormData();
body.trim().split('&').forEach(function(bytes) {
if (bytes) {
var split = bytes.split('=');
var name = split.shift().replace(/\+/g, ' ');
var value = split.join('=').replace(/\+/g, ' ');
form.append(decodeURIComponent(name), decodeURIComponent(value));
}
});
return form
}
function parseHeaders(rawHeaders) {
var headers = new Headers();
rawHeaders.split(/\r?\n/).forEach(function(line) {
var parts = line.split(':');
var key = parts.shift().trim();
if (key) {
var value = parts.join(':').trim();
headers.append(key, value);
}
});
return headers
}
Body.call(Request.prototype);
function Response(bodyInit, options) {
if (!options) {
options = {};
}
this.type = 'default';
this.status = 'status' in options ? options.status : 200;
this.ok = this.status >= 200 && this.status < 300;
this.statusText = 'statusText' in options ? options.statusText : 'OK';
this.headers = new Headers(options.headers);
this.url = options.url || '';
this._initBody(bodyInit);
}
Body.call(Response.prototype);
Response.prototype.clone = function() {
return new Response(this._bodyInit, {
status: this.status,
statusText: this.statusText,
headers: new Headers(this.headers),
url: this.url
})
};
Response.error = function() {
var response = new Response(null, {status: 0, statusText: ''});
response.type = 'error';
return response
};
var redirectStatuses = [301, 302, 303, 307, 308];
Response.redirect = function(url, status) {
if (redirectStatuses.indexOf(status) === -1) {
throw new RangeError('Invalid status code')
}
return new Response(null, {status: status, headers: {location: url}})
};
self.Headers = Headers;
self.Request = Request;
self.Response = Response;
self.fetch = function(input, init) {
return new Promise(function(resolve, reject) {
var request = new Request(input, init);
var xhr = new XMLHttpRequest();
xhr.onload = function() {
var options = {
status: xhr.status,
statusText: xhr.statusText,
headers: parseHeaders(xhr.getAllResponseHeaders() || '')
};
options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
var body = 'response' in xhr ? xhr.response : xhr.responseText;
resolve(new Response(body, options));
};
xhr.onerror = function() {
reject(new TypeError('Network request failed'));
};
xhr.ontimeout = function() {
reject(new TypeError('Network request failed'));
};
xhr.open(request.method, request.url, true);
if (request.credentials === 'include') {
xhr.withCredentials = true;
}
if ('responseType' in xhr && support.blob) {
xhr.responseType = 'blob';
}
request.headers.forEach(function(value, name) {
xhr.setRequestHeader(name, value);
});
xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
})
};
self.fetch.polyfill = true;
})(typeof self !== 'undefined' ? self : undefined);
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
var logger = util.scopedLogger("comms/connection.ts");
var DefaultOptions = {
type: "post",
baseUrl: "",
userID: "",
password: "",
rejectUnauthorized: false,
timeoutSecs: 60
};
// comms ---
function serializeRequest(obj, prefix) {
if (prefix === void 0) { prefix = ""; }
if (prefix) {
prefix += ".";
}
if (typeof obj !== "object") {
return encodeURIComponent(obj);
}
var str = [];
var _loop_1 = function (key) {
if (obj.hasOwnProperty(key)) {
if (obj[key] instanceof Array) {
// Specific to ESP - but no REST standard exists...
var includeItemCount_1 = false;
obj[key].forEach(function (row, i) {
if (typeof row === "object") {
includeItemCount_1 = true;
str.push(serializeRequest(row, prefix + encodeURIComponent(key + "." + i)));
}
else {
str.push(prefix + encodeURIComponent(key + "_i" + i) + "=" + serializeRequest(row));
}
});
if (includeItemCount_1) {
str.push(prefix + encodeURIComponent(key + ".itemcount") + "=" + obj[key].length);
}
}
else if (typeof obj[key] === "object") {
if (obj[key] && obj[key]["Item"] instanceof Array) { // Specific to ws_machine.GetTargetClusterInfo?
str.push(serializeRequest(obj[key]["Item"], prefix + encodeURIComponent(key)));
str.push(prefix + encodeURIComponent(key + ".itemcount") + "=" + obj[key]["Item"].length);
}
else {
str.push(serializeRequest(obj[key], prefix + encodeURIComponent(key)));
}
}
else if (obj[key] !== undefined) {
str.push(prefix + encodeURIComponent(key) + "=" + encodeURIComponent(obj[key]));
}
else {
str.push(prefix + encodeURIComponent(key));
}
}
};
for (var key in obj) {
_loop_1(key);
}
return str.join("&");
}
function deserializeResponse(body) {
return JSON.parse(body);
}
function jsonp(opts, action, request, responseType) {
if (request === void 0) { request = {}; }
if (responseType === void 0) { responseType = "json"; }
return new Promise(function (resolve, reject) {
var respondedTimeout = opts.timeoutSecs * 1000;
var respondedTick = 5000;
var callbackName = "jsonp_callback_" + Math.round(Math.random() * 999999);
window[callbackName] = function (response) {
respondedTimeout = 0;
doCallback();
resolve(responseType === "json" && typeof response === "string" ? deserializeResponse(response) : response);
};
var script = document.createElement("script");
var url = util.join(opts.baseUrl, action);
url += url.indexOf("?") >= 0 ? "&" : "?";
script.src = url + "jsonp=" + callbackName + "&" + serializeRequest(request);
document.body.appendChild(script);
var progress = setInterval(function () {
if (respondedTimeout <= 0) {
clearInterval(progress);
}
else {
respondedTimeout -= respondedTick;
if (respondedTimeout <= 0) {
clearInterval(progress);
logger.error("Request timeout: " + script.src);
doCallback();
reject(Error("Request timeout: " + script.src));
}
else {
logger.debug("Request pending (" + respondedTimeout / 1000 + " sec): " + script.src);
}
}
}, respondedTick);
function doCallback() {
delete window[callbackName];
document.body.removeChild(script);
}
});
}
function authHeader(opts) {
return opts.userID ? { Authorization: "Basic " + btoa(opts.userID + ":" + opts.password) } : {};
}
// _omitMap is a workaround for older HPCC-Platform instances without credentials ---
var _omitMap = {};
function doFetch(opts, action, requestInit, headersInit, responseType) {
headersInit = __assign({}, authHeader(opts), headersInit);
requestInit = __assign({ credentials: _omitMap[opts.baseUrl] ? "omit" : "include" }, requestInit, { headers: headersInit });
function handleResponse(response) {
if (response.ok) {
return responseType === "json" ? response.json() : response.text();
}
throw new Error(response.statusText);
}
return util.promiseTimeout(opts.timeoutSecs * 1000, fetch(util.join(opts.baseUrl, action), requestInit)
.then(handleResponse)
.catch(function (e) {
// Try again with the opposite credentials mode ---
requestInit.credentials = !_omitMap[opts.baseUrl] ? "omit" : "include";
return fetch(util.join(opts.baseUrl, action), requestInit)
.then(handleResponse)
.then(function (responseBody) {
_omitMap[opts.baseUrl] = !_omitMap[opts.baseUrl]; // The "opposite" credentials mode is known to work ---
return responseBody;
});
}));
}
function post(opts, action, request, responseType) {
if (responseType === void 0) { responseType = "json"; }
return doFetch(opts, action, {
method: "post",
body: serializeRequest(request)
}, {
"Content-Type": "application/x-www-form-urlencoded"
}, responseType);
}
function get(opts, action, request, responseType) {
if (responseType === void 0) { responseType = "json"; }
return doFetch(opts, action + "?" + serializeRequest(request), {
method: "get"
}, {}, responseType);
}
function send(opts, action, request, responseType) {
if (responseType === void 0) { responseType = "json"; }
var retVal;
switch (opts.type) {
case "jsonp":
retVal = jsonp(opts, action, request, responseType);
break;
case "get":
retVal = get(opts, action, request, responseType);
break;
case "post":
default:
retVal = post(opts, action, request, responseType);
break;
}
return retVal;
}
var hookedSend = send;
function hookSend(newSend) {
var retVal = hookedSend;
if (newSend) {
hookedSend = newSend;
}
return retVal;
}
var Connection = /** @class */ (function () {
function Connection(opts) {
this.opts(opts);
}
Connection.prototype.opts = function (_) {
if (arguments.length === 0)
return this._opts;
this._opts = __assign({}, DefaultOptions, _);
return this;
};
Connection.prototype.send = function (action, request, responseType) {
if (responseType === void 0) { responseType = "json"; }
return hookedSend(this._opts, action, request, responseType);
};
Connection.prototype.clone = function () {
return new Connection(this.opts());
};
return Connection;
}());
exports.createConnection = function (opts) {
return new Connection(opts);
};
function setTransportFactory(newFunc) {
var retVal = exports.createConnection;
exports.createConnection = newFunc;
return retVal;
}
function isArray(arg) {
return Object.prototype.toString.call(arg) === "[object Array]";
}
var ESPExceptions = /** @class */ (function (_super) {
__extends(ESPExceptions, _super);
function ESPExceptions(action, request, exceptions) {
var _this = _super.call(this, "ESPException: " + exceptions.Source) || this;
_this.isESPExceptions = true;
_this.action = action;
_this.request = request;
_this.Source = exceptions.Source;
_this.Exception = exceptions.Exception;
if (exceptions.Exception.length) {
_this.message = exceptions.Exception[0].Code + ": " + exceptions.Exception[0].Message;
}
return _this;
}
return ESPExceptions;
}(Error));
function isConnection(optsConnection) {
return optsConnection.send !== undefined;
}
var ESPConnection = /** @class */ (function () {
function ESPConnection(optsConnection, service, version) {
this._connection = isConnection(optsConnection) ? optsConnection : exports.createConnection(optsConnection);
this._service = service;
this._version = version;
}
ESPConnection.prototype.service = function (_) {
if (_ === void 0)
return this._service;
this._service = _;
return this;
};
ESPConnection.prototype.version = function (_) {
if (_ === void 0)
return this._version;
this._version = _;
return this;
};
ESPConnection.prototype.toESPStringArray = function (target, arrayName) {
if (isArray(target[arrayName])) {
for (var i = 0; i < target[arrayName].length; ++i) {
target[arrayName + "_i" + i] = target[arrayName][i];
}
delete target[arrayName];
}
return target;
};
ESPConnection.prototype.opts = function (_) {
if (_ === void 0)
return this._connection.opts();
this._connection.opts(_);
return this;
};
ESPConnection.prototype.send = function (action, _request, espResponseType, largeUpload) {
if (_request === void 0) { _request = {}; }
if (espResponseType === void 0) { espResponseType = "json"; }
if (largeUpload === void 0) { largeUpload = false; }
var request = __assign({}, _request, { ver_: this._version });
if (largeUpload) {
request["upload_"] = true;
}
var serviceAction;
var responseType = "json";
switch (espResponseType) {
case "text":
serviceAction = util.join(this._service, action);
responseType = "text";
break;
case "xsd":
serviceAction = util.join(this._service, action + ".xsd");
responseType = "text";
break;
case "json2":
serviceAction = util.join(this._service, action + "/json");
espResponseType = "json";
var actionParts = action.split("/");
action = actionParts.pop();
break;
default:
serviceAction = util.join(this._service, action + ".json");
}
return this._connection.send(serviceAction, request, responseType).then(function (response) {
if (espResponseType === "json") {
var retVal = void 0;
if (response && response.Exceptions) {
throw new ESPExceptions(action, request, response.Exceptions);
}
else if (response) {
retVal = response[(action === "WUCDebug" ? "WUDebug" : action) + "Response"];
}
if (!retVal) {
throw new ESPExceptions(action, request, {
Source: "ESPConnection.send",
Exception: [{ Code: 0, Message: "Missing Response" }]
});
}
return retVal;
}
return response;
}).catch(function (e) {
if (e.isESPExceptions) {
throw e;
}
throw new ESPExceptions(action, request, {
Source: "ESPConnection.send",
Exception: [{ Code: 0, Message: e.message }]
});
});
};
ESPConnection.prototype.clone = function () {
return new ESPConnection(this._connection.clone(), this._service, this._version);
};
return ESPConnection;
}());
/*
export class WsECLConnection extends ESPConnection {
send(action: string, _request: any = {}, responseType: ResponseType = "json"): Promise<any> {
if (responseType === "json") {
serviceAction = join(this._service, action + "/json");
responseType = "json";
const actionParts = action.split("/");
action = actionParts.pop()!;
}
return super.send(action, _request, responseType);
}
}
*/
var AccountService = /** @class */ (function () {
function AccountService(optsConnection) {
this._connection = new ESPConnection(optsConnection, "Ws_Account", "1.03");
}
AccountService.prototype.connectionOptions = function () {
return this._connection.opts();
};
AccountService.prototype.VerifyUser = function (request) {
return this._connection.send("VerifyUser", request);
};
return AccountService;
}());
var DFUService = /** @class */ (function () {
function DFUService(optsConnection) {
this._connection = new ESPConnection(optsConnection, "WsDFU", "1.35");
}
DFUService.prototype.DFUQuery = function (request) {
return this._connection.send("DFUQuery", request);
};
return DFUService;
}());
function jsonToIField(id, item) {
var type = typeof item;
switch (type) {
case "boolean":
case "number":
case "string":
return { id: id, type: type };
case "object":
if (item.Row instanceof Array) {
item = item.Row;
}
if (item instanceof Array) {
return {
id: id,
type: "dataset",
children: jsonToIFieldArr(item[0])
};
}
// Fall through ---
default:
throw new Error("Unknown field type");
}
}
function jsonToIFieldArr(json) {
if (json.Row && json.Row instanceof Array) {
json = json.Row[0];
}
var retVal = [];
for (var key in json) {
retVal.push(jsonToIField(key, json[key]));
}
return retVal;
}
var EclService = /** @class */ (function () {
function EclService(optsConnection) {
this._connection = new ESPConnection(optsConnection, "WsEcl", "0");
}
EclService.prototype.opts = function () {
return this._connection.opts();
};
EclService.prototype.requestJson = function (querySet, queryId) {
// http://192.168.3.22:8002/WsEcl/example/request/query/roxie/peopleaccounts/json?display
return this._connection.send("example/request/query/" + querySet + "/" + queryId + "/json", {}, "text").then(function (response) {
var requestSchema = JSON.parse(response);
for (var key in requestSchema) {
return requestSchema[key];
}
return {};
}).then(jsonToIFieldArr);
};
EclService.prototype.responseJson = function (querySet, queryId) {
// http://192.168.3.22:8002/WsEcl/example/response/query/roxie/peopleaccounts/json?display
return this._connection.send("example/response/query/" + querySet + "/" + queryId + "/json", {}, "text").then(function (response) {
var responseSchema = JSON.parse(response);
for (var key in responseSchema) {
return responseSchema[key].Results;
}
return {};
}).then(function (resultsJson) {
var retVal = {};
for (var key in resultsJson) {
retVal[key] = jsonToIFieldArr(resultsJson[key]);
}
return retVal;
});
};
EclService.prototype.submit = function (querySet, queryId, request) {
// http://192.168.3.22:8002/WsEcl/submit/query/roxie/peopleaccounts.1/json
var action = "submit/query/" + querySet + "/" + queryId;
return this._connection.send(action, request, "json2").then(function (response) {
if (response.Results && response.Results.Exception) {
throw new ESPExceptions(action, request, {
Source: "wsEcl.submit",
Exception: response.Results.Exception
});
}
return response.Results;
});
};
return EclService;
}());
var MachineService = /** @class */ (function () {
function MachineService(optsConnection) {
this._connection = new ESPConnection(optsConnection, "ws_machine", "1.13");
}
MachineService.prototype.GetTargetClusterInfo = function (request) {
if (request === void 0) { request = {}; }
return this._connection.send("GetTargetClusterInfo", request);
};
return MachineService;
}());
var SMCService = /** @class */ (function () {
function SMCService(optsConnection) {
this._connection = new ESPConnection(optsConnection, "WsSMC", "1.19");
}
SMCService.prototype.connectionOptions = function () {
return this._connection.opts();
};
SMCService.prototype.Activity = function (request) {
return this._connection.send("Activity", request).then(function (response) {
return __assign({ Running: {
ActiveWorkunit: []
} }, response);
});
};
return SMCService;
}());
var TopologyService = /** @class */ (function () {
function TopologyService(optsConnection) {
this._connection = new ESPConnection(optsConnection, "WsTopology", "1.25");
}
TopologyService.prototype.connectionOptions = function () {
return this._connection.opts();
};
TopologyService.prototype.protocol = function () {
var parts = this._connection.opts().baseUrl.split("//");
return parts[0];
};
TopologyService.prototype.ip = function () {
var parts = this._connection.opts().baseUrl.split("//");
var parts2 = parts[1].split(":");
return parts2[0];
};
TopologyService.prototype.TpLogicalClusterQuery = function (request) {
if (request === void 0) { request = {}; }
return this._connection.send("TpLogicalClusterQuery", request);
};
TopologyService.prototype.DefaultTpLogicalClusterQuery = function (request) {
if (request === void 0) { request = {}; }
return this.TpLogicalClusterQuery(request).then(function (response) {
if (response.default) {
return response.default;
}
var firstHThor;
var first;
response.TpLogicalClusters.TpLogicalCluster.some(function (item, idx) {
if (idx === 0) {
first = item;
}
if (item.Type === "hthor") {
firstHThor = item;
return true;
}
return false;
});
return firstHThor || first;
});
};
TopologyService.prototype.TpServiceQuery = function (request) {
return this._connection.send("TpServiceQuery", request);
};
TopologyService.prototype.TpTargetClusterQuery = function (request) {
return this._connection.send("TpTargetClusterQuery", request);
};
return TopologyService;
}());
(function (WUStateID) {
WUStateID[WUStateID["Unknown"] = 0] = "Unknown";
WUStateID[WUStateID["Compiled"] = 1] = "Compiled";
WUStateID[WUStateID["Running"] = 2] = "Running";
WUStateID[WUStateID["Completed"] = 3] = "Completed";
WUStateID[WUStateID["Failed"] = 4] = "Failed";
WUStateID[WUStateID["Archived"] = 5] = "Archived";
WUStateID[WUStateID["Aborting"] = 6] = "Aborting";
WUStateID[WUStateID["Aborted"] = 7] = "Aborted";
WUStateID[WUStateID["Blocked"] = 8] = "Blocked";
WUStateID[WUStateID["Submitted"] = 9] = "Submitted";
WUStateID[WUStateID["Scheduled"] = 10] = "Scheduled";
WUStateID[WUStateID["Compiling"] = 11] = "Compiling";
WUStateID[WUStateID["Wait"] = 12] = "Wait";
WUStateID[WUStateID["UploadingFiled"] = 13] = "UploadingFiled";
WUStateID[WUStateID["DebugPaused"] = 14] = "DebugPaused";
WUStateID[WUStateID["DebugRunning"] = 15] = "DebugRunning";
WUStateID[WUStateID["Paused"] = 16] = "Paused";
WUStateID[WUStateID["LAST"] = 17] = "LAST";
WUStateID[WUStateID["NotFound"] = 999] = "NotFound";
})(exports.WUStateID || (exports.WUStateID = {}));
(function (WUUpdate) {
var Action;
(function (Action) {
Action[Action["Unknown"] = 0] = "Unknown";
Action[Action["Compile"] = 1] = "Compile";
Action[Action["Check"] = 2] = "Check";
Action[Action["Run"] = 3] = "Run";
Action[Action["ExecuteExisting"] = 4] = "ExecuteExisting";
Action[Action["Pause"] = 5] = "Pause";
Action[Action["PauseNow"] = 6] = "PauseNow";
Action[Action["Resume"] = 7] = "Resume";
Action[Action["Debug"] = 8] = "Debug";
Action[Action["__size"] = 9] = "__size";
})(Action = WUUpdate.Action || (WUUpdate.Action = {}));
})(exports.WUUpdate || (exports.WUUpdate = {}));
function isWUQueryECLWorkunit(_) {
return _.TotalClusterTime !== undefined;
}
function isWUInfoWorkunit(_) {
return _.StateEx !== undefined;
}
var WorkunitsService = /** @class */ (function () {
function WorkunitsService(optsConnection) {
this._connection = new ESPConnection(optsConnection, "WsWorkunits", "1.68");
}
WorkunitsService.prototype.opts = function () {
return this._connection.opts();
};
WorkunitsService.prototype.connection = function () {
return this._connection;
};
WorkunitsService.prototype.WUQuery = function (request) {
if (request === void 0) { request = {}; }
return this._connection.send("WUQuery", request).then(function (response) {
return util.deepMixin({ Workunits: { ECLWorkunit: [] } }, response);
});
};
WorkunitsService.prototype.WUInfo = function (_request) {
var request = __assign({ Wuid: "", TruncateEclTo64k: true, IncludeExceptions: false, IncludeGraphs: false, IncludeSourceFiles: false, IncludeResults: false, IncludeResultsViewNames: false, IncludeVariables: false, IncludeTimers: false, IncludeDebugValues: false, IncludeApplicationValues: false, IncludeWorkflows: false, IncludeXmlSchemas: false, IncludeResourceURLs: false, SuppressResultSchemas: true }, _request);
return this._connection.send("WUInfo", request);
};
WorkunitsService.prototype.WUCreate = function () {
return this._connection.send("WUCreate");
};
WorkunitsService.prototype.WUUpdate = function (request) {
return this._connection.send("WUUpdate", request, "json", true);
};
WorkunitsService.prototype.WUSubmit = function (request) {
return this._connection.send("WUSubmit", request);
};
WorkunitsService.prototype.WUResubmit = function (request) {
this._connection.toESPStringArray(request, "Wuids");
return this._connection.send("WUResubmit", request);
};
WorkunitsService.prototype.WUQueryDetails = function (request) {
return this._connection.send("WUQueryDetails", request);
};
WorkunitsService.prototype.WUListQueries = function (request) {
return this._connection.send("WUListQueries", request);
};
WorkunitsService.prototype.WUPushEvent = function (request) {
return this._connection.send("WUPushEvent", request);
};
WorkunitsService.prototype.WUAction = function (request) {
request.ActionType = request.WUActionType; // v5.x compatibility
return this._connection.send("WUAction", request);
};
WorkunitsService.prototype.WUGetZAPInfo = function (request) {
return this._connection.send("WUGetZAPInfo", request);
};
WorkunitsService.prototype.WUShowScheduled = function (request) {
return this._connection.send("WUShowScheduled", request);
};
WorkunitsService.prototype.WUQuerySetAliasAction = function (request) {
return this._connection.send("WUQuerySetAliasAction", request);
};
WorkunitsService.prototype.WUQuerySetQueryAction = function (request) {
return this._connection.send("WUQuerySetQueryAction", request);
};
WorkunitsService.prototype.WUPublishWorkunit = function (request) {
return this._connection.send("WUPublishWorkunit", request);
};
WorkunitsService.prototype.WUGetGraph = function (request) {
return this._connection.send("WUGetGraph", request);
};
WorkunitsService.prototype.WUResult = function (request) {
return this._connection.send("WUResult", request);
};
WorkunitsService.prototype.WUQueryGetGraph = function (request) {
return this._connection.send("WUQueryGetGraph", request);
};
WorkunitsService.prototype.WUFile = function (request) {
return this._connection.send("WUFile", request, "text");
};
WorkunitsService.prototype.WUGetStats = function (request) {
return this._connection.send("WUGetStats", request);
};
WorkunitsService.prototype.WUDetailsMeta = function (request) {
if (!this._WUDetailsMetaPromise) {
this._WUDetailsMetaPromise = this._connection.send("WUDetailsMeta", request);
}
return this._WUDetailsMetaPromise;
};
WorkunitsService.prototype.WUDetails = function (request) {
return this._connection.send("WUDetails", request);
};
WorkunitsService.prototype.WUCDebug = function (request) {
return this._connection.send("WUCDebug", request).then(function (response) {
var retVal = util.xml2json(response.Result);
var children = retVal.children();
if (children.length) {
return children[0];
}
return null;
});
};
return WorkunitsService;
}());
var t0 = new Date,
t1 = new Date;
function newInterval(floori, offseti, count, field) {
function interval(date) {
return floori(date = new Date(+date)), date;
}
interval.floor = interval;
interval.ceil = function(date) {
return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
};
interval.round = function(date) {
var d0 = interval(date),
d1 = interval.ceil(date);
return date - d0 < d1 - date ? d0 : d1;
};
interval.offset = function(date, step) {
return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
};
interval.range = function(start, stop, step) {
var range = [];
start = interval.ceil(start);
step = step == null ? 1 : Math.floor(step);
if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
do range.push(new Date(+start)); while (offseti(start, step), floori(start), start < stop)
return range;
};
interval.filter = function(test) {
return newInterval(function(date) {
if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1);
}, function(date, step) {
if (date >= date) while (--step >= 0) while (offseti(date, 1), !test(date)) {} // eslint-disable-line no-empty
});
};
if (count) {
interval.count = function(start, end) {
t0.setTime(+start), t1.setTime(+end);
floori(t0), floori(t1);
return Math.floor(count(t0, t1));
};
interval.every = function(step) {
step = Math.floor(step);
return !isFinite(step) || !(step > 0) ? null
: !(step > 1) ? interval
: interval.filter(field
? function(d) { return field(d) % step === 0; }
: function(d) { return interval.count(0, d) % step === 0; });
};
}
return interval;
}
var millisecond = newInterval(function() {
// noop
}, function(date, step) {
date.setTime(+date + step);
}, function(start, end) {
return end - start;
});
// An optimized implementation for this simple case.
millisecond.every = function(k) {
k = Math.floor(k);
if (!isFinite(k) || !(k > 0)) return null;
if (!(k > 1)) return millisecond;
return newInterval(function(date) {
date.setTime(Math.floor(date / k) * k);
}, function(date, step) {
date.setTime(+date + step * k);
}, function(start, end) {
return (end - start) / k;
});
};
var durationSecond = 1e3;
var durationMinute = 6e4;
var durationHour = 36e5;
var durationDay = 864e5;
var durationWeek = 6048e5;
var second = newInterval(function(date) {
date.setTime(Math.floor(date / durationSecond) * durationSecond);
}, function(date, step) {
date.setTime(+date + step * durationSecond);
}, function(start, end) {
return (end - start) / durationSecond;
}, function(date) {
return date.getUTCSeconds();
});
var minute = newInterval(function(date) {
date.setTime(Math.floor(date / durationMinute) * durationMinute);
}, function(date, step) {
date.setTime(+date + step * durationMinute);
}, function(start, end) {
return (end - start) / durationMinute;
}, function(date) {
return date.getMinutes();
});
var hour = newInterval(function(date) {
var offset = date.getTimezoneOffset() * durationMinute % durationHour;
if (offset < 0) offset += durationHour;
date.setTime(Math.floor((+date - offset) / durationHour) * durationHour + offset);
}, function(date, step) {
date.setTime(+date + step * durationHour);
}, function(start, end) {
return (end - start) / durationHour;
}, function(date) {
return date.getHours();
});
var day = newInterval(function(date) {
date.setHours(0, 0, 0, 0);
}, function(date, step) {
date.setDate(date.getDate() + step);
}, function(start, end) {
return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay;
}, function(date) {
return date.getDate()