Определение отсутствия поддержки криптографии

Node.js может быть собран без поддержки модуля node:crypto. В таких случаях попытка выполнить import из node:http2 или вызов require('node:http2') приведёт к ошибке.

При использовании CommonJS возникшую ошибку можно перехватить с помощью try/catch:

let http2;
try {
  http2 = require('node:http2');
} catch (err) {
  console.error('http2 support is disabled!');
} copy

При использовании лексического ключевого слова ESM import ошибку можно перехватить, только если обработчик для process.on('uncaughtException') зарегистрирован до любой попытки загрузить модуль (например, с помощью модуля предварительной загрузки).

При использовании ESM, если код может выполняться в сборке Node.js без поддержки криптографии, рассмотрите возможность использования функции import() вместо лексического ключевого слова import:

let http2;
try {
  http2 = await import('node:http2');
} catch (err) {
  console.error('http2 support is disabled!');
} copy

Основной API

Основной API предоставляет низкоуровневый интерфейс, разработанный специально для поддержки возможностей протокола HTTP/2. Он не предназначен для совместимости с существующим API модуля HTTP/1. Для этого предназначен API совместимости.

Основной API http2 гораздо более симметричен для клиента и сервера, чем API http. Например, большинство событий, таких как 'error', 'connect' и 'stream', могут генерироваться как кодом на стороне клиента, так и кодом на стороне сервера.

Пример для стороны сервера

В следующем примере показан простой HTTP/2-сервер, использующий основной API. Поскольку неизвестно браузеров, поддерживающих незашифрованный HTTP/2, для связи с клиентами-браузерами необходимо использовать http2.createSecureServer().

import { createSecureServer } from 'node:http2';
import { readFileSync } from 'node:fs';

const server = createSecureServer({
  key: readFileSync('localhost-privkey.pem'),
  cert: readFileSync('localhost-cert.pem'),
});

server.on('error', (err) => console.error(err));

server.on('stream', (stream, headers) => {
  // stream is a Duplex
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.end('<h1>Hello World</h1>');
});

server.listen(8443);

const http2 = require('node:http2');
const fs = require('node:fs');

const server = http2.createSecureServer({
  key: fs.readFileSync('localhost-privkey.pem'),
  cert: fs.readFileSync('localhost-cert.pem'),
});
server.on('error', (err) => console.error(err));

server.on('stream', (stream, headers) => {
  // stream is a Duplex
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.end('<h1>Hello World</h1>');
});

server.listen(8443);

Чтобы создать сертификат и ключ для этого примера, выполните:

openssl req -x509 -newkey rsa:2048 -nodes -sha256 -subj '/CN=localhost' \
  -keyout localhost-privkey.pem -out localhost-cert.pem copy

Пример для стороны клиента

В следующем примере показан HTTP/2-клиент:

import { connect } from 'node:http2';
import { readFileSync } from 'node:fs';

const client = connect('https://localhost:8443', {
  ca: readFileSync('localhost-cert.pem'),
});
client.on('error', (err) => console.error(err));

const req = client.request({ ':path': '/' });

req.on('response', (headers, flags) => {
  for (const name in headers) {
    console.log(`${name}: ${headers[name]}`);
  }
});

req.setEncoding('utf8');
let data = '';
req.on('data', (chunk) => { data += chunk; });
req.on('end', () => {
  console.log(`\n${data}`);
  client.close();
});
req.end();

const http2 = require('node:http2');
const fs = require('node:fs');

const client = http2.connect('https://localhost:8443', {
  ca: fs.readFileSync('localhost-cert.pem'),
});
client.on('error', (err) => console.error(err));

const req = client.request({ ':path': '/' });

req.on('response', (headers, flags) => {
  for (const name in headers) {
    console.log(`${name}: ${headers[name]}`);
  }
});

req.setEncoding('utf8');
let data = '';
req.on('data', (chunk) => { data += chunk; });
req.on('end', () => {
  console.log(`\n${data}`);
  client.close();
});
req.end();

Класс: Http2Session

• Наследует: <EventEmitter>

Экземпляры класса http2.Http2Session представляют активный сеанс связи между HTTP/2-клиентом и сервером. Экземпляры этого класса не предназначены для непосредственного создания пользовательским кодом.

Поведение каждого экземпляра Http2Session будет несколько различаться в зависимости от того, работает ли он как сервер или клиент. Свойство http2session.type позволяет определить режим работы Http2Session. На стороне сервера пользовательскому коду редко приходится работать непосредственно с объектом Http2Session; обычно большинство действий выполняется посредством взаимодействия с объектами Http2Server или Http2Stream.

Пользовательский код не создает экземпляры Http2Session напрямую. Экземпляры Http2Session на стороне сервера создаются экземпляром Http2Server при получении нового HTTP/2-подключения. Экземпляры Http2Session на стороне клиента создаются с помощью метода http2.connect().

Http2Session и сокеты

При создании каждый экземпляр Http2Session связывается ровно с одним объектом net.Socket или tls.TLSSocket. При уничтожении Socket или Http2Session уничтожаются оба объекта.

В связи со специфическими требованиями протокола HTTP/2 к сериализации и обработке данных не рекомендуется считывать данные из экземпляра Socket, связанного с Http2Session, или записывать данные в него средствами пользовательского кода. Это может перевести сеанс HTTP/2 в неопределенное состояние, в результате чего сеанс и сокет станут непригодны для использования.

После связывания Socket с Http2Session пользовательскому коду следует использовать исключительно API объекта Http2Session.

Событие: 'close'

Событие 'close' генерируется после уничтожения Http2Session. Обработчик этого события не ожидает аргументов.

Событие: 'connect'

• session <Http2Session>
• socket <net.Socket>

Событие 'connect' генерируется после успешного подключения Http2Session к удаленному узлу, когда может начаться обмен данными.

Пользовательский код обычно не обрабатывает это событие напрямую.

Событие: 'error'

• error <Error>

Событие 'error' генерируется при возникновении ошибки во время обработки Http2Session.

Событие: 'frameError'

• type <integer> Тип кадра.
• code <integer> Код ошибки.
• id <integer> Идентификатор потока (или 0, если кадр не связан с потоком).

Событие 'frameError' генерируется при возникновении ошибки во время отправки кадра в рамках сеанса. Если кадр, который не удалось отправить, связан с определенным Http2Stream, предпринимается попытка сгенерировать событие 'frameError' для объекта Http2Stream.

Если событие 'frameError' связано с потоком, сразу после события 'frameError' поток будет закрыт и уничтожен. Если событие не связано с потоком, сразу после события 'frameError' объект Http2Session будет отключен.

Событие: 'goaway'

• errorCode <number> Код ошибки HTTP/2, указанный в кадре GOAWAY.
• lastStreamID <number> Идентификатор последнего потока, успешно обработанного удаленным узлом (или 0, если идентификатор не указан).
• opaqueData <Buffer> Если в кадре GOAWAY были дополнительные непрозрачные данные, будет передан экземпляр Buffer, содержащий эти данные.

Событие 'goaway' генерируется при получении кадра GOAWAY.

Экземпляр Http2Session будет автоматически отключен при генерации события 'goaway'.

Событие: 'localSettings'

• settings <HTTP/2 Settings Object> Копия полученного кадра SETTINGS.

Событие 'localSettings' генерируется при получении кадра подтверждения SETTINGS.

При использовании http2session.settings() для отправки новых настроек измененные настройки вступают в силу только после генерации события 'localSettings'.

session.settings({ enablePush: false });

session.on('localSettings', (settings) => {
  /* Use the new settings */
}); copy

Событие: 'ping'

• payload <Buffer> 8-байтовая полезная нагрузка кадра PING

Событие 'ping' генерируется при каждом получении кадра PING от подключенного узла.

Событие: 'remoteSettings'

• settings <HTTP/2 Settings Object> Копия полученного кадра SETTINGS.

Событие 'remoteSettings' генерируется при получении нового кадра SETTINGS от подключенного узла.

session.on('remoteSettings', (settings) => {
  /* Use the new settings */
}); copy

Событие: 'stream'

• stream <Http2Stream> Ссылка на поток
• headers <HTTP/2 Headers Object> Объект с описанием заголовков
• flags <number> Связанные числовые флаги
• rawHeaders <Array> Массив, содержащий исходные имена заголовков, за которыми следуют соответствующие им значения.

Событие 'stream' генерируется при создании нового Http2Stream.

session.on('stream', (stream, headers, flags) => {
  const method = headers[':method'];
  const path = headers[':path'];
  // ...
  stream.respond({
    ':status': 200,
    'content-type': 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
}); copy

На стороне сервера пользовательский код обычно не обрабатывает это событие напрямую, а вместо этого регистрирует обработчик для события 'stream', генерируемого экземплярами net.Server или tls.Server, возвращаемыми соответственно методами http2.createServer() и http2.createSecureServer(), как показано в примере ниже:

import { createServer } from 'node:http2';

// Create an unencrypted HTTP/2 server
const server = createServer();

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.on('error', (error) => console.error(error));
  stream.end('<h1>Hello World</h1>');
});

server.listen(8000);

const http2 = require('node:http2');

// Create an unencrypted HTTP/2 server
const server = http2.createServer();

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.on('error', (error) => console.error(error));
  stream.end('<h1>Hello World</h1>');
});

server.listen(8000);

Несмотря на то, что потоки HTTP/2 и сетевые сокеты не соответствуют друг другу в соотношении 1:1, сетевая ошибка уничтожит каждый отдельный поток, поэтому ее необходимо обрабатывать на уровне потока, как показано выше.

Событие: 'timeout'

После вызова метода http2session.setTimeout() для установки периода ожидания этого Http2Session событие 'timeout' генерируется, если в течение заданного количества миллисекунд на Http2Session не было активности. Обработчик этого события не ожидает аргументов.

session.setTimeout(2000);
session.on('timeout', () => { /* .. */ }); copy

http2session.alpnProtocol

• <string> | <undefined>

Значение будет undefined, если Http2Session еще не подключен к сокету, h2c, если Http2Session не подключен к TLSSocket, либо будет возвращено значение свойства alpnProtocol самого подключенного TLSSocket.

http2session.close([callback])

• callback <Function>

Корректно закрывает Http2Session, позволяя всем существующим потокам завершиться самостоятельно и предотвращая создание новых экземпляров Http2Stream. После закрытия может быть вызван http2session.destroy(), если нет открытых экземпляров Http2Stream.

Если указана функция callback, она регистрируется в качестве обработчика события 'close'.

http2session.closed

• <boolean>

Значение будет true, если этот экземпляр Http2Session закрыт, и false в противном случае.

http2session.connecting

• <boolean>

Значение будет true, если этот экземпляр Http2Session все еще подключается; перед генерацией события connect и/или вызовом обратного вызова http2.connect ему будет присвоено значение false.

http2session.destroy([error][, code])

• error <Error> Объект Error, если Http2Session уничтожается из-за ошибки.
• code <number> Код ошибки HTTP/2 для отправки в заключительном кадре GOAWAY. Если значение не указано и error не равно undefined, по умолчанию используется INTERNAL_ERROR, в противном случае — NO_ERROR.

Немедленно завершает Http2Session и связанный с ним объект net.Socket или tls.TLSSocket.

После уничтожения Http2Session сгенерирует событие 'close'. Если error не равно undefined, событие 'error' будет сгенерировано непосредственно перед событием 'close'.

Все оставшиеся открытые объекты Http2Streams, связанные с Http2Session, также будут уничтожены.

http2session.destroyed

• <boolean>

Значение будет true, если этот экземпляр Http2Session уничтожен и больше не должен использоваться, и false в противном случае.

http2session.encrypted

• <boolean> | <undefined>

Значение равно undefined, если сокет сеанса Http2Session еще не подключен, true, если Http2Session подключен к TLSSocket, и false, если Http2Session подключен к сокету или потоку любого другого типа.

http2session.goaway([code[, lastStreamID[, opaqueData]]])

• code <number> Код ошибки HTTP/2
• lastStreamID <number> Числовой идентификатор последнего обработанного Http2Stream
• opaqueData <Buffer> | <TypedArray> | <DataView> Экземпляр TypedArray или DataView, содержащий дополнительные данные для передачи в кадре GOAWAY.

Передает кадр GOAWAY подключенному узлу, не отключая Http2Session.

http2session.localSettings

• <HTTP/2 Settings Object>

Объект без прототипа, описывающий текущие локальные настройки этого Http2Session. Локальные настройки относятся к этому экземпляру Http2Session.

http2session.originSet

• <string[]> | <undefined>

Если Http2Session подключен к TLSSocket, свойство originSet возвращает Array источников, для которых Http2Session может считаться авторитетным.

Свойство originSet доступно только при использовании защищенного TLS-соединения.

http2session.pendingSettingsAck

• <boolean>

Показывает, ожидает ли сейчас Http2Session подтверждения отправленного кадра SETTINGS. После вызова метода http2session.settings() значение будет true. После подтверждения всех отправленных кадров SETTINGS значение будет false.

http2session.ping([payload, ]callback)

• payload <Buffer> | <TypedArray> | <DataView> Необязательная полезная нагрузка ping.
• callback <Function>
• Возвращает: <boolean>

Отправляет кадр PING подключенному узлу HTTP/2. Необходимо указать функцию callback. Метод возвращает true, если PING был отправлен, и false в противном случае.

Максимальное количество ожидающих подтверждения ping определяется параметром конфигурации maxOutstandingPings. Максимальное значение по умолчанию — 10.

Если аргумент payload указан, он должен быть экземпляром Buffer, TypedArray или DataView, содержащим 8 байт данных, которые будут переданы вместе с PING и возвращены с подтверждением ping.

Обратный вызов будет вызван с тремя аргументами: аргументом ошибки, который будет равен null, если PING был успешно подтвержден; аргументом duration, указывающим количество миллисекунд, прошедших с момента отправки ping до получения подтверждения; и Buffer, содержащим 8-байтовую полезную нагрузку PING.

session.ping(Buffer.from('abcdefgh'), (err, duration, payload) => {
  if (!err) {
    console.log(`Ping acknowledged in ${duration} milliseconds`);
    console.log(`With payload '${payload.toString()}'`);
  }
}); copy

Если аргумент payload не указан, полезной нагрузкой по умолчанию будет 64-разрядная временная метка (в порядке байтов от младшего к старшему), обозначающая начало интервала PING.

http2session.ref()

Вызывает ref() для базового объекта net.Socket экземпляра Http2Session.

http2session.remoteSettings

• <HTTP/2 Settings Object>

