HTTP/2

[Cronologia]

Versione	Modifiche
v15.0.0	Le richieste con l'intestazione host (con o senza :authority) possono ora essere inviate/ricevute.
v15.3.0, v14.17.0	È possibile interrompere una richiesta con un AbortSignal.
v10.10.0	HTTP/2 è ora Stabile. Precedentemente era Sperimentale.
v8.4.0	Aggiunto in: v8.4.0

[Stabile: 2 - Stabile]

Stabile: 2 Stabilità: 2 - Stabile

Codice Sorgente: lib/http2.js

Il modulo node:http2 fornisce un'implementazione del protocollo HTTP/2. Vi si può accedere usando:

const http2 = require('node:http2')

Determinare se il supporto crypto non è disponibile

È possibile che Node.js venga compilato senza includere il supporto per il modulo node:crypto. In tali casi, tentare di import da node:http2 o chiamare require('node:http2') provocherà il lancio di un errore.

Quando si utilizza CommonJS, l'errore lanciato può essere intercettato utilizzando try/catch:

let http2
try {
  http2 = require('node:http2')
} catch (err) {
  console.error('il supporto http2 è disabilitato!')
}

Quando si utilizza la parola chiave lessicale ESM import, l'errore può essere intercettato solo se viene registrato un gestore per process.on('uncaughtException') prima di qualsiasi tentativo di caricare il modulo (usando, ad esempio, un modulo preload).

Quando si utilizza ESM, se esiste la possibilità che il codice possa essere eseguito su una build di Node.js in cui il supporto crypto non è abilitato, è consigliabile utilizzare la funzione import() invece della parola chiave lessicale import:

let http2
try {
  http2 = await import('node:http2')
} catch (err) {
  console.error('il supporto http2 è disabilitato!')
}

API Principale

L'API Principale fornisce un'interfaccia di basso livello progettata specificamente per il supporto delle funzionalità del protocollo HTTP/2. Non è specificamente progettata per la compatibilità con l'API del modulo HTTP/1 esistente. Tuttavia, l'API di Compatibilità lo è.

L'API Principale http2 è molto più simmetrica tra client e server rispetto all'API http. Ad esempio, la maggior parte degli eventi, come 'error', 'connect' e 'stream', possono essere emessi sia dal codice lato client che dal codice lato server.

Esempio lato server

Quanto segue illustra un semplice server HTTP/2 che utilizza l'API Core. Poiché non si conoscono browser che supportino HTTP/2 non crittografato, l'uso di http2.createSecureServer() è necessario quando si comunica con i client browser.

ESM

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

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

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

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

server.listen(8443)

CJS

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

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

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

server.listen(8443)

Per generare il certificato e la chiave per questo esempio, eseguire:

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

Esempio lato client

Quanto segue illustra un client HTTP/2:

ESM

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

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

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

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

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

CJS

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

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

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

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

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

Classe: Http2Session

Aggiunto in: v8.4.0

• Estende: <EventEmitter>

Le istanze della classe http2.Http2Session rappresentano una sessione di comunicazione attiva tra un client e un server HTTP/2. Non è previsto che le istanze di questa classe vengano costruite direttamente dal codice utente.

Ogni istanza di Http2Session mostrerà comportamenti leggermente diversi a seconda che operi come server o come client. La proprietà http2session.type può essere utilizzata per determinare la modalità in cui un Http2Session sta operando. Sul lato server, il codice utente dovrebbe raramente avere occasione di lavorare direttamente con l'oggetto Http2Session, con la maggior parte delle azioni in genere intraprese attraverso interazioni con gli oggetti Http2Server o Http2Stream.

Il codice utente non creerà direttamente istanze Http2Session. Le istanze Http2Session lato server vengono create dall'istanza Http2Server quando viene ricevuta una nuova connessione HTTP/2. Le istanze Http2Session lato client vengono create utilizzando il metodo http2.connect().

Http2Session e socket

Ogni istanza di Http2Session è associata a esattamente un net.Socket o tls.TLSSocket quando viene creata. Quando il Socket o l'Http2Session vengono distrutti, entrambi verranno distrutti.

A causa dei requisiti specifici di serializzazione ed elaborazione imposti dal protocollo HTTP/2, non è consigliabile che il codice utente legga dati da o scriva dati in un'istanza Socket associata a una Http2Session. In tal caso, la sessione HTTP/2 potrebbe entrare in uno stato indeterminato, rendendo la sessione e il socket inutilizzabili.

Una volta che un Socket è stato associato a una Http2Session, il codice utente dovrebbe fare affidamento esclusivamente sull'API di Http2Session.

Evento: 'close'

Aggiunto in: v8.4.0

L'evento 'close' viene emesso una volta che l'Http2Session è stata distrutta. Il suo listener non si aspetta alcun argomento.

Evento: 'connect'

Aggiunto in: v8.4.0

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

L'evento 'connect' viene emesso una volta che l'Http2Session è stata connessa con successo al peer remoto e la comunicazione può iniziare.

In genere, il codice utente non ascolta direttamente questo evento.

Evento: 'error'

Aggiunto in: v8.4.0

• error <Error>

L'evento 'error' viene emesso quando si verifica un errore durante l'elaborazione di una Http2Session.

Evento: 'frameError'

Aggiunto in: v8.4.0

• type <integer> Il tipo di frame.
• code <integer> Il codice di errore.
• id <integer> L'id dello stream (o 0 se il frame non è associato a uno stream).

L'evento 'frameError' viene emesso quando si verifica un errore durante il tentativo di inviare un frame sulla sessione. Se il frame che non è stato possibile inviare è associato a uno specifico Http2Stream, viene effettuato un tentativo di emettere un evento 'frameError' sull'Http2Stream.

Se l'evento 'frameError' è associato a uno stream, lo stream verrà chiuso e distrutto immediatamente dopo l'evento 'frameError'. Se l'evento non è associato a uno stream, la Http2Session verrà arrestata immediatamente dopo l'evento 'frameError'.

Evento: 'goaway'

Aggiunto in: v8.4.0

• errorCode <number> Il codice di errore HTTP/2 specificato nel frame GOAWAY.
• lastStreamID <number> L'ID dell'ultimo stream che la controparte remota ha elaborato con successo (o 0 se non è specificato alcun ID).
• opaqueData <Buffer> Se nel frame GOAWAY sono stati inclusi dati opachi aggiuntivi, verrà passato un'istanza Buffer contenente tali dati.

L'evento 'goaway' viene emesso quando viene ricevuto un frame GOAWAY.

L'istanza Http2Session verrà arrestata automaticamente quando viene emesso l'evento 'goaway'.

Evento: 'localSettings'

Aggiunto in: v8.4.0

• settings <Oggetto Impostazioni HTTP/2> Una copia del frame SETTINGS ricevuto.

L'evento 'localSettings' viene emesso quando è stato ricevuto un frame SETTINGS di riconoscimento.

Quando si utilizza http2session.settings() per inviare nuove impostazioni, le impostazioni modificate non diventano effettive fino a quando non viene emesso l'evento 'localSettings'.

session.settings({ enablePush: false })

session.on('localSettings', settings => {
  /* Usa le nuove impostazioni */
})

Evento: 'ping'

Aggiunto in: v10.12.0

• payload <Buffer> Il payload di 8 byte del frame PING

L'evento 'ping' viene emesso ogni volta che viene ricevuto un frame PING dal peer connesso.

Evento: 'remoteSettings'

Aggiunto in: v8.4.0

• settings <Oggetto Impostazioni HTTP/2> Una copia del frame SETTINGS ricevuto.

L'evento 'remoteSettings' viene emesso quando viene ricevuto un nuovo frame SETTINGS dal peer connesso.

session.on('remoteSettings', settings => {
  /* Usa le nuove impostazioni */
})

Evento: 'stream'

Aggiunto in: v8.4.0

• stream <Http2Stream> Un riferimento allo stream
• headers <Oggetto Header HTTP/2> Un oggetto che descrive gli header
• flags <number> I flag numerici associati
• rawHeaders <Array> Un array contenente i nomi degli header non elaborati seguiti dai rispettivi valori.

L'evento 'stream' viene emesso quando viene creato un nuovo Http2Stream.

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

Lato server, il codice utente in genere non sarà in ascolto diretto di questo evento, ma registrerà un gestore per l'evento 'stream' emesso dalle istanze net.Server o tls.Server restituite rispettivamente da http2.createServer() e http2.createSecureServer(), come nell'esempio seguente:

ESM

import { createServer } from 'node:http2'

// Crea un server HTTP/2 non crittografato
const server = createServer()

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

server.listen(8000)

CJS

const http2 = require('node:http2')

// Crea un server HTTP/2 non crittografato
const server = http2.createServer()

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

server.listen(8000)

Anche se gli stream HTTP/2 e i socket di rete non sono in una corrispondenza 1:1, un errore di rete distruggerà ogni singolo stream e deve essere gestito a livello di stream, come mostrato sopra.

Evento: 'timeout'

Aggiunto in: v8.4.0

Dopo che il metodo http2session.setTimeout() è stato utilizzato per impostare il periodo di timeout per questa Http2Session, l'evento 'timeout' viene emesso se non c'è attività sulla Http2Session dopo il numero di millisecondi configurato. Il suo listener non si aspetta alcun argomento.

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

http2session.alpnProtocol

Aggiunto in: v9.4.0

• <string> | <undefined>

Il valore sarà undefined se la Http2Session non è ancora connessa a un socket, h2c se la Http2Session non è connessa a un TLSSocket, oppure restituirà il valore della proprietà alpnProtocol del TLSSocket connesso.

http2session.close([callback])

Aggiunto in: v9.4.0

• callback <Function>

Chiude correttamente la Http2Session, consentendo a tutti gli stream esistenti di completarsi autonomamente e impedendo la creazione di nuove istanze di Http2Stream. Una volta chiusa, http2session.destroy() potrebbe essere chiamata se non ci sono istanze di Http2Stream aperte.

Se specificata, la funzione callback viene registrata come gestore per l'evento 'close'.

http2session.closed

Aggiunto in: v9.4.0

• <boolean>

Sarà true se questa istanza di Http2Session è stata chiusa, altrimenti false.

http2session.connecting

Aggiunto in: v10.0.0

• <boolean>

Sarà true se questa istanza di Http2Session è ancora in fase di connessione, sarà impostata su false prima di emettere l'evento connect e/o di chiamare il callback di http2.connect.

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

Aggiunto in: v8.4.0

• error <Error> Un oggetto Error se la Http2Session viene distrutta a causa di un errore.
• code <number> Il codice di errore HTTP/2 da inviare nel frame GOAWAY finale. Se non specificato, e error non è definito, il valore predefinito è INTERNAL_ERROR, altrimenti il valore predefinito è NO_ERROR.

Termina immediatamente la Http2Session e il net.Socket o tls.TLSSocket associato.

Una volta distrutta, la Http2Session emetterà l'evento 'close'. Se error non è definito, un evento 'error' verrà emesso immediatamente prima dell'evento 'close'.

Se ci sono ancora Http2Stream aperti associati alla Http2Session, anche questi verranno distrutti.

http2session.destroyed

Aggiunto in: v8.4.0

• <boolean>

Sarà true se questa istanza di Http2Session è stata distrutta e non deve più essere utilizzata, altrimenti false.

http2session.encrypted

Aggiunto in: v9.4.0

• <boolean> | <undefined>

Il valore è undefined se il socket della sessione Http2Session non è ancora stato connesso, true se la Http2Session è connessa con un TLSSocket e false se la Http2Session è connessa a qualsiasi altro tipo di socket o stream.

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

Aggiunto in: v9.4.0

• code <number> Un codice di errore HTTP/2
• lastStreamID <number> L'ID numerico dell'ultimo Http2Stream elaborato
• opaqueData <Buffer> | <TypedArray> | <DataView> Un'istanza TypedArray o DataView contenente dati aggiuntivi da trasportare all'interno del frame GOAWAY.

Trasmette un frame GOAWAY al peer connesso senza chiudere la Http2Session.

http2session.localSettings

Aggiunto in: v8.4.0

• <Oggetto Impostazioni HTTP/2>

Un oggetto senza prototipo che descrive le attuali impostazioni locali di questa Http2Session. Le impostazioni locali sono locali a questa istanza Http2Session.

http2session.originSet

Aggiunto in: v9.4.0

• <string[]> | <undefined>

Se la Http2Session è connessa a un TLSSocket, la proprietà originSet restituirà un Array di origini per le quali la Http2Session può essere considerata autorevole.

La proprietà originSet è disponibile solo quando si utilizza una connessione TLS sicura.

http2session.pendingSettingsAck

Aggiunto in: v8.4.0

• <boolean>

Indica se Http2Session sta attualmente aspettando una conferma di un frame SETTINGS inviato. Sarà true dopo aver chiamato il metodo http2session.settings(). Sarà false una volta che tutti i frame SETTINGS inviati sono stati confermati.

http2session.ping([payload, ]callback)

[Cronologia]

Versione	Modifiche
v18.0.0	Passare un callback non valido all'argomento callback ora genera ERR_INVALID_ARG_TYPE invece di ERR_INVALID_CALLBACK.
v8.9.3	Aggiunto in: v8.9.3

• payload <Buffer> | <TypedArray> | <DataView> Payload ping opzionale.
• callback <Function>
• Restituisce: <boolean>

Invia un frame PING al peer HTTP/2 connesso. Deve essere fornita una funzione callback. Il metodo restituirà true se il PING è stato inviato, false altrimenti.

Il numero massimo di ping in sospeso (non confermati) è determinato dall'opzione di configurazione maxOutstandingPings. Il valore massimo predefinito è 10.

Se fornito, il payload deve essere un Buffer, TypedArray o DataView contenente 8 byte di dati che verranno trasmessi con il PING e restituiti con la conferma del ping.

La callback verrà invocata con tre argomenti: un argomento di errore che sarà null se il PING è stato confermato con successo, un argomento duration che riporta il numero di millisecondi trascorsi dall'invio del ping e dalla ricezione della conferma e un Buffer contenente i 8 byte di payload del PING.

session.ping(Buffer.from('abcdefgh'), (err, duration, payload) => {
  if (!err) {
    console.log(`Ping confermato in ${duration} millisecondi`)
    console.log(`Con payload '${payload.toString()}'`)
  }
})

Se l'argomento payload non è specificato, il payload predefinito sarà il timestamp a 64 bit (little endian) che indica l'inizio della durata del PING.

http2session.ref()

Aggiunto in: v9.4.0

Chiama ref() sull'istanza di net.Socket sottostante di questa Http2Session.

http2session.remoteSettings

Aggiunto in: v8.4.0

• <Oggetto Impostazioni HTTP/2>

Un oggetto senza prototipo che descrive le impostazioni remote correnti di questa Http2Session. Le impostazioni remote vengono impostate dal peer HTTP/2 connesso.

http2session.setLocalWindowSize(windowSize)

Aggiunto in: v15.3.0, v14.18.0

• windowSize <numero>

Imposta la dimensione della finestra dell'endpoint locale. windowSize è la dimensione totale della finestra da impostare, non il delta.

ESM

import { createServer } from 'node:http2'

const server = createServer()
const expectedWindowSize = 2 ** 20
server.on('session', session => {
  // Imposta la dimensione della finestra locale a 2 ** 20
  session.setLocalWindowSize(expectedWindowSize)
})

CJS

const http2 = require('node:http2')

const server = http2.createServer()
const expectedWindowSize = 2 ** 20
server.on('session', session => {
  // Imposta la dimensione della finestra locale a 2 ** 20
  session.setLocalWindowSize(expectedWindowSize)
})

Per i client http2 l'evento corretto è o 'connect' o 'remoteSettings'.

http2session.setTimeout(msecs, callback)

