242 lines
10 KiB
JavaScript
242 lines
10 KiB
JavaScript
import { HttpResponse, buildQueryString } from "@smithy/core/protocols";
|
|
import { buildAbortError } from "./build-abort-error";
|
|
import { NODEJS_TIMEOUT_ERROR_CODES } from "./constants";
|
|
import { getTransformedHeaders } from "./get-transformed-headers";
|
|
import { node_https } from "./node-https";
|
|
import { setConnectionTimeout } from "./set-connection-timeout";
|
|
import { setRequestTimeout } from "./set-request-timeout";
|
|
import { setSocketKeepAlive } from "./set-socket-keep-alive";
|
|
import { setSocketTimeout } from "./set-socket-timeout";
|
|
import { timing } from "./timing";
|
|
import { writeRequestBody } from "./write-request-body";
|
|
export const DEFAULT_REQUEST_TIMEOUT = 0;
|
|
let hAgent = undefined;
|
|
let hRequest = undefined;
|
|
export class NodeHttpHandler {
|
|
config;
|
|
configProvider;
|
|
socketWarningTimestamp = 0;
|
|
externalAgent = false;
|
|
metadata = { handlerProtocol: "http/1.1" };
|
|
static create(instanceOrOptions) {
|
|
if (typeof instanceOrOptions?.handle === "function") {
|
|
return instanceOrOptions;
|
|
}
|
|
return new NodeHttpHandler(instanceOrOptions);
|
|
}
|
|
static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
|
|
const { sockets, requests, maxSockets } = agent;
|
|
if (typeof maxSockets !== "number" || maxSockets === Infinity) {
|
|
return socketWarningTimestamp;
|
|
}
|
|
const interval = 15_000;
|
|
if (Date.now() - interval < socketWarningTimestamp) {
|
|
return socketWarningTimestamp;
|
|
}
|
|
if (sockets && requests) {
|
|
for (const origin in sockets) {
|
|
const socketsInUse = sockets[origin]?.length ?? 0;
|
|
const requestsEnqueued = requests[origin]?.length ?? 0;
|
|
if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
|
|
logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
|
|
See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
|
|
or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
|
|
return Date.now();
|
|
}
|
|
}
|
|
}
|
|
return socketWarningTimestamp;
|
|
}
|
|
constructor(options) {
|
|
this.configProvider = new Promise((resolve, reject) => {
|
|
if (typeof options === "function") {
|
|
options()
|
|
.then((_options) => {
|
|
resolve(this.resolveDefaultConfig(_options));
|
|
})
|
|
.catch(reject);
|
|
}
|
|
else {
|
|
resolve(this.resolveDefaultConfig(options));
|
|
}
|
|
});
|
|
}
|
|
destroy() {
|
|
this.config?.httpAgent?.destroy();
|
|
this.config?.httpsAgent?.destroy();
|
|
}
|
|
async handle(request, { abortSignal, requestTimeout } = {}) {
|
|
if (!this.config) {
|
|
this.config = await this.configProvider;
|
|
}
|
|
const config = this.config;
|
|
const isSSL = request.protocol === "https:";
|
|
if (!isSSL && !this.config.httpAgent) {
|
|
this.config.httpAgent = await this.config.httpAgentProvider();
|
|
}
|
|
return new Promise((_resolve, _reject) => {
|
|
let writeRequestBodyPromise = undefined;
|
|
let socketWarningTimeoutId = -1;
|
|
let connectionTimeoutId = -1;
|
|
let requestTimeoutId = -1;
|
|
let socketTimeoutId = -1;
|
|
let keepAliveTimeoutId = -1;
|
|
const clearTimeouts = () => {
|
|
timing.clearTimeout(socketWarningTimeoutId);
|
|
timing.clearTimeout(connectionTimeoutId);
|
|
timing.clearTimeout(requestTimeoutId);
|
|
timing.clearTimeout(socketTimeoutId);
|
|
timing.clearTimeout(keepAliveTimeoutId);
|
|
};
|
|
const resolve = async (arg) => {
|
|
await writeRequestBodyPromise;
|
|
clearTimeouts();
|
|
_resolve(arg);
|
|
};
|
|
const reject = async (arg) => {
|
|
await writeRequestBodyPromise;
|
|
clearTimeouts();
|
|
_reject(arg);
|
|
};
|
|
if (abortSignal?.aborted) {
|
|
const abortError = buildAbortError(abortSignal);
|
|
reject(abortError);
|
|
return;
|
|
}
|
|
const headers = request.headers;
|
|
const expectContinue = headers ? (headers.Expect ?? headers.expect) === "100-continue" : false;
|
|
let agent = isSSL ? config.httpsAgent : config.httpAgent;
|
|
if (expectContinue && !this.externalAgent) {
|
|
agent = new (isSSL ? node_https.Agent : hAgent)({
|
|
keepAlive: false,
|
|
maxSockets: Infinity,
|
|
});
|
|
}
|
|
socketWarningTimeoutId = timing.setTimeout(() => {
|
|
this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger);
|
|
}, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2000) + (config.connectionTimeout ?? 1000));
|
|
const queryString = request.query ? buildQueryString(request.query) : "";
|
|
let auth = undefined;
|
|
if (request.username != null || request.password != null) {
|
|
const username = request.username ?? "";
|
|
const password = request.password ?? "";
|
|
auth = `${username}:${password}`;
|
|
}
|
|
let path = request.path;
|
|
if (queryString) {
|
|
path += `?${queryString}`;
|
|
}
|
|
if (request.fragment) {
|
|
path += `#${request.fragment}`;
|
|
}
|
|
let hostname = request.hostname ?? "";
|
|
if (hostname[0] === "[" && hostname.endsWith("]")) {
|
|
hostname = request.hostname.slice(1, -1);
|
|
}
|
|
else {
|
|
hostname = request.hostname;
|
|
}
|
|
const nodeHttpsOptions = {
|
|
headers: request.headers,
|
|
host: hostname,
|
|
method: request.method,
|
|
path,
|
|
port: request.port,
|
|
agent,
|
|
auth,
|
|
};
|
|
const requestFunc = isSSL ? node_https.request : hRequest;
|
|
const req = requestFunc(nodeHttpsOptions, (res) => {
|
|
const httpResponse = new HttpResponse({
|
|
statusCode: res.statusCode || -1,
|
|
reason: res.statusMessage,
|
|
headers: getTransformedHeaders(res.headers),
|
|
body: res,
|
|
});
|
|
resolve({ response: httpResponse });
|
|
});
|
|
req.on("error", (err) => {
|
|
if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
|
|
reject(Object.assign(err, { name: "TimeoutError" }));
|
|
}
|
|
else {
|
|
reject(err);
|
|
}
|
|
});
|
|
if (abortSignal) {
|
|
const onAbort = () => {
|
|
req.destroy();
|
|
const abortError = buildAbortError(abortSignal);
|
|
reject(abortError);
|
|
};
|
|
if (typeof abortSignal.addEventListener === "function") {
|
|
const signal = abortSignal;
|
|
signal.addEventListener("abort", onAbort, { once: true });
|
|
req.once("close", () => signal.removeEventListener("abort", onAbort));
|
|
}
|
|
else {
|
|
abortSignal.onabort = onAbort;
|
|
}
|
|
}
|
|
const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
|
|
connectionTimeoutId = setConnectionTimeout(req, reject, config.connectionTimeout);
|
|
requestTimeoutId = setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console);
|
|
socketTimeoutId = setSocketTimeout(req, reject, config.socketTimeout);
|
|
const httpAgent = nodeHttpsOptions.agent;
|
|
if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
|
|
keepAliveTimeoutId = setSocketKeepAlive(req, {
|
|
keepAlive: httpAgent.keepAlive,
|
|
keepAliveMsecs: httpAgent.keepAliveMsecs,
|
|
});
|
|
}
|
|
writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout, this.externalAgent).catch((e) => {
|
|
clearTimeouts();
|
|
return _reject(e);
|
|
});
|
|
});
|
|
}
|
|
updateHttpClientConfig(key, value) {
|
|
this.config = undefined;
|
|
this.configProvider = this.configProvider.then((config) => {
|
|
return {
|
|
...config,
|
|
[key]: value,
|
|
};
|
|
});
|
|
}
|
|
httpHandlerConfigs() {
|
|
return this.config ?? {};
|
|
}
|
|
resolveDefaultConfig(options) {
|
|
const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, logger, } = options || {};
|
|
const keepAlive = true;
|
|
const maxSockets = 50;
|
|
return {
|
|
connectionTimeout,
|
|
requestTimeout,
|
|
socketTimeout,
|
|
socketAcquisitionWarningTimeout,
|
|
throwOnRequestTimeout,
|
|
httpAgentProvider: async () => {
|
|
const node_http = await import("node:http");
|
|
const { Agent, request } = node_http.default ?? node_http;
|
|
hRequest = request;
|
|
hAgent = Agent;
|
|
if (httpAgent instanceof hAgent || typeof httpAgent?.destroy === "function") {
|
|
this.externalAgent = true;
|
|
return httpAgent;
|
|
}
|
|
return new hAgent({ keepAlive, maxSockets, ...httpAgent });
|
|
},
|
|
httpsAgent: (() => {
|
|
if (httpsAgent instanceof node_https.Agent || typeof httpsAgent?.destroy === "function") {
|
|
this.externalAgent = true;
|
|
return httpsAgent;
|
|
}
|
|
return new node_https.Agent({ keepAlive, maxSockets, ...httpsAgent });
|
|
})(),
|
|
logger,
|
|
};
|
|
}
|
|
}
|