HTTP/2¶
Стабильность: 2 - стабильная
В http2
модуль обеспечивает реализацию HTTP / 2 протокол. Доступ к нему можно получить, используя:
const http2 = require('http2');
Core API¶
Core API предоставляет интерфейс низкого уровня, специально разработанный для поддержки функций протокола HTTP / 2. Это конкретно нет разработан для совместимости с существующими HTTP / 1 модуль API. Однако Совместимость API является.
В http2
Core API гораздо более симметричен между клиентом и сервером, чем http
API. Например, большинство мероприятий, таких как 'error'
, 'connect'
а также 'stream'
, может генерироваться либо кодом на стороне клиента, либо кодом на стороне сервера.
Пример на стороне сервера¶
Ниже показан простой сервер HTTP / 2, использующий Core API. Поскольку нет известных браузеров, поддерживающих незашифрованный HTTP / 2, использование http2.createSecureServer()
необходим при общении с клиентами браузера.
const http2 = require('http2');
const fs = require('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
Пример на стороне клиента¶
Ниже показан клиент HTTP / 2:
const http2 = require('http2');
const fs = require('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
class представляют активный сеанс связи между клиентом 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'
событие генерируется, когда возникает ошибка во время обработки Http2Session
.
Событие: 'frameError'
¶
type
{integer} Тип кадра.code
{integer} Код ошибки.id
{integer} Идентификатор потока (или0
если кадр не связан с потоком).
В 'frameError'
Событие генерируется, когда возникает ошибка при попытке отправить кадр в сеансе. Если кадр, который не удалось отправить, связан с определенным Http2Stream
, попытка испустить 'frameError'
событие на Http2Stream
сделан.
Если 'frameError'
событие связано с потоком, поток будет закрыт и уничтожен сразу после 'frameError'
событие. Если событие не связано с потоком, Http2Session
будет отключен сразу после 'frameError'
событие.
Событие: 'goaway'
¶
errorCode
{number} Код ошибки HTTP / 2, указанный вGOAWAY
Рамка.lastStreamID
{number} ID последнего потока, успешно обработанного удаленным узлом (или0
если не указан ID).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 */
});
Событие: 'ping'
¶
payload
{Buffer}PING
8-байтовая полезная нагрузка кадра
В 'ping'
событие генерируется всякий раз, когда PING
фрейм получен от подключенного однорангового узла.
Событие: 'remoteSettings'
¶
settings
{HTTP / 2 Settings Object} КопияSETTINGS
кадр получен.
В 'remoteSettings'
событие испускается, когда новый SETTINGS
фрейм получен от подключенного однорангового узла.
session.on('remoteSettings', (settings) => {
/* Use the new settings */
});
Событие: 'stream'
¶
stream
{Http2Stream} Ссылка на потокheaders
{HTTP / 2 Headers Object} Объект, описывающий заголовки.flags
{number} Связанные числовые флагиrawHeaders
{Array} Массив, содержащий необработанные имена заголовков, за которыми следуют их соответствующие значения.
В 'stream'
событие испускается, когда новый Http2Stream
создано.
const http2 = require('http2');
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');
});
На стороне сервера пользовательский код обычно не будет прослушивать это событие напрямую, а вместо этого будет регистрировать обработчик для 'stream'
событие, созданное net.Server
или tls.Server
экземпляры, возвращенные http2.createServer()
а также http2.createSecureServer()
соответственно, как в примере ниже:
const http2 = require('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(80);
Несмотря на то, что потоки HTTP / 2 и сетевые сокеты не находятся в соответствии 1: 1, сетевая ошибка уничтожит каждый отдельный поток и должна обрабатываться на уровне потока, как показано выше.
Событие: 'timeout'
¶
После http2session.setTimeout()
используется для установки периода тайм-аута для этого Http2Session
, то 'timeout'
событие генерируется, если на Http2Session
после настроенного количества миллисекунд. Его слушатель не ожидает никаких аргументов.
session.setTimeout(2000);
session.on('timeout', () => {
/* .. */
});
http2session.alpnProtocol
¶
- {строка | undefined}
Стоимость будет undefined
если Http2Session
еще не подключен к розетке, h2c
если Http2Session
не связан с TLSSocket
, или вернет значение подключенного TLSSocket
собственный alpnProtocol
имущество.
http2session.close([callback])
¶
callback
{Функция}
Изящно закрывает Http2Session
, позволяя существующим потокам завершаться самостоятельно и предотвращая появление новых Http2Stream
экземпляры из создаваемых. После закрытия http2session.destroy()
мог бы называться, если нет открытых Http2Stream
экземпляры.
Если указано, callback
функция зарегистрирована как обработчик для 'close'
событие.
http2session.closed
¶
- {логический}
Будет true
если это Http2Session
экземпляр был закрыт, иначе false
.
http2session.connecting
¶
- {логический}
Будет true
если это Http2Session
экземпляр все еще подключается, будет установлено значение false
перед испусканием connect
событие и / или вызов http2.connect
Перезвоните.
http2session.destroy([error][, code])
¶
error
{Ошибка}Error
возражать, еслиHttp2Session
уничтожается из-за ошибки.code
{number} Код ошибки HTTP / 2 для отправки в окончательномGOAWAY
Рамка. Если не указано, иerror
не является неопределенным, по умолчаниюINTERNAL_ERROR
, в противном случае по умолчаниюNO_ERROR
.
Немедленно прекращает Http2Session
и связанные net.Socket
или tls.TLSSocket
.
После уничтожения Http2Session
испустит 'close'
событие. Если error
не является неопределенным, 'error'
событие будет сгенерировано непосредственно перед 'close'
событие.
Если есть еще открытые Http2Streams
связанный с Http2Session
, они также будут уничтожены.
http2session.destroyed
¶
- {логический}
Будет true
если это Http2Session
экземпляр был уничтожен и больше не может использоваться, иначе false
.
http2session.encrypted
¶
- {логическое | неопределенное}
Ценность undefined
если Http2Session
сокет сеанса еще не подключен, true
если Http2Session
связан с TLSSocket
, а также false
если Http2Session
подключен к любому другому сокету или потоку.
http2session.goaway([code[, lastStreamID[, opaqueData]]])
¶
code
{number} Код ошибки HTTP / 2lastStreamID
{number} Числовой идентификатор последнего обработанногоHttp2Stream
opaqueData
{Buffer | TypedArray | DataView} ATypedArray
илиDataView
экземпляр, содержащий дополнительные данные, которые должны быть перенесены вGOAWAY
Рамка.
Передает GOAWAY
фрейм к подключенному узлу без закрытие Http2Session
.
http2session.localSettings
¶
- {Объект настроек HTTP / 2}
Объект без прототипа, описывающий текущие локальные настройки этого Http2Session
. Локальные настройки являются локальными для это Http2Session
пример.
http2session.originSet
¶
- {строка [] | undefined}
Если Http2Session
подключен к TLSSocket
, то originSet
собственность вернет Array
происхождения, для которых Http2Session
можно считать авторитетным.
В originSet
свойство доступно только при использовании безопасного TLS-соединения.
http2session.pendingSettingsAck
¶
- {логический}
Указывает, есть ли Http2Session
в настоящее время ожидает подтверждения отправки SETTINGS
Рамка. Будет true
после вызова http2session.settings()
метод. Будет false
однажды все отправлено SETTINGS
кадры были подтверждены.
http2session.ping([payload, ]callback)
¶
payload
{Buffer | TypedArray | DataView} Необязательные полезные данные проверки связи.callback
{Функция}- Возвращает: {логическое}
Отправляет PING
фрейм к подключенному узлу HTTP / 2. А callback
функция должна быть предоставлена. Метод вернет true
если PING
было послано, false
иначе.
Максимальное количество незавершенных (неподтвержденных) эхо-запросов определяется maxOutstandingPings
вариант конфигурации. Максимальное значение по умолчанию - 10.
Если предусмотрено, payload
должен быть Buffer
, TypedArray
, или DataView
содержащий 8 байтов данных, которые будут переданы с PING
и вернулся с подтверждением ping.
Обратный вызов будет вызван с тремя аргументами: аргумент ошибки, который будет null
если PING
был успешно признан, duration
аргумент, который сообщает количество миллисекунд, прошедших с момента отправки эхо-запроса и получения подтверждения, и 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()}'`);
}
}
);
Если payload
аргумент не указан, полезной нагрузкой по умолчанию будет 64-битная временная метка (с прямым порядком байтов), обозначающая начало PING
продолжительность.
http2session.ref()
¶
Звонки ref()
на этом Http2Session
базовый экземпляр net.Socket
.
http2session.remoteSettings
¶
- {Объект настроек HTTP / 2}
Объект без прототипа, описывающий текущие удаленные настройки этого Http2Session
. Удаленные настройки устанавливаются связаны HTTP / 2 одноранговый узел.
http2session.setLocalWindowSize(windowSize)
¶
windowSize
{количество}
Устанавливает размер окна локальной конечной точки. В windowSize
- это общий размер окна, который нужно установить, а не дельта.
const http2 = require('http2');
const server = http2.createServer();
const expectedWindowSize = 2 ** 20;
server.on('connect', (session) => {
// Set local window size to be 2 ** 20
session.setLocalWindowSize(expectedWindowSize);
});
http2session.setTimeout(msecs, callback)
¶
msecs
{количество}callback
{Функция}
Используется для установки функции обратного вызова, которая вызывается при отсутствии активности на 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
и розетки для дополнительной информации.
setTimeout
метод будет вызываться на этом Http2Session
.
Все остальные взаимодействия будут направляться непосредственно в сокет.
http2session.state
¶
Предоставляет различную информацию о текущем состоянии Http2Session
.
- {Объект}
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}callback
{Функция} Обратный вызов, который вызывается после подключения сеанса или сразу же, если сеанс уже подключен.err
{Ошибка | ноль}settings
{Объект настроек HTTP / 2} Обновленныйsettings
объект.duration
{целое число}
Обновляет текущие локальные настройки для этого Http2Session
и отправляет новый SETTINGS
фрейм к подключенному узлу HTTP / 2.
После вызова http2session.pendingSettingsAck
собственность будет true
пока сеанс ожидает, пока удаленный узел подтвердит новые настройки.
Новые настройки не вступят в силу до тех пор, пока SETTINGS
подтверждение получено, и 'localSettings'
событие испускается. Можно отправить несколько SETTINGS
кадры, пока подтверждение еще не получено.
http2session.type
¶
- {количество}
В http2session.type
будет равно http2.constants.NGHTTP2_SESSION_SERVER
если это Http2Session
instance - это сервер, а http2.constants.NGHTTP2_SESSION_CLIENT
если экземпляр является клиентом.
http2session.unref()
¶
Звонки unref()
на этом Http2Session
базовый экземпляр net.Socket
.
Класс: ServerHttp2Session
¶
- Расширяется: {Http2Session}
serverhttp2session.altsvc(alt, originOrStream)
¶
alt
{строка} Описание альтернативной конфигурации службы, как определено RFC 7838.originOrStream
{number | string | URL | Object} Либо строка URL, указывающая источник (илиObject
сorigin
свойство) или числовой идентификатор активногоHttp2Stream
как даноhttp2stream.id
имущество.
Представляет ALTSVC
кадр (как определено RFC 7838) подключенному клиенту.
const http2 = require('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-адрес, и источник будет получен. Например, происхождение URL-адреса HTTP 'https://example.org/foo/bar'
это строка ASCII 'https://example.org'
. Будет выдана ошибка, если либо данная строка не может быть проанализирована как URL-адрес, либо если действительное происхождение не может быть получено.
А URL
объект или любой объект с origin
свойство, может быть передано как originOrStream
, в этом случае значение origin
собственность будет использоваться. Ценность origin
имущество должен быть правильно сериализованным источником ASCII.
Указание альтернативных услуг¶
Формат alt
параметр строго определяется RFC 7838 в виде строки ASCII, содержащей разделенный запятыми список «альтернативных» протоколов, связанных с конкретным хостом и портом.
Например, значение 'h2="example.org:81"'
указывает, что протокол HTTP / 2 доступен на хосте 'example.org'
на порт TCP / IP 81. Хост и порт должен содержаться в цитате ("
) символы.
Могут быть указаны несколько альтернатив, например: 'h2="example.org:81", h2=":82"'
.
Идентификатор протокола ('h2'
в примерах) может быть любым допустимым Идентификатор протокола ALPN.
Синтаксис этих значений не проверяется реализацией Node.js и передается, как указано пользователем или получено от однорангового узла.
serverhttp2session.origin(...origins)
¶
origins
{строка | URL | Object} Одна или несколько строк URL, переданных как отдельные аргументы.
Представляет ORIGIN
кадр (как определено RFC 8336) подключенному клиенту, чтобы объявить набор источников, для которых сервер может предоставлять достоверные ответы.
const http2 = require('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-адрес, и источник будет получен. Например, происхождение URL-адреса HTTP 'https://example.org/foo/bar'
это строка ASCII 'https://example.org'
. Будет выдана ошибка, если либо данная строка не может быть проанализирована как URL-адрес, либо если действительное происхождение не может быть получено.
А URL
объект или любой объект с origin
собственность, может быть передана как origin
, в этом случае значение origin
собственность будет использоваться. Ценность origin
имущество должен быть правильно сериализованным источником ASCII.
В качестве альтернативы origins
параметр может использоваться при создании нового сервера HTTP / 2 с помощью http2.createSecureServer()
метод:
const http2 = require('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
{нить}origin
{нить}streamId
{количество}
В 'altsvc'
событие генерируется всякий раз, когда ALTSVC
кадр получен клиентом. Событие испускается с ALTSVC
значение, источник и идентификатор потока. Если нет origin
предоставляется в ALTSVC
Рамка, origin
будет пустой строкой.
const http2 = require('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
{нить[]}
В 'origin'
событие генерируется всякий раз, когда ORIGIN
кадр получен клиентом. Событие испускается с массивом origin
струны. В http2session.originSet
будет обновлено, чтобы включить полученные исходные данные.
const http2 = require('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} -
options
{Объект} -
endStream
{логический}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 на подключенный сервер.
Этот метод доступен, только если http2session.type
равно http2.constants.NGHTTP2_SESSION_CLIENT
.
const http2 = require('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
class представляет двунаправленный поток связи HTTP / 2 по Http2Session
пример. Любой сингл Http2Session
может быть до 231 год-1 Http2Stream
экземпляров за время его существования.
Пользовательский код не будет построен Http2Stream
экземпляры напрямую. Скорее, они создаются, управляются и предоставляются пользовательскому коду через Http2Session
пример. На сервере Http2Stream
экземпляры создаются либо в ответ на входящий HTTP-запрос (и передаются пользовательскому коду через 'stream'
событие), или в ответ на вызов http2stream.pushStream()
метод. На клиенте Http2Stream
экземпляры создаются и возвращаются, когда либо http2session.request()
вызывается метод, или в ответ на входящий 'push'
событие.
В Http2Stream
класс является базой для ServerHttp2Stream
а также ClientHttp2Stream
классы, каждый из которых используется отдельно на стороне сервера или клиента соответственно.
Все Http2Stream
экземпляры Duplex
потоки. В Writable
сторона Duplex
используется для отправки данных подключенному узлу, в то время как Readable
Сторона используется для приема данных, отправленных подключенным одноранговым узлом.
Кодировка текстовых символов по умолчанию для всех Http2Stream
s - это UTF-8. Рекомендуется, чтобы при использовании Http2Stream
чтобы отправить текст, 'content-type'
заголовок должен быть установлен и должен идентифицировать используемую кодировку символов.
stream.respond({
'content-type': 'text/html; charset=utf-8',
':status': 200,
});
Http2Stream
Жизненный цикл¶
Творчество¶
На стороне сервера экземпляры ServerHttp2Stream
создаются либо когда:
- Новый HTTP / 2
HEADERS
получен кадр с ранее неиспользованным идентификатором потока; - В
http2stream.pushStream()
вызывается метод.
На стороне клиента экземпляры ClientHttp2Stream
создаются, когда http2session.request()
вызывается метод.
На клиенте Http2Stream
экземпляр, возвращенный http2session.request()
может быть не сразу готов к использованию, если родительский Http2Session
еще полностью не установлено. В таких случаях операции вызывались Http2Stream
будут буферизированы до тех пор, пока 'ready'
событие испускается. Код пользователя должен редко, если вообще когда-либо, обрабатывать 'ready'
событие напрямую. Готовый статус Http2Stream
можно определить, проверив значение http2stream.id
. Если значение равно undefined
, поток еще не готов к использованию.
Разрушение¶
Все Http2Stream
экземпляры уничтожаются либо когда:
- An
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'
событие генерируется, когда возникает ошибка во время обработки 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);
});
Событие: 'wantTrailers'
¶
В 'wantTrailers'
событие генерируется, когда Http2Stream
стоит в очереди на финал DATA
кадр для отправки на кадре и Http2Stream
готов к отправке конечных заголовков. При инициировании запроса или ответа waitForTrailers
параметр должен быть установлен, чтобы это событие было испущено.
http2stream.aborted
¶
- {логический}
Установлен в true
если Http2Stream
Экземпляр был аварийно прерван. Когда установлено, 'aborted'
событие будет отправлено.
http2stream.bufferSize
¶
- {количество}
Это свойство показывает количество символов, которые в настоящее время буферизированы для записи. Видеть 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
¶
- {логический}
Установлен в true
если Http2Stream
экземпляр был закрыт.
http2stream.destroyed
¶
- {логический}
Установлен в true
если Http2Stream
Экземпляр был уничтожен и больше не может использоваться.
http2stream.endAfterHeaders
¶
- {логический}
Установить true
если END_STREAM
в полученном кадре HEADERS запроса или ответа был установлен флаг, указывающий на то, что дополнительные данные не должны приниматься и читаемая сторона Http2Stream
будет закрыто.
http2stream.id
¶
- {number | undefined}
Числовой идентификатор потока этого Http2Stream
пример. Установлен в undefined
если идентификатор потока еще не назначен.
http2stream.pending
¶
- {логический}
Установлен в true
если Http2Stream
экземпляру еще не присвоен числовой идентификатор потока.
http2stream.priority(options)
¶
options
{Объект}exclusive
{boolean} Когдаtrue
а такжеparent
идентифицирует родительский поток, этот поток становится единственной прямой зависимостью от родительского потока, а все другие существующие зависимые объекты становятся зависимыми от этого потока. Дефолт:false
.parent
{number} Задает числовой идентификатор потока, от которого зависит этот поток.weight
{number} Определяет относительную зависимость потока по отношению к другим потокам с таким жеparent
. Значение - это число между1
а также256
(включительно).silent
{boolean} Когдаtrue
, меняет приоритет локально, не отправляяPRIORITY
фрейм к подключенному узлу.
Обновляет приоритет для этого Http2Stream
пример.
http2stream.rstCode
¶
- {количество}
Установите на RST_STREAM
код ошибки сообщил, когда Http2Stream
уничтожается после получения RST_STREAM
кадр от подключенного однорангового узла, вызывающий http2stream.close()
, или http2stream.destroy()
. Будет undefined
если Http2Stream
не был закрыт.
http2stream.sentHeaders
¶
- {Объект заголовков HTTP / 2}
Объект, содержащий исходящие заголовки, отправленные для этого Http2Stream
.
http2stream.sentInfoHeaders
¶
- {Объект заголовков HTTP / 2 []}
Массив объектов, содержащих исходящие информационные (дополнительные) заголовки, отправленные для этого Http2Stream
.
http2stream.sentTrailers
¶
- {Объект заголовков HTTP / 2}
Объект, содержащий отправленные для этого исходящие трейлеры. HttpStream
.
http2stream.session
¶
- {Http2Session}
Ссылка на Http2Session
экземпляр, которому принадлежит это Http2Stream
. Стоимость будет undefined
после Http2Stream
экземпляр уничтожен.
http2stream.setTimeout(msecs, callback)
¶
msecs
{количество}callback
{Функция}
const http2 = require('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
.
- {Объект}
localWindowSize
{number} Количество байтов, которое подключенный одноранговый узел может отправить для этогоHttp2Stream
не получивWINDOW_UPDATE
.state
{number} Флаг, указывающий на низкоуровневое текущее состояниеHttp2Stream
как определеноnghttp2
.localClose
{количество}1
если этоHttp2Stream
был закрыт на месте.remoteClose
{количество}1
если этоHttp2Stream
был закрыт удаленно.sumDependencyWeight
{number} Суммарный вес всехHttp2Stream
экземпляры, которые зависят от этогоHttp2Stream
как указано с использованиемPRIORITY
кадры.weight
{number} Приоритетный вес этогоHttp2Stream
.
Текущее состояние этого Http2Stream
.
http2stream.sendTrailers(headers)
¶
headers
{Объект заголовков HTTP / 2}
Отправляет завершающий HEADERS
фрейм к подключенному узлу HTTP / 2. Этот метод вызовет Http2Stream
должны быть немедленно закрыты и должны вызываться только после 'wantTrailers'
событие было отправлено. При отправке запроса или ответа options.waitForTrailers
параметр должен быть установлен, чтобы сохранить Http2Stream
откроется после финала DATA
рама, чтобы можно было отправлять прицепы.
const http2 = require('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'
событие генерируется, когда для потока получен дополнительный блок заголовков, например, когда блок 1xx
получены информационные заголовки. Обратный вызов слушателя передается Объект заголовков HTTP / 2 и флаги, связанные с заголовками.
stream.on('headers', (headers, flags) => {
console.log(headers);
});
Событие: 'push'
¶
В 'push'
Событие генерируется при получении заголовков ответа для потока Server Push. Обратный вызов слушателя передается Объект заголовков HTTP / 2 и флаги, связанные с заголовками.
stream.on('push', (headers, flags) => {
console.log(headers);
});
Событие: 'response'
¶
В 'response'
событие генерируется, когда ответ HEADERS
был получен кадр для этого потока от подключенного сервера HTTP / 2. Слушатель вызывается с двумя аргументами: Object
содержащий полученные Объект заголовков HTTP / 2, и флаги, связанные с заголовками.
const http2 = require('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
фрейм к подключенному узлу HTTP / 2.
http2stream.headersSent
¶
- {логический}
Истина, если заголовки были отправлены, в противном случае - ложь (только для чтения).
http2stream.pushAllowed
¶
- {логический}
Свойство только для чтения, сопоставленное с SETTINGS_ENABLE_PUSH
флаг самого последнего удаленного клиента SETTINGS
Рамка. Будет true
если удаленный узел принимает push-потоки, false
иначе. Настройки одинаковы для всех Http2Stream
В то же самое Http2Session
.
http2stream.pushStream(headers[, options], callback)
¶
headers
{Объект заголовков HTTP / 2}options
{Объект}exclusive
{boolean} Когдаtrue
а такжеparent
идентифицирует родительский поток, созданный поток становится единственной прямой зависимостью от родительского потока, а все другие существующие зависимые объекты становятся зависимыми от вновь созданного потока. Дефолт:false
.parent
{number} Задает числовой идентификатор потока, от которого зависит вновь созданный поток.callback
{Функция} Обратный вызов, который вызывается после инициирования потока push.err
{Ошибка}pushStream
{ServerHttp2Stream} ВозвращенныйpushStream
объект.headers
{HTTP / 2 Headers Object} Заголовки - объектpushStream
был инициирован с.
Инициирует push-поток. Обратный вызов вызывается с новым Http2Stream
экземпляр, созданный для потока push, переданного в качестве второго аргумента, или Error
передается как первый аргумент.
const http2 = require('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()
изнутри проталкиваемого потока не разрешено и вызовет ошибку.
http2stream.respond([headers[, options]])
¶
headers
{Объект заголовков HTTP / 2}options
{Объект}endStream
{boolean} Установить наtrue
чтобы указать, что ответ не будет включать данные полезной нагрузки.waitForTrailers
{boolean} Когдаtrue
, тоHttp2Stream
испустит'wantTrailers'
событие после финалаDATA
кадр был отправлен.
const http2 = require('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
.
const http2 = require('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}options
{Объект}statCheck
{Функция}waitForTrailers
{boolean} Когдаtrue
, тоHttp2Stream
испустит'wantTrailers'
событие после финалаDATA
кадр был отправлен.offset
{number} Позиция смещения, с которой следует начать чтение.length
{number} Объем данных из файлового дескриптора для отправки.
Инициирует ответ, данные которого считываются из указанного файлового дескриптора. Для данного файлового дескриптора проверка не выполняется. Если при попытке чтения данных с помощью дескриптора файла возникает ошибка, Http2Stream
будет закрыто с использованием RST_STREAM
рама с использованием стандарта INTERNAL_ERROR
код.
При использовании Http2Stream
объекты Duplex
интерфейс будет закрыт автоматически.
const http2 = require('http2');
const fs = require('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
детали данного фд. Если statCheck
функция предусмотрена, http2stream.respondWithFD()
метод выполнит fs.fstat()
вызов для сбора сведений о предоставленном дескрипторе файла.
В offset
а также length
параметры могут использоваться, чтобы ограничить ответ конкретным подмножеством диапазона. Это можно использовать, например, для поддержки запросов диапазона HTTP.
Дескриптор файла или FileHandle
не закрывается, когда поток закрыт, поэтому его нужно будет закрыть вручную, если он больше не нужен. Одновременное использование одного и того же файлового дескриптора для нескольких потоков не поддерживается и может привести к потере данных. Поддерживается повторное использование дескриптора файла после завершения потока.
Когда options.waitForTrailers
опция установлена, 'wantTrailers'
Событие будет сгенерировано сразу после постановки в очередь последнего блока данных полезной нагрузки для отправки. В http2stream.sendTrailers()
затем можно использовать для отправки конечных полей заголовка партнеру.
Когда options.waitForTrailers
установлен, Http2Stream
не закроется автоматически, когда последний DATA
кадр передается. Код пользователя должен позвони либо http2stream.sendTrailers()
или http2stream.close()
закрыть Http2Stream
.
const http2 = require('http2');
const fs = require('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
{строка | Буфер | URL}headers
{Объект заголовков HTTP / 2}options
{Объект}statCheck
{Функция}onError
{Функция} Функция обратного вызова, вызываемая в случае ошибки перед отправкой.waitForTrailers
{boolean} Когдаtrue
, тоHttp2Stream
испустит'wantTrailers'
событие после финалаDATA
кадр был отправлен.offset
{number} Позиция смещения, с которой следует начать чтение.length
{number} Объем данных из файлового дескриптора для отправки.
В качестве ответа отправляет обычный файл. В path
необходимо указать обычный файл или 'error'
событие будет выпущено на Http2Stream
объект.
При использовании Http2Stream
объекты Duplex
интерфейс будет закрыт автоматически.
Необязательный options.statCheck
функция может быть указана, чтобы дать пользовательскому коду возможность устанавливать дополнительные заголовки контента на основе fs.Stat
детали данного файла:
Если при попытке чтения данных файла возникает ошибка, Http2Stream
будет закрыто с использованием RST_STREAM
рама с использованием стандарта INTERNAL_ERROR
код. Если onError
callback определен, затем он будет вызван. В противном случае поток будет уничтожен.
Пример использования пути к файлу:
const http2 = require('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.log(err);
}
stream.end();
}
stream.respondWithFile(
'/some/file',
{ 'content-type': 'text/plain; charset=utf-8' },
{ statCheck, onError }
);
});
В options.statCheck
функция также может использоваться для отмены операции отправки путем возврата false
. Например, условный запрос может проверять результаты статистики, чтобы определить, был ли файл изменен, чтобы вернуть соответствующий 304
отклик:
const http2 = require('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.
В options.onError
Функция также может использоваться для обработки всех ошибок, которые могли произойти до начала доставки файла. По умолчанию поток уничтожается.
Когда options.waitForTrailers
опция установлена, 'wantTrailers'
Событие будет сгенерировано сразу после постановки в очередь последнего блока данных полезной нагрузки для отправки. В http2stream.sendTrailers()
затем можно использовать для отправки конечных полей заголовка партнеру.
Когда options.waitForTrailers
установлен, Http2Stream
не закроется автоматически, когда последний DATA
кадр передается. Код пользователя должен вызывать либо http2stream.sendTrailers()
или http2stream.close()
закрыть Http2Stream
.
const http2 = require('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
класс не экспортируется напрямую 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'
событие испускается, когда новый Http2Session
создается Http2Server
.
Событие: 'sessionError'
¶
В 'sessionError'
событие генерируется, когда 'error'
событие испускается Http2Session
объект, связанный с Http2Server
.
Событие: 'stream'
¶
stream
{Http2Stream} Ссылка на потокheaders
{HTTP / 2 Headers Object} Объект, описывающий заголовки.flags
{number} Связанные числовые флагиrawHeaders
{Array} Массив, содержащий необработанные имена заголовков, за которыми следуют их соответствующие значения.
В 'stream'
событие генерируется, когда 'stream'
событие было отправлено Http2Session
связанный с сервером.
Смотрите также Http2Session
с 'stream'
событие.
const http2 = require('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
{Функция}
Запрещает серверу устанавливать новые сеансы. Это не препятствует созданию новых потоков запросов из-за постоянного характера сеансов HTTP / 2. Чтобы корректно выключить сервер, позвоните http2session.close()
на всех активных сессиях.
Если callback
предоставляется, он не вызывается до тех пор, пока все активные сеансы не будут закрыты, хотя сервер уже прекратил разрешать новые сеансы. Видеть net.Server.close()
Больше подробностей.
server.setTimeout([msecs][, callback])
¶
msecs
{количество} Дефолт: 0 (без тайм-аута)callback
{Функция}- Возвращает: {Http2Server}
Используется для установки значения тайм-аута для запросов сервера http2 и устанавливает функцию обратного вызова, которая вызывается, когда на сервере нет активности. Http2Server
после msecs
миллисекунды.
Данный обратный вызов зарегистрирован как слушатель на 'timeout'
событие.
В случае если callback
это не функция, а новый ERR_INVALID_CALLBACK
будет выброшена ошибка.
server.timeout
¶
- {number} Тайм-аут в миллисекундах. Дефолт: 0 (без тайм-аута)
Количество миллисекунд бездействия до истечения тайм-аута сокета.
Ценность 0
отключит поведение тайм-аута для входящих подключений.
Логика тайм-аута сокета настраивается при подключении, поэтому изменение этого значения влияет только на новые подключения к серверу, но не на существующие подключения.
server.updateSettings([settings])
¶
settings
{Объект настроек HTTP / 2}
Используется для обновления сервера с предоставленными настройками.
Броски ERR_HTTP2_INVALID_SETTING_VALUE
для недействительных settings
ценности.
Броски ERR_INVALID_ARG_TYPE
для недействительных settings
аргумент.
Класс: Http2SecureServer
¶
- Расширяется: {tls.Server}
Экземпляры Http2SecureServer
создаются с использованием http2.createSecureServer()
функция. В Http2SecureServer
класс не экспортируется напрямую 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'
событие испускается, когда новый Http2Session
создается Http2SecureServer
.
Событие: 'sessionError'
¶
В 'sessionError'
событие генерируется, когда 'error'
событие испускается Http2Session
объект, связанный с Http2SecureServer
.
Событие: 'stream'
¶
stream
{Http2Stream} Ссылка на потокheaders
{HTTP / 2 Headers Object} Объект, описывающий заголовки.flags
{number} Связанные числовые флагиrawHeaders
{Array} Массив, содержащий необработанные имена заголовков, за которыми следуют их соответствующие значения.
В 'stream'
событие генерируется, когда 'stream'
событие было отправлено Http2Session
связанный с сервером.
Смотрите также Http2Session
с 'stream'
событие.
const http2 = require('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'
¶
В 'unknownProtocol'
Событие генерируется, когда подключающийся клиент не может согласовать разрешенный протокол (например, HTTP / 2 или HTTP / 1.1). Обработчик событий получает сокет для обработки. Если для этого события не зарегистрирован прослушиватель, соединение разрывается. Тайм-аут можно указать с помощью 'unknownProtocolTimeout'
опция передана http2.createSecureServer()
. Увидеть Совместимость API.
server.close([callback])
¶
callback
{Функция}
Запрещает серверу устанавливать новые сеансы. Это не препятствует созданию новых потоков запросов из-за постоянного характера сеансов HTTP / 2. Чтобы корректно выключить сервер, позвоните http2session.close()
на всех активных сессиях.
Если callback
предоставляется, он не вызывается до тех пор, пока все активные сеансы не будут закрыты, хотя сервер уже прекратил разрешать новые сеансы. Видеть tls.Server.close()
Больше подробностей.
server.setTimeout([msecs][, callback])
¶
msecs
{количество} Дефолт:120000
(2 минуты)callback
{Функция}- Возвращает: {Http2SecureServer}
Используется для установки значения тайм-аута для запросов к защищенному серверу http2 и устанавливает функцию обратного вызова, которая вызывается, когда на сервере нет активности. Http2SecureServer
после msecs
миллисекунды.
Данный обратный вызов зарегистрирован как слушатель на 'timeout'
событие.
В случае если callback
это не функция, а новый ERR_INVALID_CALLBACK
будет выброшена ошибка.
server.timeout
¶
- {number} Тайм-аут в миллисекундах. Дефолт: 0 (без тайм-аута)
Количество миллисекунд бездействия до истечения тайм-аута сокета.
Ценность 0
отключит поведение тайм-аута для входящих подключений.
Логика тайм-аута сокета настраивается при подключении, поэтому изменение этого значения влияет только на новые подключения к серверу, но не на существующие подключения.
server.updateSettings([settings])
¶
settings
{Объект настроек HTTP / 2}
Используется для обновления сервера с предоставленными настройками.
Броски ERR_HTTP2_INVALID_SETTING_VALUE
для недействительных settings
ценности.
Броски ERR_INVALID_ARG_TYPE
для недействительных settings
аргумент.
http2.createServer(options[, onRequestHandler])
¶
options
{Объект}maxDeflateDynamicTableSize
{number} Устанавливает максимальный размер динамической таблицы для дефлятирования полей заголовка. Дефолт:4Kib
.maxSettings
{number} Задает максимальное количество записей настроек наSETTINGS
Рамка. Минимальное допустимое значение:1
. Дефолт:32
.maxSessionMemory
Устанавливает максимальный объем памяти, которыйHttp2Session
разрешено использовать. Значение выражается в количестве мегабайт, например1
равняется 1 мегабайту. Минимальное допустимое значение:1
. Это кредитный лимит, существующийHttp2Stream
s может привести к превышению этого лимита, но новыеHttp2Stream
экземпляры будут отклонены, пока этот лимит превышен. Текущее количествоHttp2Stream
сеансы, текущее использование памяти таблицами сжатия заголовков, текущие данные в очереди на отправку и неподтвержденныеPING
а такжеSETTINGS
все кадры учитываются по текущему пределу. Дефолт:10
.maxHeaderListPairs
{число} Устанавливает максимальное количество записей заголовка. Это похоже наhttp.Server#maxHeadersCount
илиhttp.ClientRequest#maxHeadersCount
. Минимальное значение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} Начальные настройки для отправки удаленному узлу при подключении.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()
необходим при общении с клиентами браузера.
const http2 = require('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(80);
http2.createSecureServer(options[, onRequestHandler])
¶
options
{Объект}allowHTTP1
{boolean} Входящие клиентские подключения, не поддерживающие HTTP / 2, будут переведены на HTTP / 1.x, если для него установлено значениеtrue
. Увидеть'unknownProtocol'
событие. Видеть Согласование ALPN. Дефолт:false
.maxDeflateDynamicTableSize
{number} Устанавливает максимальный размер динамической таблицы для дефлятирования полей заголовка. Дефолт:4Kib
.maxSettings
{number} Задает максимальное количество записей настроек наSETTINGS
Рамка. Минимальное допустимое значение:1
. Дефолт:32
.maxSessionMemory
Устанавливает максимальный объем памяти, которыйHttp2Session
разрешено использовать. Значение выражается в количестве мегабайт, например1
равняется 1 мегабайту. Минимальное допустимое значение:1
. Это кредитный лимит, существующийHttp2Stream
s может привести к превышению этого лимита, но новыеHttp2Stream
экземпляры будут отклонены, пока этот лимит превышен. Текущее количествоHttp2Stream
сеансы, текущее использование памяти таблицами сжатия заголовков, текущие данные в очереди на отправку и неподтвержденныеPING
а такжеSETTINGS
все кадры учитываются по текущему пределу. Дефолт:10
.maxHeaderListPairs
{число} Устанавливает максимальное количество записей заголовка. Это похоже наhttp.Server#maxHeadersCount
илиhttp.ClientRequest#maxHeadersCount
. Минимальное значение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} Начальные настройки для отправки удаленному узлу при подключении.- ...: Любой
tls.createServer()
варианты могут быть предоставлены. Для серверов параметры идентификации (pfx
илиkey
/cert
) обычно требуются. origins
{string []} Массив исходных строк для отправки вORIGIN
кадр сразу после создания нового сервераHttp2Session
.unknownProtocolTimeout
{number} Определяет тайм-аут в миллисекундах, в течение которого сервер должен ждать, когда'unknownProtocol'
событие испускается. Если к этому времени сокет не был уничтожен, сервер уничтожит его. Дефолт:10000
.onRequestHandler
{Function} См. Совместимость API- Возвращает: {Http2SecureServer}
Возвращает tls.Server
экземпляр, который создает и управляет Http2Session
экземпляры.
const http2 = require('http2');
const fs = require('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(80);
http2.connect(authority[, options][, listener])
¶
authority
{string | URL} Удаленный сервер HTTP / 2 для подключения. Это должен быть минимальный действительный URL-адрес сhttp://
илиhttps://
префикс, имя хоста и IP-порт (если используется порт, отличный от порта по умолчанию). Информация о пользователе (идентификатор пользователя и пароль), путь, строка запроса и сведения о фрагменте в URL-адресе будут проигнорированы.options
{Объект}maxDeflateDynamicTableSize
{number} Устанавливает максимальный размер динамической таблицы для дефлятирования полей заголовка. Дефолт:4Kib
.maxSettings
{number} Задает максимальное количество записей настроек наSETTINGS
Рамка. Минимальное допустимое значение:1
. Дефолт:32
.maxSessionMemory
Устанавливает максимальный объем памяти, которыйHttp2Session
разрешено использовать. Значение выражается в количестве мегабайт, например1
равняется 1 мегабайту. Минимальное допустимое значение:1
. Это кредитный лимит, существующийHttp2Stream
s может привести к превышению этого лимита, но новыеHttp2Stream
экземпляры будут отклонены, пока этот лимит превышен. Текущее количествоHttp2Stream
сеансы, текущее использование памяти таблицами сжатия заголовков, текущие данные в очереди на отправку и неподтвержденныеPING
а такжеSETTINGS
все кадры учитываются по текущему пределу. Дефолт:10
.maxHeaderListPairs
{число} Устанавливает максимальное количество записей заголовка. Это похоже наhttp.Server#maxHeadersCount
илиhttp.ClientRequest#maxHeadersCount
. Минимальное значение1
. Дефолт:128
.maxOutstandingPings
{number} Устанавливает максимальное количество незавершенных неподтвержденных запросов ping. Дефолт:10
.maxReservedRemoteStreams
{number} Устанавливает максимальное количество зарезервированных push-потоков, которые клиент будет принимать в любой момент времени. Как только текущее количество зарезервированных push-потоков превысит этот предел, новые push-потоки, отправленные сервером, будут автоматически отклонены. Минимальное допустимое значение - 0. Максимально допустимое значение - 2.32-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
{строка} Протокол для подключения, если он не установлен вauthority
. Значение может быть либо'http:'
или'https:'
. Дефолт:'https:'
settings
{HTTP / 2 Settings Object} Начальные настройки для отправки удаленному узлу при подключении.createConnection
{Function} Необязательный обратный вызов, который получаетURL
экземпляр переданconnect
иoptions
объект и возвращает любойDuplex
поток, который будет использоваться в качестве соединения для этого сеанса.- ...: Любой
net.connect()
илиtls.connect()
варианты могут быть предоставлены. unknownProtocolTimeout
{number} Определяет тайм-аут в миллисекундах, в течение которого сервер должен ждать, когда'unknownProtocol'
событие испускается. Если к этому времени сокет не был уничтожен, сервер уничтожит его. Дефолт:10000
.listener
{Function} Будет зарегистрирован как разовый слушатель'connect'
событие.- Возвращает: {ClientHttp2Session}
Возвращает ClientHttp2Session
пример.
const http2 = require('http2');
const client = http2.connect('https://localhost:1234');
/* Use the client */
client.close();
http2.constants
¶
Коды ошибок для RST_STREAM
а также GOAWAY
¶
| Значение | Имя | Постоянный | | -------- | --------------------- | ------------------ ----------------------------- | | 0x00
| Нет ошибок | http2.constants.NGHTTP2_NO_ERROR
| | 0x01
| Ошибка протокола | http2.constants.NGHTTP2_PROTOCOL_ERROR
| | 0x02
| Внутренняя ошибка | http2.constants.NGHTTP2_INTERNAL_ERROR
| | 0x03
| Ошибка управления потоком | http2.constants.NGHTTP2_FLOW_CONTROL_ERROR
| | 0x04
| Настройки Тайм-аут | http2.constants.NGHTTP2_SETTINGS_TIMEOUT
| | 0x05
| Поток закрыт | http2.constants.NGHTTP2_STREAM_CLOSED
| | 0x06
| Ошибка размера кадра | http2.constants.NGHTTP2_FRAME_SIZE_ERROR
| | 0x07
| Отказ от потока | http2.constants.NGHTTP2_REFUSED_STREAM
| | 0x08
| Отмена | http2.constants.NGHTTP2_CANCEL
| | 0x09
| Ошибка сжатия | http2.constants.NGHTTP2_COMPRESSION_ERROR
| | 0x0a
| Ошибка подключения | http2.constants.NGHTTP2_CONNECT_ERROR
| | 0x0b
| Укрепите свое спокойствие | http2.constants.NGHTTP2_ENHANCE_YOUR_CALM
| | 0x0c
| Неадекватная безопасность | http2.constants.NGHTTP2_INADEQUATE_SECURITY
| | 0x0d
| HTTP / 1.1 Требуется | http2.constants.NGHTTP2_HTTP_1_1_REQUIRED
|
В 'timeout'
событие генерируется, когда на сервере нет активности в течение заданного количества миллисекунд, установленных с помощью http2server.setTimeout()
.
http2.getDefaultSettings()
¶
- Возвращает: {объект настроек HTTP / 2}.
Возвращает объект, содержащий настройки по умолчанию для Http2Session
пример. Этот метод возвращает новый экземпляр объекта каждый раз, когда он вызывается, поэтому возвращенные экземпляры могут быть безопасно изменены для использования.
http2.getPackedSettings([settings])
¶
settings
{Объект настроек HTTP / 2}- Возвращает: {Buffer}
Возвращает Buffer
экземпляр, содержащий сериализованное представление заданных параметров HTTP / 2, как указано в HTTP / 2 Технические характеристики. Это предназначено для использования с HTTP2-Settings
поле заголовка.
const http2 = require('http2');
const packed = http2.getPackedSettings({
enablePush: false,
});
console.log(packed.toString('base64'));
// Prints: AAIAAAAA
http2.getUnpackedSettings(buf)
¶
buf
{Buffer | TypedArray} Упакованные настройки.- Возвращает: {объект настроек HTTP / 2}.
Возвращает Объект настроек HTTP / 2 содержащие десериализованные настройки из заданного Buffer
как создано http2.getPackedSettings()
.
http2.sensitiveHeaders
¶
- {условное обозначение}
Этот символ может быть установлен как свойство объекта заголовков HTTP / 2 со значением массива, чтобы предоставить список заголовков, считающихся конфиденциальными. Видеть Конфиденциальные заголовки Больше подробностей.
Объект заголовков¶
Заголовки представлены как собственные свойства в объектах JavaScript. Ключи свойств будут преобразованы в нижний регистр. Значения свойств должны быть строками (в противном случае они будут преобразованы в строки) или Array
строк (для отправки более одного значения в поле заголовка).
const headers = {
':status': '200',
'content-type': 'text-plain',
ABC: ['has', 'more', 'than', 'one', 'value'],
};
stream.respond(headers);
Объекты заголовка, передаваемые функциям обратного вызова, будут иметь 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
заголовки, значения объединяются вместе с помощью '; '. - Для всех остальных заголовков значения объединяются вместе с помощью ','.
const http2 = require('http2');
const server = http2.createServer();
server.on('stream', (stream, headers) => {
console.log(headers[':path']);
console.log(headers.ABC);
});
Конфиденциальные заголовки¶
Заголовки HTTP2 могут быть помечены как конфиденциальные, что означает, что алгоритм сжатия заголовков 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);
Для некоторых заголовков, например Authorization
и коротко Cookie
заголовки этот флаг устанавливается автоматически.
Это свойство также устанавливается для полученных заголовков. Он будет содержать имена всех заголовков, помеченных как конфиденциальные, в том числе помеченных таким образом автоматически.
Объект настроек¶
В http2.getDefaultSettings()
, http2.getPackedSettings()
, http2.createServer()
, http2.createSecureServer()
, http2session.settings()
, http2session.localSettings
, а также http2session.remoteSettings
API либо возвращают, либо получают в качестве входных данных объект, который определяет параметры конфигурации для Http2Session
объект. Эти объекты являются обычными объектами JavaScript, содержащими следующие свойства.
headerTableSize
{число} Задает максимальное количество байтов, используемых для сжатия заголовка. Минимальное допустимое значение - 0. Максимально допустимое значение - 2.32-1. Дефолт:4096
.enablePush
{boolean} Определяетtrue
если потоки HTTP / 2 Push будут разрешены наHttp2Session
экземпляры. Дефолт:true
.initialWindowSize
{number} Определяет отправитель начальный размер окна в байтах для управления потоком на уровне потока. Минимальное допустимое значение - 0. Максимально допустимое значение - 2.32-1. Дефолт:65535
.maxFrameSize
{число} Определяет размер в байтах полезной нагрузки самого большого кадра. Минимально допустимое значение - 16 384. Максимально допустимое значение - 224-1. Дефолт:16384
.maxConcurrentStreams
{number} Определяет максимальное количество одновременных потоков, разрешенных наHttp2Session
. Не существует значения по умолчанию, которое подразумевает, по крайней мере теоретически, 232-1 поток может быть открыт одновременно в любой момент времени вHttp2Session
. Минимальное значение - 0. Максимально допустимое значение - 2.32-1. Дефолт:4294967295
.maxHeaderListSize
{число} Задает максимальный размер (несжатые октеты) списка заголовков, который будет принят. Минимальное допустимое значение - 0. Максимально допустимое значение - 2.32-1. Дефолт:65535
.maxHeaderSize
{number} Псевдоним дляmaxHeaderListSize
.enableConnectProtocol
Определяетtrue
если «Протокол расширенного подключения», определенный RFC 8441 должен быть включен. Этот параметр имеет смысл только в том случае, если он отправлен сервером. ОднаждыenableConnectProtocol
настройка была включена для данногоHttp2Session
, его нельзя отключить. Дефолт:false
.
Все дополнительные свойства объекта настроек игнорируются.
Обработка ошибок¶
Есть несколько типов ошибок, которые могут возникнуть при использовании http2
модуль:
Ошибки проверки возникают, когда передается неверный аргумент, параметр или значение параметра. Об этом всегда будет сообщать синхронный throw
.
Ошибки состояния возникают, когда действие предпринимается в неправильное время (например, при попытке отправить данные в потоке после его закрытия). Об этом будет сообщено с использованием синхронного throw
или через 'error'
событие на Http2Stream
, Http2Session
или объекты HTTP / 2 Server, в зависимости от того, где и когда возникает ошибка.
Внутренние ошибки возникают при неожиданном сбое сеанса 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.
Пуш-потоки на клиенте¶
Чтобы получать проталкиваемые потоки на клиенте, установите прослушиватель для 'stream'
событие на ClientHttp2Session
:
const http2 = require('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-сервер:
const net = require('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:
const http2 = require('http2');
const { NGHTTP2_REFUSED_STREAM } = http2.constants;
const net = require('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:
const http2 = require('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:${port}`,
});
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 определяет расширение «Extended CONNECT Protocol» для HTTP / 2, которое может использоваться для начальной загрузки использования Http2Stream
с помощью CONNECT
как туннель для других протоколов связи (например, WebSockets).
Использование расширенного протокола CONNECT разрешено серверами HTTP / 2 с помощью enableConnectProtocol
параметр:
const http2 = require('http2');
const settings = { enableConnectProtocol: true };
const server = http2.createServer({ settings });
Как только клиент получит SETTINGS
кадр с сервера, указывающий, что можно использовать расширенное соединение CONNECT, он может отправить CONNECT
запросы, использующие ':protocol'
Псевдо-заголовок HTTP / 2:
const http2 = require('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. Однако многие модули используют внутренние методы или состояние, а те не поддерживаются поскольку это совершенно другая реализация.
В следующем примере создается сервер HTTP / 2 с использованием API совместимости:
const http2 = require('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.
В следующем примере создается сервер, поддерживающий оба протокола:
const { createSecureServer } = require('http2');
const { readFileSync } = require('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
¶
- {логический}
В request.aborted
собственность будет true
если запрос был прерван.
request.authority
¶
- {нить}
Поле псевдозаголовка центра запроса. Поскольку HTTP / 2 позволяет запросам устанавливать либо :authority
или host
, это значение получено из req.headers[':authority']
если представить. В противном случае он получается из req.headers['host']
.
request.complete
¶
- {логический}
В request.complete
собственность будет true
если запрос был завершен, прерван или уничтожен.
request.connection
¶
Стабильность: 0 - Не рекомендуется. Использовать
request.socket
.
- {net.Socket | tls.TLSSocket}
Видеть request.socket
.
request.destroy([error])
¶
error
{Ошибка}
Звонки destroy()
на Http2Stream
который получил Http2ServerRequest
. Если error
предоставляется, 'error'
событие испускается и error
передается в качестве аргумента всем слушателям события.
Он ничего не делает, если поток уже был уничтожен.
request.headers
¶
- {Объект}
Объект заголовков запроса / ответа.
Пары "ключ-значение", состоящие из имен и значений заголовков. Имена заголовков в нижнем регистре.
// Prints something like:
//
// { 'user-agent': 'curl/7.22.0',
// host: '127.0.0.1:8000',
// accept: '*/*' }
console.log(request.headers);
Видеть Объект заголовков HTTP / 2.
В HTTP / 2 путь запроса, имя хоста, протокол и метод представлены в виде специальных заголовков с префиксом :
персонаж (например, ':path'
). Эти специальные заголовки будут включены в request.headers
объект. Следует проявлять осторожность, чтобы случайно не изменить эти специальные заголовки, иначе могут возникнуть ошибки. Например, удаление всех заголовков из запроса приведет к возникновению ошибок:
removeAllHeaders(request.headers);
assert(request.url); // Fails because the :path header has been removed
request.httpVersion
¶
- {нить}
В случае запроса сервера - версия HTTP, отправленная клиентом. В случае ответа клиента - версия HTTP подключенного сервера. Возврат '2.0'
.
Также message.httpVersionMajor
- первое целое число и message.httpVersionMinor
это второй.
request.method
¶
- {нить}
Метод запроса в виде строки. Только для чтения. Примеры: 'GET'
, 'DELETE'
.
request.rawHeaders
¶
- {нить[]}
Необработанные заголовки запроса / ответа перечислены в том виде, в котором они были получены.
Ключи и значения находятся в одном списке. это нет список кортежей. Таким образом, смещения с четными номерами являются ключевыми значениями, а смещения с нечетными номерами - соответствующими значениями.
Имена заголовков не в нижнем регистре, и дубликаты не объединяются.
// 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);
request.rawTrailers
¶
- {нить[]}
Необработанные ключи и значения трейлера запроса / ответа в том виде, в котором они были получены. Заселены только в 'end'
событие.
request.scheme
¶
- {нить}
Поле псевдозаголовка схемы запроса, указывающее часть схемы целевого URL.
request.setTimeout(msecs, callback)
¶
msecs
{количество}callback
{Функция}- Возвращает: {http2.Http2ServerRequest}
Устанавливает Http2Stream
значение тайм-аута до msecs
. Если предоставляется обратный вызов, он добавляется в качестве слушателя на 'timeout'
событие в объекте ответа.
Если нет 'timeout'
слушатель добавляется к запросу, ответу или серверу, затем Http2Stream
s уничтожаются по истечении времени ожидания. Если на запрос назначен обработчик, ответ или серверный '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
¶
- {Объект}
Объект трейлеров запроса / ответа. Заселены только в 'end'
событие.
request.url
¶
- {нить}
Строка URL-адреса запроса. Он содержит только URL-адрес, который присутствует в фактическом HTTP-запросе. Если запрос:
GET /status?name=ryan HTTP/1.1
Accept: text/plain
потом request.url
будет:
'/status?name=ryan';
Чтобы разобрать 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: ''
}
Класс: http2.Http2ServerResponse
¶
- Расширяется: {Stream}
Этот объект создается внутри HTTP-сервером, а не пользователем. Он передается вторым параметром в 'request'
событие.
Событие: 'close'
¶
Указывает, что основной Http2Stream
был прекращен до response.end()
был вызван или смог промыть.
Событие: 'finish'
¶
Выдается после отправки ответа. В частности, это событие генерируется, когда последний сегмент заголовков и тела ответа был передан мультиплексору HTTP / 2 для передачи по сети. Это не означает, что клиент еще что-то получил.
После этого события в объекте ответа больше не будет событий.
response.addTrailers(headers)
¶
headers
{Объект}
Этот метод добавляет к ответу завершающие заголовки HTTP (заголовок, но в конце сообщения).
Попытка установить имя поля заголовка или значение, содержащее недопустимые символы, приведет к TypeError
быть брошенным.
response.connection
¶
Стабильность: 0 - Не рекомендуется. Использовать
response.socket
.
- {net.Socket | tls.TLSSocket}
Видеть response.socket
.
response.createPushResponse(headers, callback)
¶
headers
{HTTP / 2 Headers Object} Объект, описывающий заголовки.callback
{Function} Вызывается один разhttp2stream.pushStream()
завершено, либо когда попытка создать отправленныйHttp2Stream
не удалось или был отклонен, или состояниеHttp2ServerRequest
закрывается до вызоваhttp2stream.pushStream()
методerr
{Ошибка}res
{http2.Http2ServerResponse} Недавно созданныйHttp2ServerResponse
объект
Вызов http2stream.pushStream()
с заданными заголовками и оберните данный Http2Stream
на вновь созданном Http2ServerResponse
в качестве параметра обратного вызова в случае успеха. Когда Http2ServerRequest
закрывается, обратный вызов вызывается с ошибкой ERR_HTTP2_INVALID_STREAM
.
response.end([data[, encoding]][, callback])
¶
data
{строка | Буфер | Uint8Array}encoding
{нить}callback
{Функция}- Возвращает: {this}
Этот метод сигнализирует серверу, что все заголовки и тело ответа отправлены; этот сервер должен считать это сообщение завершенным. Метод, response.end()
, ДОЛЖЕН вызываться при каждом ответе.
Если data
указано, это эквивалентно вызову response.write(data, encoding)
с последующим response.end(callback)
.
Если callback
указан, он будет вызываться по завершении потока ответа.
response.finished
¶
Стабильность: 0 - Не рекомендуется. Использовать
response.writableEnded
.
- {логический}
Логическое значение, указывающее, завершен ли ответ. Начинается как false
. После response.end()
выполняется, значение будет true
.
response.getHeader(name)
¶
name
{нить}- Возвращает: {строка}
Считывает заголовок, который уже был поставлен в очередь, но не отправлен клиенту. Имя не чувствительно к регистру.
const contentType = response.getHeader('content-type');
response.getHeaderNames()
¶
- Возвращает: {строка []}
Возвращает массив, содержащий уникальные имена текущих исходящих заголовков. Все имена заголовков в нижнем регистре.
response.setHeader('Foo', 'bar');
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);
const headerNames = response.getHeaderNames();
// headerNames === ['foo', 'set-cookie']
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'] }
response.hasHeader(name)
¶
name
{нить}- Возвращает: {логическое}
Возврат true
если заголовок идентифицирован name
в настоящее время устанавливается в исходящих заголовках. При сопоставлении имени заголовка регистр не учитывается.
const hasContentType = response.hasHeader('content-type');
response.headersSent
¶
- {логический}
Истина, если заголовки были отправлены, в противном случае - ложь (только для чтения).
response.removeHeader(name)
¶
name
{нить}
Удаляет заголовок, который был поставлен в очередь для неявной отправки.
response.removeHeader('Content-Encoding');
response.req
¶
- {http2.Http2ServerRequest}
Ссылка на оригинальный HTTP2 request
объект.
response.sendDate
¶
- {логический}
Если установлено значение true, заголовок Date будет автоматически сгенерирован и отправлен в ответе, если он еще не присутствует в заголовках. По умолчанию true.
Это следует отключать только для тестирования; HTTP требует заголовка Date в ответах.
response.setHeader(name, value)
¶
name
{нить}value
{строка | строка []}
Устанавливает одно значение заголовка для неявных заголовков. Если этот заголовок уже существует в заголовках для отправки, его значение будет заменено. Используйте здесь массив строк, чтобы отправить несколько заголовков с одним и тем же именем.
response.setHeader(
'Content-Type',
'text/html; charset=utf-8'
);
или
response.setHeader('Set-Cookie', [
'type=ninja',
'language=javascript',
]);
Попытка установить имя поля заголовка или значение, содержащее недопустимые символы, приведет к 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');
});
response.setTimeout(msecs[, callback])
¶
msecs
{количество}callback
{Функция}- Возвращает: {http2.Http2ServerResponse}.
Устанавливает Http2Stream
значение тайм-аута до msecs
. Если предоставляется обратный вызов, он добавляется в качестве слушателя на 'timeout'
событие в объекте ответа.
Если нет 'timeout'
слушатель добавляется к запросу, ответу или серверу, затем Http2Stream
s уничтожаются по истечении времени ожидания. Если на запрос назначен обработчик, ответ или серверный '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
и розетки для дополнительной информации.
Все остальные взаимодействия будут направляться непосредственно в сокет.
const http2 = require('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
¶
- {количество}
При использовании неявных заголовков (не вызывающих response.writeHead()
явно), это свойство управляет кодом состояния, который будет отправлен клиенту при сбросе заголовков.
response.statusCode = 404;
После того, как заголовок ответа был отправлен клиенту, это свойство указывает код состояния, который был отправлен.
response.statusMessage
¶
- {нить}
Сообщение о состоянии не поддерживается HTTP / 2 (RFC 7540 8.1.2.4). Возвращает пустую строку.
response.stream
¶
- {Http2Stream}
В Http2Stream
объект, подтверждающий ответ.
response.writableEnded
¶
- {логический}
Является true
после response.end()
был вызван. Это свойство не указывает, были ли данные сброшены, для этого использования. writable.writableFinished
вместо.
response.write(chunk[, encoding][, callback])
¶
chunk
{строка | Буфер | Uint8Array}encoding
{нить}callback
{Функция}- Возвращает: {логическое}
Если этот метод вызван и response.writeHead()
не был вызван, он переключится в режим неявного заголовка и сбрасывает неявные заголовки.
Это отправляет кусок тела ответа. Этот метод может вызываться несколько раз для получения последовательных частей тела.
в http
модуль, тело ответа опускается, если запрос является запросом HEAD. Аналогичным образом 204
а также 304
ответы не должен включить тело сообщения.
chunk
может быть строкой или буфером. Если chunk
является строкой, второй параметр указывает, как ее кодировать в поток байтов. По умолчанию encoding
является 'utf8'
. callback
будет вызываться, когда этот фрагмент данных будет сброшен.
Это необработанное тело HTTP и не имеет ничего общего с кодировками, состоящими из нескольких частей, которые могут быть использованы.
Первый раз response.write()
вызывается, он отправит клиенту буферизованную информацию заголовка и первый фрагмент тела. Второй раз response.write()
вызывается, Node.js предполагает, что данные будут передаваться в потоковом режиме, и отправляет новые данные отдельно. То есть ответ буферизируется до первого фрагмента тела.
Возврат true
если все данные были успешно сброшены в буфер ядра. Возврат false
если все или часть данных были помещены в очередь в пользовательской памяти. 'drain'
будет выдан, когда буфер снова освободится.
response.writeContinue()
¶
Отправляет статус 100 Continue
клиенту, указывая, что тело запроса должно быть отправлено. Увидеть 'checkContinue'
событие на Http2Server
а также Http2SecureServer
.
response.writeHead(statusCode[, statusMessage][, headers])
¶
statusCode
{количество}statusMessage
{нить}headers
{Объект}- Возвращает: {http2.Http2ServerResponse}.
Отправляет заголовок ответа на запрос. Код состояния представляет собой трехзначный код состояния HTTP, например 404
. Последний аргумент, headers
, являются заголовками ответа.
Возвращает ссылку на Http2ServerResponse
, так что вызовы можно связывать.
Для совместимости с HTTP / 1, удобочитаемый statusMessage
может быть передан как второй аргумент. Однако, поскольку statusMessage
не имеет значения в HTTP / 2, аргумент не будет иметь никакого эффекта, и будет выдано предупреждение процесса.
const body = 'hello world';
response.writeHead(200, {
'Content-Length': Buffer.byteLength(body),
'Content-Type': 'text/plain; charset=utf-8',
});
Content-Length
дается в байтах, а не в символах. В Buffer.byteLength()
API может использоваться для определения количества байтов в данной кодировке. В исходящих сообщениях 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');
});
Попытка установить имя поля заголовка или значение, содержащее недопустимые символы, приведет к TypeError
быть брошенным.
Сбор метрик производительности HTTP / 2¶
В Наблюдатель за производительностью API можно использовать для сбора основных показателей производительности для каждого Http2Session
а также Http2Stream
пример.
const { PerformanceObserver } = require('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
{строка} Либо'server'
или'client'
определить типHttp2Session
.
Обратите внимание на :authority
а также host
¶
HTTP / 2 требует, чтобы запросы имели либо :authority
псевдо-заголовок или host
заголовок. Предпочитать :authority
при построении запроса HTTP / 2 напрямую, и host
при конвертации из HTTP / 1 (например, в прокси).
API совместимости возвращается к host
если :authority
нет. Видеть request.authority
для дополнительной информации. Однако, если вы не используете API совместимости (или используете req.headers
напрямую), вам необходимо самостоятельно реализовать любое откатное поведение.