[Cronologia]

Versione	Modifiche
v18.0.0	Passare un callback non valido all'argomento callback ora genera ERR_INVALID_ARG_TYPE invece di ERR_INVALID_CALLBACK.
v8.4.0	Aggiunto in: v8.4.0

• msecs <numero>
• callback <Funzione>

Utilizzato per impostare una funzione di callback che viene chiamata quando non c'è attività sulla Http2Session dopo msecs millisecondi. Il callback dato viene registrato come listener sull'evento 'timeout'.

http2session.socket

Aggiunto in: v8.4.0

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

Restituisce un oggetto Proxy che funge da net.Socket (o tls.TLSSocket) ma limita i metodi disponibili a quelli sicuri da usare con HTTP/2.

destroy, emit, end, pause, read, resume e write genereranno un errore con codice ERR_HTTP2_NO_SOCKET_MANIPULATION. Vedere Http2Session e socket per maggiori informazioni.

Il metodo setTimeout verrà chiamato su questa Http2Session.

Tutte le altre interazioni verranno instradate direttamente al socket.

http2session.state

Aggiunto in: v8.4.0

Fornisce informazioni varie sullo stato corrente della Http2Session.

• <Object>
  • effectiveLocalWindowSize <number> La dimensione corrente della finestra di controllo del flusso locale (ricezione) per la Http2Session.
  • effectiveRecvDataLength <number> Il numero corrente di byte che sono stati ricevuti dall'ultimo WINDOW_UPDATE del controllo del flusso.
  • nextStreamID <number> L'identificatore numerico da utilizzare la prossima volta che un nuovo Http2Stream viene creato da questa Http2Session.
  • localWindowSize <number> Il numero di byte che il peer remoto può inviare senza ricevere un WINDOW_UPDATE.
  • lastProcStreamID <number> L'ID numerico dell'Http2Stream per il quale è stato ricevuto più recentemente un frame HEADERS o DATA.
  • remoteWindowSize <number> Il numero di byte che questa Http2Session può inviare senza ricevere un WINDOW_UPDATE.
  • outboundQueueSize <number> Il numero di frame attualmente all'interno della coda in uscita per questa Http2Session.
  • deflateDynamicTableSize <number> La dimensione corrente in byte della tabella di stato della compressione dell'intestazione in uscita.
  • inflateDynamicTableSize <number> La dimensione corrente in byte della tabella di stato della compressione dell'intestazione in entrata.

Un oggetto che descrive lo stato corrente di questa Http2Session.

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

[Cronologia]

Versione	Modifiche
v18.0.0	Il passaggio di una callback non valida all'argomento callback ora genera ERR_INVALID_ARG_TYPE invece di ERR_INVALID_CALLBACK.
v8.4.0	Aggiunto in: v8.4.0

• settings <Oggetto Impostazioni HTTP/2>
• callback <Funzione> Callback che viene chiamata una volta che la sessione è connessa o immediatamente se la sessione è già connessa.
  • err <Errore> | <null>
  • settings <Oggetto Impostazioni HTTP/2> L'oggetto settings aggiornato.
  • duration <numero intero>

Aggiorna le impostazioni locali correnti per questo Http2Session e invia un nuovo frame SETTINGS al peer HTTP/2 connesso.

Una volta chiamato, la proprietà http2session.pendingSettingsAck sarà true mentre la sessione è in attesa che il peer remoto confermi le nuove impostazioni.

Le nuove impostazioni non diventeranno effettive fino a quando non verrà ricevuto l'acknowledgment di SETTINGS e non verrà emesso l'evento 'localSettings'. È possibile inviare più frame SETTINGS mentre l'acknowledgment è ancora in sospeso.

http2session.type

Aggiunto in: v8.4.0

• <numero>

Il valore di http2session.type sarà uguale a http2.constants.NGHTTP2_SESSION_SERVER se questa istanza Http2Session è un server e http2.constants.NGHTTP2_SESSION_CLIENT se l'istanza è un client.

http2session.unref()

Aggiunto in: v9.4.0

Chiama unref() sul net.Socket sottostante di questa istanza Http2Session.

Classe: ServerHttp2Session

Aggiunto in: v8.4.0

• Estende: <Http2Session>

serverhttp2session.altsvc(alt, originOrStream)

Aggiunto in: v9.4.0

• alt <string> Una descrizione della configurazione del servizio alternativo come definito da RFC 7838.
• originOrStream <number> | <string> | <URL> | <Object> Una stringa URL che specifica l'origine (o un Object con una proprietà origin) oppure l'identificatore numerico di uno Http2Stream attivo come dato dalla proprietà http2stream.id.

Invia un frame ALTSVC (come definito da RFC 7838) al client connesso.

ESM

import { createServer } from 'node:http2'

const server = createServer()
server.on('session', session => {
  // Imposta altsvc per l'origine https://example.org:80
  session.altsvc('h2=":8000"', 'https://example.org:80')
})

server.on('stream', stream => {
  // Imposta altsvc per uno stream specifico
  stream.session.altsvc('h2=":8000"', stream.id)
})

CJS

const http2 = require('node:http2')

const server = http2.createServer()
server.on('session', session => {
  // Imposta altsvc per l'origine https://example.org:80
  session.altsvc('h2=":8000"', 'https://example.org:80')
})

server.on('stream', stream => {
  // Imposta altsvc per uno stream specifico
  stream.session.altsvc('h2=":8000"', stream.id)
})

L'invio di un frame ALTSVC con un ID stream specifico indica che il servizio alternativo è associato all'origine dello Http2Stream fornito.

La stringa alt e la stringa dell'origine devono contenere solo byte ASCII e sono interpretate rigorosamente come una sequenza di byte ASCII. Il valore speciale 'clear' può essere passato per cancellare qualsiasi servizio alternativo impostato precedentemente per un dato dominio.

Quando viene passata una stringa per l'argomento originOrStream, questa sarà analizzata come un URL e l'origine sarà derivata. Ad esempio, l'origine per l'URL HTTP 'https://example.org/foo/bar' è la stringa ASCII 'https://example.org'. Verrà generato un errore se la stringa fornita non può essere analizzata come URL o se non è possibile derivare un'origine valida.

Un oggetto URL, o qualsiasi oggetto con una proprietà origin, può essere passato come originOrStream, nel qual caso verrà utilizzato il valore della proprietà origin. Il valore della proprietà origin deve essere un'origine ASCII serializzata correttamente.

Specifica di servizi alternativi

Il formato del parametro alt è strettamente definito da RFC 7838 come una stringa ASCII contenente un elenco delimitato da virgole di protocolli "alternativi" associati a un host e una porta specifici.

Ad esempio, il valore 'h2="example.org:81"' indica che il protocollo HTTP/2 è disponibile sull'host 'example.org' sulla porta TCP/IP 81. L'host e la porta devono essere contenuti all'interno dei caratteri virgolette (").

È possibile specificare più alternative, ad esempio: 'h2="example.org:81", h2=":82"'.

L'identificatore del protocollo ('h2' negli esempi) può essere qualsiasi ID di protocollo ALPN valido.

La sintassi di questi valori non viene convalidata dall'implementazione di Node.js e viene passata così come fornita dall'utente o ricevuta dal peer.

serverhttp2session.origin(...origins)

Aggiunto in: v10.12.0

• origins <stringa> | <URL> | <Oggetto> Una o più stringhe URL passate come argomenti separati.

Invia un frame ORIGIN (come definito da RFC 8336) al client connesso per annunciare l'insieme di origini per le quali il server è in grado di fornire risposte autorevoli.

ESM

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

CJS

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

Quando una stringa viene passata come origin, verrà analizzata come URL e verrà derivata l'origine. Ad esempio, l'origine per l'URL HTTP 'https://example.org/foo/bar' è la stringa ASCII 'https://example.org'. Verrà generato un errore se la stringa specificata non può essere analizzata come URL o se non è possibile derivare un'origine valida.

Un oggetto URL o qualsiasi oggetto con una proprietà origin può essere passato come origin, nel qual caso verrà utilizzato il valore della proprietà origin. Il valore della proprietà origin deve essere un'origine ASCII serializzata correttamente.

In alternativa, l'opzione origins può essere utilizzata quando si crea un nuovo server HTTP/2 utilizzando il metodo http2.createSecureServer():

ESM

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

CJS

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

Classe: ClientHttp2Session

Aggiunto in: v8.4.0

• Estende: <Http2Session>

Evento: 'altsvc'

Aggiunto in: v9.4.0

• alt <stringa>
• origin <stringa>
• streamId <numero>

L'evento 'altsvc' viene emesso ogni volta che il client riceve un frame ALTSVC. L'evento viene emesso con il valore ALTSVC, l'origine e l'ID dello stream. Se nel frame ALTSVC non viene fornita alcuna origin, origin sarà una stringa vuota.

ESM

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

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

CJS

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

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

Evento: 'origin'

Aggiunto in: v10.12.0

• origins <stringa[]>

L'evento 'origin' viene emesso ogni volta che il client riceve un frame ORIGIN. L'evento viene emesso con un array di stringhe origin. http2session.originSet verrà aggiornato per includere le origini ricevute.

ESM

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

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

CJS

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

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

L'evento 'origin' viene emesso solo quando si utilizza una connessione TLS sicura.

clienthttp2session.request(headers[, options])

Aggiunto in: v8.4.0

• headers <Oggetto di intestazioni HTTP/2>

• options <Oggetto>

  • endStream <boolean> true se il lato scrivibile di Http2Stream deve essere chiuso inizialmente, come quando si invia una richiesta GET che non dovrebbe aspettarsi un corpo di payload.
  • exclusive <boolean> Quando true e parent identifica uno Stream genitore, lo stream creato diventa l'unica dipendenza diretta del genitore, con tutte le altre dipendenze esistenti rese dipendenti dallo stream appena creato. Predefinito: false.
  • parent <number> Specifica l'identificatore numerico di uno stream da cui dipende lo stream appena creato.
  • weight <number> Specifica la dipendenza relativa di uno stream in relazione ad altri stream con lo stesso parent. Il valore è un numero compreso tra 1 e 256 (inclusi).
  • waitForTrailers <boolean> Quando true, Http2Stream emetterà l'evento 'wantTrailers' dopo che è stato inviato l'ultimo frame DATA.
  • signal <AbortSignal> Un AbortSignal che può essere utilizzato per interrompere una richiesta in corso.

• Restituisce: <ClientHttp2Stream>

Solo per le istanze Http2Session del client HTTP/2, http2session.request() crea e restituisce un'istanza Http2Stream che può essere utilizzata per inviare una richiesta HTTP/2 al server connesso.

Quando viene creata per la prima volta una ClientHttp2Session, il socket potrebbe non essere ancora connesso. Se clienthttp2session.request() viene chiamato durante questo periodo, la richiesta effettiva verrà rinviata fino a quando il socket non sarà pronto per l'uso. Se la session viene chiusa prima che la richiesta effettiva venga eseguita, viene generato un errore ERR_HTTP2_GOAWAY_SESSION.

Questo metodo è disponibile solo se http2session.type è uguale a http2.constants.NGHTTP2_SESSION_CLIENT.

ESM

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

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

CJS

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

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

Quando l'opzione options.waitForTrailers è impostata, l'evento 'wantTrailers' viene emesso immediatamente dopo aver accodato l'ultimo chunk di dati payload da inviare. Il metodo http2stream.sendTrailers() può quindi essere chiamato per inviare intestazioni finali al peer.

Quando options.waitForTrailers è impostato, Http2Stream non si chiuderà automaticamente quando viene trasmesso l'ultimo frame DATA. Il codice utente deve chiamare http2stream.sendTrailers() o http2stream.close() per chiudere Http2Stream.

Quando options.signal è impostato con un AbortSignal e poi viene chiamato abort sul AbortController corrispondente, la richiesta emetterà un evento 'error' con un errore AbortError.

Gli pseudo-header :method e :path non sono specificati all'interno di headers, di conseguenza di default:

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

Classe: Http2Stream

Aggiunto in: v8.4.0

• Estende: <stream.Duplex>

Ogni istanza della classe Http2Stream rappresenta un flusso di comunicazione HTTP/2 bidirezionale su un'istanza Http2Session. Una singola Http2Session può avere fino a 2-1 istanze di Http2Stream durante la sua vita.

Il codice utente non costruirà direttamente istanze di Http2Stream. Piuttosto, queste vengono create, gestite e fornite al codice utente attraverso l'istanza Http2Session. Sul server, le istanze di Http2Stream vengono create in risposta a una richiesta HTTP in entrata (e consegnate al codice utente tramite l'evento 'stream') o in risposta a una chiamata al metodo http2stream.pushStream(). Sul client, le istanze di Http2Stream vengono create e restituite quando viene chiamato il metodo http2session.request() o in risposta a un evento 'push' in entrata.

La classe Http2Stream è una base per le classi ServerHttp2Stream e ClientHttp2Stream, ciascuna delle quali viene utilizzata specificamente dal lato Server o Client, rispettivamente.

Tutte le istanze di Http2Stream sono flussi Duplex. Il lato Writable del Duplex viene utilizzato per inviare dati al peer connesso, mentre il lato Readable viene utilizzato per ricevere dati inviati dal peer connesso.

La codifica dei caratteri di testo predefinita per un Http2Stream è UTF-8. Quando si utilizza un Http2Stream per inviare testo, utilizzare l'intestazione 'content-type' per impostare la codifica dei caratteri.

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

Ciclo di vita di Http2Stream

Creazione

Sul lato server, le istanze di ServerHttp2Stream vengono create quando:

• Viene ricevuto un nuovo frame HTTP/2 HEADERS con un ID di flusso precedentemente non utilizzato;
• Viene chiamato il metodo http2stream.pushStream().

Sul lato client, le istanze di ClientHttp2Stream vengono create quando viene chiamato il metodo http2session.request().

Sul client, l'istanza Http2Stream restituita da http2session.request() potrebbe non essere immediatamente pronta per l'uso se l'elemento padre Http2Session non è stato ancora completamente stabilito. In tali casi, le operazioni chiamate sull'Http2Stream verranno memorizzate nel buffer finché non viene emesso l'evento 'ready'. Il codice utente raramente, se non mai, ha bisogno di gestire direttamente l'evento 'ready'. Lo stato di prontezza di un Http2Stream può essere determinato controllando il valore di http2stream.id. Se il valore è undefined, il flusso non è ancora pronto per l'uso.

Distruzione

Tutte le istanze Http2Stream vengono distrutte quando:

• Un frame RST_STREAM per lo stream viene ricevuto dal peer connesso, e (solo per gli stream client) i dati in sospeso sono stati letti.
• Viene chiamato il metodo http2stream.close(), e (solo per gli stream client) i dati in sospeso sono stati letti.
• Vengono chiamati i metodi http2stream.destroy() o http2session.destroy().

Quando un'istanza Http2Stream viene distrutta, verrà fatto un tentativo di inviare un frame RST_STREAM al peer connesso.

Quando l'istanza Http2Stream viene distrutta, verrà emesso l'evento 'close'. Poiché Http2Stream è un'istanza di stream.Duplex, verrà emesso anche l'evento 'end' se i dati dello stream sono attualmente in flusso. L'evento 'error' può anche essere emesso se http2stream.destroy() è stato chiamato con un Error passato come primo argomento.

Dopo che Http2Stream è stato distrutto, la proprietà http2stream.destroyed sarà true e la proprietà http2stream.rstCode specificherà il codice di errore RST_STREAM. L'istanza Http2Stream non è più utilizzabile una volta distrutta.

Evento: 'aborted'

Aggiunto in: v8.4.0

L'evento 'aborted' viene emesso ogni volta che un'istanza Http2Stream viene interrotta in modo anomalo durante la comunicazione. Il suo listener non si aspetta argomenti.

