http2: allow setting the local window size of a session

PR-URL: #35978Fixes: #31084
Refs: #26962
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Ricky Zhou <0x19951125@gmail.com>

Author: zhangyongsheng

doc/api/errors.md

@@ -1226,6 +1226,11 @@ reached.
 An attempt was made to initiate a new push stream from within a push stream.
 Nested push streams are not permitted.
 
+<aid="ERR_HTTP2_NO_MEM"></a>
+### `ERR_HTTP2_NO_MEM`
+
+Out of memory when using the `http2session.setLocalWindowSize(windowSize)` API.
+
 <aid="ERR_HTTP2_NO_SOCKET_MANIPULATION"></a>
 ### `ERR_HTTP2_NO_SOCKET_MANIPULATION`
 

doc/api/http2.md

@@ -519,6 +519,29 @@ added: v8.4.0
 A prototype-less object describing the current remote settings of this
 `Http2Session`. The remote settings are set by the *connected* HTTP/2 peer.
 
+#### `http2session.setLocalWindowSize(windowSize)`
+<!-- YAML
+added: REPLACEME
+-->
+
+*`windowSize` {number}
+
+Sets the local endpoint's window size.
+The `windowSize` is the total window size to set, not
+the delta.
+
+```js
+consthttp2=require('http2');
+
+constserver=http2.createServer();
+constexpectedWindowSize=2**20;
+server.on('connect', (session) => {
+
+// Set local window size to be 2 ** 20
+session.setLocalWindowSize(expectedWindowSize);
+});
+```
+
 #### `http2session.setTimeout(msecs, callback)`
 <!-- YAML
 added: v8.4.0

lib/internal/errors.js

@@ -904,6 +904,7 @@ E('ERR_HTTP2_MAX_PENDING_SETTINGS_ACK',
 'Maximum number of pending settings acknowledgements',Error);
 E('ERR_HTTP2_NESTED_PUSH',
 'A push stream cannot initiate another push stream.',Error);
+E('ERR_HTTP2_NO_MEM','Out of memory',Error);
 E('ERR_HTTP2_NO_SOCKET_MANIPULATION',
 'HTTP/2 sockets should not be directly manipulated (e.g. read and written)',
 Error);

lib/internal/http2/core.js

@@ -70,6 +70,7 @@ const {
 ERR_HTTP2_INVALID_STREAM,
 ERR_HTTP2_MAX_PENDING_SETTINGS_ACK,
 ERR_HTTP2_NESTED_PUSH,
+ERR_HTTP2_NO_MEM,
 ERR_HTTP2_NO_SOCKET_MANIPULATION,
 ERR_HTTP2_ORIGIN_LENGTH,
 ERR_HTTP2_OUT_OF_STREAMS,
@@ -101,11 +102,13 @@ const {
 },
  hideStackFrames
 }=require('internal/errors');
