296 lines
9.0 KiB
JavaScript
296 lines
9.0 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true,
|
|
});
|
|
exports.default = void 0;
|
|
var _HttpError = _interopRequireDefault(require("./HttpError"));
|
|
var _NetworkError = _interopRequireDefault(require("./NetworkError"));
|
|
var _exponentialBackoff = require("exponential-backoff");
|
|
var _http = _interopRequireDefault(require("http"));
|
|
var _https = _interopRequireDefault(require("https"));
|
|
var _httpsProxyAgent = require("https-proxy-agent");
|
|
var _zlib = _interopRequireDefault(require("zlib"));
|
|
function _interopRequireDefault(e) {
|
|
return e && e.__esModule ? e : { default: e };
|
|
}
|
|
const ZLIB_OPTIONS = {
|
|
level: 9,
|
|
};
|
|
const NULL_BYTE = 0x00;
|
|
const NULL_BYTE_BUFFER = Buffer.from([NULL_BYTE]);
|
|
class HttpStore {
|
|
static HttpError = _HttpError.default;
|
|
static NetworkError = _NetworkError.default;
|
|
#getEndpoint;
|
|
#setEndpoint;
|
|
constructor(options) {
|
|
this.#getEndpoint = this.#createEndpointConfig(
|
|
options.getOptions != null ? options.getOptions : options,
|
|
);
|
|
this.#setEndpoint = this.#createEndpointConfig(
|
|
options.setOptions != null ? options.setOptions : options,
|
|
);
|
|
}
|
|
#createEndpointConfig(options) {
|
|
const agentConfig = {
|
|
family: options.family,
|
|
keepAlive: true,
|
|
keepAliveMsecs: options.timeout || 5000,
|
|
maxSockets: 64,
|
|
maxFreeSockets: 64,
|
|
};
|
|
if (options.key != null) {
|
|
agentConfig.key = options.key;
|
|
}
|
|
if (options.cert != null) {
|
|
agentConfig.cert = options.cert;
|
|
}
|
|
if (options.ca != null) {
|
|
agentConfig.ca = options.ca;
|
|
}
|
|
if (options.socketPath != null) {
|
|
agentConfig.socketPath = options.socketPath;
|
|
}
|
|
const uri = new URL(options.endpoint);
|
|
const module = uri.protocol === "http:" ? _http.default : _https.default;
|
|
const agent =
|
|
options.proxy != null
|
|
? new _httpsProxyAgent.HttpsProxyAgent(options.proxy, agentConfig)
|
|
: new module.Agent(agentConfig);
|
|
if (!uri.hostname || !uri.pathname) {
|
|
throw new TypeError("Invalid endpoint: " + options.endpoint);
|
|
}
|
|
return {
|
|
agent,
|
|
headers: options.headers,
|
|
host: uri.hostname,
|
|
path: uri.pathname,
|
|
port: +uri.port,
|
|
params: new URLSearchParams(options.params),
|
|
timeout: options.timeout || 5000,
|
|
module: uri.protocol === "http:" ? _http.default : _https.default,
|
|
additionalSuccessStatuses: new Set(
|
|
options.additionalSuccessStatuses ?? [],
|
|
),
|
|
debug: options.debug ?? false,
|
|
maxAttempts: options.maxAttempts ?? 1,
|
|
retryStatuses: new Set(options.retryStatuses ?? []),
|
|
retryNetworkErrors: options.retryNetworkErrors ?? false,
|
|
};
|
|
}
|
|
get(key) {
|
|
return this.#withRetries(() => this.#getOnce(key), this.#getEndpoint);
|
|
}
|
|
#getOnce(key) {
|
|
return new Promise((resolve, reject) => {
|
|
let searchParamsString = this.#getEndpoint.params.toString();
|
|
if (searchParamsString != "") {
|
|
searchParamsString = "?" + searchParamsString;
|
|
}
|
|
const options = {
|
|
agent: this.#getEndpoint.agent,
|
|
headers: this.#getEndpoint.headers,
|
|
host: this.#getEndpoint.host,
|
|
method: "GET",
|
|
path: `${this.#getEndpoint.path}/${key.toString("hex")}${searchParamsString}`,
|
|
port: this.#getEndpoint.port,
|
|
timeout: this.#getEndpoint.timeout,
|
|
};
|
|
const req = this.#getEndpoint.module.request(options, (res) => {
|
|
const code = res.statusCode;
|
|
const data = [];
|
|
if (code === 404) {
|
|
res.resume();
|
|
resolve(null);
|
|
return;
|
|
} else if (
|
|
code !== 200 &&
|
|
!this.#getEndpoint.additionalSuccessStatuses.has(code)
|
|
) {
|
|
if (this.#getEndpoint.debug) {
|
|
res.on("data", (chunk) => {
|
|
data.push(chunk);
|
|
});
|
|
res.on("error", (err) => {
|
|
reject(
|
|
new _HttpError.default(
|
|
"Encountered network error (" +
|
|
err.message +
|
|
") while handling HTTP error: " +
|
|
code +
|
|
" " +
|
|
_http.default.STATUS_CODES[code],
|
|
code,
|
|
),
|
|
);
|
|
});
|
|
res.on("end", () => {
|
|
const buffer = Buffer.concat(data);
|
|
reject(
|
|
new _HttpError.default(
|
|
"HTTP error: " +
|
|
code +
|
|
" " +
|
|
_http.default.STATUS_CODES[code] +
|
|
"\n\n" +
|
|
buffer.toString(),
|
|
code,
|
|
),
|
|
);
|
|
});
|
|
} else {
|
|
res.resume();
|
|
reject(
|
|
new _HttpError.default(
|
|
"HTTP error: " + code + " " + _http.default.STATUS_CODES[code],
|
|
code,
|
|
),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
const gunzipped = res.pipe(_zlib.default.createGunzip());
|
|
gunzipped.on("data", (chunk) => {
|
|
data.push(chunk);
|
|
});
|
|
gunzipped.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
gunzipped.on("end", () => {
|
|
try {
|
|
const buffer = Buffer.concat(data);
|
|
if (buffer.length > 0 && buffer[0] === NULL_BYTE) {
|
|
resolve(buffer.slice(1));
|
|
} else {
|
|
resolve(JSON.parse(buffer.toString("utf8")));
|
|
}
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
res.on("error", (err) => gunzipped.emit("error", err));
|
|
});
|
|
req.on("error", (err) => {
|
|
reject(new _NetworkError.default(err.message, err.code));
|
|
});
|
|
req.on("timeout", () => {
|
|
req.destroy(new Error("Request timed out"));
|
|
});
|
|
req.end();
|
|
});
|
|
}
|
|
set(key, value) {
|
|
return this.#withRetries(
|
|
() => this.#setOnce(key, value),
|
|
this.#setEndpoint,
|
|
);
|
|
}
|
|
#setOnce(key, value) {
|
|
return new Promise((resolve, reject) => {
|
|
const gzip = _zlib.default.createGzip(ZLIB_OPTIONS);
|
|
let searchParamsString = this.#setEndpoint.params.toString();
|
|
if (searchParamsString != "") {
|
|
searchParamsString = "?" + searchParamsString;
|
|
}
|
|
const options = {
|
|
agent: this.#setEndpoint.agent,
|
|
headers: this.#setEndpoint.headers,
|
|
host: this.#setEndpoint.host,
|
|
method: "PUT",
|
|
path: `${this.#setEndpoint.path}/${key.toString("hex")}${searchParamsString}`,
|
|
port: this.#setEndpoint.port,
|
|
timeout: this.#setEndpoint.timeout,
|
|
};
|
|
const req = this.#setEndpoint.module.request(options, (res) => {
|
|
const code = res.statusCode;
|
|
if (
|
|
(code < 200 || code > 299) &&
|
|
!this.#setEndpoint.additionalSuccessStatuses.has(code)
|
|
) {
|
|
if (this.#setEndpoint.debug) {
|
|
const data = [];
|
|
res.on("data", (chunk) => {
|
|
data.push(chunk);
|
|
});
|
|
res.on("error", (err) => {
|
|
reject(
|
|
new _HttpError.default(
|
|
"Encountered network error (" +
|
|
err.message +
|
|
") while handling HTTP error: " +
|
|
code +
|
|
" " +
|
|
_http.default.STATUS_CODES[code],
|
|
code,
|
|
),
|
|
);
|
|
});
|
|
res.on("end", () => {
|
|
const buffer = Buffer.concat(data);
|
|
reject(
|
|
new _HttpError.default(
|
|
"HTTP error: " +
|
|
code +
|
|
" " +
|
|
_http.default.STATUS_CODES[code] +
|
|
"\n\n" +
|
|
buffer.toString(),
|
|
code,
|
|
),
|
|
);
|
|
});
|
|
} else {
|
|
res.resume();
|
|
reject(
|
|
new _HttpError.default(
|
|
"HTTP error: " + code + " " + _http.default.STATUS_CODES[code],
|
|
code,
|
|
),
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
res.on("error", (err) => {
|
|
reject(err);
|
|
});
|
|
res.on("end", () => {
|
|
resolve();
|
|
});
|
|
res.resume();
|
|
});
|
|
req.on("timeout", () => {
|
|
req.destroy(new Error("Request timed out"));
|
|
});
|
|
gzip.pipe(req);
|
|
if (value instanceof Buffer) {
|
|
gzip.write(NULL_BYTE_BUFFER);
|
|
gzip.end(value);
|
|
} else {
|
|
gzip.end(JSON.stringify(value) || "null");
|
|
}
|
|
});
|
|
}
|
|
clear() {}
|
|
#withRetries(fn, endpoint) {
|
|
if (endpoint.maxAttempts === 1) {
|
|
return fn();
|
|
}
|
|
return (0, _exponentialBackoff.backOff)(fn, {
|
|
jitter: "full",
|
|
maxDelay: 30000,
|
|
numOfAttempts: this.#getEndpoint.maxAttempts || Number.POSITIVE_INFINITY,
|
|
retry: (e) => {
|
|
if (e instanceof _HttpError.default) {
|
|
return this.#getEndpoint.retryStatuses.has(e.code);
|
|
}
|
|
return (
|
|
e instanceof _NetworkError.default &&
|
|
this.#getEndpoint.retryNetworkErrors
|
|
);
|
|
},
|
|
});
|
|
}
|
|
}
|
|
exports.default = HttpStore;
|