L'evento 'aborted' verrà emesso solo se il lato scrivibile di Http2Stream non è stato terminato.

Evento: 'close'

Aggiunto in: v8.4.0

L'evento 'close' viene emesso quando Http2Stream viene distrutto. Una volta che questo evento è stato emesso, l'istanza Http2Stream non è più utilizzabile.

Il codice di errore HTTP/2 utilizzato durante la chiusura dello stream può essere recuperato utilizzando la proprietà http2stream.rstCode. Se il codice è un valore diverso da NGHTTP2_NO_ERROR (0), sarà stato emesso anche un evento 'error'.

Evento: 'error'

Aggiunto in: v8.4.0

• error <Error>

L'evento 'error' viene emesso quando si verifica un errore durante l'elaborazione di un Http2Stream.

Evento: 'frameError'

Aggiunto in: v8.4.0

• type <integer> Il tipo di frame.
• code <integer> Il codice di errore.
• id <integer> L'ID dello stream (o 0 se il frame non è associato a uno stream).

L'evento 'frameError' viene emesso quando si verifica un errore durante il tentativo di inviare un frame. Quando invocata, la funzione handler riceverà un argomento intero che identifica il tipo di frame e un argomento intero che identifica il codice di errore. L'istanza Http2Stream verrà distrutta immediatamente dopo l'emissione dell'evento 'frameError'.

Evento: 'ready'

Aggiunto in: v8.4.0

L'evento 'ready' viene emesso quando Http2Stream è stato aperto, gli è stato assegnato un id e può essere utilizzato. Il listener non si aspetta argomenti.

Evento: 'timeout'

Aggiunto in: v8.4.0

L'evento 'timeout' viene emesso dopo che non viene ricevuta alcuna attività per questo Http2Stream entro il numero di millisecondi impostato utilizzando http2stream.setTimeout(). Il suo listener non si aspetta argomenti.

Evento: 'trailers'

Aggiunto in: v8.4.0

• headers <Oggetto Header HTTP/2> Un oggetto che descrive gli header
• flags <number> I flag numerici associati

L'evento 'trailers' viene emesso quando viene ricevuto un blocco di header associato a campi di header di chiusura. Il callback del listener riceve l'Oggetto Header HTTP/2 e i flag associati agli header.

Questo evento potrebbe non essere emesso se http2stream.end() viene chiamato prima che vengano ricevuti i trailers e i dati in arrivo non vengono letti o ascoltati.

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

Evento: 'wantTrailers'

Aggiunto in: v10.0.0

L'evento 'wantTrailers' viene emesso quando l'oggetto Http2Stream ha accodato l'ultimo frame DATA da inviare su un frame e l'oggetto Http2Stream è pronto a inviare gli header finali. Quando si avvia una richiesta o una risposta, l'opzione waitForTrailers deve essere impostata per far sì che questo evento venga emesso.

http2stream.aborted

Aggiunto in: v8.4.0

• <boolean>

Impostato su true se l'istanza di Http2Stream è stata interrotta in modo anomalo. Quando impostato, l'evento 'aborted' sarà stato emesso.

http2stream.bufferSize

Aggiunto in: v11.2.0, v10.16.0

• <number>

Questa proprietà mostra il numero di caratteri attualmente memorizzati nel buffer per essere scritti. Vedere net.Socket.bufferSize per i dettagli.

http2stream.close(code[, callback])

[Cronologia]

Versione	Modifiche
v18.0.0	Passare una callback non valida all'argomento callback ora genera ERR_INVALID_ARG_TYPE invece di ERR_INVALID_CALLBACK.
v8.4.0	Aggiunto in: v8.4.0

• code <number> Intero a 32 bit senza segno che identifica il codice di errore. Predefinito: http2.constants.NGHTTP2_NO_ERROR (0x00).
• callback <Function> Una funzione opzionale registrata per ascoltare l'evento 'close'.

Chiude l'istanza di Http2Stream inviando un frame RST_STREAM al peer HTTP/2 connesso.

http2stream.closed

Aggiunto in: v9.4.0

• <boolean>

Impostato su true se l'istanza di Http2Stream è stata chiusa.

http2stream.destroyed

Aggiunto in: v8.4.0

• <boolean>

Impostato su true se l'istanza di Http2Stream è stata distrutta e non è più utilizzabile.

http2stream.endAfterHeaders

Aggiunto in: v10.11.0

• <boolean>

Impostato su true se il flag END_STREAM era impostato nel frame HEADERS di richiesta o risposta ricevuto, indicando che non dovrebbero essere ricevuti dati aggiuntivi e il lato leggibile di Http2Stream verrà chiuso.

http2stream.id

Aggiunto in: v8.4.0

• <number> | <undefined>

L'identificatore numerico del flusso di questa istanza Http2Stream. Impostato su undefined se l'identificatore del flusso non è stato ancora assegnato.

http2stream.pending

Aggiunto in: v9.4.0

• <boolean>

Impostato su true se all'istanza Http2Stream non è stato ancora assegnato un identificatore numerico del flusso.

http2stream.priority(options)

Aggiunto in: v8.4.0

• options <Object>
  • exclusive <boolean> Quando true e parent identifica un flusso genitore, questo flusso viene reso l'unica dipendenza diretta del genitore, con tutti gli altri dipendenti esistenti resi dipendenti da questo flusso. Predefinito: false.
  • parent <number> Specifica l'identificatore numerico di un flusso da cui questo flusso dipende.
  • weight <number> Specifica la dipendenza relativa di un flusso rispetto ad altri flussi con lo stesso parent. Il valore è un numero compreso tra 1 e 256 (inclusi).
  • silent <boolean> Quando true, cambia la priorità localmente senza inviare un frame PRIORITY al peer connesso.

Aggiorna la priorità per questa istanza Http2Stream.

http2stream.rstCode

Aggiunto in: v8.4.0

• <number>

Impostato sul codice di errore RST_STREAM segnalato quando l'Http2Stream viene distrutto dopo aver ricevuto un frame RST_STREAM dal peer connesso, aver chiamato http2stream.close() o http2stream.destroy(). Sarà undefined se l'Http2Stream non è stato chiuso.

http2stream.sentHeaders

Aggiunto in: v9.5.0

• <Oggetto Header HTTP/2>

Un oggetto contenente gli header in uscita inviati per questo Http2Stream.

http2stream.sentInfoHeaders

Aggiunto in: v9.5.0

• <Array di Oggetti Header HTTP/2>

Un array di oggetti contenente gli header informativi (aggiuntivi) in uscita inviati per questo Http2Stream.

http2stream.sentTrailers

Aggiunto in: v9.5.0

• <Oggetto Header HTTP/2>

Un oggetto contenente i trailer in uscita inviati per questo HttpStream.

http2stream.session

Aggiunto in: v8.4.0

• <Http2Session>

Un riferimento all'istanza Http2Session proprietaria di questo Http2Stream. Il valore sarà undefined dopo che l'istanza Http2Stream viene distrutta.

http2stream.setTimeout(msecs, callback)

[Cronologia]

Versione	Modifiche
v18.0.0	Il passaggio di un callback non valido all'argomento callback ora genera ERR_INVALID_ARG_TYPE invece di ERR_INVALID_CALLBACK.
v8.4.0	Aggiunto in: v8.4.0

• msecs <number>
• callback <Function>

ESM

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

// Annulla lo stream se non c'è attività dopo 5 secondi
req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL))

CJS

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

// Annulla lo stream se non c'è attività dopo 5 secondi
req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL))

http2stream.state

Aggiunto in: v8.4.0

Fornisce informazioni varie sullo stato corrente di Http2Stream.

• <Oggetto>
  • localWindowSize <numero> Il numero di byte che il peer connesso può inviare per questo Http2Stream senza ricevere un WINDOW_UPDATE.
  • state <numero> Un flag che indica lo stato attuale di basso livello di Http2Stream come determinato da nghttp2.
  • localClose <numero> 1 se questo Http2Stream è stato chiuso localmente.
  • remoteClose <numero> 1 se questo Http2Stream è stato chiuso in remoto.
  • sumDependencyWeight <numero> La somma del peso di tutte le istanze Http2Stream che dipendono da questo Http2Stream come specificato utilizzando i frame PRIORITY.
  • weight <numero> Il peso di priorità di questo Http2Stream.

Uno stato attuale di questo Http2Stream.

http2stream.sendTrailers(headers)

Aggiunto in: v10.0.0

• headers <Oggetto Header HTTP/2>

Invia un frame HEADERS di coda al peer HTTP/2 connesso. Questo metodo causerà la chiusura immediata di Http2Stream e deve essere chiamato solo dopo che l'evento 'wantTrailers' è stato emesso. Quando si invia una richiesta o si invia una risposta, l'opzione options.waitForTrailers deve essere impostata per mantenere Http2Stream aperto dopo l'ultimo frame DATA in modo che i trailer possano essere inviati.

ESM

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

CJS

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

La specifica HTTP/1 vieta ai trailer di contenere campi pseudo-header HTTP/2 (ad es. ':method', ':path', ecc.).

Classe: ClientHttp2Stream

Aggiunto in: v8.4.0

• Estende <Http2Stream>

La classe ClientHttp2Stream è un'estensione di Http2Stream che viene utilizzata esclusivamente sui client HTTP/2. Le istanze di Http2Stream sul client forniscono eventi come 'response' e 'push' che sono rilevanti solo sul client.

Evento: 'continue'

Aggiunto in: v8.5.0

Emesso quando il server invia uno stato 100 Continue, di solito perché la richiesta conteneva Expect: 100-continue. Questa è un'istruzione che indica che il client deve inviare il corpo della richiesta.

Evento: 'headers'

Aggiunto in: v8.4.0

• headers <Oggetto Intestazioni HTTP/2>
• flags <numero>

L'evento 'headers' viene emesso quando viene ricevuto un blocco aggiuntivo di intestazioni per uno stream, ad esempio quando viene ricevuto un blocco di intestazioni informative 1xx. La callback del listener riceve l' Oggetto Intestazioni HTTP/2 e i flag associati alle intestazioni.

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

Evento: 'push'

Aggiunto in: v8.4.0

• headers <Oggetto Intestazioni HTTP/2>
• flags <numero>

L'evento 'push' viene emesso quando vengono ricevute le intestazioni di risposta per uno stream Server Push. La callback del listener riceve l' Oggetto Intestazioni HTTP/2 e i flag associati alle intestazioni.

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

Evento: 'response'

Aggiunto in: v8.4.0

• headers <Oggetto Intestazioni HTTP/2>
• flags <numero>

L'evento 'response' viene emesso quando è stato ricevuto un frame HEADERS di risposta per questo stream dal server HTTP/2 connesso. Il listener viene invocato con due argomenti: un Oggetto contenente l' Oggetto Intestazioni HTTP/2 ricevuto e i flag associati alle intestazioni.

ESM

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

CJS

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

Classe: ServerHttp2Stream

Aggiunto in: v8.4.0

• Estende: <Http2Stream>

La classe ServerHttp2Stream è un'estensione di Http2Stream che viene utilizzata esclusivamente sui server HTTP/2. Le istanze Http2Stream sul server forniscono metodi aggiuntivi come http2stream.pushStream() e http2stream.respond() che sono rilevanti solo sul server.

http2stream.additionalHeaders(headers)

Aggiunto in: v8.4.0

• headers <Oggetto di intestazioni HTTP/2>

Invia un frame HEADERS informativo aggiuntivo al peer HTTP/2 connesso.

http2stream.headersSent

Aggiunto in: v8.4.0

• <boolean>

Vero se le intestazioni sono state inviate, falso altrimenti (sola lettura).

http2stream.pushAllowed

Aggiunto in: v8.4.0

• <boolean>

Proprietà di sola lettura mappata al flag SETTINGS_ENABLE_PUSH del frame SETTINGS più recente del client remoto. Sarà true se il peer remoto accetta flussi push, false altrimenti. Le impostazioni sono le stesse per ogni Http2Stream nella stessa Http2Session.

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

[Cronologia]

Versione	Modifiche
v18.0.0	Il passaggio di un callback non valido all'argomento callback ora genera ERR_INVALID_ARG_TYPE anziché ERR_INVALID_CALLBACK.
v8.4.0	Aggiunto in: v8.4.0

• headers <Oggetto di intestazioni HTTP/2>

• options <Oggetto>

  • exclusive <boolean> Quando true e parent identifica uno Stream padre, il flusso creato diventa l'unica dipendenza diretta del padre, con tutte le altre dipendenze esistenti che diventano dipendenti del flusso appena creato. Predefinito: false.
  • parent <numero> Specifica l'identificatore numerico di uno stream da cui dipende il nuovo stream creato.

• callback <Funzione> Callback che viene chiamato una volta che il flusso push è stato avviato.

  • err <Errore>
  • pushStream <ServerHttp2Stream> L'oggetto pushStream restituito.
  • headers <Oggetto di intestazioni HTTP/2> Oggetto di intestazioni con cui è stato avviato pushStream.

Avvia un flusso push. Il callback viene richiamato con la nuova istanza Http2Stream creata per il flusso push passata come secondo argomento, o un Errore passato come primo argomento.

ESM

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

CJS

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

Non è consentito impostare il peso di un flusso push nel frame HEADERS. Passa un valore weight a http2stream.priority con l'opzione silent impostata su true per abilitare il bilanciamento della larghezza di banda lato server tra flussi simultanei.

La chiamata a http2stream.pushStream() dall'interno di un flusso push non è consentita e genererà un errore.

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

[Cronologia]

Versione	Modifiche
v14.5.0, v12.19.0	Consenti di impostare esplicitamente le intestazioni della data.
v8.4.0	Aggiunto in: v8.4.0

• headers <Oggetto Intestazioni HTTP/2>
• options <Oggetto>
  • endStream <boolean> Impostato su true per indicare che la risposta non includerà dati payload.
  • waitForTrailers <boolean> Quando è true, l'Http2Stream emetterà l'evento 'wantTrailers' dopo che l'ultimo frame DATA è stato inviato.

ESM

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

CJS

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

Avvia una risposta. Quando l'opzione options.waitForTrailers è impostata, l'evento 'wantTrailers' verrà emesso immediatamente dopo aver accodato l'ultimo blocco di dati payload da inviare. Il metodo http2stream.sendTrailers() può quindi essere utilizzato per inviare campi di intestazione di chiusura al peer.

Quando options.waitForTrailers è impostato, l'Http2Stream non si chiuderà automaticamente quando viene trasmesso l'ultimo frame DATA. Il codice utente deve chiamare http2stream.sendTrailers() o http2stream.close() per chiudere l'Http2Stream.

ESM

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

CJS

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

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

[Cronologia]

Versione	Modifiche
v14.5.0, v12.19.0	Consente l'impostazione esplicita delle intestazioni di data.
v12.12.0	L'opzione fd ora può essere un FileHandle.
v10.0.0	Qualsiasi descrittore di file leggibile, non necessariamente per un file normale, è ora supportato.
v8.4.0	Aggiunto in: v8.4.0

• fd <number> | <FileHandle> Un descrittore di file leggibile.
• headers <Oggetto Intestazioni HTTP/2>
• options <Object>
  • statCheck <Function>
  • waitForTrailers <boolean> Quando è true, Http2Stream emetterà l'evento 'wantTrailers' dopo l'invio del frame DATA finale.
  • offset <number> La posizione di offset da cui iniziare la lettura.
  • length <number> La quantità di dati da inviare dal fd.

Inizia una risposta i cui dati vengono letti dal descrittore di file specificato. Non viene eseguita alcuna convalida sul descrittore di file specificato. Se si verifica un errore durante il tentativo di leggere i dati utilizzando il descrittore di file, l'Http2Stream verrà chiuso utilizzando un frame RST_STREAM con il codice standard INTERNAL_ERROR.