Объект без прототипа, описывающий текущие удаленные настройки этого Http2Session. Удаленные настройки задаются подключенным узлом HTTP/2.

http2session.setLocalWindowSize(windowSize)

• windowSize <number>

Устанавливает размер окна локальной конечной точки. windowSize — это общий размер окна, который нужно установить, а не изменение размера.

import { createServer } from 'node:http2';

const server = createServer();
const expectedWindowSize = 2 ** 20;
server.on('session', (session) => {

  // Set local window size to be 2 ** 20
  session.setLocalWindowSize(expectedWindowSize);
});

const http2 = require('node:http2');

const server = http2.createServer();
const expectedWindowSize = 2 ** 20;
server.on('session', (session) => {

  // Set local window size to be 2 ** 20
  session.setLocalWindowSize(expectedWindowSize);
});

Для клиентов http2 подходящим событием будет 'connect' или 'remoteSettings'.

http2session.setTimeout(msecs, callback)

• msecs <number>
• callback <Function>

Используется для установки функции обратного вызова, которая вызывается, если на Http2Session нет активности в течение msecs миллисекунд. Указанный callback регистрируется как обработчик события 'timeout'.

http2session.socket

• <net.Socket> | <tls.TLSSocket>

Возвращает объект Proxy, который действует как net.Socket (или tls.TLSSocket), но предоставляет только те методы, которые безопасно использовать с HTTP/2.

Вызов destroy, emit, end, pause, read, resume и write вызовет ошибку с кодом ERR_HTTP2_NO_SOCKET_MANIPULATION. Дополнительные сведения см. в разделе Http2Session и сокеты.

Для этого объекта Http2Session будет вызван метод setTimeout.

Все остальные взаимодействия будут напрямую перенаправлены сокету.

http2session.state

Предоставляет различную информацию о текущем состоянии Http2Session.

• <Object>
  • effectiveLocalWindowSize <number> Текущий размер окна управления потоком для приема данных у Http2Session.
  • effectiveRecvDataLength <number> Текущее количество байтов, полученных после последнего WINDOW_UPDATE управления потоком.
  • nextStreamID <number> Числовой идентификатор, который будет использоваться при следующем создании нового Http2Stream этим объектом Http2Session.
  • localWindowSize <number> Количество байтов, которое удаленный узел может отправить, не получив WINDOW_UPDATE.
  • lastProcStreamID <number> Числовой идентификатор Http2Stream, для которого последним был получен кадр HEADERS или DATA.
  • remoteWindowSize <number> Количество байтов, которое этот Http2Session может отправить, не получив WINDOW_UPDATE.
  • outboundQueueSize <number> Количество кадров, находящихся в данный момент в очереди исходящих данных для этого Http2Session.
  • deflateDynamicTableSize <number> Текущий размер таблицы состояния сжатия исходящих заголовков в байтах.
  • inflateDynamicTableSize <number> Текущий размер таблицы состояния сжатия входящих заголовков в байтах.

Объект, описывающий текущее состояние этого Http2Session.

http2session.settings([settings][, callback])

• settings <HTTP/2 Settings Object>
• callback <Function> Обратный вызов, который вызывается после подключения сеанса или сразу же, если сеанс уже подключен.
  • err <Error> | <null>
  • settings <HTTP/2 Settings Object> Обновленный объект settings.
  • duration <integer>

Обновляет текущие локальные настройки этого Http2Session и отправляет новый кадр SETTINGS подключенному узлу HTTP/2.

После вызова свойство http2session.pendingSettingsAck будет иметь значение true, пока сеанс ожидает подтверждения новых настроек от удаленного узла.

Новые настройки вступят в силу только после получения подтверждения SETTINGS и генерации события 'localSettings'. Пока ожидается подтверждение, можно отправить несколько кадров SETTINGS.

http2session.type

• <number>

Значение http2session.type будет равно http2.constants.NGHTTP2_SESSION_SERVER, если этот экземпляр Http2Session является сервером, и http2.constants.NGHTTP2_SESSION_CLIENT, если экземпляр является клиентом.

http2session.unref()

Вызывает unref() для базового объекта net.Socket экземпляра Http2Session.

Класс: ServerHttp2Session

• Наследует: <Http2Session>

serverhttp2session.altsvc(alt, originOrStream)

• alt <string> Описание конфигурации альтернативной службы, определенной в RFC 7838.
• originOrStream <number> | <string> | <URL> | <Object> Строка URL, задающая источник (или Object со свойством origin), либо числовой идентификатор активного Http2Stream, заданный свойством http2stream.id.

Отправляет подключенному клиенту кадр ALTSVC (определенный в RFC 7838).

import { createServer } from 'node:http2';

const server = createServer();
server.on('session', (session) => {
  // Set altsvc for origin https://example.org:80
  session.altsvc('h2=":8000"', 'https://example.org:80');
});

server.on('stream', (stream) => {
  // Set altsvc for a specific stream
  stream.session.altsvc('h2=":8000"', stream.id);
});

const http2 = require('node:http2');

const server = http2.createServer();
server.on('session', (session) => {
  // Set altsvc for origin https://example.org:80
  session.altsvc('h2=":8000"', 'https://example.org:80');
});

server.on('stream', (stream) => {
  // Set altsvc for a specific stream
  stream.session.altsvc('h2=":8000"', stream.id);
});

Отправка кадра ALTSVC с определенным идентификатором потока указывает, что альтернативная служба связана с источником указанного Http2Stream.

alt и строка источника должны содержать только байты ASCII и интерпретируются строго как последовательность байтов ASCII. Специальное значение 'clear' можно передать, чтобы очистить ранее заданную альтернативную службу для указанного домена.

Если аргументом originOrStream передана строка, она будет обработана как URL, а источник будет определен из нее. Например, источником HTTP URL 'https://example.org/foo/bar' является строка ASCII 'https://example.org'. Будет выброшена ошибка, если указанную строку невозможно обработать как URL или если невозможно определить допустимый источник.

В качестве originOrStream можно передать объект URL или любой объект со свойством origin; в таком случае будет использовано значение свойства origin. Значение свойства origin должно представлять собой правильно сериализованный источник ASCII.

Задание альтернативных служб

Формат параметра alt строго определен в RFC 7838 как строка ASCII, содержащая разделенный запятыми список «альтернативных» протоколов, связанных с определенными узлом и портом.

Например, значение 'h2="example.org:81"' указывает, что протокол HTTP/2 доступен на узле 'example.org' через порт 81 TCP/IP. Узел и порт должны быть заключены в символы кавычек (").

Можно указать несколько альтернатив, например: 'h2="example.org:81", h2=":82"'.

Идентификатор протокола ('h2' в примерах) может быть любым допустимым идентификатором протокола ALPN.

Синтаксис этих значений не проверяется реализацией Node.js; они передаются без изменений, как предоставлены пользователем или получены от узла.

serverhttp2session.origin(...origins)

• origins <string> | <URL> | <Object> Одна или несколько строк URL, переданных в виде отдельных аргументов.

Отправляет подключенному клиенту кадр ORIGIN (определенный в RFC 8336), чтобы объявить набор источников, для которых сервер способен предоставлять авторитетные ответы.

import { createSecureServer } from 'node:http2';
const options = getSecureOptionsSomehow();
const server = createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});
server.on('session', (session) => {
  session.origin('https://example.com', 'https://example.org');
});

const http2 = require('node:http2');
const options = getSecureOptionsSomehow();
const server = http2.createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});
server.on('session', (session) => {
  session.origin('https://example.com', 'https://example.org');
});

Если в качестве origin передана строка, она будет обработана как URL, а источник будет определен из нее. Например, источником HTTP URL 'https://example.org/foo/bar' является строка ASCII 'https://example.org'. Будет выброшена ошибка, если указанную строку невозможно обработать как URL или если невозможно определить допустимый источник.

В качестве origin можно передать объект URL или любой объект со свойством origin; в таком случае будет использовано значение свойства origin. Значение свойства origin должно представлять собой правильно сериализованный источник ASCII.

Также можно использовать параметр origins при создании нового HTTP/2-сервера с помощью метода http2.createSecureServer():

import { createSecureServer } from 'node:http2';
const options = getSecureOptionsSomehow();
options.origins = ['https://example.com', 'https://example.org'];
const server = createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});

const http2 = require('node:http2');
const options = getSecureOptionsSomehow();
options.origins = ['https://example.com', 'https://example.org'];
const server = http2.createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});

Класс: ClientHttp2Session

• Расширяет: <Http2Session>

Событие: 'altsvc'

• alt <string>
• origin <string>
• streamId <number>

Событие 'altsvc' генерируется при получении клиентом кадра ALTSVC. Событие генерируется с передачей значения ALTSVC, источника и идентификатора потока. Если в кадре ALTSVC не указан origin, значением origin будет пустая строка.

import { connect } from 'node:http2';
const client = connect('https://example.org');

client.on('altsvc', (alt, origin, streamId) => {
  console.log(alt);
  console.log(origin);
  console.log(streamId);
});

const http2 = require('node:http2');
const client = http2.connect('https://example.org');

client.on('altsvc', (alt, origin, streamId) => {
  console.log(alt);
  console.log(origin);
  console.log(streamId);
});

Событие: 'origin'

• origins <string[]>

Событие 'origin' генерируется при получении клиентом кадра ORIGIN. Событие генерируется с передачей массива строк origin. Значение http2session.originSet будет обновлено с учетом полученных источников.

import { connect } from 'node:http2';
const client = connect('https://example.org');

client.on('origin', (origins) => {
  for (let n = 0; n < origins.length; n++)
    console.log(origins[n]);
});

const http2 = require('node:http2');
const client = http2.connect('https://example.org');

client.on('origin', (origins) => {
  for (let n = 0; n < origins.length; n++)
    console.log(origins[n]);
});

Событие 'origin' генерируется только при использовании защищенного TLS-соединения.

clienthttp2session.request(headers[, options])

• headers <HTTP/2 Headers Object>

• options <Object>

  • endStream <boolean> true, если Http2Stream сторона для записи должна быть изначально закрыта, например при отправке запроса GET, для которого не ожидается тело с данными.
  • exclusive <boolean> Если true и parent задает родительский поток, созданный поток становится единственной прямой зависимостью родительского потока, а все остальные существующие зависимые потоки становятся зависимыми от вновь созданного потока. Значение по умолчанию: false.
  • parent <number> Задает числовой идентификатор потока, от которого зависит вновь созданный поток.
  • weight <number> Задает относительную зависимость потока по отношению к другим потокам с тем же parent. Значение — число от 1 до 256 включительно.
  • waitForTrailers <boolean> Если true, Http2Stream сгенерирует событие 'wantTrailers' после отправки последнего кадра DATA.
  • signal <AbortSignal> AbortSignal, который можно использовать для прерывания выполняющегося запроса.

• Возвращает: <ClientHttp2Stream>

Только для экземпляров клиентского HTTP/2 Http2Session: метод http2session.request() создает и возвращает экземпляр Http2Stream, который можно использовать для отправки HTTP/2-запроса подключенному серверу.

При первом создании ClientHttp2Session сокет может быть еще не подключен. Если в это время вызывается clienthttp2session.request(), фактическая отправка запроса будет отложена до готовности сокета. Если session закрывается до выполнения фактического запроса, выбрасывается ERR_HTTP2_GOAWAY_SESSION.

Этот метод доступен только в том случае, если http2session.type равно http2.constants.NGHTTP2_SESSION_CLIENT.

import { connect, constants } from 'node:http2';
const clientSession = connect('https://localhost:1234');
const {
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
} = constants;

const req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });
req.on('response', (headers) => {
  console.log(headers[HTTP2_HEADER_STATUS]);
  req.on('data', (chunk) => { /* .. */ });
  req.on('end', () => { /* .. */ });
});

const http2 = require('node:http2');
const clientSession = http2.connect('https://localhost:1234');
const {
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
} = http2.constants;

const req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });
req.on('response', (headers) => {
  console.log(headers[HTTP2_HEADER_STATUS]);
  req.on('data', (chunk) => { /* .. */ });
  req.on('end', () => { /* .. */ });
});

Если задан параметр options.waitForTrailers, событие 'wantTrailers' генерируется сразу после постановки в очередь последнего фрагмента данных тела для отправки. Затем можно вызвать метод http2stream.sendTrailers(), чтобы отправить завершающие заголовки узлу.

Если задан options.waitForTrailers, Http2Stream не будет автоматически закрыт после передачи последнего кадра DATA. Пользовательский код должен вызвать http2stream.sendTrailers() или http2stream.close(), чтобы закрыть Http2Stream.

Если задан options.signal с AbortSignal, а затем вызван abort для соответствующего AbortController, запрос сгенерирует событие 'error' с ошибкой AbortError.

Псевдозаголовки :method и :path не указаны в headers; по умолчанию для них используются соответственно:

• :method = 'GET'
• :path = /

Класс: Http2Stream

• Расширяет: <stream.Duplex>

Каждый экземпляр класса Http2Stream представляет собой двунаправленный поток HTTP/2 для обмена данными через экземпляр Http2Session. За время существования одного Http2Session может быть создано до 2³¹-1 экземпляров Http2Stream.

Пользовательский код не создает экземпляры Http2Stream напрямую. Вместо этого они создаются, управляются и передаются пользовательскому коду через экземпляр Http2Session. На сервере экземпляры Http2Stream создаются либо в ответ на входящий HTTP-запрос (и передаются пользовательскому коду через событие 'stream'), либо в ответ на вызов метода http2stream.pushStream(). На клиенте экземпляры Http2Stream создаются и возвращаются при вызове метода http2session.request() или в ответ на входящее событие 'push'.

Класс Http2Stream является базовым для классов ServerHttp2Stream и ClientHttp2Stream, каждый из которых предназначен соответственно для стороны сервера или клиента.

Все экземпляры Http2Stream являются потоками Duplex. Сторона Writable объекта Duplex используется для отправки данных подключенному узлу, а сторона Readable — для получения данных от подключенного узла.

По умолчанию для текста в Http2Stream используется кодировка UTF-8. При использовании Http2Stream для отправки текста задайте кодировку символов с помощью заголовка 'content-type'.

stream.respond({
  'content-type': 'text/html; charset=utf-8',
  ':status': 200,
}); copy

Жизненный цикл Http2Stream

Создание

На стороне сервера экземпляры ServerHttp2Stream создаются в следующих случаях:

• Получен новый кадр HTTP/2 HEADERS с ранее не использовавшимся идентификатором потока;
• Вызван метод http2stream.pushStream().

На стороне клиента экземпляры ClientHttp2Stream создаются при вызове метода http2session.request().