-const{ validateInteger,
- validateNumber,
- validateString,
- validateUint32,
- isUint32,
+const{
+ isUint32,
+ validateInt32,
+ validateInteger,
+ validateNumber,
+ validateString,
+ validateUint32,
 }=require('internal/validators');
 constfsPromisesInternal=require('internal/fs/promises');
 const{ utcDate }=require('internal/http');
@@ -252,6 +255,7 @@ const {
 NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE,
 NGHTTP2_ERR_INVALID_ARGUMENT,
 NGHTTP2_ERR_STREAM_CLOSED,
+NGHTTP2_ERR_NOMEM,
 
 HTTP2_HEADER_AUTHORITY,
 HTTP2_HEADER_DATE,
@@ -1254,6 +1258,21 @@ class Http2Session extends EventEmitter {
 this[kHandle].setNextStreamID(id);
 }
 
+// Sets the local window size (local endpoints's window size)
+// Returns 0 if sucess or throw an exception if NGHTTP2_ERR_NOMEM
+// if the window allocation fails
+setLocalWindowSize(windowSize){
+if(this.destroyed)
+thrownewERR_HTTP2_INVALID_SESSION();
+
+validateInt32(windowSize,'windowSize',0);
+constret=this[kHandle].setLocalWindowSize(windowSize);
+
+if(ret===NGHTTP2_ERR_NOMEM){
+this.destroy(newERR_HTTP2_NO_MEM());
+}
+}
+
 // If ping is called while we are still connecting, or after close() has
 // been called, the ping callback will be invoked immediately will a ping
 // cancelled error and a duration of 0.0.

src/node_http2.cc

@@ -2416,6 +2416,25 @@ void Http2Session::SetNextStreamID(const FunctionCallbackInfo<Value>& args) {
 Debug(session, "set next stream id to %d", id);
 }
 
+// Set local window size (local endpoints's window size) to the given
+// window_size for the stream denoted by 0.
+// This function returns 0 if it succeeds, or one of a negative codes
+voidHttp2Session::SetLocalWindowSize(
+const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+ Http2Session* session;
+ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
+
+int32_t window_size = args[0]->Int32Value(env->context()).ToChecked();
+
+int result = nghttp2_session_set_local_window_size(
+ session->session(), NGHTTP2_FLAG_NONE, 0, window_size);
+
+ args.GetReturnValue().Set(result);
+
+Debug(session, "set local window size to %d", window_size);
+}
+
 // A TypedArray instance is shared between C++ and JS land to contain the
 // SETTINGS (either remote or local). RefreshSettings updates the current
 // values established for each of the settings so those can be read in JS land.
@@ -3088,6 +3107,8 @@ void Initialize(Local<Object> target,
  env->SetProtoMethod(session, "request", Http2Session::Request);
  env->SetProtoMethod(session, "setNextStreamID",
  Http2Session::SetNextStreamID);
+ env->SetProtoMethod(session, "setLocalWindowSize",
+ Http2Session::SetLocalWindowSize);
  env->SetProtoMethod(session, "updateChunksSent",
  Http2Session::UpdateChunksSent);
  env->SetProtoMethod(session, "refreshState", Http2Session::RefreshState);

src/node_http2.h

@@ -699,6 +699,8 @@ class Http2Session : public AsyncWrap,
 staticvoidSettings(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidRequest(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidSetNextStreamID(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidSetLocalWindowSize(
+const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidGoaway(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidUpdateChunksSent(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidRefreshState(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -1115,6 +1117,7 @@ class Origins {
  V(NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE) \
  V(NGHTTP2_ERR_INVALID_ARGUMENT) \
  V(NGHTTP2_ERR_STREAM_CLOSED) \
+ V(NGHTTP2_ERR_NOMEM) \
  V(STREAM_OPTION_EMPTY_PAYLOAD) \
  V(STREAM_OPTION_GET_TRAILERS)
 

test/parallel/test-http2-client-destroy.js

@@ -77,6 +77,7 @@ const Countdown = require('../common/countdown');
 };
 
 assert.throws(()=>client.setNextStreamID(),sessionError);
+assert.throws(()=>client.setLocalWindowSize(),sessionError);
 assert.throws(()=>client.ping(),sessionError);
 assert.throws(()=>client.settings({}),sessionError);
 assert.throws(()=>client.goaway(),sessionError);
@@ -87,6 +88,7 @@ const Countdown = require('../common/countdown');
 // so that state.destroyed is set to true
 setImmediate(()=>{
 assert.throws(()=>client.setNextStreamID(),sessionError);
+assert.throws(()=>client.setLocalWindowSize(),sessionError);
 assert.throws(()=>client.ping(),sessionError);
 assert.throws(()=>client.settings({}),sessionError);
 assert.throws(()=>client.goaway(),sessionError);

test/parallel/test-http2-client-setLocalWindowSize.js

@@ -0,0 +1,121 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+consthttp2=require('http2');
+
+{
+constserver=http2.createServer();
+server.on('stream',common.mustNotCall((stream)=>{
+stream.respond();
+stream.end('ok');
+}));
+
+consttypes={
+boolean: true,
+function: ()=>{},
+number: 1,
+object: {},
+array: [],
+null: null,
+};
+
+server.listen(0,common.mustCall(()=>{
+constclient=http2.connect(`http://localhost:${server.address().port}`);
+
+client.on('connect',common.mustCall(()=>{
+constoutOfRangeNum=2**32;
+assert.throws(
+()=>client.setLocalWindowSize(outOfRangeNum),
+{
+name: 'RangeError',
+code: 'ERR_OUT_OF_RANGE',
+message: 'The value of "windowSize" is out of range.'+
+' It must be >= 0 && <= 2147483647. Received '+outOfRangeNum
+}
+);
+
+// Throw if something other than number is passed to setLocalWindowSize
+Object.entries(types).forEach(([type,value])=>{
+if(type==='number'){
+return;
+}
+
+assert.throws(
+()=>client.setLocalWindowSize(value),
+{
+name: 'TypeError',
+code: 'ERR_INVALID_ARG_TYPE',
+message: 'The "windowSize" argument must be of type number.'+
+common.invalidArgTypeHelper(value)
+}
+);
+});
+
+server.close();
+client.close();
+}));
+}));
+}
+
+{
+constserver=http2.createServer();
+server.on('stream',common.mustNotCall((stream)=>{
+stream.respond();
+stream.end('ok');
+}));
+
+server.listen(0,common.mustCall(()=>{
+constclient=http2.connect(`http://localhost:${server.address().port}`);
+
+client.on('connect',common.mustCall(()=>{
+constwindowSize=2**20;
+constdefaultSetting=http2.getDefaultSettings();
+client.setLocalWindowSize(windowSize);
+
+assert.strictEqual(client.state.effectiveLocalWindowSize,windowSize);
+assert.strictEqual(client.state.localWindowSize,windowSize);
+assert.strictEqual(
+client.state.remoteWindowSize,
+defaultSetting.initialWindowSize
+);
+
+server.close();
+client.close();
+}));
+}));
+}
+
+{
+constserver=http2.createServer();
+server.on('stream',common.mustNotCall((stream)=>{
+stream.respond();
+stream.end('ok');
+}));
+
+server.listen(0,common.mustCall(()=>{
+constclient=http2.connect(`http://localhost:${server.address().port}`);
+
+client.on('connect',common.mustCall(()=>{
+constwindowSize=20;
+constdefaultSetting=http2.getDefaultSettings();
+client.setLocalWindowSize(windowSize);
+
+assert.strictEqual(client.state.effectiveLocalWindowSize,windowSize);
+assert.strictEqual(
+client.state.localWindowSize,
+defaultSetting.initialWindowSize
+);
+assert.strictEqual(
+client.state.remoteWindowSize,
+defaultSetting.initialWindowSize
+);
+
+server.close();
+client.close();
+}));
+}));
+}

test/parallel/test-http2-server-setLocalWindowSize.js

@@ -0,0 +1,37 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+consthttp2=require('http2');
+
+constserver=http2.createServer();
+server.on('stream',common.mustCall((stream)=>{
+stream.respond();
+stream.end('ok');
+}));
+server.on('session',common.mustCall((session)=>{
+constwindowSize=2**20;
+constdefaultSetting=http2.getDefaultSettings();
+session.setLocalWindowSize(windowSize);
+
+assert.strictEqual(session.state.effectiveLocalWindowSize,windowSize);
+assert.strictEqual(session.state.localWindowSize,windowSize);
+assert.strictEqual(
+session.state.remoteWindowSize,
+defaultSetting.initialWindowSize
+);
+}));
+
+server.listen(0,common.mustCall(()=>{
+constclient=http2.connect(`http://localhost:${server.address().port}`);
+
+constreq=client.request();
+req.resume();
+req.on('close',common.mustCall(()=>{
+client.close();
+server.close();
+}));
+}));