Quando utilizzato, l'interfaccia Duplex dell'oggetto Http2Stream verrà chiusa automaticamente.

ESM

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

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

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

CJS

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

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

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

La funzione options.statCheck opzionale può essere specificata per dare al codice utente l'opportunità di impostare ulteriori intestazioni di contenuto in base ai dettagli fs.Stat del fd specificato. Se viene fornita la funzione statCheck, il metodo http2stream.respondWithFD() eseguirà una chiamata fs.fstat() per raccogliere i dettagli sul descrittore di file fornito.

Le opzioni offset e length possono essere utilizzate per limitare la risposta a un sottoinsieme di intervallo specifico. Questo può essere utilizzato, ad esempio, per supportare le richieste di intervallo HTTP.

Il descrittore di file o FileHandle non viene chiuso quando il flusso viene chiuso, quindi dovrà essere chiuso manualmente una volta che non è più necessario. L'utilizzo dello stesso descrittore di file in contemporanea per più flussi non è supportato e potrebbe causare la perdita di dati. Il riutilizzo di un descrittore di file dopo che un flusso è terminato è supportato.

Quando l'opzione options.waitForTrailers è impostata, l'evento 'wantTrailers' verrà emesso immediatamente dopo aver accodato l'ultimo chunk di dati del payload da inviare. Il metodo http2stream.sendTrailers() può quindi essere utilizzato per inviare i campi di intestazione finali al peer.

Quando options.waitForTrailers è impostato, Http2Stream non si chiuderà automaticamente quando viene trasmesso il frame DATA finale. Il codice utente deve chiamare http2stream.sendTrailers() o http2stream.close() per chiudere Http2Stream.

ESM

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

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

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

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

CJS

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

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

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

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

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

[Cronologia]

Versione	Modifiche
v14.5.0, v12.19.0	Consenti l'impostazione esplicita delle intestazioni della data.
v10.0.0	Qualsiasi file leggibile, non necessariamente un file regolare, è ora supportato.
v8.4.0	Aggiunto in: v8.4.0

• path <string> | <Buffer> | <URL>
• headers <Oggetto Intestazioni HTTP/2>
• options <Oggetto>
  • statCheck <Funzione>
  • onError <Funzione> Funzione di callback invocata in caso di errore prima dell'invio.
  • waitForTrailers <boolean> Quando true, l'Http2Stream emetterà l'evento 'wantTrailers' dopo l'invio dell'ultimo frame DATA.
  • offset <numero> La posizione di offset da cui iniziare la lettura.
  • length <numero> La quantità di dati dal fd da inviare.

Invia un file regolare come risposta. Il path deve specificare un file regolare oppure verrà emesso un evento 'error' sull'oggetto Http2Stream.

Quando utilizzato, l'interfaccia Duplex dell'oggetto Http2Stream verrà chiusa automaticamente.

La funzione options.statCheck opzionale può essere specificata per dare al codice utente l'opportunità di impostare ulteriori intestazioni di contenuto in base ai dettagli fs.Stat del file specificato:

Se si verifica un errore durante il tentativo di lettura dei dati del file, l'Http2Stream verrà chiuso utilizzando un frame RST_STREAM con il codice standard INTERNAL_ERROR. Se è definita la callback onError, verrà chiamata. Altrimenti lo stream verrà distrutto.

Esempio che utilizza un percorso file:

ESM

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

  function onError(err) {
    // stream.respond() può generare un'eccezione se lo stream è stato distrutto dall'altra parte.
    try {
      if (err.code === 'ENOENT') {
        stream.respond({ ':status': 404 })
      } else {
        stream.respond({ ':status': 500 })
      }
    } catch (err) {
      // Eseguire la gestione effettiva degli errori.
      console.error(err)
    }
    stream.end()
  }

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

CJS

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

  function onError(err) {
    // stream.respond() può generare un'eccezione se lo stream è stato distrutto dall'altra parte.
    try {
      if (err.code === 'ENOENT') {
        stream.respond({ ':status': 404 })
      } else {
        stream.respond({ ':status': 500 })
      }
    } catch (err) {
      // Eseguire la gestione effettiva degli errori.
      console.error(err)
    }
    stream.end()
  }

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

La funzione options.statCheck può anche essere utilizzata per annullare l'operazione di invio restituendo false. Ad esempio, una richiesta condizionale può controllare i risultati di stato per determinare se il file è stato modificato e restituire una risposta 304 appropriata:

ESM

import { createServer } from 'node:http2'
const server = createServer()
server.on('stream', stream => {
  function statCheck(stat, headers) {
    // Controlla lo stato qui...
    stream.respond({ ':status': 304 })
    return false // Annulla l'operazione di invio
  }
  stream.respondWithFile('/some/file', { 'content-type': 'text/plain; charset=utf-8' }, { statCheck })
})

CJS

const http2 = require('node:http2')
const server = http2.createServer()
server.on('stream', stream => {
  function statCheck(stat, headers) {
    // Controlla lo stato qui...
    stream.respond({ ':status': 304 })
    return false // Annulla l'operazione di invio
  }
  stream.respondWithFile('/some/file', { 'content-type': 'text/plain; charset=utf-8' }, { statCheck })
})

Il campo di intestazione content-length verrà impostato automaticamente.

Le opzioni offset e length possono essere utilizzate per limitare la risposta a un sottoinsieme di intervalli specifici. Questo può essere utilizzato, ad esempio, per supportare le richieste di intervalli HTTP.

La funzione options.onError può anche essere utilizzata per gestire tutti gli errori che potrebbero verificarsi prima che venga avviata la consegna del file. Il comportamento predefinito è distruggere lo stream.

Quando l'opzione options.waitForTrailers è impostata, l'evento 'wantTrailers' verrà emesso immediatamente dopo aver accodato l'ultimo blocco di dati del payload da inviare. Il metodo http2stream.sendTrailers() può quindi essere utilizzato per inviare campi di intestazione di coda al peer.

Quando options.waitForTrailers è impostato, l'Http2Stream non si chiuderà automaticamente quando viene trasmesso l'ultimo frame DATA. Il codice utente deve chiamare http2stream.sendTrailers() o http2stream.close() per chiudere l'Http2Stream.

ESM

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

CJS

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

Classe: Http2Server

Aggiunto in: v8.4.0

• Estende: <net.Server>

Le istanze di Http2Server vengono create utilizzando la funzione http2.createServer(). La classe Http2Server non viene esportata direttamente dal modulo node:http2.

Evento: 'checkContinue'

Aggiunto in: v8.5.0

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

Se viene registrato un listener 'request' o se a http2.createServer() viene fornita una funzione di callback, l'evento 'checkContinue' viene emesso ogni volta che viene ricevuta una richiesta con un HTTP Expect: 100-continue. Se questo evento non viene ascoltato, il server risponderà automaticamente con uno stato 100 Continue in modo appropriato.

La gestione di questo evento implica la chiamata di response.writeContinue() se il client deve continuare a inviare il corpo della richiesta, oppure la generazione di una risposta HTTP appropriata (ad es. 400 Bad Request) se il client non deve continuare a inviare il corpo della richiesta.

Quando questo evento viene emesso e gestito, l'evento 'request' non verrà emesso.

Evento: 'connection'

Aggiunto in: v8.4.0

• socket <stream.Duplex>

Questo evento viene emesso quando viene stabilito un nuovo flusso TCP. socket è in genere un oggetto di tipo net.Socket. Di solito gli utenti non vorranno accedere a questo evento.

Questo evento può anche essere emesso esplicitamente dagli utenti per iniettare connessioni nel server HTTP. In tal caso, può essere passato qualsiasi flusso Duplex.

Evento: 'request'

Aggiunto in: v8.4.0

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

Emesso ogni volta che c'è una richiesta. Potrebbero esserci più richieste per sessione. Vedere l'API di compatibilità.

Event: 'session'

Aggiunto in: v8.4.0

• session <ServerHttp2Session>

L'evento 'session' viene emesso quando una nuova Http2Session viene creata da Http2Server.

Event: 'sessionError'

Aggiunto in: v8.4.0

• error <Error>
• session <ServerHttp2Session>

L'evento 'sessionError' viene emesso quando un evento 'error' viene emesso da un oggetto Http2Session associato a Http2Server.

Event: 'stream'

Aggiunto in: v8.4.0

• stream <Http2Stream> Un riferimento allo stream
• headers <Oggetto Header HTTP/2> Un oggetto che descrive gli header
• flags <number> I flag numerici associati
• rawHeaders <Array> Un array contenente i nomi degli header non elaborati seguiti dai rispettivi valori.

L'evento 'stream' viene emesso quando un evento 'stream' è stato emesso da una Http2Session associata al server.

Vedi anche l'evento 'stream' di Http2Session.

ESM

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

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

CJS

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

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

Evento: 'timeout'

[Cronologia]

Versione	Modifiche
v13.0.0	Il timeout predefinito è cambiato da 120 secondi a 0 (nessun timeout).
v8.4.0	Aggiunto in: v8.4.0

L'evento 'timeout' viene emesso quando non c'è attività sul Server per un determinato numero di millisecondi impostato utilizzando http2server.setTimeout(). Predefinito: 0 (nessun timeout)

server.close([callback])

Aggiunto in: v8.4.0

• callback <Funzione>

Impedisce al server di stabilire nuove sessioni. Ciò non impedisce la creazione di nuovi flussi di richieste a causa della natura persistente delle sessioni HTTP/2. Per arrestare correttamente il server, chiama http2session.close() su tutte le sessioni attive.

Se callback viene fornito, non viene richiamato finché tutte le sessioni attive non sono state chiuse, sebbene il server abbia già smesso di consentire nuove sessioni. Per maggiori dettagli, vedere net.Server.close().

server[Symbol.asyncDispose]()

Aggiunto in: v20.4.0

[Stabile: 1 - Sperimentale]

Stabile: 1 Stabilità: 1 - Sperimentale

Chiama server.close() e restituisce una promise che viene soddisfatta quando il server è stato chiuso.

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

[Cronologia]

Versione	Modifiche
v18.0.0	Il passaggio di una callback non valida all'argomento callback ora genera ERR_INVALID_ARG_TYPE anziché ERR_INVALID_CALLBACK.
v13.0.0	Il timeout predefinito è cambiato da 120 secondi a 0 (nessun timeout).
v8.4.0	Aggiunto in: v8.4.0

• msecs <numero> Predefinito: 0 (nessun timeout)
• callback <Funzione>
• Restituisce: <Http2Server>

Utilizzato per impostare il valore di timeout per le richieste del server http2 e imposta una funzione di callback che viene chiamata quando non c'è attività sull'Http2Server dopo msecs millisecondi.

La callback fornita viene registrata come listener sull'evento 'timeout'.

Nel caso in cui callback non sia una funzione, verrà generato un nuovo errore ERR_INVALID_ARG_TYPE.

server.timeout

[Cronologia]

Versione	Cambiamenti
v13.0.0	Il timeout predefinito è cambiato da 120 secondi a 0 (nessun timeout).
v8.4.0	Aggiunto in: v8.4.0

• <numero> Timeout in millisecondi. Predefinito: 0 (nessun timeout)

Il numero di millisecondi di inattività prima che si presuma che un socket sia scaduto.

Un valore di 0 disabiliterà il comportamento di timeout sulle connessioni in entrata.

La logica del timeout del socket viene impostata alla connessione, quindi la modifica di questo valore influisce solo sulle nuove connessioni al server, non sulle connessioni esistenti.

server.updateSettings([settings])

Aggiunto in: v15.1.0, v14.17.0

• settings <Oggetto Impostazioni HTTP/2>

Usato per aggiornare il server con le impostazioni fornite.

Genera ERR_HTTP2_INVALID_SETTING_VALUE per valori settings non validi.

Genera ERR_INVALID_ARG_TYPE per un argomento settings non valido.

Classe: Http2SecureServer

Aggiunto in: v8.4.0

• Estende: <tls.Server>

Le istanze di Http2SecureServer vengono create utilizzando la funzione http2.createSecureServer(). La classe Http2SecureServer non viene esportata direttamente dal modulo node:http2.

Evento: 'checkContinue'

Aggiunto in: v8.5.0

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

Se un listener 'request' è registrato o se http2.createSecureServer() viene fornita una funzione di callback, l'evento 'checkContinue' viene emesso ogni volta che viene ricevuta una richiesta con un HTTP Expect: 100-continue. Se questo evento non viene ascoltato, il server risponderà automaticamente con uno stato 100 Continue come appropriato.

La gestione di questo evento implica la chiamata a response.writeContinue() se il client deve continuare a inviare il corpo della richiesta, o la generazione di una risposta HTTP appropriata (es. 400 Bad Request) se il client non deve continuare a inviare il corpo della richiesta.

Quando questo evento viene emesso e gestito, l'evento 'request' non verrà emesso.

Evento: 'connection'

Aggiunto in: v8.4.0

• socket <stream.Duplex>

Questo evento viene emesso quando viene stabilito un nuovo flusso TCP, prima che inizi l'handshake TLS. socket è in genere un oggetto di tipo net.Socket. Solitamente gli utenti non desiderano accedere a questo evento.

Questo evento può anche essere emesso esplicitamente dagli utenti per iniettare connessioni nel server HTTP. In tal caso, può essere passato qualsiasi flusso Duplex.

Evento: 'request'

Aggiunto in: v8.4.0

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

Emesso ogni volta che c'è una richiesta. Ci possono essere più richieste per sessione. Vedere l'API di compatibilità.

Evento: 'session'

Aggiunto in: v8.4.0

• session <ServerHttp2Session>

L'evento 'session' viene emesso quando un nuovo Http2Session viene creato dall'Http2SecureServer.

Evento: 'sessionError'

Aggiunto in: v8.4.0

• error <Error>
• session <ServerHttp2Session>

L'evento 'sessionError' viene emesso quando un evento 'error' viene emesso da un oggetto Http2Session associato all'Http2SecureServer.

Evento: 'stream'

Aggiunto in: v8.4.0

• stream <Http2Stream> Un riferimento al flusso
• headers <Oggetto di intestazioni HTTP/2> Un oggetto che descrive le intestazioni
• flags <numero> I flag numerici associati
• rawHeaders <Array> Un array contenente i nomi delle intestazioni grezze seguiti dai rispettivi valori.

L'evento 'stream' viene emesso quando un evento 'stream' è stato emesso da un Http2Session associato al server.

Vedere anche l'evento 'stream' di Http2Session.

ESM

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

const options = getOptionsSomehow()

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

CJS

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

const options = getOptionsSomehow()

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

Evento: 'timeout'

Aggiunto in: v8.4.0

L'evento 'timeout' viene emesso quando non c'è attività sul Server per un determinato numero di millisecondi impostato tramite http2secureServer.setTimeout(). Predefinito: 2 minuti.

Evento: 'unknownProtocol'

[Cronologia]

Versione	Modifiche
v19.0.0	Questo evento verrà emesso solo se il client non ha trasmesso un'estensione ALPN durante l'handshake TLS.
v8.4.0	Aggiunto in: v8.4.0

• socket <stream.Duplex>

L'evento 'unknownProtocol' viene emesso quando un client che si connette non riesce a negoziare un protocollo consentito (ovvero HTTP/2 o HTTP/1.1). L'handler dell'evento riceve il socket per la gestione. Se non è registrato alcun listener per questo evento, la connessione viene terminata. È possibile specificare un timeout utilizzando l'opzione 'unknownProtocolTimeout' passata a http2.createSecureServer().