На клиенте экземпляр Http2Stream, возвращаемый методом http2session.request(), может быть не готов к использованию, если родительский Http2Session еще не установлен полностью. В таких случаях вызовы операций для Http2Stream будут буферизованы до генерации события 'ready'. Пользовательскому коду редко, если вообще когда-либо, требуется обрабатывать событие 'ready' напрямую. Готовность Http2Stream можно определить, проверив значение http2stream.id. Если значение равно undefined, поток еще не готов к использованию.

Уничтожение

Все экземпляры Http2Stream уничтожаются в следующих случаях:

• Подключенный узел получает для потока кадр RST_STREAM и (только для клиентских потоков) считываются ожидающие данные.
• Вызывается метод http2stream.close() и (только для клиентских потоков) считываются ожидающие данные.
• Вызываются методы http2stream.destroy() или http2session.destroy().

При уничтожении экземпляра Http2Stream выполняется попытка отправить подключенному узлу кадр RST_STREAM.

При уничтожении экземпляра Http2Stream генерируется событие 'close'. Поскольку Http2Stream является экземпляром stream.Duplex, событие 'end' также генерируется, если данные потока в данный момент передаются. Событие 'error' также может быть сгенерировано, если http2stream.destroy() был вызван с переданным в качестве первого аргумента Error.

После уничтожения Http2Stream свойство http2stream.destroyed получит значение true, а свойство http2stream.rstCode будет содержать код ошибки RST_STREAM. После уничтожения экземпляр Http2Stream больше нельзя использовать.

Событие: 'aborted'

Событие 'aborted' генерируется, когда экземпляр Http2Stream неожиданно прерывается в ходе обмена данными. Обработчик события не ожидает аргументов.

Событие 'aborted' будет сгенерировано только в том случае, если записываемая сторона Http2Stream еще не завершена.

Событие: 'close'

Событие 'close' генерируется при уничтожении Http2Stream. После генерации этого события экземпляр Http2Stream больше нельзя использовать.

Код ошибки HTTP/2, использованный при закрытии потока, можно получить с помощью свойства http2stream.rstCode. Если код имеет любое значение, отличное от NGHTTP2_NO_ERROR (0), также будет сгенерировано событие 'error'.

Событие: 'error'

• error <Error>

Событие 'error' генерируется при возникновении ошибки во время обработки Http2Stream.

Событие: 'frameError'

• type <integer> Тип кадра.
• code <integer> Код ошибки.
• id <integer> Идентификатор потока (или 0, если кадр не связан с потоком).

Событие 'frameError' генерируется при возникновении ошибки во время попытки отправить кадр. При вызове функции-обработчика ей передаются целочисленный аргумент с типом кадра и целочисленный аргумент с кодом ошибки. Экземпляр Http2Stream будет уничтожен сразу после генерации события 'frameError'.

Событие: 'ready'

Событие 'ready' генерируется, когда Http2Stream открыт, ему назначен id и его можно использовать. Обработчик события не ожидает аргументов.

Событие: 'timeout'

Событие 'timeout' генерируется, если для этого Http2Stream не поступает никаких данных в течение числа миллисекунд, заданного с помощью http2stream.setTimeout(). Обработчик события не ожидает аргументов.

Событие: 'trailers'

• headers <HTTP/2 Headers Object> Объект с описанием заголовков
• flags <number> Связанные числовые флаги

Событие 'trailers' генерируется при получении блока заголовков, связанного с завершающими полями заголовков. В функцию обратного вызова обработчика передаются объект заголовков HTTP/2 и связанные с заголовками флаги.

Это событие может не генерироваться, если http2stream.end() вызывается до получения завершающих заголовков, а входящие данные не считываются и для них не установлен обработчик.

stream.on('trailers', (headers, flags) => {
  console.log(headers);
}); copy

Событие: 'wantTrailers'

Событие 'wantTrailers' генерируется, когда Http2Stream поставил в очередь последний кадр DATA для отправки в кадре и Http2Stream готов отправить завершающие заголовки. Чтобы это событие генерировалось при создании запроса или ответа, необходимо задать параметр waitForTrailers.

http2stream.aborted

• <boolean>

Получает значение true, если экземпляр Http2Stream был аварийно прерван. В этом случае событие 'aborted' уже было сгенерировано.

http2stream.bufferSize

• <number>

Это свойство показывает количество символов, которые в данный момент буферизованы для записи. Подробности см. в разделе net.Socket.bufferSize.

http2stream.close(code[, callback])

• code <number> Беззнаковое 32-разрядное целое число, задающее код ошибки. Значение по умолчанию: http2.constants.NGHTTP2_NO_ERROR (0x00).
• callback <Function> Необязательная функция, зарегистрированная для прослушивания события 'close'.

Закрывает экземпляр Http2Stream, отправляя кадр RST_STREAM подключенному узлу HTTP/2.

http2stream.closed

• <boolean>

Получает значение true, если экземпляр Http2Stream закрыт.

http2stream.destroyed

• <boolean>

Получает значение true, если экземпляр Http2Stream уничтожен и больше не может использоваться.

http2stream.endAfterHeaders

• <boolean>

Получает значение true, если во фрейме HEADERS запроса или ответа установлен флаг END_STREAM. Это означает, что дополнительные данные не должны поступать, а читаемая сторона Http2Stream будет закрыта.

http2stream.id

• <number> | <undefined>

Числовой идентификатор потока для этого экземпляра Http2Stream. Получает значение undefined, если идентификатор потока еще не назначен.

http2stream.pending

• <boolean>

Получает значение true, если экземпляру Http2Stream еще не назначен числовой идентификатор потока.

http2stream.priority(options)

• options <Object>
  • exclusive <boolean> Если true и parent задает родительский поток, этот поток становится единственной прямой зависимостью родительского потока, а все остальные существующие зависимые потоки становятся зависимыми от этого потока. Значение по умолчанию: false.
  • parent <number> Задает числовой идентификатор потока, от которого зависит этот поток.
  • weight <number> Задает относительную зависимость потока по отношению к другим потокам с тем же parent. Значение — число от 1 до 256 включительно.
  • silent <boolean> Если true, изменяет приоритет локально, не отправляя кадр PRIORITY подключенному узлу.

Обновляет приоритет этого экземпляра Http2Stream.

http2stream.rstCode

• <number>

Устанавливается в значение кода ошибки RST_STREAM, сообщаемого при уничтожении Http2Stream после получения кадра RST_STREAM от подключенного узла, вызова http2stream.close() или http2stream.destroy(). Получает значение undefined, если Http2Stream еще не закрыт.

http2stream.sentHeaders

• <HTTP/2 Headers Object>

Объект, содержащий отправленные исходящие заголовки для этого Http2Stream.

http2stream.sentInfoHeaders

• <HTTP/2 Headers Object[]>

Массив объектов, содержащих отправленные исходящие информационные (дополнительные) заголовки для этого Http2Stream.

http2stream.sentTrailers

• <HTTP/2 Headers Object>

Объект, содержащий отправленные исходящие завершающие заголовки для этого HttpStream.

http2stream.session

• <Http2Session>

Ссылка на экземпляр Http2Session, которому принадлежит этот Http2Stream. После уничтожения экземпляра Http2Stream значением будет undefined.

http2stream.setTimeout(msecs, callback)

• msecs <number>
• callback <Function>

import { connect, constants } from 'node:http2';
const client = connect('http://example.org:8000');
const { NGHTTP2_CANCEL } = constants;
const req = client.request({ ':path': '/' });

// Cancel the stream if there's no activity after 5 seconds
req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL));

const http2 = require('node:http2');
const client = http2.connect('http://example.org:8000');
const { NGHTTP2_CANCEL } = http2.constants;
const req = client.request({ ':path': '/' });

// Cancel the stream if there's no activity after 5 seconds
req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL));

http2stream.state

Предоставляет различную информацию о текущем состоянии Http2Stream.

• <Object>
  • localWindowSize <number> Количество байтов, которые подключенный узел может отправить для этого Http2Stream, не получая WINDOW_UPDATE.
  • state <number> Флаг, указывающий текущее состояние низкого уровня Http2Stream, определяемое с помощью nghttp2.
  • localClose <number> 1, если этот Http2Stream был закрыт локально.
  • remoteClose <number> 1, если этот Http2Stream был закрыт удалённо.
  • sumDependencyWeight <number> Суммарный вес всех экземпляров Http2Stream, зависящих от этого Http2Stream, как указано с помощью кадров PRIORITY.
  • weight <number> Вес приоритета этого Http2Stream.

Текущее состояние этого Http2Stream.

http2stream.sendTrailers(headers)

• headers <HTTP/2 Headers Object>

Отправляет завершающий кадр HEADERS подключенному узлу HTTP/2. Этот метод немедленно закрывает Http2Stream и должен вызываться только после генерации события 'wantTrailers'. При отправке запроса или ответа необходимо установить параметр options.waitForTrailers, чтобы Http2Stream оставался открытым после последнего кадра DATA и можно было отправить завершающие заголовки.

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond(undefined, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ xyz: 'abc' });
  });
  stream.end('Hello World');
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond(undefined, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ xyz: 'abc' });
  });
  stream.end('Hello World');
});

Спецификация HTTP/1 запрещает включать в завершающие заголовки псевдозаголовки HTTP/2 (например, ':method', ':path' и т. д.).

Класс: ClientHttp2Stream

• Наследует <Http2Stream>

Класс ClientHttp2Stream расширяет Http2Stream и используется исключительно клиентами HTTP/2. Экземпляры Http2Stream на стороне клиента предоставляют такие события, как 'response' и 'push', актуальные только для клиента.

Событие: 'continue'

Генерируется, когда сервер отправляет статус 100 Continue, обычно потому, что запрос содержал Expect: 100-continue. Это указание клиенту отправить тело запроса.

Событие: 'headers'

• headers <HTTP/2 Headers Object>
• flags <number>

Событие 'headers' генерируется, когда для потока получен дополнительный блок заголовков, например блок информационных заголовков 1xx. В качестве аргументов функции-обработчика передаются объект заголовков HTTP/2 и связанные с заголовками флаги.

stream.on('headers', (headers, flags) => {
  console.log(headers);
}); copy

Событие: 'push'

• headers <HTTP/2 Headers Object>
• flags <number>

Событие 'push' генерируется при получении заголовков ответа для потока Server Push. В качестве аргументов функции-обработчика передаются объект заголовков HTTP/2 и связанные с заголовками флаги.

stream.on('push', (headers, flags) => {
  console.log(headers);
}); copy

Событие: 'response'

• headers <HTTP/2 Headers Object>
• flags <number>

Событие 'response' генерируется, когда от подключенного сервера HTTP/2 для этого потока получен кадр ответа HEADERS. Обработчик вызывается с двумя аргументами: Object, содержащим полученный объект заголовков HTTP/2, и флагами, связанными с заголовками.

import { connect } from 'node:http2';
const client = connect('https://localhost');
const req = client.request({ ':path': '/' });
req.on('response', (headers, flags) => {
  console.log(headers[':status']);
});

const http2 = require('node:http2');
const client = http2.connect('https://localhost');
const req = client.request({ ':path': '/' });
req.on('response', (headers, flags) => {
  console.log(headers[':status']);
});

Класс: ServerHttp2Stream

• Наследует: <Http2Stream>

Класс ServerHttp2Stream расширяет Http2Stream и используется исключительно серверами HTTP/2. Экземпляры Http2Stream на стороне сервера предоставляют дополнительные методы, такие как http2stream.pushStream() и http2stream.respond(), актуальные только для сервера.

http2stream.additionalHeaders(headers)

• headers <HTTP/2 Headers Object>

Отправляет подключенному узлу HTTP/2 дополнительный информационный кадр HEADERS.

http2stream.headersSent

• <boolean>

True, если заголовки были отправлены, иначе false (только для чтения).

http2stream.pushAllowed

• <boolean>

Доступное только для чтения свойство, соответствующее флагу SETTINGS_ENABLE_PUSH последнего кадра SETTINGS удалённого клиента. Равно true, если удалённый узел принимает потоки push, и false в противном случае. Параметры одинаковы для каждого Http2Stream в рамках одного Http2Session.

http2stream.pushStream(headers[, options], callback)

• headers <HTTP/2 Headers Object>
• options <Object>
  • exclusive <boolean> Если true и parent указывают на родительский поток, созданный поток становится единственной прямой зависимостью родительского, а все остальные существующие зависимые потоки становятся зависимыми от вновь созданного потока. По умолчанию: false.
  • parent <number> Указывает числовой идентификатор потока, от которого зависит вновь созданный поток.
• callback <Function> Функция обратного вызова, вызываемая после инициализации потока push.
  • err <Error>
  • pushStream <ServerHttp2Stream> Возвращённый объект pushStream.
  • headers <HTTP/2 Headers Object> Объект заголовков, с которым был инициализирован pushStream.

Инициализирует поток push. Функция обратного вызова вызывается с новым экземпляром Http2Stream, созданным для потока push и переданным вторым аргументом, либо с Error, переданным первым аргументом.

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.pushStream({ ':path': '/' }, (err, pushStream, headers) => {
    if (err) throw err;
    pushStream.respond({ ':status': 200 });
    pushStream.end('some pushed data');
  });
  stream.end('some data');
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.pushStream({ ':path': '/' }, (err, pushStream, headers) => {
    if (err) throw err;
    pushStream.respond({ ':status': 200 });
    pushStream.end('some pushed data');
  });
  stream.end('some data');
});

Задать вес потока push в кадре HEADERS нельзя. Передайте значение weight в http2stream.priority, установив параметр silent в true, чтобы включить балансировку пропускной способности на стороне сервера между одновременно работающими потоками.

Вызов http2stream.pushStream() из потока push запрещён и приведёт к ошибке.

http2stream.respond([headers[, options]])

• headers <HTTP/2 Headers Object>
• options <Object>
  • endStream <boolean> Установите в true, чтобы указать, что ответ не будет содержать данные полезной нагрузки.
  • waitForTrailers <boolean> Если задано true, Http2Stream сгенерирует событие 'wantTrailers' после отправки последнего кадра DATA.

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.end('some data');
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.end('some data');
});

Инициализирует ответ. Если задан параметр options.waitForTrailers, событие 'wantTrailers' будет сгенерировано сразу после добавления в очередь последнего фрагмента данных полезной нагрузки для отправки. Затем метод http2stream.sendTrailers() можно использовать для отправки узлу завершающих полей заголовка.

