http.mjs
No OneTemporary
Actions

Size

11 KB

Referenced Files

None

Subscribers

None

http.mjs
View Options

	import net from 'node:net';

	import httpParser from 'ant:internal/http_parser';
	import httpWriter from 'ant:internal/http_writer';

	import { EventEmitter } from 'node:events';
	import { STATUS_CODES } from 'ant:internal/http_metadata';

	function createHeadersObject() {
	return Object.create(null);
	}

	function normalizeHeaderName(name) {
	return String(name).toLowerCase();
	}

	function appendHeaderValue(headers, key, value) {
	if (key === 'set-cookie') {
	if (!headers[key]) headers[key] = [];
	headers[key].push(value);
	return;
	}

	if (headers[key] === undefined) {
	headers[key] = value;
	return;
	}

	if (key === 'cookie') headers[key] += '; ' + value;
	else headers[key] += ', ' + value;
	}

	function buildHeaders(rawHeaders) {
	const headers = createHeadersObject();
	let i = 0;

	for (i = 0; i + 1 < rawHeaders.length; i += 2) {
	appendHeaderValue(headers, normalizeHeaderName(rawHeaders[i]), String(rawHeaders[i + 1]));
	}

	return headers;
	}

	function bufferFrom(value, encoding) {
	if (value === undefined \|\| value === null) return Buffer.alloc(0);
	if (Buffer.isBuffer(value)) return value;
	if (value && typeof value === 'object' && typeof value.byteLength === 'number') return Buffer.from(value);
	if (typeof value === 'string') return Buffer.from(value, encoding \|\| 'utf8');
	return Buffer.from(String(value), encoding \|\| 'utf8');
	}

	function appendRawHeader(rawHeaders, name, value) {
	if (Array.isArray(value)) {
	value.forEach(item => rawHeaders.push(name, String(item)));
	return;
	}

	rawHeaders.push(name, String(value));
	}

	function hasResponseBody(method, statusCode) {
	if (method === 'HEAD') return false;
	if (statusCode === 204 \|\| statusCode === 304) return false;
	return true;
	}

	function applyHeaderObject(target, headers) {
	if (!headers) return;

	if (Array.isArray(headers)) {
	for (let i = 0; i + 1 < headers.length; i += 2) {
	target.setHeader(headers[i], headers[i + 1]);
	}
	return;
	}

	Object.keys(headers).forEach(name => {
	target.setHeader(name, headers[name]);
	});
	}

	function makeSocketState(server, socket) {
	return {
	server,
	socket,
	buffered: Buffer.alloc(0),
	activeResponse: null,
	closed: false
	};
	}

	function appendSocketChunk(buffered, chunk) {
	const next = bufferFrom(chunk);
	if (buffered.length === 0) return next;
	return Buffer.concat([buffered, next]);
	}

	function handleClientError(server, socket, error) {
	if (server.listenerCount('clientError') > 0) {
	server.emit('clientError', error, socket);
	return;
	}

	if (socket && !socket.destroyed) {
	socket.end(httpWriter.writeBasicResponse(400, 'Bad Request', 'text/plain;charset=UTF-8', 'Bad Request', false));
	}
	}

	export class IncomingMessage extends EventEmitter {
	constructor(socket, parsed) {
	super();
	this.socket = socket;
	this.connection = socket;
	this.method = parsed.method;
	this.url = parsed.target;
	this.headers = buildHeaders(parsed.rawHeaders \|\| []);
	this.rawHeaders = (parsed.rawHeaders \|\| []).slice();
	this.httpVersion = parsed.httpVersion;
	this.httpVersionMajor = parsed.httpVersionMajor;
	this.httpVersionMinor = parsed.httpVersionMinor;
	this._keepAlive = !!parsed.keepAlive;
	this.complete = false;
	this.aborted = false;
	this.destroyed = false;
	this.readableEnded = false;
	this._body = bufferFrom(parsed.body);
	this._bodyConsumed = false;
	}

	_takeBody() {
	if (this._bodyConsumed) return Buffer.alloc(0);
	this._bodyConsumed = true;
	return this._body;
	}

	_deliverBody() {
	if (this.destroyed \|\| this.complete) return;

	const body = this._takeBody();
	if (body.length > 0) this.emit('data', body);
	this.complete = true;
	this.readableEnded = true;
	this.emit('end');
	this.emit('close');
	}

	[Symbol.asyncIterator]() {
	const body = this._takeBody();
	let emitted = false;
	let finished = false;

	return {
	next: async () => {
	if (finished) return { done: true, value: undefined };
	if (!emitted && body.length > 0) {
	emitted = true;
	return { done: false, value: body };
	}
	finished = true;
	this.complete = true;
	this.readableEnded = true;
	return { done: true, value: undefined };
	},
	return: async () => {
	finished = true;
	this.complete = true;
	this.readableEnded = true;
	return { done: true, value: undefined };
	},
	[Symbol.asyncIterator]() {
	return this;
	}
	};
	}

	destroy(error) {
	if (this.destroyed) return this;
	this.destroyed = true;
	if (error) this.emit('error', error);
	if (this.socket && !this.socket.destroyed) this.socket.destroy(error);
	return this;
	}

	setTimeout(msecs, callback) {
	if (this.socket && this.socket.setTimeout) this.socket.setTimeout(msecs, callback);
	return this;
	}
	}

	export class ServerResponse extends EventEmitter {
	constructor(req, socket, socketState) {
	super();
	this.req = req;
	this.socket = socket;
	this.connection = socket;
	this.statusCode = 200;
	this.statusMessage = undefined;
	this.sendDate = true;
	this.strictContentLength = false;
	this.headersSent = false;
	this.writableEnded = false;
	this.writableFinished = false;
	this.finished = false;
	this._headers = createHeadersObject();
	this._headerNames = createHeadersObject();
	this._socketState = socketState;
	this._streaming = false;
	}

	setHeader(name, value) {
	const headerName = String(name);
	const key = normalizeHeaderName(headerName);
	this._headers[key] = value;
	this._headerNames[key] = headerName;
	return this;
	}

	getHeader(name) {
	return this._headers[normalizeHeaderName(name)];
	}

	getHeaders() {
	const copy = createHeadersObject();
	Object.keys(this._headers).forEach(key => {
	copy[key] = this._headers[key];
	});
	return copy;
	}

	getHeaderNames() {
	return Object.keys(this._headers);
	}

	hasHeader(name) {
	return this._headers[normalizeHeaderName(name)] !== undefined;
	}

	removeHeader(name) {
	const key = normalizeHeaderName(name);
	delete this._headers[key];
	delete this._headerNames[key];
	return this;
	}

	writeHead(statusCode, statusMessage, headers) {
	this.statusCode = statusCode \| 0;

	if (typeof statusMessage === 'string') {
	this.statusMessage = statusMessage;
	applyHeaderObject(this, headers);
	} else {
	applyHeaderObject(this, statusMessage);
	}

	return this;
	}

	_rawHeaders() {
	const rawHeaders = [];

	if (this.sendDate && !this.hasHeader('date')) {
	this.setHeader('Date', new Date().toUTCString());
	}

	Object.keys(this._headers).forEach(key => {
	const name = this._headerNames[key] \|\| key;
	appendRawHeader(rawHeaders, name, this._headers[key]);
	});

	return rawHeaders;
	}

	_shouldKeepAlive() {
	const connection = this.getHeader('connection');
	if (typeof connection === 'string') {
	if (connection.toLowerCase() === 'close') return false;
	if (connection.toLowerCase() === 'keep-alive') return true;
	}

	return !!(this.req && this.req._keepAlive);
	}

	_writeHead(bodyIsStream, bodySize) {
	if (this.headersSent) return;

	const statusText = this.statusMessage \|\| STATUS_CODES[this.statusCode] \|\| httpWriter.defaultStatusText(this.statusCode);
	const head = httpWriter.writeHead(this.statusCode, statusText, this._rawHeaders(), bodyIsStream, bodySize, this._shouldKeepAlive());

	this.headersSent = true;
	this.socket.write(head);
	}

	write(chunk, encoding, callback) {
	const body = hasResponseBody(this.req && this.req.method, this.statusCode)
	? bufferFrom(chunk, typeof encoding === 'string' ? encoding : undefined)
	: Buffer.alloc(0);

	if (typeof encoding === 'function') callback = encoding;
	if (!this.headersSent) this._writeHead(true, 0);
	this._streaming = true;

	if (body.length > 0) this.socket.write(httpWriter.writeChunk(body));
	if (typeof callback === 'function') callback();
	return true;
	}

	end(chunk, encoding, callback) {
	let body = Buffer.alloc(0);
	let keepAlive = false;

	if (this.writableEnded) return this;
	if (typeof encoding === 'function') {
	callback = encoding;
	encoding = undefined;
	}

	if (hasResponseBody(this.req && this.req.method, this.statusCode)) {
	body = bufferFrom(chunk, typeof encoding === 'string' ? encoding : undefined);
	}

	if (this._streaming) {
	if (!this.headersSent) this._writeHead(true, 0);
	if (body.length > 0) this.socket.write(httpWriter.writeChunk(body));
	this.socket.write(httpWriter.writeFinalChunk());
	} else {
	this._writeHead(false, body.length);
	if (body.length > 0) this.socket.write(body);
	}

	this.writableEnded = true;
	this.writableFinished = true;
	this.finished = true;
	this.emit('finish');
	this.emit('close');

	keepAlive = this._shouldKeepAlive();
	this._socketState.activeResponse = null;
	if (typeof callback === 'function') callback();

	if (!keepAlive) this.socket.end();
	else if (this._socketState.buffered.length > 0) this._socketState.server._drainSocket(this.socket, this._socketState);
	return this;
	}

	setTimeout(msecs, callback) {
	if (this.socket && this.socket.setTimeout) this.socket.setTimeout(msecs, callback);
	return this;
	}
	}

	export class Server extends net.Server {
	constructor(options, requestListener) {
	const serverOptions = typeof options === 'function' ? undefined : options;
	const onRequest = typeof options === 'function' ? options : requestListener;

	super(serverOptions);
	this.timeout = 0;
	this.headersTimeout = 60000;
	this.requestTimeout = 300000;
	this.keepAliveTimeout = 5000;
	this.maxHeadersCount = 2000;

	this.on('connection', socket => {
	this._attachSocket(socket);
	});

	if (typeof onRequest === 'function') this.on('request', onRequest);
	}

	_attachSocket(socket) {
	const state = makeSocketState(this, socket);

	if (this.timeout > 0 && socket.setTimeout) {
	socket.setTimeout(this.timeout, () => {
	this.emit('timeout', socket);
	});
	}

	socket.on('data', chunk => {
	state.buffered = appendSocketChunk(state.buffered, chunk);
	this._drainSocket(socket, state);
	});

	socket.on('error', error => {
	handleClientError(this, socket, error);
	});

	socket.on('close', () => {
	state.closed = true;
	});
	}

	_drainSocket(socket, state) {
	while (!state.closed) {
	let parsed = null;

	if (state.activeResponse && !state.activeResponse.writableEnded) return;
	if (state.buffered.length === 0) return;

	try {
	parsed = httpParser.parseRequest(state.buffered);
	} catch (error) {
	state.closed = true;
	handleClientError(this, socket, error);
	return;
	}

	if (parsed === null) return;
	if (!parsed.consumed \|\| parsed.consumed < 0) {
	state.closed = true;
	handleClientError(this, socket, new Error('Invalid HTTP parser state'));
	return;
	}

	state.buffered = parsed.consumed < state.buffered.length ? state.buffered.subarray(parsed.consumed) : Buffer.alloc(0);

	const req = new IncomingMessage(socket, parsed);
	const res = new ServerResponse(req, socket, state);
	state.activeResponse = res;

	this.emit('request', req, res);
	req._deliverBody();

	if (!res.writableEnded) return;
	}
	}

	setTimeout(msecs, callback) {
	this.timeout = msecs \| 0;
	if (typeof callback === 'function') this.on('timeout', callback);
	return this;
	}
	}

	export function createServer(options, requestListener) {
	return new Server(options, requestListener);
	}

	export { METHODS, STATUS_CODES } from 'ant:internal/http_metadata';

File Metadata

Mime Type: application/javascript
Expires: Fri, Apr 3, 4:50 PM (2 d)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 521490
Default Alt Text: http.mjs (11 KB)

Event Timeline