Nelle versioni precedenti di Node.js, questo evento veniva emesso se allowHTTP1 era false e, durante l'handshake TLS, il client non inviava un'estensione ALPN o inviava un'estensione ALPN che non includeva HTTP/2 (h2). Le versioni più recenti di Node.js emettono questo evento solo se allowHTTP1 è false e il client non invia un'estensione ALPN. Se il client invia un'estensione ALPN che non include HTTP/2 (o HTTP/1.1 se allowHTTP1 è true), l'handshake TLS fallirà e non verrà stabilita alcuna connessione sicura.

Vedere l'API di compatibilità.

server.close([callback])

Aggiunto in: v8.4.0

• callback <Function>

Impedisce al server di stabilire nuove sessioni. Ciò non impedisce la creazione di nuovi flussi di richiesta a causa della natura persistente delle sessioni HTTP/2. Per arrestare correttamente il server, chiamare http2session.close() su tutte le sessioni attive.

Se viene fornito callback, non viene richiamato fino a quando tutte le sessioni attive non sono state chiuse, sebbene il server abbia già smesso di consentire nuove sessioni. Vedere tls.Server.close() per maggiori dettagli.

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

[Cronologia]

Versione	Modifiche
v18.0.0	Il passaggio di un callback non valido all'argomento callback ora genera ERR_INVALID_ARG_TYPE invece di ERR_INVALID_CALLBACK.
v8.4.0	Aggiunto in: v8.4.0

• msecs <number> Predefinito: 120000 (2 minuti)
• callback <Function>
• Restituisce: <Http2SecureServer>

Utilizzato per impostare il valore di timeout per le richieste del server protetto http2 e imposta una funzione di callback che viene chiamata quando non c'è attività sull'Http2SecureServer dopo msecs millisecondi.

Il callback fornito viene registrato come listener sull'evento 'timeout'.

Nel caso in cui callback non sia una funzione, verrà generato un nuovo errore ERR_INVALID_ARG_TYPE.

server.timeout

[Cronologia]

Versione	Modifiche
v13.0.0	Il timeout predefinito è cambiato da 120s a 0 (nessun timeout).
v8.4.0	Aggiunto in: v8.4.0

• <number> Timeout in millisecondi. Predefinito: 0 (nessun timeout)

Il numero di millisecondi di inattività prima che si presuma che un socket abbia raggiunto il timeout.

Un valore di 0 disabiliterà il comportamento di timeout sulle connessioni in entrata.

La logica del timeout del socket viene impostata sulla connessione, quindi la modifica di questo valore influisce solo sulle nuove connessioni al server, non su quelle esistenti.

server.updateSettings([settings])

Aggiunto in: v15.1.0, v14.17.0

• settings <Oggetto Impostazioni HTTP/2>

Utilizzato per aggiornare il server con le impostazioni fornite.

Genera ERR_HTTP2_INVALID_SETTING_VALUE per valori settings non validi.

Genera ERR_INVALID_ARG_TYPE per argomento settings non valido.

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

[Cronologia]

Versione	Modifiche
v23.0.0	Aggiunti streamResetBurst e streamResetRate.
v13.0.0	Il PADDING_STRATEGY_CALLBACK è stato reso equivalente alla fornitura di PADDING_STRATEGY_ALIGNED ed è stato rimosso selectPadding.
v13.3.0, v12.16.0	Aggiunta l'opzione maxSessionRejectedStreams con un valore predefinito di 100.
v13.3.0, v12.16.0	Aggiunta l'opzione maxSessionInvalidFrames con un valore predefinito di 1000.
v12.4.0	Il parametro options ora supporta le opzioni di net.createServer().
v15.10.0, v14.16.0, v12.21.0, v10.24.0	Aggiunta l'opzione unknownProtocolTimeout con un valore predefinito di 10000.
v14.4.0, v12.18.0, v10.21.0	Aggiunta l'opzione maxSettings con un valore predefinito di 32.
v9.6.0	Aggiunta l'opzione Http1IncomingMessage e Http1ServerResponse.
v8.9.3	Aggiunta l'opzione maxOutstandingPings con un limite predefinito di 10.
v8.9.3	Aggiunta l'opzione maxHeaderListPairs con un limite predefinito di 128 coppie di header.
v8.4.0	Aggiunto in: v8.4.0

• options <Oggetto>
  • maxDeflateDynamicTableSize <number> Imposta la dimensione massima della tabella dinamica per la deflazione dei campi header. Predefinito: 4Kib.
  • maxSettings <number> Imposta il numero massimo di voci di impostazioni per frame SETTINGS. Il valore minimo consentito è 1. Predefinito: 32.
  • maxSessionMemory<number> Imposta la memoria massima che Http2Session è autorizzata a utilizzare. Il valore è espresso in termini di numero di megabyte, ad es. 1 uguale a 1 megabyte. Il valore minimo consentito è 1. Questo è un limite basato sul credito, le Http2Stream esistenti possono causare il superamento di questo limite, ma le nuove istanze Http2Stream verranno rifiutate finché questo limite viene superato. Il numero corrente di sessioni Http2Stream, l'uso corrente della memoria delle tabelle di compressione degli header, i dati correnti in coda per essere inviati e i frame PING e SETTINGS non riconosciuti sono tutti conteggiati nel limite corrente. Predefinito: 10.
  • maxHeaderListPairs <number> Imposta il numero massimo di voci di header. Questo è simile a server.maxHeadersCount o request.maxHeadersCount nel modulo node:http. Il valore minimo è 4. Predefinito: 128.
  • maxOutstandingPings <number> Imposta il numero massimo di ping in sospeso e non riconosciuti. Predefinito: 10.
  • maxSendHeaderBlockLength <number> Imposta la dimensione massima consentita per un blocco serializzato e compresso di header. I tentativi di inviare header che superano questo limite comporteranno l'emissione di un evento 'frameError' e la chiusura e l'eliminazione dello stream. Mentre questo imposta la dimensione massima consentita per l'intero blocco di header, nghttp2 (la libreria http2 interna) ha un limite di 65536 per ogni coppia chiave/valore decompressa.
  • paddingStrategy <number> La strategia utilizzata per determinare la quantità di padding da utilizzare per i frame HEADERS e DATA. Predefinito: http2.constants.PADDING_STRATEGY_NONE. Il valore può essere uno dei seguenti:
  • http2.constants.PADDING_STRATEGY_NONE: non viene applicato alcun padding.
  • http2.constants.PADDING_STRATEGY_MAX: viene applicata la quantità massima di padding, determinata dall'implementazione interna.
  • http2.constants.PADDING_STRATEGY_ALIGNED: tenta di applicare un padding sufficiente per garantire che la lunghezza totale del frame, incluso l'header di 9 byte, sia un multiplo di 8. Per ciascun frame, esiste un numero massimo consentito di byte di padding che è determinato dallo stato e dalle impostazioni correnti del controllo del flusso. Se questo massimo è inferiore alla quantità calcolata necessaria per garantire l'allineamento, viene utilizzato il massimo e la lunghezza totale del frame non è necessariamente allineata a 8 byte.
  • peerMaxConcurrentStreams <number> Imposta il numero massimo di stream simultanei per il peer remoto come se fosse stato ricevuto un frame SETTINGS. Verrà sovrascritto se il peer remoto imposta il proprio valore per maxConcurrentStreams. Predefinito: 100.
  • maxSessionInvalidFrames <integer> Imposta il numero massimo di frame non validi che verranno tollerati prima che la sessione venga chiusa. Predefinito: 1000.
  • maxSessionRejectedStreams <integer> Imposta il numero massimo di stream rifiutati alla creazione che verranno tollerati prima che la sessione venga chiusa. Ogni rifiuto è associato a un errore NGHTTP2_ENHANCE_YOUR_CALM che dovrebbe indicare al peer di non aprire ulteriori stream, continuare ad aprire stream è quindi considerato un segno di un peer che si comporta in modo scorretto. Predefinito: 100.
  • settings <Oggetto Impostazioni HTTP/2> Le impostazioni iniziali da inviare al peer remoto al momento della connessione.
  • streamResetBurst <number> e streamResetRate <number> Imposta il limite di velocità per il reset dello stream in entrata (frame RST_STREAM). Entrambe le impostazioni devono essere impostate per avere un effetto e per impostazione predefinita sono rispettivamente 1000 e 33.
  • remoteCustomSettings <Array> L'array di valori interi determina i tipi di impostazioni, che sono inclusi nella proprietà CustomSettings delle impostazioni remote ricevute. Fare riferimento alla proprietà CustomSettings dell'oggetto Http2Settings per ulteriori informazioni sui tipi di impostazioni consentiti.
  • Http1IncomingMessage <http.IncomingMessage> Specifica la classe IncomingMessage da utilizzare per il fallback HTTP/1. Utile per estendere l'originale http.IncomingMessage. Predefinito: http.IncomingMessage.
  • Http1ServerResponse <http.ServerResponse> Specifica la classe ServerResponse da utilizzare per il fallback HTTP/1. Utile per estendere l'originale http.ServerResponse. Predefinito: http.ServerResponse.
  • Http2ServerRequest <http2.Http2ServerRequest> Specifica la classe Http2ServerRequest da utilizzare. Utile per estendere l'originale Http2ServerRequest. Predefinito: Http2ServerRequest.
  • Http2ServerResponse <http2.Http2ServerResponse> Specifica la classe Http2ServerResponse da utilizzare. Utile per estendere l'originale Http2ServerResponse. Predefinito: Http2ServerResponse.
  • unknownProtocolTimeout <number> Specifica un timeout in millisecondi che un server dovrebbe attendere quando viene emesso un 'unknownProtocol'. Se il socket non è stato distrutto entro tale termine, il server lo distruggerà. Predefinito: 10000.
  • ...: È possibile fornire qualsiasi opzione net.createServer().
• onRequestHandler <Function> Vedi API di compatibilità
• Restituisce: <Http2Server>

Restituisce un'istanza net.Server che crea e gestisce le istanze Http2Session.

Poiché non si conoscono browser che supportano HTTP/2 non crittografato, l'uso di http2.createSecureServer() è necessario quando si comunica con i client browser.

ESM

import { createServer } from 'node:http2'

// Crea un server HTTP/2 non crittografato.
// Poiché non si conoscono browser che supportano
// HTTP/2 non crittografato, l'uso di `createSecureServer()`
// è necessario quando si comunica con i client browser.
const server = createServer()

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

server.listen(8000)

CJS

const http2 = require('node:http2')

// Crea un server HTTP/2 non crittografato.
// Poiché non si conoscono browser che supportano
// HTTP/2 non crittografato, l'uso di `http2.createSecureServer()`
// è necessario quando si comunica con i client browser.
const server = http2.createServer()

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

server.listen(8000)

http2.createSecureServer(options[, onRequestHandler])

[Cronologia]

Versione	Modifiche
v13.0.0	La PADDING_STRATEGY_CALLBACK è stata resa equivalente alla fornitura di PADDING_STRATEGY_ALIGNED e selectPadding è stata rimossa.
v13.3.0, v12.16.0	Aggiunta l'opzione maxSessionRejectedStreams con un valore predefinito di 100.
v13.3.0, v12.16.0	Aggiunta l'opzione maxSessionInvalidFrames con un valore predefinito di 1000.
v15.10.0, v14.16.0, v12.21.0, v10.24.0	Aggiunta l'opzione unknownProtocolTimeout con un valore predefinito di 10000.
v14.4.0, v12.18.0, v10.21.0	Aggiunta l'opzione maxSettings con un valore predefinito di 32.
v10.12.0	Aggiunta l'opzione origins per inviare automaticamente un frame ORIGIN all'avvio di Http2Session.
v8.9.3	Aggiunta l'opzione maxOutstandingPings con un limite predefinito di 10.
v8.9.3	Aggiunta l'opzione maxHeaderListPairs con un limite predefinito di 128 coppie di header.
v8.4.0	Aggiunta in: v8.4.0

• options <Object>
  • allowHTTP1 <boolean> Le connessioni client in ingresso che non supportano HTTP/2 verranno declassate a HTTP/1.x quando impostato su true. Vedere l'evento 'unknownProtocol'. Vedere negoziazione ALPN. Predefinito: false.
  • maxDeflateDynamicTableSize <number> Imposta la dimensione massima della tabella dinamica per la decompressione dei campi header. Predefinito: 4Kib.
  • maxSettings <number> Imposta il numero massimo di voci di impostazioni per frame SETTINGS. Il valore minimo consentito è 1. Predefinito: 32.
  • maxSessionMemory<number> Imposta la memoria massima che Http2Session può utilizzare. Il valore è espresso in megabyte, ad es. 1 equivale a 1 megabyte. Il valore minimo consentito è 1. Questo è un limite basato sul credito, le Http2Stream esistenti potrebbero far superare questo limite, ma le nuove istanze di Http2Stream verranno rifiutate mentre questo limite viene superato. Il numero corrente di sessioni Http2Stream, l'uso corrente della memoria delle tabelle di compressione degli header, i dati correnti in coda per essere inviati e i frame PING e SETTINGS non riconosciuti sono tutti conteggiati ai fini del limite corrente. Predefinito: 10.
  • maxHeaderListPairs <number> Imposta il numero massimo di voci di header. Questo è simile a server.maxHeadersCount o request.maxHeadersCount nel modulo node:http. Il valore minimo è 4. Predefinito: 128.
  • maxOutstandingPings <number> Imposta il numero massimo di ping in sospeso non riconosciuti. Predefinito: 10.
  • maxSendHeaderBlockLength <number> Imposta la dimensione massima consentita per un blocco serializzato e compresso di header. I tentativi di inviare header che superano questo limite comporteranno l'emissione di un evento 'frameError' e la chiusura e la distruzione dello stream.
  • paddingStrategy <number> Strategia utilizzata per determinare la quantità di padding da utilizzare per i frame HEADERS e DATA. Predefinito: http2.constants.PADDING_STRATEGY_NONE. Il valore può essere uno tra:
    • http2.constants.PADDING_STRATEGY_NONE: Non viene applicato alcun padding.
    • http2.constants.PADDING_STRATEGY_MAX: Viene applicata la quantità massima di padding, determinata dall'implementazione interna.
    • http2.constants.PADDING_STRATEGY_ALIGNED: Tenta di applicare una quantità di padding sufficiente per garantire che la lunghezza totale del frame, incluso l'header di 9 byte, sia un multiplo di 8. Per ogni frame, esiste un numero massimo consentito di byte di padding che viene determinato dallo stato e dalle impostazioni correnti del controllo di flusso. Se questo massimo è inferiore alla quantità calcolata necessaria per garantire l'allineamento, viene utilizzato il massimo e la lunghezza totale del frame non è necessariamente allineata a 8 byte.
  • peerMaxConcurrentStreams <number> Imposta il numero massimo di stream concorrenti per il peer remoto come se fosse stato ricevuto un frame SETTINGS. Verrà sovrascritto se il peer remoto imposta il proprio valore per maxConcurrentStreams. Predefinito: 100.
  • maxSessionInvalidFrames <integer> Imposta il numero massimo di frame non validi che saranno tollerati prima della chiusura della sessione. Predefinito: 1000.
  • maxSessionRejectedStreams <integer> Imposta il numero massimo di stream rifiutati alla creazione che saranno tollerati prima della chiusura della sessione. Ogni rifiuto è associato a un errore NGHTTP2_ENHANCE_YOUR_CALM che dovrebbe indicare al peer di non aprire altri stream, continuare ad aprire stream è quindi considerato un segno di un peer che si comporta in modo anomalo. Predefinito: 100.
  • settings <Oggetto Impostazioni HTTP/2> Le impostazioni iniziali da inviare al peer remoto al momento della connessione.
  • remoteCustomSettings <Array> L'array di valori interi determina i tipi di impostazioni, che sono inclusi nella proprietà customSettings delle remoteSettings ricevute. Per maggiori informazioni, consultare la proprietà customSettings dell'oggetto Http2Settings, sui tipi di impostazioni consentiti.
  • ...: È possibile fornire qualsiasi opzione tls.createServer(). Per i server, le opzioni di identità (pfx o key/cert) sono solitamente richieste.
  • origins <string[]> Un array di stringhe di origine da inviare all'interno di un frame ORIGIN immediatamente dopo la creazione di una nuova Http2Session del server.
  • unknownProtocolTimeout <number> Specifica un timeout in millisecondi che un server deve attendere quando viene emesso un evento 'unknownProtocol'. Se il socket non è stato distrutto entro tale termine, il server lo distruggerà. Predefinito: 10000.