Если задано options.waitForTrailers, Http2Stream не будет автоматически закрыт после передачи последнего кадра DATA. Пользовательский код должен вызвать http2stream.sendTrailers() или http2stream.close(), чтобы закрыть Http2Stream.

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 }, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
  stream.end('some data');
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 }, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
  stream.end('some data');
});

http2stream.respondWithFD(fd[, headers[, options]])

• fd <number> | <FileHandle> Читаемый файловый дескриптор.
• headers <HTTP/2 Headers Object>
• options <Object>
  • statCheck <Function>
  • waitForTrailers <boolean> Если задано true, Http2Stream сгенерирует событие 'wantTrailers' после отправки последнего кадра DATA.
  • offset <number> Позиция смещения, с которой начинается чтение.
  • length <number> Объём данных, отправляемых из fd.

Инициализирует ответ, данные которого считываются из указанного файлового дескриптора. Проверка указанного файлового дескриптора не выполняется. Если при попытке считывания данных с помощью файлового дескриптора возникает ошибка, Http2Stream будет закрыт с использованием кадра RST_STREAM и стандартного кода INTERNAL_ERROR.

При использовании этого метода интерфейс Duplex объекта Http2Stream будет закрыт автоматически.

import { createServer } from 'node:http2';
import { openSync, fstatSync, closeSync } from 'node:fs';

const server = createServer();
server.on('stream', (stream) => {
  const fd = openSync('/some/file', 'r');

  const stat = fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers);
  stream.on('close', () => closeSync(fd));
});

const http2 = require('node:http2');
const fs = require('node:fs');

const server = http2.createServer();
server.on('stream', (stream) => {
  const fd = fs.openSync('/some/file', 'r');

  const stat = fs.fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers);
  stream.on('close', () => fs.closeSync(fd));
});

Можно указать необязательную функцию options.statCheck, чтобы предоставить пользовательскому коду возможность задать дополнительные заголовки содержимого на основе сведений fs.Stat указанного fd. Если функция statCheck указана, метод http2stream.respondWithFD() выполнит вызов fs.fstat() для получения сведений о предоставленном файловом дескрипторе.

Параметры offset и length можно использовать, чтобы ограничить ответ определённым диапазоном. Например, это позволяет поддерживать запросы HTTP Range.

Файловый дескриптор или FileHandle не закрывается при закрытии потока, поэтому его необходимо закрыть вручную, когда он больше не нужен. Одновременное использование одного файлового дескриптора в нескольких потоках не поддерживается и может привести к потере данных. Повторное использование файлового дескриптора после завершения потока поддерживается.

Если задан параметр options.waitForTrailers, событие 'wantTrailers' будет сгенерировано сразу после добавления в очередь последнего фрагмента данных полезной нагрузки для отправки. Затем метод http2stream.sendTrailers() можно использовать для отправки узлу завершающих полей заголовка.

Если задано options.waitForTrailers, Http2Stream не будет автоматически закрыт после передачи последнего кадра DATA. Пользовательский код должен вызвать http2stream.sendTrailers() или http2stream.close(), чтобы закрыть Http2Stream.

import { createServer } from 'node:http2';
import { openSync, fstatSync, closeSync } from 'node:fs';

const server = createServer();
server.on('stream', (stream) => {
  const fd = openSync('/some/file', 'r');

  const stat = fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });

  stream.on('close', () => closeSync(fd));
});

const http2 = require('node:http2');
const fs = require('node:fs');

const server = http2.createServer();
server.on('stream', (stream) => {
  const fd = fs.openSync('/some/file', 'r');

  const stat = fs.fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });

  stream.on('close', () => fs.closeSync(fd));
});

http2stream.respondWithFile(path[, headers[, options]])

• path <string> | <Buffer> | <URL>
• headers <HTTP/2 Headers Object>
• options <Object>
  • statCheck <Function>
  • onError <Function> Функция обратного вызова, вызываемая в случае ошибки до отправки.
  • waitForTrailers <boolean> Если задано true, Http2Stream сгенерирует событие 'wantTrailers' после отправки последнего кадра DATA.
  • offset <number> Позиция смещения, с которой начинается чтение.
  • length <number> Объём данных, отправляемых из fd.

Отправляет обычный файл в качестве ответа. Параметр path должен указывать на обычный файл, иначе для объекта Http2Stream будет сгенерировано событие 'error'.

При использовании этого метода интерфейс Duplex объекта Http2Stream будет закрыт автоматически.

Можно указать необязательную функцию options.statCheck, чтобы предоставить пользовательскому коду возможность задать дополнительные заголовки содержимого на основе сведений fs.Stat указанного файла:

Если при попытке чтения данных файла возникает ошибка, Http2Stream будет закрыт с использованием кадра RST_STREAM и стандартного кода INTERNAL_ERROR. Если задана функция обратного вызова onError, она будет вызвана. В противном случае поток будет уничтожен.

Пример с использованием пути к файлу:

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    headers['last-modified'] = stat.mtime.toUTCString();
  }

  function onError(err) {
    // stream.respond() can throw if the stream has been destroyed by
    // the other side.
    try {
      if (err.code === 'ENOENT') {
        stream.respond({ ':status': 404 });
      } else {
        stream.respond({ ':status': 500 });
      }
    } catch (err) {
      // Perform actual error handling.
      console.error(err);
    }
    stream.end();
  }

  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck, onError });
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    headers['last-modified'] = stat.mtime.toUTCString();
  }

  function onError(err) {
    // stream.respond() can throw if the stream has been destroyed by
    // the other side.
    try {
      if (err.code === 'ENOENT') {
        stream.respond({ ':status': 404 });
      } else {
        stream.respond({ ':status': 500 });
      }
    } catch (err) {
      // Perform actual error handling.
      console.error(err);
    }
    stream.end();
  }

  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck, onError });
});

Функцию options.statCheck также можно использовать для отмены операции отправки, вернув false. Например, условный запрос может проверять результаты stat, чтобы определить, был ли изменён файл, и вернуть соответствующий ответ 304:

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    // Check the stat here...
    stream.respond({ ':status': 304 });
    return false; // Cancel the send operation
  }
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck });
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    // Check the stat here...
    stream.respond({ ':status': 304 });
    return false; // Cancel the send operation
  }
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck });
});

Поле заголовка content-length будет установлено автоматически.

Параметры offset и length можно использовать, чтобы ограничить ответ определённым диапазоном. Например, это позволяет поддерживать запросы HTTP Range.

Функцию options.onError также можно использовать для обработки всех ошибок, которые могут возникнуть до начала передачи файла. По умолчанию поток уничтожается.

Если задан параметр options.waitForTrailers, событие 'wantTrailers' будет сгенерировано сразу после добавления в очередь последнего фрагмента данных полезной нагрузки для отправки. Затем метод http2stream.sendTrailers() можно использовать для отправки узлу завершающих полей заголовка.

Если задано options.waitForTrailers, Http2Stream не будет автоматически закрыт после передачи последнего кадра DATA. Пользовательский код должен вызвать http2stream.sendTrailers() или http2stream.close(), чтобы закрыть Http2Stream.

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
});

Класс: Http2Server

• Наследует: <net.Server>

Экземпляры Http2Server создаются с помощью функции http2.createServer(). Класс Http2Server не экспортируется напрямую модулем node:http2.

Событие: 'checkContinue'

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

Если зарегистрирован обработчик 'request' или в http2.createServer() передана функция обратного вызова, событие 'checkContinue' генерируется при каждом получении запроса с HTTP Expect: 100-continue. Если обработчик этого события отсутствует, сервер автоматически отправит соответствующий статус 100 Continue.

Для обработки этого события необходимо вызвать response.writeContinue(), если клиенту следует продолжить отправку тела запроса, либо сформировать соответствующий ответ HTTP (например, 400 Bad Request), если клиенту не следует продолжать отправку тела запроса.

Если это событие сгенерировано и обработано, событие 'request' сгенерировано не будет.

Событие: 'connection'

• socket <stream.Duplex>

Это событие генерируется при установлении нового потока TCP. Обычно socket — это объект типа net.Socket. Как правило, пользователям не требуется обращаться к этому событию.

Пользователи также могут явно генерировать это событие, чтобы добавить соединения в HTTP-сервер. В этом случае можно передать любой поток Duplex.

Событие: 'request'

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

Генерируется при каждом запросе. В рамках одного сеанса может быть несколько запросов. См. API совместимости.

Событие: 'session'

• session <ServerHttp2Session>

Событие 'session' генерируется при создании нового Http2Session объектом Http2Server.

Событие: 'sessionError'

• error <Error>
• session <ServerHttp2Session>

Событие 'sessionError' генерируется, когда событие 'error' генерируется объектом Http2Session, связанным с Http2Server.

Событие: 'stream'

• stream <Http2Stream> Ссылка на поток
• headers <HTTP/2 Headers Object> Объект с описанием заголовков
• flags <number> Связанные числовые флаги
• rawHeaders <Array> Массив, содержащий исходные имена заголовков, за которыми следуют соответствующие значения.

Событие 'stream' генерируется, когда объект Http2Session, связанный с сервером, сгенерировал событие 'stream'.

См. также событие 'stream' объекта Http2Session.

import { createServer, constants } from 'node:http2';
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = constants;

const server = createServer();
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});

const http2 = require('node:http2');
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = http2.constants;

const server = http2.createServer();
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});

Событие: 'timeout'

Событие 'timeout' генерируется, если на сервере нет активности в течение заданного количества миллисекунд, установленного с помощью http2server.setTimeout(). По умолчанию: 0 (тайм-аут отсутствует)

server.close([callback])

• callback <Function>

Запрещает серверу устанавливать новые сеансы. Это не препятствует созданию новых потоков запросов из-за постоянного характера сеансов HTTP/2. Чтобы корректно завершить работу сервера, вызовите http2session.close() для всех активных сеансов.

Если указан callback, он не будет вызван, пока не будут закрыты все активные сеансы, хотя сервер уже перестанет принимать новые сеансы. Дополнительные сведения см. в разделе net.Server.close().

server[Symbol.asyncDispose]()

Вызывает server.close() и возвращает промис, который выполняется после закрытия сервера.

server.setTimeout([msecs][, callback])

• msecs <number> По умолчанию: 0 (тайм-аут отсутствует)
• callback <Function>
• Возвращает: <Http2Server>

Используется для установки значения тайм-аута запросов HTTP/2-сервера и задания функции обратного вызова, которая вызывается при отсутствии активности на Http2Server в течение msecs миллисекунд.

Указанная функция обратного вызова регистрируется как обработчик события 'timeout'.

Если callback не является функцией, будет выброшена новая ошибка ERR_INVALID_ARG_TYPE.

server.timeout

• <number> Тайм-аут в миллисекундах. По умолчанию: 0 (без тайм-аута)

Количество миллисекунд бездействия, после которого считается, что время ожидания сокета истекло.

Значение 0 отключает тайм-аут для входящих соединений.

Логика тайм-аута сокета настраивается при подключении, поэтому изменение этого значения влияет только на новые соединения с сервером, но не на уже существующие.

server.updateSettings([settings])

• settings <HTTP/2 Settings Object>

Используется для обновления сервера с помощью предоставленных параметров.

Вызывает ERR_HTTP2_INVALID_SETTING_VALUE для недопустимых значений settings.

Вызывает ERR_INVALID_ARG_TYPE для недопустимого аргумента settings.

Класс: Http2SecureServer

• Наследует: <tls.Server>

Экземпляры Http2SecureServer создаются с помощью функции http2.createSecureServer(). Класс Http2SecureServer не экспортируется напрямую модулем node:http2.

Событие: 'checkContinue'

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

Если зарегистрирован обработчик события 'request' или для параметра http2.createSecureServer() передана функция обратного вызова, событие 'checkContinue' генерируется каждый раз при получении запроса с заголовком HTTP Expect: 100-continue. Если обработчик этого события не задан, сервер автоматически отправит соответствующий код состояния 100 Continue.

Для обработки этого события необходимо вызвать response.writeContinue(), если клиент должен продолжить отправку тела запроса, либо сформировать подходящий ответ HTTP (например, 400 Bad Request), если клиенту не следует продолжать отправку тела запроса.

Когда это событие генерируется и обрабатывается, событие 'request' не генерируется.

Событие: 'connection'

• socket <stream.Duplex>

Это событие генерируется при установлении нового потока TCP, до начала TLS-рукопожатия. Обычно socket — это объект типа net.Socket. Как правило, пользователям не требуется обращаться к этому событию.

Пользователи также могут явно генерировать это событие, чтобы передавать соединения HTTP-серверу. В этом случае можно передать любой поток Duplex.

Событие: 'request'

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

Генерируется при каждом поступлении запроса. В рамках одного сеанса может быть несколько запросов. См. API совместимости.

Событие: 'session'

• session <ServerHttp2Session>

Событие 'session' генерируется при создании нового Http2Session объектом Http2SecureServer.

Событие: 'sessionError'

• error <Error>
• session <ServerHttp2Session>

Событие 'sessionError' генерируется, когда объект Http2Session, связанный с Http2SecureServer, генерирует событие 'error'.

Событие: 'stream'

• stream <Http2Stream> Ссылка на поток
• headers <HTTP/2 Headers Object> Объект с описанием заголовков
• flags <number> Связанные числовые флаги
• rawHeaders <Array> Массив, содержащий исходные имена заголовков, за которыми следуют соответствующие им значения.

Событие 'stream' генерируется, когда объект Http2Session, связанный с сервером, генерирует событие 'stream'.

См. также событие 'stream' объекта Http2Session.

import { createSecureServer, constants } from 'node:http2';
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = constants;

const options = getOptionsSomehow();

const server = createSecureServer(options);
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});

const http2 = require('node:http2');
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = http2.constants;

const options = getOptionsSomehow();

const server = http2.createSecureServer(options);
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});

Событие: 'timeout'

Событие 'timeout' генерируется, если на сервере отсутствует активность в течение заданного количества миллисекунд, установленного с помощью http2secureServer.setTimeout(). По умолчанию: 2 минуты.

Событие: 'unknownProtocol'

• socket <stream.Duplex>

Событие 'unknownProtocol' генерируется, если подключающийся клиент не может согласовать поддерживаемый протокол (то есть HTTP/2 или HTTP/1.1). Обработчик события получает сокет для его обработки. Если обработчик этого события не зарегистрирован, соединение разрывается. Тайм-аут можно указать с помощью параметра 'unknownProtocolTimeout', передаваемого в http2.createSecureServer().