• onRequestHandler <Function> Vedere API di compatibilità
• Restituisce: <Http2SecureServer>

Restituisce un'istanza tls.Server che crea e gestisce istanze Http2Session.

ESM

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

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

// Crea un server HTTP/2 sicuro
const server = createSecureServer(options)

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

server.listen(8443)

CJS

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

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

// Crea un server HTTP/2 sicuro
const server = http2.createSecureServer(options)

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

server.listen(8443)

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

[Cronologia]

Versione	Cambiamenti
v13.0.0	La PADDING_STRATEGY_CALLBACK è stata resa equivalente alla fornitura di PADDING_STRATEGY_ALIGNED e selectPadding è stata rimossa.
v15.10.0, v14.16.0, v12.21.0, v10.24.0	Aggiunta l'opzione unknownProtocolTimeout con un valore predefinito di 10000.
v14.4.0, v12.18.0, v10.21.0	Aggiunta l'opzione maxSettings con un valore predefinito di 32.
v8.9.3	Aggiunta l'opzione maxOutstandingPings con un limite predefinito di 10.
v8.9.3	Aggiunta l'opzione maxHeaderListPairs con un limite predefinito di 128 coppie di intestazioni.
v8.4.0	Aggiunto in: v8.4.0

• authority <stringa> | <URL> Il server HTTP/2 remoto a cui connettersi. Deve essere nella forma di un URL minimo e valido con il prefisso http:// o https://, il nome host e la porta IP (se viene utilizzata una porta non predefinita). Le informazioni utente (ID utente e password), il percorso, la stringa di query e i dettagli del frammento nell'URL verranno ignorati.

• options <Oggetto>

  • maxDeflateDynamicTableSize <numero> Imposta la dimensione massima della tabella dinamica per la deflazione dei campi dell'intestazione. Predefinito: 4Kib.

  • maxSettings <numero> Imposta il numero massimo di voci di impostazione per frame SETTINGS. Il valore minimo consentito è 1. Predefinito: 32.

  • maxSessionMemory <numero> Imposta la memoria massima che Http2Session è autorizzato a utilizzare. Il valore è espresso in termini di numero di megabyte, ad esempio 1 uguale a 1 megabyte. Il valore minimo consentito è 1. Questo è un limite basato sul credito, Http2Stream esistenti potrebbero causare il superamento di questo limite, ma nuove istanze Http2Stream verranno rifiutate mentre questo limite viene superato. Il numero corrente di sessioni Http2Stream, l'utilizzo di memoria corrente delle tabelle di compressione dell'intestazione, i dati correnti accodati da inviare e i frame PING e SETTINGS non riconosciuti vengono tutti conteggiati nel limite corrente. Predefinito: 10.

  • maxHeaderListPairs <numero> Imposta il numero massimo di voci di intestazione. Questo è simile a server.maxHeadersCount o request.maxHeadersCount nel modulo node:http. Il valore minimo è 1. Predefinito: 128.

  • maxOutstandingPings <numero> Imposta il numero massimo di ping in sospeso e non riconosciuti. Predefinito: 10.

  • maxReservedRemoteStreams <numero> Imposta il numero massimo di stream push riservati che il client accetterà in qualsiasi momento. Una volta che il numero corrente di stream push attualmente riservati supera questo limite, i nuovi stream push inviati dal server verranno automaticamente rifiutati. Il valore minimo consentito è 0. Il valore massimo consentito è 2-1. Un valore negativo imposta questa opzione al valore massimo consentito. Predefinito: 200.

  • maxSendHeaderBlockLength <numero> Imposta la dimensione massima consentita per un blocco di intestazioni serializzato e compresso. I tentativi di inviare intestazioni che superano questo limite comporteranno l'emissione di un evento 'frameError' e lo stream verrà chiuso e distrutto.

  • paddingStrategy <numero> Strategia utilizzata per determinare la quantità di padding da utilizzare per i frame HEADERS e DATA. Predefinito: http2.constants.PADDING_STRATEGY_NONE. Il valore può essere uno dei seguenti:

  • http2.constants.PADDING_STRATEGY_NONE: Non viene applicato alcun padding.

  • http2.constants.PADDING_STRATEGY_MAX: Viene applicata la quantità massima di padding, determinata dall'implementazione interna.

  • http2.constants.PADDING_STRATEGY_ALIGNED: Tenta di applicare un padding sufficiente per garantire che la lunghezza totale del frame, inclusa l'intestazione di 9 byte, sia un multiplo di 8. Per ogni frame, esiste un numero massimo consentito di byte di padding che è determinato dallo stato e dalle impostazioni correnti del controllo del flusso. Se questo massimo è inferiore alla quantità calcolata necessaria per garantire l'allineamento, viene utilizzato il massimo e la lunghezza totale del frame non è necessariamente allineata a 8 byte.

  • peerMaxConcurrentStreams <numero> Imposta il numero massimo di stream simultanei per il peer remoto come se fosse stato ricevuto un frame SETTINGS. Verrà sovrascritto se il peer remoto imposta il proprio valore per maxConcurrentStreams. Predefinito: 100.

  • protocol <stringa> Il protocollo con cui connettersi, se non impostato in authority. Il valore può essere 'http:' o 'https:'. Predefinito: 'https:'

  • settings <Oggetto Impostazioni HTTP/2> Le impostazioni iniziali da inviare al peer remoto al momento della connessione.

  • remoteCustomSettings <Array> L'array di valori interi determina i tipi di impostazioni, che sono inclusi nella proprietà CustomSettings del remoteSettings ricevuto. Si prega di consultare la proprietà CustomSettings dell'oggetto Http2Settings per ulteriori informazioni sui tipi di impostazione consentiti.

  • createConnection <Funzione> Un callback opzionale che riceve l'istanza URL passata a connect e l'oggetto options e restituisce qualsiasi stream Duplex che deve essere utilizzato come connessione per questa sessione.

  • ...: Possono essere fornite tutte le opzioni net.connect() o tls.connect().

  • unknownProtocolTimeout <numero> Specifica un timeout in millisecondi che un server dovrebbe attendere quando viene emesso un evento 'unknownProtocol'. Se il socket non è stato distrutto entro tale termine, il server lo distruggerà. Predefinito: 10000.

• listener <Funzione> Verrà registrato come listener una tantum dell'evento 'connect'.

• Restituisce: <ClientHttp2Session>

Restituisce un'istanza ClientHttp2Session.

ESM

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

/* Usa il client */

client.close()

CJS

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

/* Usa il client */

client.close()

http2.constants

Aggiunto in: v8.4.0

Codici di errore per RST_STREAM e GOAWAY

Valore	Nome	Costante
0x00	Nessun Errore	http2.constants.NGHTTP2_NO_ERROR
0x01	Errore di Protocollo	http2.constants.NGHTTP2_PROTOCOL_ERROR
0x02	Errore Interno	http2.constants.NGHTTP2_INTERNAL_ERROR
0x03	Errore di Controllo di Flusso	http2.constants.NGHTTP2_FLOW_CONTROL_ERROR
0x04	Timeout Impostazioni	http2.constants.NGHTTP2_SETTINGS_TIMEOUT
0x05	Stream Chiuso	http2.constants.NGHTTP2_STREAM_CLOSED
0x06	Errore Dimensione Frame	http2.constants.NGHTTP2_FRAME_SIZE_ERROR
0x07	Stream Rifiutato	http2.constants.NGHTTP2_REFUSED_STREAM
0x08	Annulla	http2.constants.NGHTTP2_CANCEL
0x09	Errore di Compressione	http2.constants.NGHTTP2_COMPRESSION_ERROR
0x0a	Errore di Connessione	http2.constants.NGHTTP2_CONNECT_ERROR
0x0b	Rilassati	http2.constants.NGHTTP2_ENHANCE_YOUR_CALM
0x0c	Sicurezza Inadeguata	http2.constants.NGHTTP2_INADEQUATE_SECURITY
0x0d	HTTP/1.1 Richiesto	http2.constants.NGHTTP2_HTTP_1_1_REQUIRED

L'evento 'timeout' viene emesso quando non c'è attività sul Server per un determinato numero di millisecondi impostato tramite http2server.setTimeout().

http2.getDefaultSettings()

Aggiunto in: v8.4.0

• Restituisce: <Oggetto Impostazioni HTTP/2>

Restituisce un oggetto contenente le impostazioni predefinite per un'istanza di Http2Session. Questo metodo restituisce una nuova istanza dell'oggetto ogni volta che viene chiamato, quindi le istanze restituite possono essere modificate in modo sicuro per l'uso.

http2.getPackedSettings([settings])

Aggiunto in: v8.4.0

• settings <Oggetto Impostazioni HTTP/2>
• Restituisce: <Buffer>

Restituisce un'istanza di Buffer contenente la rappresentazione serializzata delle impostazioni HTTP/2 date come specificato nella specifica HTTP/2. Questo è destinato all'uso con il campo dell'intestazione HTTP2-Settings.

ESM

import { getPackedSettings } from 'node:http2'

const packed = getPackedSettings({ enablePush: false })

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

CJS

const http2 = require('node:http2')

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

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

http2.getUnpackedSettings(buf)

Aggiunto in: v8.4.0

• buf <Buffer> | <TypedArray> Le impostazioni impacchettate.
• Restituisce: <Oggetto Impostazioni HTTP/2>

Restituisce un Oggetto Impostazioni HTTP/2 contenente le impostazioni deserializzate dal Buffer dato, come generato da http2.getPackedSettings().

http2.performServerHandshake(socket[, options])

Aggiunto in: v21.7.0, v20.12.0

• socket <stream.Duplex>

• options <Object>

  • ...: È possibile fornire qualsiasi opzione di http2.createServer().

• Restituisce: <ServerHttp2Session>

Crea una sessione server HTTP/2 da un socket esistente.

http2.sensitiveHeaders

Aggiunto in: v15.0.0, v14.18.0

• <simbolo>

Questo simbolo può essere impostato come proprietà sull'oggetto delle intestazioni HTTP/2 con un valore array per fornire un elenco di intestazioni considerate sensibili. Per maggiori dettagli, vedere Intestazioni sensibili.

Oggetto delle intestazioni

Le intestazioni sono rappresentate come proprietà proprie sugli oggetti JavaScript. Le chiavi delle proprietà saranno serializzate in minuscolo. I valori delle proprietà dovrebbero essere stringhe (se non lo sono, saranno convertite in stringhe) o un Array di stringhe (per inviare più di un valore per campo di intestazione).

const headers = {
  ':status': '200',
  'content-type': 'text-plain',
  ABC: ['ha', 'più', 'di', 'un', 'valore'],
}

stream.respond(headers)

Gli oggetti di intestazione passati alle funzioni di callback avranno un prototipo null. Ciò significa che i normali metodi dell'oggetto JavaScript come Object.prototype.toString() e Object.prototype.hasOwnProperty() non funzioneranno.

Per le intestazioni in entrata:

• L'intestazione :status viene convertita in number.
• I duplicati di :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 o x-content-type-options vengono scartati.
• set-cookie è sempre un array. I duplicati vengono aggiunti all'array.
• Per le intestazioni cookie duplicate, i valori vengono uniti con '; '.
• Per tutte le altre intestazioni, i valori vengono uniti con ', '.

ESM

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

CJS

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

Intestazioni sensibili

Le intestazioni HTTP2 possono essere contrassegnate come sensibili, il che significa che l'algoritmo di compressione delle intestazioni HTTP/2 non le indicizzerà mai. Questo può avere senso per i valori delle intestazioni con bassa entropia e che possono essere considerati preziosi per un attaccante, ad esempio Cookie o Authorization. Per ottenere ciò, aggiungi il nome dell'intestazione alla proprietà [http2.sensitiveHeaders] come array:

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)

Per alcune intestazioni, come Authorization e le intestazioni Cookie brevi, questo flag viene impostato automaticamente.

Questa proprietà viene impostata anche per le intestazioni ricevute. Conterrà i nomi di tutte le intestazioni contrassegnate come sensibili, incluse quelle contrassegnate automaticamente.

Oggetto Impostazioni

[Cronologia]

Versione	Modifiche
v12.12.0	L'impostazione maxConcurrentStreams è più rigorosa.
v8.9.3	L'impostazione maxHeaderListSize è ora applicata rigorosamente.
v8.4.0	Aggiunto in: v8.4.0

Le API http2.getDefaultSettings(), http2.getPackedSettings(), http2.createServer(), http2.createSecureServer(), http2session.settings(), http2session.localSettings e http2session.remoteSettings restituiscono o ricevono come input un oggetto che definisce le impostazioni di configurazione per un oggetto Http2Session. Questi oggetti sono oggetti JavaScript ordinari contenenti le seguenti proprietà.

• headerTableSize <number> Specifica il numero massimo di byte utilizzati per la compressione delle intestazioni. Il valore minimo consentito è 0. Il valore massimo consentito è 2-1. Predefinito: 4096.
• enablePush <boolean> Specifica true se gli stream push HTTP/2 devono essere consentiti nelle istanze di Http2Session. Predefinito: true.
• initialWindowSize <number> Specifica la dimensione iniziale della finestra del mittente in byte per il controllo del flusso a livello di stream. Il valore minimo consentito è 0. Il valore massimo consentito è 2-1. Predefinito: 65535.
• maxFrameSize <number> Specifica la dimensione in byte del payload del frame più grande. Il valore minimo consentito è 16.384. Il valore massimo consentito è 2-1. Predefinito: 16384.
• maxConcurrentStreams <number> Specifica il numero massimo di stream simultanei consentiti su un Http2Session. Non esiste un valore predefinito, il che implica che, almeno teoricamente, 2-1 stream possono essere aperti contemporaneamente in qualsiasi momento in una Http2Session. Il valore minimo è 0. Il valore massimo consentito è 2-1. Predefinito: 4294967295.
• maxHeaderListSize <number> Specifica la dimensione massima (ottetti non compressi) della lista di intestazioni che verrà accettata. Il valore minimo consentito è 0. Il valore massimo consentito è 2-1. Predefinito: 65535.
• maxHeaderSize <number> Alias per maxHeaderListSize.
• enableConnectProtocol<boolean> Specifica true se deve essere abilitato il "Protocollo di connessione estesa" definito da RFC 8441. Questa impostazione è significativa solo se inviata dal server. Una volta che l'impostazione enableConnectProtocol è stata abilitata per una determinata Http2Session, non può essere disabilitata. Predefinito: false.
• customSettings <Object> Specifica impostazioni aggiuntive, non ancora implementate in node e nelle librerie sottostanti. La chiave dell'oggetto definisce il valore numerico del tipo di impostazioni (come definito nel registro "HTTP/2 SETTINGS" stabilito da [RFC 7540]) e i valori il valore numerico effettivo delle impostazioni. Il tipo di impostazione deve essere un numero intero nell'intervallo da 1 a 2^16-1. Non deve essere un tipo di impostazione già gestito da node, ovvero attualmente dovrebbe essere maggiore di 6, sebbene non sia un errore. I valori devono essere numeri interi senza segno nell'intervallo da 0 a 2^32-1. Attualmente, è supportato un massimo di 10 impostazioni personalizzate. È supportato solo per l'invio di SETTINGS o per la ricezione di valori di impostazioni specificati nelle opzioni remoteCustomSettings dell'oggetto server o client. Non mescolare il meccanismo customSettings per un ID di impostazione con interfacce per le impostazioni gestite in modo nativo, nel caso in cui un'impostazione diventi supportata in modo nativo in una futura versione di node.

Tutte le proprietà aggiuntive sull'oggetto delle impostazioni vengono ignorate.

Gestione degli errori

Ci sono diversi tipi di condizioni di errore che possono verificarsi quando si utilizza il modulo node:http2:

Gli errori di validazione si verificano quando viene passato un argomento, un'opzione o un valore di impostazione errato. Questi saranno sempre segnalati da un throw sincrono.

Gli errori di stato si verificano quando si tenta un'azione in un momento errato (ad esempio, tentare di inviare dati su uno stream dopo che è stato chiuso). Questi verranno segnalati utilizzando un throw sincrono o tramite un evento 'error' sugli oggetti Http2Stream, Http2Session o Server HTTP/2, a seconda di dove e quando si verifica l'errore.

Gli errori interni si verificano quando una sessione HTTP/2 fallisce inaspettatamente. Questi verranno segnalati tramite un evento 'error' sugli oggetti Http2Session o Server HTTP/2.

Gli errori di protocollo si verificano quando vengono violate varie limitazioni del protocollo HTTP/2. Questi verranno segnalati utilizzando un throw sincrono o tramite un evento 'error' sugli oggetti Http2Stream, Http2Session o Server HTTP/2, a seconda di dove e quando si verifica l'errore.

Gestione dei caratteri non validi nei nomi e nei valori degli header

L'implementazione di HTTP/2 applica una gestione più rigorosa dei caratteri non validi nei nomi e nei valori degli header HTTP rispetto all'implementazione di HTTP/1.

I nomi dei campi header non fanno distinzione tra maiuscole e minuscole e vengono trasmessi via cavo rigorosamente come stringhe minuscole. L'API fornita da Node.js consente di impostare i nomi degli header come stringhe in maiuscolo e minuscolo (ad esempio, Content-Type), ma le convertirà in minuscolo (ad esempio, content-type) al momento della trasmissione.

I nomi dei campi header devono contenere solo uno o più dei seguenti caratteri ASCII: a-z, A-Z, 0-9, !, #, $, %, &, ', *, +, -, ., ^, _, ```(backtick),|e~.

L'utilizzo di caratteri non validi all'interno di un nome di campo header HTTP farà chiudere lo stream con la segnalazione di un errore di protocollo.

I valori dei campi header vengono gestiti con maggiore indulgenza, ma non devono contenere caratteri di nuova riga o ritorno a capo e devono essere limitati ai caratteri US-ASCII, secondo i requisiti della specifica HTTP.

Push stream sul client

Per ricevere stream pushati sul client, imposta un listener per l'evento 'stream' sulla ClientHttp2Session:

ESM

import { connect } from 'node:http2'

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

client.on('stream', (pushedStream, requestHeaders) => {
  pushedStream.on('push', responseHeaders => {
    // Processa gli header di risposta
  })
  pushedStream.on('data', chunk => {
    /* gestisci i dati pushati */
  })
})

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

CJS

const http2 = require('node:http2')

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

client.on('stream', (pushedStream, requestHeaders) => {
  pushedStream.on('push', responseHeaders => {
    // Processa gli header di risposta
  })
  pushedStream.on('data', chunk => {
    /* gestisci i dati pushati */
  })
})

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

Supporto del metodo CONNECT

Il metodo CONNECT viene utilizzato per consentire a un server HTTP/2 di essere utilizzato come proxy per connessioni TCP/IP.

Un semplice Server TCP:

ESM

import { createServer } from 'node:net'

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

server.listen(8000)

CJS

const net = require('node:net')

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

server.listen(8000)

Un proxy HTTP/2 CONNECT:

ESM

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

const proxy = createServer()
proxy.on('stream', (stream, headers) => {
  if (headers[':method'] !== 'CONNECT') {
    // Accetta solo richieste CONNECT
    stream.close(NGHTTP2_REFUSED_STREAM)
    return
  }
  const auth = new URL(`tcp://${headers[':authority']}`)
  // È una buona idea verificare che hostname e porta siano
  // cose a cui questo proxy dovrebbe connettersi.
  const socket = connect(auth.port, auth.hostname, () => {
    stream.respond()
    socket.pipe(stream)
    stream.pipe(socket)
  })
  socket.on('error', error => {
    stream.close(NGHTTP2_CONNECT_ERROR)
  })
})

proxy.listen(8001)

CJS

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

const proxy = http2.createServer()
proxy.on('stream', (stream, headers) => {
  if (headers[':method'] !== 'CONNECT') {
    // Accetta solo richieste CONNECT
    stream.close(NGHTTP2_REFUSED_STREAM)
    return
  }
  const auth = new URL(`tcp://${headers[':authority']}`)
  // È una buona idea verificare che hostname e porta siano
  // cose a cui questo proxy dovrebbe connettersi.
  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)

Un client HTTP/2 CONNECT:

ESM

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

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

// Non è necessario specificare gli header ':path' e ':scheme'
// per le richieste CONNECT o verrà generato un errore.
const req = client.request({
  ':method': 'CONNECT',
  ':authority': 'localhost:8000',
})

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

CJS

const http2 = require('node:http2')

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

// Non è necessario specificare gli header ':path' e ':scheme'
// per le richieste CONNECT o verrà generato un errore.
const req = client.request({
  ':method': 'CONNECT',
  ':authority': 'localhost:8000',
})

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

Il protocollo CONNECT esteso

La RFC 8441 definisce un'estensione "Extended CONNECT Protocol" a HTTP/2 che può essere utilizzata per avviare l'uso di un Http2Stream utilizzando il metodo CONNECT come tunnel per altri protocolli di comunicazione (come WebSockets).

L'uso del protocollo Extended CONNECT è abilitato dai server HTTP/2 tramite l'impostazione enableConnectProtocol:

ESM

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

CJS

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

Una volta che il client riceve il frame SETTINGS dal server che indica che il CONNECT esteso può essere utilizzato, può inviare richieste CONNECT che utilizzano lo pseudo-header HTTP/2 ':protocol':

ESM

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

CJS

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

API di compatibilità

L'API di compatibilità ha l'obiettivo di fornire un'esperienza di sviluppo simile a quella di HTTP/1 quando si utilizza HTTP/2, rendendo possibile lo sviluppo di applicazioni che supportano sia HTTP/1 che HTTP/2. Questa API si rivolge solo all'API pubblica di HTTP/1. Tuttavia, molti moduli utilizzano metodi o stati interni, che non sono supportati poiché si tratta di un'implementazione completamente diversa.

L'esempio seguente crea un server HTTP/2 utilizzando l'API di compatibilità:

ESM

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

CJS

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

Per creare un server misto HTTPS e HTTP/2, fare riferimento alla sezione negoziazione ALPN. L'aggiornamento da server HTTP/1 non-tls non è supportato.

L'API di compatibilità HTTP/2 è composta da Http2ServerRequest e Http2ServerResponse. Esse mirano alla compatibilità dell'API con HTTP/1, ma non nascondono le differenze tra i protocolli. Ad esempio, il messaggio di stato per i codici HTTP viene ignorato.

Negoziazione ALPN

La negoziazione ALPN consente di supportare sia HTTPS che HTTP/2 sulla stessa socket. Gli oggetti req e res possono essere HTTP/1 o HTTP/2 e un'applicazione deve limitarsi all'API pubblica di HTTP/1 e rilevare se è possibile utilizzare le funzionalità più avanzate di HTTP/2.

L'esempio seguente crea un server che supporta entrambi i protocolli:

ESM

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

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

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

function onRequest(req, res) {
  // Rileva se è una richiesta HTTPS o 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,
    })
  )
}

CJS

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

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

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

function onRequest(req, res) {
  // Rileva se è una richiesta HTTPS o 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,
    })
  )
}

L'evento 'request' funziona in modo identico sia su HTTPS che su HTTP/2.

Classe: http2.Http2ServerRequest

Aggiunto in: v8.4.0

• Estende: <stream.Readable>

Un oggetto Http2ServerRequest viene creato da http2.Server o http2.SecureServer e passato come primo argomento all'evento 'request'. Può essere utilizzato per accedere allo stato, agli header e ai dati di una richiesta.

Evento: 'aborted'

Aggiunto in: v8.4.0

L'evento 'aborted' viene emesso ogni volta che un'istanza di Http2ServerRequest viene interrotta in modo anomalo durante la comunicazione.

L'evento 'aborted' verrà emesso solo se il lato scrivibile di Http2ServerRequest non è stato terminato.

Evento: 'close'

Aggiunto in: v8.4.0

Indica che lo Http2Stream sottostante è stato chiuso. Proprio come 'end', questo evento si verifica una sola volta per risposta.

request.aborted

Aggiunto in: v10.1.0

• <boolean>

La proprietà request.aborted sarà true se la richiesta è stata interrotta.

request.authority

Aggiunto in: v8.4.0

• <string>

Il campo pseudo header della richiesta authority. Poiché HTTP/2 consente alle richieste di impostare :authority o host, questo valore deriva da req.headers[':authority'] se presente. Altrimenti, deriva da req.headers['host'].

request.complete

Aggiunto in: v12.10.0

• <boolean>

La proprietà request.complete sarà true se la richiesta è stata completata, interrotta o distrutta.

request.connection

Aggiunto in: v8.4.0

Deprecato a partire da: v13.0.0

[Stabile: 0 - Deprecato]

Stabile: 0 Stabilità: 0 - Deprecato. Utilizzare request.socket.

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

Vedere request.socket.

request.destroy([error])

Aggiunto in: v8.4.0

• error <Error>

Chiama destroy() sul Http2Stream che ha ricevuto la Http2ServerRequest. Se viene fornito error, viene emesso un evento 'error' e error viene passato come argomento a tutti i listener dell'evento.

Non fa nulla se lo stream è già stato distrutto.

request.headers

Aggiunto in: v8.4.0

• <Oggetto>

L'oggetto delle intestazioni della richiesta/risposta.

Coppie chiave-valore di nomi e valori delle intestazioni. I nomi delle intestazioni sono in minuscolo.

// Stampa qualcosa del genere:
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers)

Vedi Oggetto delle Intestazioni HTTP/2.

In HTTP/2, il percorso della richiesta, il nome host, il protocollo e il metodo sono rappresentati come intestazioni speciali con il prefisso del carattere :. (es. ':path'). Queste intestazioni speciali saranno incluse nell'oggetto request.headers. Si deve prestare attenzione a non modificare inavvertitamente queste intestazioni speciali, altrimenti potrebbero verificarsi errori. Ad esempio, rimuovere tutte le intestazioni dalla richiesta causerà degli errori:

removeAllHeaders(request.headers)
assert(request.url) // Fallisce perché l'intestazione :path è stata rimossa

request.httpVersion

Aggiunto in: v8.4.0

• <stringa>

Nel caso di una richiesta del server, la versione HTTP inviata dal client. Nel caso di una risposta del client, la versione HTTP del server a cui si è connesso. Restituisce '2.0'.

Inoltre message.httpVersionMajor è il primo intero e message.httpVersionMinor è il secondo.

request.method

Aggiunto in: v8.4.0

• <stringa>

Il metodo di richiesta come stringa. Sola lettura. Esempi: 'GET', 'DELETE'.

request.rawHeaders

Aggiunto in: v8.4.0

• <stringa[]>

La lista delle intestazioni della richiesta/risposta grezze esattamente come sono state ricevute.

Le chiavi e i valori sono nella stessa lista. Non è una lista di tuple. Quindi, gli offset con numero pari sono i valori delle chiavi e gli offset con numero dispari sono i valori associati.

I nomi delle intestazioni non sono in minuscolo e i duplicati non vengono uniti.

// Stampa qualcosa del genere:
//
// [ '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

Aggiunto in: v8.4.0

• <string[]>

Le chiavi e i valori dei trailer grezzi di richiesta/risposta esattamente come sono stati ricevuti. Popolato solo all'evento 'end'.

request.scheme

Aggiunto in: v8.4.0

• <string>

Il campo pseudo-header della richiesta che indica la porzione dello schema dell'URL di destinazione.

request.setTimeout(msecs, callback)

Aggiunto in: v8.4.0

• msecs <number>
• callback <Function>
• Restituisce: <http2.Http2ServerRequest>

Imposta il valore di timeout di Http2Stream a msecs. Se viene fornito un callback, viene aggiunto come listener sull'evento 'timeout' dell'oggetto response.

Se non viene aggiunto alcun listener 'timeout' alla richiesta, alla risposta o al server, gli Http2Stream vengono distrutti quando scadono. Se viene assegnato un gestore agli eventi 'timeout' della richiesta, della risposta o del server, i socket scaduti devono essere gestiti esplicitamente.

request.socket

Aggiunto in: v8.4.0

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

Restituisce un oggetto Proxy che agisce come un net.Socket (o tls.TLSSocket) ma applica getter, setter e metodi basati sulla logica HTTP/2.

Le proprietà destroyed, readable e writable verranno recuperate e impostate su request.stream.

I metodi destroy, emit, end, on e once verranno chiamati su request.stream.

Il metodo setTimeout verrà chiamato su request.stream.session.

pause, read, resume e write genereranno un errore con il codice ERR_HTTP2_NO_SOCKET_MANIPULATION. Consulta Http2Session e Socket per maggiori informazioni.

Tutte le altre interazioni verranno indirizzate direttamente al socket. Con il supporto TLS, utilizzare request.socket.getPeerCertificate() per ottenere i dettagli di autenticazione del client.

request.stream

Aggiunto in: v8.4.0

• <Http2Stream>

L'oggetto Http2Stream che supporta la richiesta.

request.trailers

Aggiunto in: v8.4.0

• <Object>

L'oggetto dei trailer della richiesta/risposta. Popolato solo all'evento 'end'.

request.url

Aggiunto in: v8.4.0

• <string>

Stringa URL della richiesta. Contiene solo l'URL presente nell'effettiva richiesta HTTP. Se la richiesta è:

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

Allora request.url sarà:

'/status?name=ryan'

Per analizzare l'URL nelle sue parti, è possibile utilizzare 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: ''
}

Classe: http2.Http2ServerResponse

Aggiunto in: v8.4.0

• Estende: <Stream>

Questo oggetto viene creato internamente da un server HTTP, non dall'utente. Viene passato come secondo parametro all'evento 'request'.

Evento: 'close'

Aggiunto in: v8.4.0

Indica che l'oggetto Http2Stream sottostante è stato terminato prima che response.end() fosse chiamato o in grado di essere scaricato.

Evento: 'finish'

Aggiunto in: v8.4.0

Emesso quando la risposta è stata inviata. Più specificamente, questo evento viene emesso quando l'ultimo segmento degli header e del corpo della risposta sono stati passati al multiplexing HTTP/2 per la trasmissione sulla rete. Non implica che il client abbia già ricevuto qualcosa.

Dopo questo evento, non verranno emessi altri eventi sull'oggetto di risposta.

response.addTrailers(headers)

Aggiunto in: v8.4.0

• headers <Object>

Questo metodo aggiunge gli header di coda HTTP (un header ma alla fine del messaggio) alla risposta.

Il tentativo di impostare un nome o un valore di campo header che contenga caratteri non validi comporterà la generazione di un TypeError.

response.appendHeader(name, value)

Aggiunto in: v21.7.0, v20.12.0

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

Aggiunge un singolo valore header all'oggetto header.

Se il valore è un array, questo è equivalente a chiamare questo metodo più volte.