В предыдущих версиях Node.js это событие генерировалось, если allowHTTP1 имело значение false и во время TLS-рукопожатия клиент либо не отправлял расширение ALPN, либо отправлял расширение ALPN, не включающее HTTP/2 (h2). В более новых версиях Node.js это событие генерируется, только если allowHTTP1 имеет значение false и клиент не отправляет расширение ALPN. Если клиент отправляет расширение ALPN, не включающее HTTP/2 (или HTTP/1.1, если allowHTTP1 имеет значение true), TLS-рукопожатие завершится ошибкой, и защищённое соединение установлено не будет.

См. API совместимости.

server.close([callback])

• callback <Function>

Останавливает создание сервером новых сеансов. Это не мешает создавать новые потоки запросов из-за постоянного характера сеансов HTTP/2. Чтобы корректно завершить работу сервера, вызовите http2session.close() для всех активных сеансов.

Если указан callback, он будет вызван только после закрытия всех активных сеансов, хотя сервер уже прекратил принимать новые сеансы. Дополнительные сведения см. в разделе tls.Server.close().

server.setTimeout([msecs][, callback])

• msecs <number> По умолчанию: 120000 (2 минуты)
• callback <Function>
• Возвращает: <Http2SecureServer>

Используется для установки значения тайм-аута для запросов защищённого сервера http2 и для задания функции обратного вызова, которая вызывается при отсутствии активности на Http2SecureServer в течение msecs миллисекунд.

Переданный обратный вызов регистрируется как обработчик события 'timeout'.

Если callback не является функцией, будет выброшена новая ошибка ERR_INVALID_ARG_TYPE.

server.timeout

• <number> Тайм-аут в миллисекундах. По умолчанию: 0 (без тайм-аута)

Количество миллисекунд бездействия, после которого считается, что время ожидания сокета истекло.

Значение 0 отключает тайм-аут для входящих соединений.

Логика тайм-аута сокета настраивается при подключении, поэтому изменение этого значения влияет только на новые соединения с сервером, но не на уже существующие.

server.updateSettings([settings])

• settings <HTTP/2 Settings Object>

Используется для обновления сервера с помощью предоставленных параметров.

Вызывает ERR_HTTP2_INVALID_SETTING_VALUE для недопустимых значений settings.

Вызывает ERR_INVALID_ARG_TYPE для недопустимого аргумента settings.

http2.createServer([options][, onRequestHandler])

• options <Object>
  • maxDeflateDynamicTableSize <number> Устанавливает максимальный размер динамической таблицы для сжатия полей заголовков. По умолчанию: 4Kib.
  • maxSettings <number> Устанавливает максимальное количество записей параметров в каждом кадре SETTINGS. Минимально допустимое значение — 1. По умолчанию: 32.
  • maxSessionMemory<number> Устанавливает максимальный объём памяти, который разрешено использовать Http2Session. Значение задаётся в мегабайтах: например, 1 соответствует 1 мегабайту. Минимально допустимое значение — 1. Это ограничение основано на кредитной модели: существующие экземпляры Http2Stream могут привести к превышению этого ограничения, но новые экземпляры Http2Stream будут отклоняться, пока ограничение превышено. В текущий лимит учитываются текущее количество сеансов Http2Stream, текущее использование памяти таблицами сжатия заголовков, текущие данные в очереди на отправку, а также неподтверждённые кадры PING и SETTINGS. По умолчанию: 10.
  • maxHeaderListPairs <number> Устанавливает максимальное количество записей заголовков. Это аналогично параметрам server.maxHeadersCount или request.maxHeadersCount модуля node:http. Минимальное значение — 4. По умолчанию: 128.
  • maxOutstandingPings <number> Устанавливает максимальное количество неподтверждённых ping-запросов. По умолчанию: 10.
  • maxSendHeaderBlockLength <number> Устанавливает максимально допустимый размер сериализованного сжатого блока заголовков. Попытка отправить заголовки, превышающие этот лимит, приведёт к генерации события 'frameError', а поток будет закрыт и уничтожен. Хотя этот параметр устанавливает максимальный допустимый размер всего блока заголовков, nghttp2 (внутренняя библиотека http2) ограничивает размер каждой распакованной пары ключ/значение значением 65536.
  • paddingStrategy <number> Стратегия определения объёма дополнения для кадров HEADERS и DATA. По умолчанию: http2.constants.PADDING_STRATEGY_NONE. Возможные значения:
    • http2.constants.PADDING_STRATEGY_NONE: Дополнение не применяется.
    • http2.constants.PADDING_STRATEGY_MAX: Применяется максимально возможный объём дополнения, определяемый внутренней реализацией.
    • http2.constants.PADDING_STRATEGY_ALIGNED: Предпринимается попытка добавить достаточно дополнения, чтобы общая длина кадра, включая заголовок размером 9 байт, была кратна 8. Для каждого кадра существует максимально допустимое количество байтов дополнения, определяемое текущим состоянием управления потоком и параметрами. Если это максимальное значение меньше рассчитанного количества, необходимого для выравнивания, используется максимальное значение, и общая длина кадра не обязательно будет выровнена по 8 байтам.
  • peerMaxConcurrentStreams <number> Устанавливает максимальное количество параллельных потоков для удалённого узла, как если бы был получен кадр SETTINGS. Это значение будет переопределено, если удалённый узел задаст собственное значение для maxConcurrentStreams. По умолчанию: 100.
  • maxSessionInvalidFrames <integer> Устанавливает максимальное количество недопустимых кадров, которое будет допускаться до закрытия сеанса. По умолчанию: 1000.
  • maxSessionRejectedStreams <integer> Устанавливает максимальное количество отклонённых при создании потоков, которое будет допускаться до закрытия сеанса. Каждое отклонение связано с ошибкой NGHTTP2_ENHANCE_YOUR_CALM, которая должна сообщать узлу, что не следует открывать новые потоки; поэтому продолжение открытия потоков считается признаком некорректного поведения узла. По умолчанию: 100.
  • settings <HTTP/2 Settings Object> Начальные параметры, отправляемые удалённому узлу при подключении.
  • remoteCustomSettings <Array> Массив целочисленных значений определяет типы параметров, которые включаются в свойство CustomSettings полученного объекта remoteSettings. Дополнительные сведения о допустимых типах параметров см. в свойстве CustomSettings объекта Http2Settings.
  • Http1IncomingMessage <http.IncomingMessage> Указывает класс IncomingMessage, используемый для резервного режима HTTP/1. Полезно для расширения исходного http.IncomingMessage. По умолчанию: http.IncomingMessage.
  • Http1ServerResponse <http.ServerResponse> Указывает класс ServerResponse, используемый для резервного режима HTTP/1. Полезно для расширения исходного http.ServerResponse. По умолчанию: http.ServerResponse.
  • Http2ServerRequest <http2.Http2ServerRequest> Указывает используемый класс Http2ServerRequest. Полезно для расширения исходного Http2ServerRequest. По умолчанию: Http2ServerRequest.
  • Http2ServerResponse <http2.Http2ServerResponse> Указывает используемый класс Http2ServerResponse. Полезно для расширения исходного Http2ServerResponse. По умолчанию: Http2ServerResponse.
  • unknownProtocolTimeout <number> Указывает тайм-аут в миллисекундах, который сервер должен выждать при генерации события 'unknownProtocol'. Если к этому моменту сокет не будет уничтожен, сервер уничтожит его. По умолчанию: 10000.
  • ...: Можно указать любой параметр net.createServer().
• onRequestHandler <Function> См. API совместимости
• Возвращает: <Http2Server>

Возвращает экземпляр net.Server, который создаёт экземпляры Http2Session и управляет ими.

Поскольку неизвестно ни одного браузера, поддерживающего незашифрованный HTTP/2, для взаимодействия с клиентами-браузерами необходимо использовать http2.createSecureServer().

import { createServer } from 'node:http2';

// Create an unencrypted HTTP/2 server.
// Since there are no browsers known that support
// unencrypted HTTP/2, the use of `createSecureServer()`
// is necessary when communicating with browser clients.
const server = createServer();

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.end('<h1>Hello World</h1>');
});

server.listen(8000);

const http2 = require('node:http2');

// Create an unencrypted HTTP/2 server.
// Since there are no browsers known that support
// unencrypted HTTP/2, the use of `http2.createSecureServer()`
// is necessary when communicating with browser clients.
const server = http2.createServer();

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.end('<h1>Hello World</h1>');
});

server.listen(8000);

http2.createSecureServer(options[, onRequestHandler])

• options <Object>
  • allowHTTP1 <boolean> При установке значения true входящие подключения клиентов, не поддерживающих HTTP/2, будут понижены до HTTP/1.x. См. событие 'unknownProtocol'. См. согласование ALPN. По умолчанию: false.
  • maxDeflateDynamicTableSize <number> Задает максимальный размер динамической таблицы для сжатия полей заголовка. По умолчанию: 4Kib.
  • maxSettings <number> Задает максимальное количество записей настроек в каждом кадре SETTINGS. Минимальное допустимое значение — 1. По умолчанию: 32.
  • maxSessionMemory<number> Задает максимальный объем памяти, который разрешено использовать Http2Session. Значение выражается в мегабайтах, например 1 равно 1 мегабайту. Минимальное допустимое значение — 1. Это ограничение на основе кредитов: существующие экземпляры Http2Streams могут привести к превышению этого лимита, но новые экземпляры Http2Stream будут отклонены, пока лимит превышен. В текущий лимит включаются текущее число сеансов Http2Stream, текущее использование памяти таблицами сжатия заголовков, данные, ожидающие отправки, а также неподтвержденные кадры PING и SETTINGS. По умолчанию: 10.
  • maxHeaderListPairs <number> Задает максимальное количество записей заголовков. Это аналогично server.maxHeadersCount или request.maxHeadersCount в модуле node:http. Минимальное значение — 4. По умолчанию: 128.
  • maxOutstandingPings <number> Задает максимальное количество ожидающих подтверждения ping-запросов. По умолчанию: 10.
  • maxSendHeaderBlockLength <number> Задает максимально допустимый размер сериализованного сжатого блока заголовков. Попытки отправить заголовки, превышающие этот лимит, приведут к генерации события 'frameError' и закрытию и уничтожению потока.
  • paddingStrategy <number> Стратегия определения количества дополнения для кадров HEADERS и DATA. По умолчанию: http2.constants.PADDING_STRATEGY_NONE. Возможны следующие значения:
    • http2.constants.PADDING_STRATEGY_NONE: дополнение не применяется.
    • http2.constants.PADDING_STRATEGY_MAX: применяется максимальное количество дополнения, определяемое внутренней реализацией.
    • http2.constants.PADDING_STRATEGY_ALIGNED: предпринимается попытка добавить столько дополнения, чтобы общая длина кадра, включая 9-байтовый заголовок, была кратна 8. Для каждого кадра максимально допустимое число байтов дополнения определяется текущим состоянием управления потоком и настройками. Если этот максимум меньше рассчитанного количества, необходимого для выравнивания, используется максимум, и общая длина кадра необязательно будет кратна 8 байтам.
  • peerMaxConcurrentStreams <number> Задает максимальное количество одновременных потоков для удаленного узла, как если бы был получен кадр SETTINGS. Это значение будет переопределено, если удаленный узел задаст собственное значение для maxConcurrentStreams. По умолчанию: 100.
  • maxSessionInvalidFrames <integer> Задает максимальное количество недопустимых кадров, которое будет допускаться до закрытия сеанса. По умолчанию: 1000.
  • maxSessionRejectedStreams <integer> Задает максимальное количество потоков, отклоненных при создании, которое будет допускаться до закрытия сеанса. Каждое отклонение связано с ошибкой NGHTTP2_ENHANCE_YOUR_CALM, которая должна указывать удаленному узлу, что ему не следует открывать новые потоки; поэтому продолжение их открытия считается признаком некорректного поведения удаленного узла. По умолчанию: 100.
  • settings <HTTP/2 Settings Object> Начальные настройки, отправляемые удаленному узлу при подключении.
  • remoteCustomSettings <Array> Массив целочисленных значений определяет типы настроек, включенные в свойство customSettings полученного объекта remoteSettings. Дополнительные сведения о допустимых типах настроек см. в свойстве customSettings объекта Http2Settings.
  • ...: Можно указать любые параметры tls.createServer(). Для серверов обычно требуются параметры идентификации (pfx или key/cert).
  • origins <string[]> Массив строк источников для отправки в кадре ORIGIN сразу после создания нового серверного Http2Session.
  • unknownProtocolTimeout <number> Задает тайм-аут в миллисекундах, в течение которого сервер должен ожидать после генерации события 'unknownProtocol'. Если к этому времени сокет не будет уничтожен, сервер уничтожит его. По умолчанию: 10000.
• onRequestHandler <Function> См. API совместимости
• Возвращает: <Http2SecureServer>

Возвращает экземпляр tls.Server, который создает экземпляры Http2Session и управляет ими.

import { createSecureServer } from 'node:http2';
import { readFileSync } from 'node:fs';

const options = {
  key: readFileSync('server-key.pem'),
  cert: readFileSync('server-cert.pem'),
};

// Create a secure HTTP/2 server
const server = createSecureServer(options);

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.end('<h1>Hello World</h1>');
});

server.listen(8443);

const http2 = require('node:http2');
const fs = require('node:fs');

const options = {
  key: fs.readFileSync('server-key.pem'),
  cert: fs.readFileSync('server-cert.pem'),
};

// Create a secure HTTP/2 server
const server = http2.createSecureServer(options);

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.end('<h1>Hello World</h1>');
});

server.listen(8443);

http2.connect(authority[, options][, listener])