Se non c'erano valori precedenti per l'header, questo è equivalente a chiamare response.setHeader().

Il tentativo di impostare un nome o un valore di campo header che contenga caratteri non validi comporterà la generazione di un TypeError.

// Restituisce gli header includendo "set-cookie: a" e "set-cookie: b"
const server = http2.createServer((req, res) => {
  res.setHeader('set-cookie', 'a')
  res.appendHeader('set-cookie', 'b')
  res.writeHead(200)
  res.end('ok')
})

response.connection

Aggiunto in: v8.4.0

Deprecato a partire da: v13.0.0

[Stabile: 0 - Deprecato]

Stabile: 0 Stabilità: 0 - Deprecato. Utilizzare response.socket.

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

Vedi response.socket.

response.createPushResponse(headers, callback)

[Cronologia]

Versione	Modifiche
v18.0.0	Passare un callback non valido all'argomento callback ora genera ERR_INVALID_ARG_TYPE invece di ERR_INVALID_CALLBACK.
v8.4.0	Aggiunto in: v8.4.0

• headers <Oggetto Header HTTP/2> Un oggetto che descrive gli header
• callback <Funzione> Chiamato una volta che http2stream.pushStream() è terminato, o quando il tentativo di creare l'oggetto Http2Stream inviato ha avuto esito negativo o è stato rifiutato, oppure lo stato di Http2ServerRequest è chiuso prima di chiamare il metodo http2stream.pushStream()
  • err <Errore>
  • res <http2.Http2ServerResponse> L'oggetto Http2ServerResponse appena creato

Chiama http2stream.pushStream() con gli header dati e racchiude l'oggetto Http2Stream dato in un Http2ServerResponse appena creato come parametro di callback in caso di successo. Quando Http2ServerRequest è chiuso, il callback viene chiamato con un errore ERR_HTTP2_INVALID_STREAM.

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

[Cronologia]

Versione	Modifiche
v10.0.0	Questo metodo ora restituisce un riferimento a ServerResponse.
v8.4.0	Aggiunto in: v8.4.0

• data <string> | <Buffer> | <Uint8Array>
• encoding <string>
• callback <Function>
• Restituisce: <this>

Questo metodo segnala al server che tutti gli header di risposta e il corpo sono stati inviati; che il server dovrebbe considerare questo messaggio completato. Il metodo, response.end(), DEVE essere chiamato su ogni risposta.

Se data è specificato, è equivalente a chiamare response.write(data, encoding) seguito da response.end(callback).

Se callback è specificato, verrà chiamato quando lo stream di risposta è terminato.

response.finished

Aggiunto in: v8.4.0

Deprecato a partire da: v13.4.0, v12.16.0

[Stabile: 0 - Deprecato]

Stabile: 0 Stabilità: 0 - Deprecato. Utilizzare response.writableEnded.

• <boolean>

Valore booleano che indica se la risposta è stata completata. Inizia come false. Dopo che response.end() viene eseguito, il valore sarà true.

response.getHeader(name)

Aggiunto in: v8.4.0

• name <string>
• Restituisce: <string>

Legge un header che è già stato accodato ma non inviato al client. Il nome non è sensibile al maiuscolo/minuscolo.

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

response.getHeaderNames()

Aggiunto in: v8.4.0

• Restituisce: <string[]>

Restituisce un array contenente i nomi univoci delle intestazioni in uscita correnti. Tutti i nomi delle intestazioni sono in minuscolo.

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

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

response.getHeaders()

Aggiunto in: v8.4.0

• Restituisce: <Object>

Restituisce una copia superficiale delle intestazioni in uscita correnti. Poiché viene utilizzata una copia superficiale, i valori dell'array possono essere modificati senza chiamate aggiuntive a vari metodi del modulo http relativi all'intestazione. Le chiavi dell'oggetto restituito sono i nomi delle intestazioni e i valori sono i rispettivi valori delle intestazioni. Tutti i nomi delle intestazioni sono in minuscolo.

L'oggetto restituito dal metodo response.getHeaders() non eredita prototipicamente da Object di JavaScript. Ciò significa che i metodi Object tipici come obj.toString(), obj.hasOwnProperty() e altri non sono definiti e non funzioneranno.

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)

Aggiunto in: v8.4.0

• name <string>
• Restituisce: <boolean>

Restituisce true se l'intestazione identificata da name è attualmente impostata nelle intestazioni in uscita. La corrispondenza del nome dell'intestazione non fa distinzione tra maiuscole e minuscole.

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

response.headersSent

Aggiunto in: v8.4.0

• <boolean>

Vero se le intestazioni sono state inviate, falso altrimenti (solo lettura).

response.removeHeader(name)

Aggiunto in: v8.4.0

• name <stringa>

Rimuove un'intestazione che è stata messa in coda per l'invio implicito.

response.removeHeader('Content-Encoding')

response.req

Aggiunto in: v15.7.0

• <http2.Http2ServerRequest>

Un riferimento all'oggetto request HTTP2 originale.

response.sendDate

Aggiunto in: v8.4.0

• <booleano>

Quando è true, l'intestazione Date verrà generata e inviata automaticamente nella risposta se non è già presente nelle intestazioni. Il valore predefinito è true.

Questo dovrebbe essere disabilitato solo per i test; HTTP richiede l'intestazione Date nelle risposte.

response.setHeader(name, value)

Aggiunto in: v8.4.0

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

Imposta un singolo valore di intestazione per le intestazioni implicite. Se questa intestazione esiste già nelle intestazioni da inviare, il suo valore verrà sostituito. Utilizzare un array di stringhe qui per inviare più intestazioni con lo stesso nome.

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

oppure

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

Tentare di impostare un nome o un valore di campo di intestazione che contenga caratteri non validi genererà un TypeError.

Quando le intestazioni sono state impostate con response.setHeader(), verranno unite a tutte le intestazioni passate a response.writeHead(), con le intestazioni passate a response.writeHead() a cui viene data la precedenza.

// Restituisce 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])

Aggiunto in: v8.4.0

• msecs <number>
• callback <Function>
• Restituisce: <http2.Http2ServerResponse>

Imposta il valore di timeout di Http2Stream su msecs. Se viene fornito un callback, viene aggiunto come listener all'evento 'timeout' sull'oggetto response.

Se non viene aggiunto alcun listener 'timeout' alla richiesta, alla response o al server, gli Http2Stream vengono distrutti quando scadono. Se un gestore viene assegnato agli eventi 'timeout' della richiesta, della response o del server, i socket scaduti devono essere gestiti esplicitamente.

response.socket

Aggiunto in: v8.4.0

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

Restituisce un oggetto Proxy che funge da net.Socket (o tls.TLSSocket) ma applica getter, setter e metodi basati sulla logica HTTP/2.

Le proprietà destroyed, readable e writable verranno recuperate e impostate su response.stream.

I metodi destroy, emit, end, on e once verranno chiamati su response.stream.

Il metodo setTimeout verrà chiamato su response.stream.session.

pause, read, resume e write genereranno un errore con codice ERR_HTTP2_NO_SOCKET_MANIPULATION. Vedi Http2Session e Socket per maggiori informazioni.

Tutte le altre interazioni verranno indirizzate direttamente al socket.

ESM

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

CJS

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

response.statusCode

Aggiunto in: v8.4.0

• <number>

Quando si utilizzano header impliciti (non chiamando esplicitamente response.writeHead()), questa proprietà controlla il codice di stato che verrà inviato al client quando gli header vengono scaricati.

response.statusCode = 404

Dopo che l'header di risposta è stato inviato al client, questa proprietà indica il codice di stato che è stato inviato.

response.statusMessage

Aggiunto in: v8.4.0

• <string>

Il messaggio di stato non è supportato da HTTP/2 (RFC 7540 8.1.2.4). Restituisce una stringa vuota.

response.stream

Aggiunto in: v8.4.0

• <Http2Stream>

L'oggetto Http2Stream che supporta la risposta.

response.writableEnded

Aggiunto in: v12.9.0

• <boolean>

È true dopo che è stato chiamato response.end(). Questa proprietà non indica se i dati sono stati scaricati, per questo utilizzare invece writable.writableFinished.

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

Aggiunto in: v8.4.0

• chunk <string> | <Buffer> | <Uint8Array>
• encoding <string>
• callback <Function>
• Restituisce: <boolean>

Se questo metodo viene chiamato e response.writeHead() non è stato chiamato, passerà alla modalità header implicita e scaricherà gli header impliciti.

Questo invia un blocco del corpo della risposta. Questo metodo può essere chiamato più volte per fornire parti successive del corpo.

Nel modulo node:http, il corpo della risposta viene omesso quando la richiesta è una richiesta HEAD. Allo stesso modo, le risposte 204 e 304 non devono includere un corpo di messaggio.

chunk può essere una stringa o un buffer. Se chunk è una stringa, il secondo parametro specifica come codificarlo in un flusso di byte. Per impostazione predefinita, la encoding è 'utf8'. callback verrà chiamato quando questo blocco di dati viene scaricato.

Questo è il corpo HTTP raw e non ha nulla a che vedere con codifiche di corpo multi-parte di livello superiore che potrebbero essere utilizzate.

La prima volta che viene chiamato response.write(), invierà le informazioni dell'header in buffer e il primo blocco del corpo al client. La seconda volta che viene chiamato response.write(), Node.js presume che i dati verranno trasmessi in streaming e invia i nuovi dati separatamente. Cioè, la risposta viene memorizzata nel buffer fino al primo blocco del corpo.

Restituisce true se tutti i dati sono stati scaricati correttamente nel buffer del kernel. Restituisce false se tutti o parte dei dati sono stati accodati nella memoria utente. 'drain' verrà emesso quando il buffer è di nuovo libero.

response.writeContinue()

Aggiunto in: v8.4.0

Invia uno stato 100 Continue al client, indicando che il corpo della richiesta dovrebbe essere inviato. Vedere l'evento 'checkContinue' su Http2Server e Http2SecureServer.

response.writeEarlyHints(hints)

Aggiunto in: v18.11.0

• hints <Object>

Invia uno stato 103 Early Hints al client con un'intestazione Link, indicando che lo user agent può precaricare/preconnettere le risorse collegate. hints è un oggetto contenente i valori delle intestazioni da inviare con il messaggio di early hints.

Esempio

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

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

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

[Cronologia]

Versione	Modifiche
v11.10.0, v10.17.0	Restituisce this da writeHead() per consentire l'incatenamento con end().
v8.4.0	Aggiunto in: v8.4.0

• statusCode <number>
• statusMessage <string>
• headers <Object> | <Array>
• Restituisce: <http2.Http2ServerResponse>

Invia un'intestazione di risposta alla richiesta. Il codice di stato è un codice di stato HTTP a 3 cifre, come 404. L'ultimo argomento, headers, sono le intestazioni di risposta.

Restituisce un riferimento a Http2ServerResponse, in modo che le chiamate possano essere concatenate.

Per compatibilità con HTTP/1, un statusMessage leggibile dall'uomo può essere passato come secondo argomento. Tuttavia, poiché statusMessage non ha significato in HTTP/2, l'argomento non avrà effetto e verrà emesso un avviso di processo.

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

Content-Length è specificato in byte, non in caratteri. L'API Buffer.byteLength() può essere utilizzata per determinare il numero di byte in una determinata codifica. Sui messaggi in uscita, Node.js non controlla se Content-Length e la lunghezza del corpo trasmesso siano uguali o meno. Tuttavia, quando si ricevono messaggi, Node.js rifiuterà automaticamente i messaggi quando Content-Length non corrisponde alla dimensione effettiva del payload.

Questo metodo può essere chiamato al massimo una volta su un messaggio prima che venga chiamato response.end().

Se response.write() o response.end() vengono chiamati prima di chiamare questo, le intestazioni implicite/modificabili verranno calcolate e verrà chiamata questa funzione.

Quando le intestazioni sono state impostate con response.setHeader(), verranno unite con qualsiasi intestazione passata a response.writeHead(), con le intestazioni passate a response.writeHead() che hanno la precedenza.

// Restituisce 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')
})

Il tentativo di impostare un nome o un valore di campo di intestazione che contenga caratteri non validi comporterà la generazione di un TypeError.

Raccolta delle metriche delle prestazioni HTTP/2

L'API Performance Observer può essere utilizzata per raccogliere metriche di performance di base per ciascuna istanza Http2Session e Http2Stream.

ESM

import { PerformanceObserver } from 'node:perf_hooks'

const obs = new PerformanceObserver(items => {
  const entry = items.getEntries()[0]
  console.log(entry.entryType) // stampa 'http2'
  if (entry.name === 'Http2Session') {
    // L'entry contiene statistiche sull'Http2Session
  } else if (entry.name === 'Http2Stream') {
    // L'entry contiene statistiche sull'Http2Stream
  }
})
obs.observe({ entryTypes: ['http2'] })

CJS

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

const obs = new PerformanceObserver(items => {
  const entry = items.getEntries()[0]
  console.log(entry.entryType) // stampa 'http2'
  if (entry.name === 'Http2Session') {
    // L'entry contiene statistiche sull'Http2Session
  } else if (entry.name === 'Http2Stream') {
    // L'entry contiene statistiche sull'Http2Stream
  }
})
obs.observe({ entryTypes: ['http2'] })

La proprietà entryType di PerformanceEntry sarà uguale a 'http2'.

La proprietà name di PerformanceEntry sarà uguale a 'Http2Stream' o 'Http2Session'.

Se name è uguale a Http2Stream, PerformanceEntry conterrà le seguenti proprietà aggiuntive:

• bytesRead <number> Il numero di byte del frame DATA ricevuti per questo Http2Stream.
• bytesWritten <number> Il numero di byte del frame DATA inviati per questo Http2Stream.
• id <number> L'identificatore dell'Http2Stream associato
• timeToFirstByte <number> Il numero di millisecondi trascorsi tra lo startTime di PerformanceEntry e la ricezione del primo frame DATA.
• timeToFirstByteSent <number> Il numero di millisecondi trascorsi tra lo startTime di PerformanceEntry e l'invio del primo frame DATA.
• timeToFirstHeader <number> Il numero di millisecondi trascorsi tra lo startTime di PerformanceEntry e la ricezione del primo header.

Se name è uguale a Http2Session, PerformanceEntry conterrà le seguenti proprietà aggiuntive:

• bytesRead <number> Il numero di byte ricevuti per questa Http2Session.
• bytesWritten <number> Il numero di byte inviati per questa Http2Session.
• framesReceived <number> Il numero di frame HTTP/2 ricevuti dall'Http2Session.
• framesSent <number> Il numero di frame HTTP/2 inviati dall'Http2Session.
• maxConcurrentStreams <number> Il numero massimo di stream aperti contemporaneamente durante la durata dell'Http2Session.
• pingRTT <number> Il numero di millisecondi trascorsi tra la trasmissione di un frame PING e la ricezione del suo riconoscimento. Presente solo se un frame PING è stato inviato sull'Http2Session.
• streamAverageDuration <number> La durata media (in millisecondi) per tutte le istanze Http2Stream.
• streamCount <number> Il numero di istanze Http2Stream elaborate dall'Http2Session.
• type <string> O 'server' o 'client' per identificare il tipo di Http2Session.

Nota su :authority e host

HTTP/2 richiede che le richieste abbiano lo pseudo-header :authority o l'header host. Preferisci :authority quando costruisci una richiesta HTTP/2 direttamente, e host quando converti da HTTP/1 (nei proxy, per esempio).

L'API di compatibilità fa fallback a host se :authority non è presente. Consulta request.authority per maggiori informazioni. Tuttavia, se non usi l'API di compatibilità (o usi req.headers direttamente), devi implementare tu stesso qualsiasi comportamento di fallback.