• authority <string> | <URL> Удаленный HTTP/2-сервер для подключения. Значение должно представлять собой минимальный допустимый URL с префиксом http:// или https://, именем узла и IP-портом (если используется порт, отличный от порта по умолчанию). Данные пользователя (идентификатор пользователя и пароль), путь, строка запроса и фрагмент URL игнорируются.
• options <Object>
  • maxDeflateDynamicTableSize <number> Задает максимальный размер динамической таблицы для сжатия полей заголовка. По умолчанию: 4Kib.
  • maxSettings <number> Задает максимальное количество записей настроек в каждом кадре SETTINGS. Минимальное допустимое значение — 1. По умолчанию: 32.
  • maxSessionMemory<number> Задает максимальный объем памяти, который разрешено использовать Http2Session. Значение выражается в мегабайтах, например 1 равно 1 мегабайту. Минимальное допустимое значение — 1. Это ограничение на основе кредитов: существующие экземпляры Http2Streams могут привести к превышению этого лимита, но новые экземпляры Http2Stream будут отклонены, пока лимит превышен. В текущий лимит включаются текущее число сеансов Http2Stream, текущее использование памяти таблицами сжатия заголовков, данные, ожидающие отправки, а также неподтвержденные кадры PING и SETTINGS. По умолчанию: 10.
  • maxHeaderListPairs <number> Задает максимальное количество записей заголовков. Это аналогично server.maxHeadersCount или request.maxHeadersCount в модуле node:http. Минимальное значение — 1. По умолчанию: 128.
  • maxOutstandingPings <number> Задает максимальное количество ожидающих подтверждения ping-запросов. По умолчанию: 10.
  • maxReservedRemoteStreams <number> Задает максимальное количество зарезервированных потоков push, которое клиент может одновременно принимать. Когда текущее количество зарезервированных потоков push достигнет этого лимита, новые потоки push, отправленные сервером, будут автоматически отклоняться. Минимальное допустимое значение — 0. Максимальное допустимое значение — 2³²-1. Отрицательное значение устанавливает для этого параметра максимально допустимое значение. По умолчанию: 200.
  • maxSendHeaderBlockLength <number> Задает максимально допустимый размер сериализованного сжатого блока заголовков. Попытки отправить заголовки, превышающие этот лимит, приведут к генерации события 'frameError' и закрытию и уничтожению потока.
  • paddingStrategy <number> Стратегия определения количества дополнения для кадров HEADERS и DATA. По умолчанию: http2.constants.PADDING_STRATEGY_NONE. Возможны следующие значения:
    • http2.constants.PADDING_STRATEGY_NONE: дополнение не применяется.
    • http2.constants.PADDING_STRATEGY_MAX: применяется максимальное количество дополнения, определяемое внутренней реализацией.
    • http2.constants.PADDING_STRATEGY_ALIGNED: предпринимается попытка добавить столько дополнения, чтобы общая длина кадра, включая 9-байтовый заголовок, была кратна 8. Для каждого кадра максимально допустимое число байтов дополнения определяется текущим состоянием управления потоком и настройками. Если этот максимум меньше рассчитанного количества, необходимого для выравнивания, используется максимум, и общая длина кадра необязательно будет кратна 8 байтам.
  • peerMaxConcurrentStreams <number> Задает максимальное количество одновременных потоков для удаленного узла, как если бы был получен кадр SETTINGS. Это значение будет переопределено, если удаленный узел задаст собственное значение для maxConcurrentStreams. По умолчанию: 100.
  • protocol <string> Протокол подключения, если он не задан в authority. Возможны значения 'http:' или 'https:'. По умолчанию: 'https:'
  • settings <HTTP/2 Settings Object> Начальные настройки, отправляемые удаленному узлу при подключении.
  • remoteCustomSettings <Array> Массив целочисленных значений определяет типы настроек, включенные в свойство CustomSettings полученного объекта remoteSettings. Дополнительные сведения о допустимых типах настроек см. в свойстве CustomSettings объекта Http2Settings.
  • createConnection <Function> Необязательная функция обратного вызова, получающая экземпляр URL, переданный в connect, и объект options и возвращающая любой поток Duplex, который будет использоваться в качестве подключения для этого сеанса.
  • ...: Можно указать любые параметры net.connect() или tls.connect().
  • unknownProtocolTimeout <number> Задает тайм-аут в миллисекундах, в течение которого сервер должен ожидать после генерации события 'unknownProtocol'. Если к этому времени сокет не будет уничтожен, сервер уничтожит его. По умолчанию: 10000.
• listener <Function> Будет зарегистрирована как одноразовый обработчик события 'connect'.
• Возвращает: <ClientHttp2Session>

Возвращает экземпляр ClientHttp2Session.

import { connect } from 'node:http2';
const client = connect('https://localhost:1234');

/* Use the client */

client.close();

const http2 = require('node:http2');
const client = http2.connect('https://localhost:1234');

/* Use the client */

client.close();

http2.constants

Коды ошибок для RST_STREAM и GOAWAY

Событие 'timeout' генерируется, если на сервере отсутствует активность в течение заданного количества миллисекунд, установленного с помощью http2server.setTimeout().

http2.getDefaultSettings()

• Возвращает: <HTTP/2 Settings Object>

Возвращает объект, содержащий настройки по умолчанию для экземпляра Http2Session. При каждом вызове этот метод возвращает новый экземпляр объекта, поэтому возвращенные экземпляры можно безопасно изменять.

http2.getPackedSettings([settings])

• settings <HTTP/2 Settings Object>
• Возвращает: <Buffer>

Возвращает экземпляр Buffer, содержащий сериализованное представление заданных настроек HTTP/2 в соответствии со спецификацией HTTP/2. Он предназначен для использования с полем заголовка HTTP2-Settings.

import { getPackedSettings } from 'node:http2';

const packed = getPackedSettings({ enablePush: false });

console.log(packed.toString('base64'));
// Prints: AAIAAAAA

const http2 = require('node:http2');

const packed = http2.getPackedSettings({ enablePush: false });

console.log(packed.toString('base64'));
// Prints: AAIAAAAA

http2.getUnpackedSettings(buf)

• buf <Buffer> | <TypedArray> Упакованные настройки.
• Возвращает: <HTTP/2 Settings Object>

Возвращает объект настроек HTTP/2, содержащий десериализованные настройки из заданного Buffer, созданного с помощью http2.getPackedSettings().

http2.performServerHandshake(socket[, options])

• socket <stream.Duplex>
• options <Object>
  • ...: Можно указать любой параметр http2.createServer().
• Возвращает: <ServerHttp2Session>

Создает сеанс сервера HTTP/2 на основе существующего сокета.

http2.sensitiveHeaders

• <symbol>

Этот символ можно задать в качестве свойства объекта заголовков HTTP/2 со значением-массивом, чтобы указать список заголовков, считающихся конфиденциальными. Подробнее см. в разделе Конфиденциальные заголовки.

Объект заголовков

Заголовки представлены в виде собственных свойств объектов JavaScript. Ключи свойств при сериализации будут преобразованы в нижний регистр. Значения свойств должны быть строками (если это не так, они будут преобразованы в строки) или Array строк, чтобы отправить несколько значений для одного поля заголовка.

const headers = {
  ':status': '200',
  'content-type': 'text-plain',
  'ABC': ['has', 'more', 'than', 'one', 'value'],
};

stream.respond(headers); copy

Объекты заголовков, передаваемые функциям обратного вызова, будут иметь прототип null. Это означает, что обычные методы объектов JavaScript, такие как Object.prototype.toString() и Object.prototype.hasOwnProperty(), работать не будут.

Для входящих заголовков:

• Заголовок :status преобразуется в number.
• Дубликаты заголовков :status, :method, :authority, :scheme, :path, :protocol, age, authorization, access-control-allow-credentials, access-control-max-age, access-control-request-method, content-encoding, content-language, content-length, content-location, content-md5, content-range, content-type, date, dnt, etag, expires, from, host, if-match, if-modified-since, if-none-match, if-range, if-unmodified-since, last-modified, location, max-forwards, proxy-authorization, range, referer,retry-after, tk, upgrade-insecure-requests, user-agent или x-content-type-options отбрасываются.
• set-cookie всегда является массивом. Дубликаты добавляются в массив.
• Значения дублирующихся заголовков cookie объединяются с помощью '; '.
• Значения всех остальных заголовков объединяются с помощью ', '.

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream, headers) => {
  console.log(headers[':path']);
  console.log(headers.ABC);
});

const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream, headers) => {
  console.log(headers[':path']);
  console.log(headers.ABC);
});

Конфиденциальные заголовки

Заголовки HTTP/2 можно пометить как конфиденциальные; это означает, что алгоритм сжатия заголовков HTTP/2 никогда не будет включать их в индекс. Это может быть полезно для значений заголовков с низкой энтропией, которые могут представлять ценность для злоумышленника, например Cookie или Authorization. Чтобы сделать это, добавьте имя заголовка в свойство [http2.sensitiveHeaders] в виде массива:

const headers = {
  ':status': '200',
  'content-type': 'text-plain',
  'cookie': 'some-cookie',
  'other-sensitive-header': 'very secret data',
  [http2.sensitiveHeaders]: ['cookie', 'other-sensitive-header'],
};

stream.respond(headers); copy

Для некоторых заголовков, таких как Authorization и коротких заголовков Cookie, этот флаг устанавливается автоматически.

Это свойство также устанавливается для полученных заголовков. Оно будет содержать имена всех заголовков, помеченных как конфиденциальные, в том числе автоматически.

Объект настроек

API http2.getDefaultSettings(), http2.getPackedSettings(), http2.createServer(), http2.createSecureServer(), http2session.settings(), http2session.localSettings и http2session.remoteSettings возвращают объект или принимают его в качестве входных данных. Этот объект определяет параметры конфигурации для объекта Http2Session. Такие объекты являются обычными объектами JavaScript, содержащими следующие свойства.

• headerTableSize <number> Задает максимальное количество байтов, используемых для сжатия заголовков. Минимальное допустимое значение — 0. Максимальное допустимое значение — 2³²-1. По умолчанию: 4096.
• enablePush <boolean> Указывает true, если потоки HTTP/2 Push разрешены для экземпляров Http2Session. По умолчанию: true.
• initialWindowSize <number> Задает начальный размер окна отправителя в байтах для управления потоком на уровне потоков. Минимальное допустимое значение — 0. Максимальное допустимое значение — 2³²-1. По умолчанию: 65535.
• maxFrameSize <number> Задает размер полезной нагрузки самого большого кадра в байтах. Минимальное допустимое значение — 16 384. Максимальное допустимое значение — 2²⁴-1. По умолчанию: 16384.
• maxConcurrentStreams <number> Задает максимальное количество одновременных потоков, разрешенных для Http2Session. Значение по умолчанию отсутствует, что означает, по крайней мере теоретически, возможность одновременного открытия 2³²-1 потоков в любой момент времени в Http2Session. Минимальное значение — 0. Максимальное допустимое значение — 2³²-1. По умолчанию: 4294967295.
• maxHeaderListSize <number> Задает максимальный размер (несжатое число октетов) принимаемого списка заголовков. Минимальное допустимое значение — 0. Максимальное допустимое значение — 2³²-1. По умолчанию: 65535.
• maxHeaderSize <number> Псевдоним для maxHeaderListSize.
• enableConnectProtocol<boolean> Указывает true, если должен быть включен «расширенный протокол Connect», определенный в RFC 8441. Эта настройка имеет значение только в том случае, если ее отправляет сервер. После включения настройки enableConnectProtocol для данного Http2Session отключить ее нельзя. По умолчанию: false.
• customSettings <Object> Задает дополнительные настройки, которые пока не реализованы в Node и нижележащих библиотеках. Ключ объекта определяет числовое значение типа настройки (согласно реестру «HTTP/2 SETTINGS», созданному в соответствии с [RFC 7540]), а значение — фактическое числовое значение настройки. Тип настройки должен быть целым числом в диапазоне от 1 до 2^16-1. Это не должен быть тип настройки, уже обрабатываемый Node; то есть в настоящее время он должен быть больше 6, хотя это не считается ошибкой. Значения должны быть беззнаковыми целыми числами в диапазоне от 0 до 2^32-1. В настоящее время поддерживается не более 10 пользовательских настроек. Эта возможность поддерживается только для отправки SETTINGS или получения значений настроек, указанных в параметрах remoteCustomSettings объекта сервера или клиента. Не смешивайте механизм customSettings для идентификатора настройки с интерфейсами для настроек, обрабатываемых изначально, поскольку в будущей версии Node настройка может получить встроенную поддержку.

Все дополнительные свойства объекта настроек игнорируются.

Обработка ошибок

При использовании модуля node:http2 могут возникать ошибки нескольких типов:

Ошибки проверки возникают, если передан неверный аргумент, параметр или значение настройки. О таких ошибках всегда сообщается синхронным throw.

Ошибки состояния возникают, если действие выполняется в неподходящий момент (например, при попытке отправить данные по уже закрытому потоку). В зависимости от того, где и когда возникает ошибка, о ней сообщается либо с помощью синхронного throw, либо через событие 'error' объекта Http2Stream, Http2Session или сервера HTTP/2.

Внутренние ошибки возникают, когда сеанс HTTP/2 неожиданно завершается сбоем. О них сообщается с помощью события 'error' для объектов Http2Session или HTTP/2 Server.

Ошибки протокола возникают при нарушении различных ограничений протокола HTTP/2. О них сообщается либо с помощью синхронного throw, либо через событие 'error' для объектов Http2Stream, Http2Session или HTTP/2 Server — в зависимости от того, где и когда произошла ошибка.

Обработка недопустимых символов в именах и значениях заголовков

Реализация HTTP/2 строже обрабатывает недопустимые символы в именах и значениях HTTP-заголовков, чем реализация HTTP/1.

Имена полей заголовков нечувствительны к регистру и передаются по сети исключительно в виде строк, состоящих из строчных букв. API Node.js позволяет задавать имена заголовков строками с буквами разного регистра (например, Content-Type), но при передаче преобразует их в нижний регистр (например, content-type).

Имена полей заголовков должны содержать только один или несколько следующих символов ASCII: a-z, A-Z, 0-9, !, #, $, %, &, ', *, +, -, ., ^, _, ` (обратная кавычка), | и ~.

Использование недопустимых символов в имени поля HTTP-заголовка приведёт к закрытию потока и сообщению об ошибке протокола.

К значениям полей заголовков предъявляются менее строгие требования, однако они не должны содержать символы новой строки или возврата каретки и должны состоять только из символов US-ASCII согласно требованиям спецификации HTTP.

Потоки push на стороне клиента

Чтобы получать потоки push на стороне клиента, задайте прослушиватель события 'stream' для ClientHttp2Session:

import { connect } from 'node:http2';

const client = connect('http://localhost');

client.on('stream', (pushedStream, requestHeaders) => {
  pushedStream.on('push', (responseHeaders) => {
    // Process response headers
  });
  pushedStream.on('data', (chunk) => { /* handle pushed data */ });
});

const req = client.request({ ':path': '/' });

const http2 = require('node:http2');

const client = http2.connect('http://localhost');

client.on('stream', (pushedStream, requestHeaders) => {
  pushedStream.on('push', (responseHeaders) => {
    // Process response headers
  });
  pushedStream.on('data', (chunk) => { /* handle pushed data */ });
});

const req = client.request({ ':path': '/' });

Поддержка метода CONNECT

Метод CONNECT позволяет использовать сервер HTTP/2 в качестве прокси для TCP/IP-соединений.

Простой TCP-сервер:

import { createServer } from 'node:net';

const server = createServer((socket) => {
  let name = '';
  socket.setEncoding('utf8');
  socket.on('data', (chunk) => name += chunk);
  socket.on('end', () => socket.end(`hello ${name}`));
});

server.listen(8000);

const net = require('node:net');

const server = net.createServer((socket) => {
  let name = '';
  socket.setEncoding('utf8');
  socket.on('data', (chunk) => name += chunk);
  socket.on('end', () => socket.end(`hello ${name}`));
});

server.listen(8000);

Прокси-сервер HTTP/2 CONNECT:

import { createServer, constants } from 'node:http2';
const { NGHTTP2_REFUSED_STREAM, NGHTTP2_CONNECT_ERROR } = constants;
import { connect } from 'node:net';

const proxy = createServer();
proxy.on('stream', (stream, headers) => {
  if (headers[':method'] !== 'CONNECT') {
    // Only accept CONNECT requests
    stream.close(NGHTTP2_REFUSED_STREAM);
    return;
  }
  const auth = new URL(`tcp://${headers[':authority']}`);
  // It's a very good idea to verify that hostname and port are
  // things this proxy should be connecting to.
  const socket = connect(auth.port, auth.hostname, () => {
    stream.respond();
    socket.pipe(stream);
    stream.pipe(socket);
  });
  socket.on('error', (error) => {
    stream.close(NGHTTP2_CONNECT_ERROR);
  });
});

proxy.listen(8001);

const http2 = require('node:http2');
const { NGHTTP2_REFUSED_STREAM } = http2.constants;
const net = require('node:net');

const proxy = http2.createServer();
proxy.on('stream', (stream, headers) => {
  if (headers[':method'] !== 'CONNECT') {
    // Only accept CONNECT requests
    stream.close(NGHTTP2_REFUSED_STREAM);
    return;
  }
  const auth = new URL(`tcp://${headers[':authority']}`);
  // It's a very good idea to verify that hostname and port are
  // things this proxy should be connecting to.
  const socket = net.connect(auth.port, auth.hostname, () => {
    stream.respond();
    socket.pipe(stream);
    stream.pipe(socket);
  });
  socket.on('error', (error) => {
    stream.close(http2.constants.NGHTTP2_CONNECT_ERROR);
  });
});

proxy.listen(8001);

Клиент HTTP/2 CONNECT:

import { connect, constants } from 'node:http2';

const client = connect('http://localhost:8001');

// Must not specify the ':path' and ':scheme' headers
// for CONNECT requests or an error will be thrown.
const req = client.request({
  ':method': 'CONNECT',
  ':authority': 'localhost:8000',
});

req.on('response', (headers) => {
  console.log(headers[constants.HTTP2_HEADER_STATUS]);
});
let data = '';
req.setEncoding('utf8');
req.on('data', (chunk) => data += chunk);
req.on('end', () => {
  console.log(`The server says: ${data}`);
  client.close();
});
req.end('Jane');

const http2 = require('node:http2');

const client = http2.connect('http://localhost:8001');

// Must not specify the ':path' and ':scheme' headers
// for CONNECT requests or an error will be thrown.
const req = client.request({
  ':method': 'CONNECT',
  ':authority': 'localhost:8000',
});

req.on('response', (headers) => {
  console.log(headers[http2.constants.HTTP2_HEADER_STATUS]);
});
let data = '';
req.setEncoding('utf8');
req.on('data', (chunk) => data += chunk);
req.on('end', () => {
  console.log(`The server says: ${data}`);
  client.close();
});
req.end('Jane');

Расширенный протокол CONNECT

RFC 8441 определяет расширение HTTP/2 «расширенный протокол CONNECT», которое можно использовать для инициализации Http2Stream с помощью метода CONNECT, применяемого в качестве туннеля для других протоколов связи (например, WebSockets).

Серверы HTTP/2 включают поддержку расширенного протокола CONNECT с помощью настройки enableConnectProtocol:

import { createServer } from 'node:http2';
const settings = { enableConnectProtocol: true };
const server = createServer({ settings });

const http2 = require('node:http2');
const settings = { enableConnectProtocol: true };
const server = http2.createServer({ settings });

Получив от сервера кадр SETTINGS, указывающий, что можно использовать расширенный CONNECT, клиент может отправлять запросы CONNECT с псевдозаголовком HTTP/2 ':protocol':

import { connect } from 'node:http2';
const client = connect('http://localhost:8080');
client.on('remoteSettings', (settings) => {
  if (settings.enableConnectProtocol) {
    const req = client.request({ ':method': 'CONNECT', ':protocol': 'foo' });
    // ...
  }
});

const http2 = require('node:http2');
const client = http2.connect('http://localhost:8080');
client.on('remoteSettings', (settings) => {
  if (settings.enableConnectProtocol) {
    const req = client.request({ ':method': 'CONNECT', ':protocol': 'foo' });
    // ...
  }
});

API совместимости

API совместимости предназначен для предоставления аналогичного взаимодействия разработчика с HTTP/1 при использовании HTTP/2, что позволяет разрабатывать приложения, поддерживающие и HTTP/1, и HTTP/2. Этот API предназначен только для публичного API HTTP/1. Однако многие модули используют внутренние методы или состояние, и они не поддерживаются, поскольку это совершенно иная реализация.

В следующем примере с помощью API совместимости создается сервер HTTP/2:

import { createServer } from 'node:http2';
const server = createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('ok');
});

const http2 = require('node:http2');
const server = http2.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('ok');
});

Чтобы создать сервер, поддерживающий и HTTPS, и HTTP/2, см. раздел Согласование ALPN. Обновление серверов HTTP/1 без TLS не поддерживается.

API совместимости HTTP/2 состоит из Http2ServerRequest и Http2ServerResponse. Они обеспечивают совместимость API с HTTP/1, но не скрывают различия между протоколами. Например, текст сообщения для кодов состояния HTTP игнорируется.

Согласование ALPN

Согласование ALPN позволяет поддерживать и HTTPS, и HTTP/2 через один и тот же сокет. Объекты req и res могут быть как HTTP/1, так и HTTP/2, поэтому приложение должно ограничиваться публичным API HTTP/1 и определять, можно ли использовать более расширенные возможности HTTP/2.

В следующем примере создается сервер, поддерживающий оба протокола:

import { createSecureServer } from 'node:http2';
import { readFileSync } from 'node:fs';

const cert = readFileSync('./cert.pem');
const key = readFileSync('./key.pem');

const server = createSecureServer(
  { cert, key, allowHTTP1: true },
  onRequest,
).listen(8000);

function onRequest(req, res) {
  // Detects if it is a HTTPS request or HTTP/2
  const { socket: { alpnProtocol } } = req.httpVersion === '2.0' ?
    req.stream.session : req;
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(JSON.stringify({
    alpnProtocol,
    httpVersion: req.httpVersion,
  }));
}

const { createSecureServer } = require('node:http2');
const { readFileSync } = require('node:fs');

const cert = readFileSync('./cert.pem');
const key = readFileSync('./key.pem');

const server = createSecureServer(
  { cert, key, allowHTTP1: true },
  onRequest,
).listen(4443);

function onRequest(req, res) {
  // Detects if it is a HTTPS request or HTTP/2
  const { socket: { alpnProtocol } } = req.httpVersion === '2.0' ?
    req.stream.session : req;
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(JSON.stringify({
    alpnProtocol,
    httpVersion: req.httpVersion,
  }));
}

Событие 'request' работает одинаково и для HTTPS, и для HTTP/2.

Класс: http2.Http2ServerRequest

• Расширяет: <stream.Readable>

Объект Http2ServerRequest создается объектом http2.Server или http2.SecureServer и передается в качестве первого аргумента событию 'request'. Он может использоваться для доступа к состоянию запроса, заголовкам и данным.

Событие: 'aborted'

Событие 'aborted' возникает, если экземпляр Http2ServerRequest неожиданно прерывается во время обмена данными.

Событие 'aborted' возникает только в том случае, если запись в Http2ServerRequest еще не завершена.

Событие: 'close'

Указывает, что базовый Http2Stream был закрыт. Как и 'end', это событие возникает только один раз для каждого ответа.

request.aborted

• <boolean>

Свойство request.aborted имеет значение true, если запрос был прерван.

request.authority

• <string>

Псевдополе заголовка authority запроса. Поскольку HTTP/2 позволяет запросам задавать либо :authority, либо host, это значение определяется по req.headers[':authority'], если оно присутствует. В противном случае оно определяется по req.headers['host'].

request.complete

• <boolean>

Свойство request.complete имеет значение true, если запрос был завершен, прерван или уничтожен.

request.connection

• <net.Socket> | <tls.TLSSocket>

См. request.socket.

request.destroy([error])

• error <Error>

Вызывает destroy() для Http2Stream, получившего Http2ServerRequest. Если указан error, возникает событие 'error', а error передается в качестве аргумента всем обработчикам этого события.

Ничего не делает, если поток уже уничтожен.

request.headers

• <Object>

Объект заголовков запроса/ответа.

Пары «ключ-значение», содержащие имена и значения заголовков. Имена заголовков приводятся к нижнему регистру.

// Prints something like:
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers); copy

См. Объект заголовков HTTP/2.

В HTTP/2 путь запроса, имя хоста, протокол и метод представлены специальными заголовками, начинающимися с символа : (например, ':path'). Эти специальные заголовки включаются в объект request.headers. Не изменяйте их по ошибке, иначе могут возникнуть ошибки. Например, удаление всех заголовков из запроса приведет к ошибкам:

removeAllHeaders(request.headers);
assert(request.url);   // Fails because the :path header has been removed copy

request.httpVersion

• <string>

Для запроса сервера — версия HTTP, отправленная клиентом. Для ответа клиента — версия HTTP подключенного сервера. Возвращает '2.0'.

При этом message.httpVersionMajor — первое целое число, а message.httpVersionMinor — второе.

request.method

• <string>

Метод запроса в виде строки. Только для чтения. Примеры: 'GET', 'DELETE'.

request.rawHeaders

• <string[]>

Список исходных заголовков запроса/ответа в точности в том виде, в котором они были получены.

Ключи и значения находятся в одном списке. Это не список кортежей. Поэтому элементы с четными индексами содержат ключи, а элементы с нечетными индексами — соответствующие значения.

Имена заголовков не приводятся к нижнему регистру, а дубликаты не объединяются.

// Prints something like:
//
// [ 'user-agent',
//   'this is invalid because there can be only one',
//   'User-Agent',
//   'curl/7.22.0',
//   'Host',
//   '127.0.0.1:8000',
//   'ACCEPT',
//   '*/*' ]
console.log(request.rawHeaders); copy

request.rawTrailers

• <string[]>

Исходные ключи и значения завершающих заголовков запроса/ответа в точности в том виде, в котором они были получены. Заполняется только при событии 'end'.

request.scheme

• <string>

Псевдополе заголовка scheme запроса, указывающее часть целевого URL, относящуюся к схеме.

request.setTimeout(msecs, callback)

• msecs <number>
• callback <Function>
• Возвращает: <http2.Http2ServerRequest>

Задает для Http2Stream время ожидания msecs. Если передан callback, он добавляется в качестве обработчика события 'timeout' объекта ответа.

Если для запроса, ответа или сервера не добавлен обработчик события 'timeout', то Http2Stream уничтожаются по истечении времени ожидания. Если для событий 'timeout' запроса, ответа или сервера назначен обработчик, сокеты с истекшим временем ожидания необходимо обрабатывать явно.

request.socket

• <net.Socket> | <tls.TLSSocket>

Возвращает объект Proxy, который действует как net.Socket (или tls.TLSSocket), но применяет геттеры, сеттеры и методы на основе логики HTTP/2.

Свойства destroyed, readable и writable будут получаться из request.stream и устанавливаться в нем.

Методы destroy, emit, end, on и once будут вызываться для request.stream.

Метод setTimeout будет вызван для request.stream.session.

Вызов pause, read, resume и write приведет к ошибке с кодом ERR_HTTP2_NO_SOCKET_MANIPULATION. Дополнительные сведения см. в разделе Http2Session и сокеты.

Все остальные взаимодействия будут напрямую перенаправляться сокету. При использовании TLS применяйте request.socket.getPeerCertificate(), чтобы получить сведения об аутентификации клиента.

request.stream

• <Http2Stream>

Объект Http2Stream, лежащий в основе запроса.

request.trailers

• <Object>

Объект завершающих заголовков запроса/ответа. Заполняется только при событии 'end'.

request.url

• <string>

Строка URL запроса. Содержит только URL, указанный в фактическом HTTP-запросе. Если запрос имеет вид:

GET /status?name=ryan HTTP/1.1
Accept: text/plain copy

Тогда request.url будет иметь значение:

'/status?name=ryan' copy

Для разбора URL на составляющие можно использовать new URL():

$ node
> new URL('/status?name=ryan', 'http://example.com')
URL {
  href: 'http://example.com/status?name=ryan',
  origin: 'http://example.com',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'example.com',
  hostname: 'example.com',
  port: '',
  pathname: '/status',
  search: '?name=ryan',
  searchParams: URLSearchParams { 'name' => 'ryan' },
  hash: ''
} copy

Класс: http2.Http2ServerResponse

• Расширяет: <Stream>

Этот объект создается внутренними средствами HTTP-сервера, а не пользователем. Он передается в качестве второго параметра событию 'request'.

Событие: 'close'

Указывает, что базовый Http2Stream был завершен до вызова response.end() или до того, как он смог сбросить данные.

Событие: 'finish'

Возникает, когда ответ отправлен. Точнее, это событие возникает, когда последний фрагмент заголовков и тела ответа передан мультиплексору HTTP/2 для отправки по сети. Это не означает, что клиент уже что-либо получил.

После этого события объект ответа больше не генерирует событий.

response.addTrailers(headers)

• headers <Object>

Этот метод добавляет к ответу завершающие HTTP-заголовки (заголовки в конце сообщения).

Попытка задать имя или значение поля заголовка, содержащее недопустимые символы, приведет к выбрасыванию TypeError.

response.appendHeader(name, value)

• name <string>
• value <string> | <string[]>

Добавляет одно значение заголовка в объект заголовков.

Если значение является массивом, это равносильно многократному вызову данного метода.

Если предыдущих значений для этого заголовка не было, это равносильно вызову response.setHeader().

Попытка задать имя или значение поля заголовка, содержащее недопустимые символы, приведет к выбрасыванию TypeError.

// Returns headers including "set-cookie: a" and "set-cookie: b"
const server = http2.createServer((req, res) => {
  res.setHeader('set-cookie', 'a');
  res.appendHeader('set-cookie', 'b');
  res.writeHead(200);
  res.end('ok');
}); copy

response.connection

• <net.Socket> | <tls.TLSSocket>

См. response.socket.

response.createPushResponse(headers, callback)

• headers <HTTP/2 Headers Object> Объект, описывающий заголовки
• callback <Function> Вызывается после завершения http2stream.pushStream(), либо если попытка создать отправленный Http2Stream завершилась неудачей или была отклонена, либо если состояние Http2ServerRequest закрыто до вызова метода http2stream.pushStream()
  • err <Error>
  • res <http2.Http2ServerResponse> Вновь созданный объект Http2ServerResponse

Вызывает http2stream.pushStream() с указанными заголовками и при успехе оборачивает заданный Http2Stream в новый Http2ServerResponse, передавая его в качестве параметра callback. Если Http2ServerRequest закрыт, callback вызывается с ошибкой ERR_HTTP2_INVALID_STREAM.

response.end([data[, encoding]][, callback])

• data <string> | <Buffer> | <Uint8Array>
• encoding <string>
• callback <Function>
• Возвращает: <this>

Этот метод сообщает серверу, что все заголовки и тело ответа отправлены и сервер должен считать сообщение завершенным. Метод response.end() ДОЛЖЕН вызываться для каждого ответа.

Если задан data, это равносильно вызову response.write(data, encoding), за которым следует response.end(callback).

Если задан callback, он будет вызван после завершения потока ответа.

response.finished

• <boolean>

Логическое значение, указывающее, завершен ли ответ. Изначально равно false. После выполнения response.end() значение станет true.

response.getHeader(name)

• name <string>
• Возвращает: <string>

Считывает заголовок, который уже помещен в очередь, но еще не отправлен клиенту. Регистр символов в имени не учитывается.

const contentType = response.getHeader('content-type'); copy

response.getHeaderNames()

• Возвращает: <string[]>

Возвращает массив с уникальными именами текущих исходящих заголовков. Все имена заголовков записаны строчными буквами.

response.setHeader('Foo', 'bar');
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);

const headerNames = response.getHeaderNames();
// headerNames === ['foo', 'set-cookie'] copy

response.getHeaders()

• Возвращает: <Object>

Возвращает поверхностную копию текущих исходящих заголовков. Поскольку используется поверхностная копия, значения-массивы можно изменять без дополнительных вызовов различных методов модуля http, связанных с заголовками. Ключами возвращаемого объекта являются имена заголовков, а значениями — соответствующие значения заголовков. Все имена заголовков записаны строчными буквами.

Объект, возвращаемый методом response.getHeaders(), не наследуется по цепочке прототипов от объекта JavaScript Object. Это означает, что стандартные методы Object, такие как obj.toString(), obj.hasOwnProperty() и другие, не определены и не будут работать.

response.setHeader('Foo', 'bar');
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);

const headers = response.getHeaders();
// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] } copy

response.hasHeader(name)

• name <string>
• Возвращает: <boolean>

Возвращает true, если заголовок с именем name присутствует в исходящих заголовках. При сопоставлении имен заголовков регистр не учитывается.

const hasContentType = response.hasHeader('content-type'); copy

response.headersSent

• <boolean>

Имеет значение true, если заголовки отправлены, и false в противном случае (только для чтения).

response.removeHeader(name)

• name <string>

Удаляет заголовок, поставленный в очередь для неявной отправки.

response.removeHeader('Content-Encoding'); copy

response.req

• <http2.Http2ServerRequest>

Ссылка на исходный объект HTTP2 request.

response.sendDate

• <boolean>

Если значение равно true, заголовок Date будет автоматически сформирован и отправлен в ответе, если его еще нет в заголовках. По умолчанию — true.

Отключать эту настройку следует только при тестировании; согласно требованиям HTTP, ответы должны содержать заголовок Date.

response.setHeader(name, value)

• name <string>
• value <string> | <string[]>

Задает одно значение заголовка для неявных заголовков. Если такой заголовок уже есть среди заголовков, предназначенных для отправки, его значение будет заменено. Чтобы отправить несколько заголовков с одинаковым именем, используйте массив строк.

response.setHeader('Content-Type', 'text/html; charset=utf-8'); copy

или

response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript']); copy

Попытка задать имя или значение поля заголовка, содержащее недопустимые символы, приведет к выбрасыванию TypeError.

Заголовки, заданные с помощью response.setHeader(), объединяются с заголовками, переданными в response.writeHead(). При этом приоритет имеют заголовки, переданные в response.writeHead().

// Returns content-type = text/plain
const server = http2.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html; charset=utf-8');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('ok');
}); copy

response.setTimeout(msecs[, callback])

• msecs <number>
• callback <Function>
• Возвращает: <http2.Http2ServerResponse>

Задает для Http2Stream время ожидания msecs. Если передан callback, он добавляется в качестве обработчика события 'timeout' объекта ответа.

Если для запроса, ответа или сервера не добавлен обработчик события 'timeout', то Http2Stream уничтожаются по истечении времени ожидания. Если для событий 'timeout' запроса, ответа или сервера назначен обработчик, сокеты с истекшим временем ожидания необходимо обрабатывать явно.

response.socket

• <net.Socket> | <tls.TLSSocket>

Возвращает объект Proxy, который действует как net.Socket (или tls.TLSSocket), но применяет геттеры, сеттеры и методы на основе логики HTTP/2.

Свойства destroyed, readable и writable будут получаться из response.stream и устанавливаться в нем.

Методы destroy, emit, end, on и once будут вызываться для response.stream.

Метод setTimeout будет вызван для response.stream.session.

Вызов pause, read, resume и write приведет к ошибке с кодом ERR_HTTP2_NO_SOCKET_MANIPULATION. Дополнительные сведения см. в разделе Http2Session и сокеты.

Все остальные взаимодействия будут напрямую перенаправляться сокету.

import { createServer } from 'node:http2';
const server = createServer((req, res) => {
  const ip = req.socket.remoteAddress;
  const port = req.socket.remotePort;
  res.end(`Your IP address is ${ip} and your source port is ${port}.`);
}).listen(3000);

const http2 = require('node:http2');
const server = http2.createServer((req, res) => {
  const ip = req.socket.remoteAddress;
  const port = req.socket.remotePort;
  res.end(`Your IP address is ${ip} and your source port is ${port}.`);
}).listen(3000);

response.statusCode

• <number>

При использовании неявных заголовков (то есть без явного вызова response.writeHead()) это свойство задает код состояния, который будет отправлен клиенту при сбросе заголовков.

response.statusCode = 404; copy

После отправки заголовка ответа клиенту это свойство указывает отправленный код состояния.

response.statusMessage

• <string>

Текст сообщения о состоянии не поддерживается HTTP/2 (RFC 7540 8.1.2.4). Возвращается пустая строка.

response.stream

• <Http2Stream>

Объект Http2Stream, лежащий в основе ответа.

response.writableEnded

• <boolean>

Равно true после вызова response.end(). Это свойство не указывает, были ли данные сброшены; для этого используйте вместо него writable.writableFinished.

response.write(chunk[, encoding][, callback])

• chunk <string> | <Buffer> | <Uint8Array>
• encoding <string>
• callback <Function>
• Возвращает: <boolean>

Если вызвать этот метод, а response.writeHead() ещё не был вызван, произойдёт переключение в режим неявных заголовков и отправка неявных заголовков.

Этот метод отправляет фрагмент тела ответа. Его можно вызывать несколько раз, чтобы передать последовательные части тела.

В модуле node:http тело ответа опускается, если запрос является запросом HEAD. Аналогично, ответы 204 и 304 не должны содержать тело сообщения.

Значением chunk может быть строка или буфер. Если chunk — строка, второй параметр задаёт способ её кодирования в поток байтов. По умолчанию encoding имеет значение 'utf8'. callback будет вызван, когда этот фрагмент данных будет сброшен.

Это необработанное тело HTTP, не связанное с кодированием тела в формате multipart более высокого уровня, которое может использоваться.

При первом вызове response.write() буферизованные заголовки и первый фрагмент тела отправляются клиенту. При втором вызове response.write() Node.js предполагает, что данные будут передаваться потоком, и отправляет новые данные отдельно. Иными словами, ответ буферизуется до отправки первого фрагмента тела.

Возвращает true, если все данные успешно сброшены в буфер ядра. Возвращает false, если все данные или их часть были поставлены в очередь в пользовательской памяти. Событие 'drain' будет сгенерировано, когда буфер снова освободится.

response.writeContinue()

Отправляет клиенту статус 100 Continue, указывая, что следует отправить тело запроса. См. событие 'checkContinue' в Http2Server и Http2SecureServer.

response.writeEarlyHints(hints)

• hints <Object>

Отправляет клиенту статус 103 Early Hints с заголовком Link, указывая, что пользовательский агент может предварительно загрузить связанные ресурсы или установить с ними предварительное соединение. hints — это объект, содержащий значения заголовков, которые будут отправлены в сообщении с ранними подсказками.

Пример

const earlyHintsLink = '</styles.css>; rel=preload; as=style';
response.writeEarlyHints({
  'link': earlyHintsLink,
});

const earlyHintsLinks = [
  '</styles.css>; rel=preload; as=style',
  '</scripts.js>; rel=preload; as=script',
];
response.writeEarlyHints({
  'link': earlyHintsLinks,
}); copy

response.writeHead(statusCode[, statusMessage][, headers])

• statusCode <number>
• statusMessage <string>
• headers <Object> | <Array>
• Возвращает: <http2.Http2ServerResponse>

Отправляет заголовок ответа на запрос. Код состояния — это трёхзначный код состояния HTTP, например 404. Последний аргумент, headers, — это заголовки ответа.

Возвращает ссылку на Http2ServerResponse, позволяя объединять вызовы в цепочку.

Для совместимости с HTTP/1 в качестве второго аргумента можно передать человекочитаемое значение statusMessage. Однако, поскольку в HTTP/2 значение statusMessage не имеет смысла, этот аргумент не повлияет на результат, а процесс выдаст предупреждение.

const body = 'hello world';
response.writeHead(200, {
  'Content-Length': Buffer.byteLength(body),
  'Content-Type': 'text/plain; charset=utf-8',
}); copy

Значение Content-Length задаётся в байтах, а не в символах. Для определения количества байтов в заданной кодировке можно использовать API Buffer.byteLength(). Для исходящих сообщений Node.js не проверяет, совпадают ли Content-Length и длина передаваемого тела. Однако при получении сообщений Node.js автоматически отклоняет сообщения, если значение Content-Length не совпадает с фактическим размером полезной нагрузки.

Этот метод можно вызвать для сообщения не более одного раза до вызова response.end().

Если до этого вызвать response.write() или response.end(), неявные/изменяемые заголовки будут вычислены, а эта функция будет вызвана.

Заголовки, заданные с помощью response.setHeader(), будут объединены с заголовками, переданными в response.writeHead(). При этом приоритет имеют заголовки, переданные в response.writeHead().

// Returns content-type = text/plain
const server = http2.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html; charset=utf-8');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('ok');
}); copy

Попытка задать имя или значение поля заголовка, содержащие недопустимые символы, приведёт к возникновению TypeError.

Сбор показателей производительности HTTP/2

API Performance Observer можно использовать для сбора основных показателей производительности для каждого экземпляра Http2Session и Http2Stream.

import { PerformanceObserver } from 'node:perf_hooks';

const obs = new PerformanceObserver((items) => {
  const entry = items.getEntries()[0];
  console.log(entry.entryType);  // prints 'http2'
  if (entry.name === 'Http2Session') {
    // Entry contains statistics about the Http2Session
  } else if (entry.name === 'Http2Stream') {
    // Entry contains statistics about the Http2Stream
  }
});
obs.observe({ entryTypes: ['http2'] });

const { PerformanceObserver } = require('node:perf_hooks');

const obs = new PerformanceObserver((items) => {
  const entry = items.getEntries()[0];
  console.log(entry.entryType);  // prints 'http2'
  if (entry.name === 'Http2Session') {
    // Entry contains statistics about the Http2Session
  } else if (entry.name === 'Http2Stream') {
    // Entry contains statistics about the Http2Stream
  }
});
obs.observe({ entryTypes: ['http2'] });

Свойство entryType объекта PerformanceEntry будет равно 'http2'.

Свойство name объекта PerformanceEntry будет равно 'Http2Stream' или 'Http2Session'.

Если name равно Http2Stream, объект PerformanceEntry будет содержать следующие дополнительные свойства:

• bytesRead <number> Количество байтов кадров DATA, полученных для этого Http2Stream.
• bytesWritten <number> Количество байтов кадров DATA, отправленных для этого Http2Stream.
• id <number> Идентификатор связанного Http2Stream
• timeToFirstByte <number> Количество миллисекунд, прошедших между PerformanceEntry startTime и получением первого кадра DATA.
• timeToFirstByteSent <number> Количество миллисекунд, прошедших между PerformanceEntry startTime и отправкой первого кадра DATA.
• timeToFirstHeader <number> Количество миллисекунд, прошедших между PerformanceEntry startTime и получением первого заголовка.

Если name равно Http2Session, объект PerformanceEntry будет содержать следующие дополнительные свойства:

• bytesRead <number> Количество байтов, полученных для этого Http2Session.
• bytesWritten <number> Количество байтов, отправленных для этого Http2Session.
• framesReceived <number> Количество кадров HTTP/2, полученных Http2Session.
• framesSent <number> Количество кадров HTTP/2, отправленных Http2Session.
• maxConcurrentStreams <number> Максимальное количество одновременно открытых потоков за время существования Http2Session.
• pingRTT <number> Количество миллисекунд, прошедших между отправкой кадра PING и получением подтверждения на него. Присутствует только в том случае, если кадр PING был отправлен через Http2Session.
• streamAverageDuration <number> Средняя длительность (в миллисекундах) для всех экземпляров Http2Stream.
• streamCount <number> Количество экземпляров Http2Stream, обработанных Http2Session.
• type <string> Значение 'server' или 'client', указывающее тип Http2Session.

Примечание о :authority и host

Для запросов HTTP/2 требуется либо псевдозаголовок :authority, либо заголовок host. При непосредственном создании запроса HTTP/2 предпочтительно использовать :authority, а при преобразовании из HTTP/1 (например, в прокси) — host.

API совместимости использует host, если :authority отсутствует. Подробнее см. request.authority. Однако если вы не используете API совместимости (или используете непосредственно req.headers), вам нужно самостоятельно реализовать резервное поведение.