grpc-libp2p-client 0.0.8 → 0.0.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/grpc.js +149 -21
- package/dist/grpc.js.map +1 -1
- package/dist/grpc.min.js +1 -1
- package/dist/grpc.min.js.map +1 -1
- package/dist/index.cjs.js +141 -7
- package/dist/index.cjs.js.map +1 -1
- package/dist/index.d.ts +16 -1
- package/dist/index.esm.js +141 -7
- package/dist/index.esm.js.map +1 -1
- package/package.json +1 -1
- package/src/dc-http2/parser.ts +39 -23
- package/src/index.ts +298 -135
package/dist/grpc.js
CHANGED
|
@@ -3316,30 +3316,77 @@
|
|
|
3316
3316
|
});
|
|
3317
3317
|
});
|
|
3318
3318
|
};
|
|
3319
|
-
|
|
3319
|
+
/**
|
|
3320
|
+
* 执行GRPC调用，支持通过context和返回的取消函数控制终止
|
|
3321
|
+
* @param method GRPC方法名
|
|
3322
|
+
* @param requestData 请求数据
|
|
3323
|
+
* @param timeout 超时时间(毫秒)
|
|
3324
|
+
* @param mode 调用模式: 'unary'|'server-streaming'|'client-streaming'|'bidirectional'
|
|
3325
|
+
* @param onDataCallback 数据回调函数
|
|
3326
|
+
* @param dataSourceCallback 客户端流数据源回调
|
|
3327
|
+
* @param onEndCallback 结束回调函数
|
|
3328
|
+
* @param onErrorCallback 错误回调函数
|
|
3329
|
+
* @param context 操作上下文，包含AbortSignal用于取消操作
|
|
3330
|
+
* @returns 取消函数，可随时调用终止操作
|
|
3331
|
+
*/
|
|
3332
|
+
Libp2pGrpcClient.prototype.Call = function (method, requestData, timeout, mode, onDataCallback, dataSourceCallback, onEndCallback, onErrorCallback, context) {
|
|
3320
3333
|
return __awaiter(this, void 0, void 0, function () {
|
|
3321
|
-
var timeoutHandle,
|
|
3334
|
+
var internalController, timeoutHandle, stream, cancelOperation, timeoutPromise, operationPromise;
|
|
3322
3335
|
var _this = this;
|
|
3323
3336
|
return __generator(this, function (_a) {
|
|
3337
|
+
internalController = new AbortController();
|
|
3338
|
+
stream = null;
|
|
3339
|
+
cancelOperation = function () {
|
|
3340
|
+
internalController.abort();
|
|
3341
|
+
if (timeoutHandle) {
|
|
3342
|
+
clearTimeout(timeoutHandle);
|
|
3343
|
+
}
|
|
3344
|
+
if (stream) {
|
|
3345
|
+
try {
|
|
3346
|
+
stream.abort(new Error('Operation cancelled'));
|
|
3347
|
+
}
|
|
3348
|
+
catch (err) {
|
|
3349
|
+
console.error('Error closing stream on cancel:', err);
|
|
3350
|
+
}
|
|
3351
|
+
}
|
|
3352
|
+
};
|
|
3353
|
+
// 如果提供了外部信号，监听它
|
|
3354
|
+
if (context === null || context === void 0 ? void 0 : context.signal) {
|
|
3355
|
+
// 如果外部信号已经触发中止，立即返回
|
|
3356
|
+
if (context.signal.aborted) {
|
|
3357
|
+
if (onErrorCallback) {
|
|
3358
|
+
onErrorCallback(new Error('Operation aborted by context'));
|
|
3359
|
+
}
|
|
3360
|
+
cancelOperation();
|
|
3361
|
+
}
|
|
3362
|
+
// 监听外部的abort事件
|
|
3363
|
+
context.signal.addEventListener('abort', function () {
|
|
3364
|
+
cancelOperation();
|
|
3365
|
+
});
|
|
3366
|
+
}
|
|
3324
3367
|
timeoutPromise = new Promise(function (_, reject) {
|
|
3325
|
-
|
|
3368
|
+
timeoutHandle = setTimeout(function () {
|
|
3369
|
+
reject(new Error('Operation timed out'));
|
|
3370
|
+
cancelOperation();
|
|
3371
|
+
}, timeout);
|
|
3326
3372
|
});
|
|
3327
|
-
hpack = new HPACK();
|
|
3328
3373
|
operationPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
|
|
3329
|
-
var
|
|
3374
|
+
var messageBuffer, expectedMessageLength, hpack, connection, streamId, writer_2, parser, preface, settingFrame, ackSettingFrame, headerFrame, dataFrames, _i, dataFrames_2, dataFrame, dataFrames, _a, dataFrames_3, dataFrame, _b, _c, _d, chunk, dataFrames, _e, dataFrames_4, dataFrame, e_1_1, finalFrame, err_2, err_3;
|
|
3330
3375
|
var _this = this;
|
|
3331
3376
|
var _f, e_1, _g, _h;
|
|
3332
3377
|
return __generator(this, function (_j) {
|
|
3333
3378
|
switch (_j.label) {
|
|
3334
3379
|
case 0:
|
|
3335
|
-
|
|
3336
|
-
|
|
3337
|
-
;
|
|
3338
|
-
expectedMessageLength = -1 // 当前消息的期望长度
|
|
3339
|
-
;
|
|
3380
|
+
messageBuffer = new Uint8Array(0);
|
|
3381
|
+
expectedMessageLength = -1;
|
|
3382
|
+
hpack = new HPACK();
|
|
3340
3383
|
_j.label = 1;
|
|
3341
3384
|
case 1:
|
|
3342
|
-
_j.trys.push([1, 37, 38,
|
|
3385
|
+
_j.trys.push([1, 37, 38, 43]);
|
|
3386
|
+
// 检查是否已经中止
|
|
3387
|
+
if (internalController.signal.aborted) {
|
|
3388
|
+
throw new Error('Operation aborted');
|
|
3389
|
+
}
|
|
3343
3390
|
return [4 /*yield*/, this.node.dial(this.peerAddr)];
|
|
3344
3391
|
case 2:
|
|
3345
3392
|
connection = _j.sent();
|
|
@@ -3350,10 +3397,14 @@
|
|
|
3350
3397
|
writer_2 = new StreamWriter(stream.sink);
|
|
3351
3398
|
parser = new HTTP2Parser(writer_2);
|
|
3352
3399
|
clearTimeout(timeoutHandle);
|
|
3353
|
-
//
|
|
3400
|
+
// 在各个回调中检查是否已中止
|
|
3354
3401
|
parser.onData = function (payload, frameHeader) { return __awaiter(_this, void 0, void 0, function () {
|
|
3355
3402
|
var newBuffer, compressionFlag, lengthBytes, completeMessage;
|
|
3356
3403
|
return __generator(this, function (_a) {
|
|
3404
|
+
// 检查是否已中止
|
|
3405
|
+
if (internalController.signal.aborted) {
|
|
3406
|
+
return [2 /*return*/];
|
|
3407
|
+
}
|
|
3357
3408
|
try {
|
|
3358
3409
|
newBuffer = new Uint8Array(messageBuffer.length + payload.length);
|
|
3359
3410
|
newBuffer.set(messageBuffer);
|
|
@@ -3361,6 +3412,10 @@
|
|
|
3361
3412
|
messageBuffer = newBuffer;
|
|
3362
3413
|
// 处理缓冲区中的完整消息
|
|
3363
3414
|
while (messageBuffer.length > 0) {
|
|
3415
|
+
// 如果已经中止，停止处理
|
|
3416
|
+
if (internalController.signal.aborted) {
|
|
3417
|
+
return [2 /*return*/];
|
|
3418
|
+
}
|
|
3364
3419
|
// 如果还没有读取消息长度，且缓冲区有足够数据
|
|
3365
3420
|
if (expectedMessageLength === -1 && messageBuffer.length >= 5) {
|
|
3366
3421
|
compressionFlag = messageBuffer[0];
|
|
@@ -3394,10 +3449,16 @@
|
|
|
3394
3449
|
});
|
|
3395
3450
|
}); };
|
|
3396
3451
|
parser.onSettings = function () {
|
|
3452
|
+
// 检查是否已中止
|
|
3453
|
+
if (internalController.signal.aborted)
|
|
3454
|
+
return;
|
|
3397
3455
|
var ackSettingFrame = Http2Frame.createSettingsAckFrame();
|
|
3398
3456
|
writer_2.write(ackSettingFrame);
|
|
3399
3457
|
};
|
|
3400
3458
|
parser.onHeaders = function (headers, header) {
|
|
3459
|
+
// 检查是否已中止
|
|
3460
|
+
if (internalController.signal.aborted)
|
|
3461
|
+
return;
|
|
3401
3462
|
var plainHeaders = hpack.decodeHeaderFields(headers);
|
|
3402
3463
|
if (plainHeaders.get('grpc-status') === '0') ;
|
|
3403
3464
|
else if (plainHeaders.get('grpc-status') !== undefined) {
|
|
@@ -3412,34 +3473,62 @@
|
|
|
3412
3473
|
}
|
|
3413
3474
|
};
|
|
3414
3475
|
parser.processStream(stream);
|
|
3476
|
+
// 检查是否已中止
|
|
3477
|
+
if (internalController.signal.aborted) {
|
|
3478
|
+
throw new Error('Operation aborted');
|
|
3479
|
+
}
|
|
3415
3480
|
preface = Http2Frame.createPreface();
|
|
3416
3481
|
return [4 /*yield*/, writer_2.write(preface)];
|
|
3417
3482
|
case 4:
|
|
3418
3483
|
_j.sent();
|
|
3484
|
+
// 检查是否已中止
|
|
3485
|
+
if (internalController.signal.aborted) {
|
|
3486
|
+
throw new Error('Operation aborted');
|
|
3487
|
+
}
|
|
3419
3488
|
settingFrame = Http2Frame.createSettingsFrame();
|
|
3420
3489
|
return [4 /*yield*/, writer_2.write(settingFrame)];
|
|
3421
3490
|
case 5:
|
|
3422
3491
|
_j.sent();
|
|
3492
|
+
// 检查是否已中止
|
|
3493
|
+
if (internalController.signal.aborted) {
|
|
3494
|
+
throw new Error('Operation aborted');
|
|
3495
|
+
}
|
|
3423
3496
|
// Wait for the acknowledgement of SETTINGS
|
|
3424
3497
|
return [4 /*yield*/, parser.waitForSettingsAck()];
|
|
3425
3498
|
case 6:
|
|
3426
3499
|
// Wait for the acknowledgement of SETTINGS
|
|
3427
3500
|
_j.sent();
|
|
3501
|
+
// 检查是否已中止
|
|
3502
|
+
if (internalController.signal.aborted) {
|
|
3503
|
+
throw new Error('Operation aborted');
|
|
3504
|
+
}
|
|
3428
3505
|
ackSettingFrame = Http2Frame.createSettingsAckFrame();
|
|
3429
3506
|
return [4 /*yield*/, writer_2.write(ackSettingFrame)];
|
|
3430
3507
|
case 7:
|
|
3431
3508
|
_j.sent();
|
|
3509
|
+
// 检查是否已中止
|
|
3510
|
+
if (internalController.signal.aborted) {
|
|
3511
|
+
throw new Error('Operation aborted');
|
|
3512
|
+
}
|
|
3432
3513
|
headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
|
|
3433
3514
|
if (!(mode === 'unary' || mode === 'server-streaming')) return [3 /*break*/, 13];
|
|
3434
3515
|
dataFrames = Http2Frame.createDataFrames(streamId, requestData, true);
|
|
3435
3516
|
return [4 /*yield*/, writer_2.write(new Uint8Array(__spreadArray([], headerFrame, true)))];
|
|
3436
3517
|
case 8:
|
|
3437
3518
|
_j.sent();
|
|
3519
|
+
// 检查是否已中止
|
|
3520
|
+
if (internalController.signal.aborted) {
|
|
3521
|
+
throw new Error('Operation aborted');
|
|
3522
|
+
}
|
|
3438
3523
|
_i = 0, dataFrames_2 = dataFrames;
|
|
3439
3524
|
_j.label = 9;
|
|
3440
3525
|
case 9:
|
|
3441
3526
|
if (!(_i < dataFrames_2.length)) return [3 /*break*/, 12];
|
|
3442
3527
|
dataFrame = dataFrames_2[_i];
|
|
3528
|
+
// 检查是否已中止
|
|
3529
|
+
if (internalController.signal.aborted) {
|
|
3530
|
+
throw new Error('Operation aborted');
|
|
3531
|
+
}
|
|
3443
3532
|
return [4 /*yield*/, writer_2.write(dataFrame)];
|
|
3444
3533
|
case 10:
|
|
3445
3534
|
_j.sent();
|
|
@@ -3453,6 +3542,10 @@
|
|
|
3453
3542
|
return [4 /*yield*/, writer_2.write(headerFrame)];
|
|
3454
3543
|
case 14:
|
|
3455
3544
|
_j.sent();
|
|
3545
|
+
// 检查是否已中止
|
|
3546
|
+
if (internalController.signal.aborted) {
|
|
3547
|
+
throw new Error('Operation aborted');
|
|
3548
|
+
}
|
|
3456
3549
|
if (!(requestData.length > 0)) return [3 /*break*/, 18];
|
|
3457
3550
|
dataFrames = Http2Frame.createDataFrames(streamId, requestData, false);
|
|
3458
3551
|
_a = 0, dataFrames_3 = dataFrames;
|
|
@@ -3460,6 +3553,10 @@
|
|
|
3460
3553
|
case 15:
|
|
3461
3554
|
if (!(_a < dataFrames_3.length)) return [3 /*break*/, 18];
|
|
3462
3555
|
dataFrame = dataFrames_3[_a];
|
|
3556
|
+
// 检查是否已中止
|
|
3557
|
+
if (internalController.signal.aborted) {
|
|
3558
|
+
throw new Error('Operation aborted');
|
|
3559
|
+
}
|
|
3463
3560
|
return [4 /*yield*/, writer_2.write(dataFrame)];
|
|
3464
3561
|
case 16:
|
|
3465
3562
|
_j.sent();
|
|
@@ -3477,12 +3574,20 @@
|
|
|
3477
3574
|
_h = _d.value;
|
|
3478
3575
|
_b = false;
|
|
3479
3576
|
chunk = _h;
|
|
3577
|
+
// 检查是否已中止
|
|
3578
|
+
if (internalController.signal.aborted) {
|
|
3579
|
+
throw new Error('Operation aborted');
|
|
3580
|
+
}
|
|
3480
3581
|
dataFrames = Http2Frame.createDataFrames(streamId, chunk, false);
|
|
3481
3582
|
_e = 0, dataFrames_4 = dataFrames;
|
|
3482
3583
|
_j.label = 21;
|
|
3483
3584
|
case 21:
|
|
3484
3585
|
if (!(_e < dataFrames_4.length)) return [3 /*break*/, 24];
|
|
3485
3586
|
dataFrame = dataFrames_4[_e];
|
|
3587
|
+
// 检查是否已中止
|
|
3588
|
+
if (internalController.signal.aborted) {
|
|
3589
|
+
throw new Error('Operation aborted');
|
|
3590
|
+
}
|
|
3486
3591
|
return [4 /*yield*/, writer_2.write(dataFrame)];
|
|
3487
3592
|
case 22:
|
|
3488
3593
|
_j.sent();
|
|
@@ -3511,6 +3616,10 @@
|
|
|
3511
3616
|
return [7 /*endfinally*/];
|
|
3512
3617
|
case 31: return [7 /*endfinally*/];
|
|
3513
3618
|
case 32:
|
|
3619
|
+
// 检查是否已中止
|
|
3620
|
+
if (internalController.signal.aborted) {
|
|
3621
|
+
throw new Error('Operation aborted');
|
|
3622
|
+
}
|
|
3514
3623
|
finalFrame = Http2Frame.createDataFrame(streamId, new Uint8Array(), true);
|
|
3515
3624
|
return [4 /*yield*/, writer_2.write(finalFrame)];
|
|
3516
3625
|
case 33:
|
|
@@ -3519,16 +3628,27 @@
|
|
|
3519
3628
|
case 34:
|
|
3520
3629
|
_j.sent();
|
|
3521
3630
|
_j.label = 35;
|
|
3522
|
-
case 35:
|
|
3631
|
+
case 35:
|
|
3632
|
+
// 检查是否已中止
|
|
3633
|
+
if (internalController.signal.aborted) {
|
|
3634
|
+
throw new Error('Operation aborted');
|
|
3635
|
+
}
|
|
3636
|
+
return [4 /*yield*/, parser.waitForEndOfStream(0)];
|
|
3523
3637
|
case 36:
|
|
3524
3638
|
_j.sent();
|
|
3525
3639
|
if (onEndCallback) {
|
|
3526
3640
|
onEndCallback();
|
|
3527
3641
|
}
|
|
3528
|
-
return [3 /*break*/,
|
|
3642
|
+
return [3 /*break*/, 43];
|
|
3529
3643
|
case 37:
|
|
3530
3644
|
err_2 = _j.sent();
|
|
3531
|
-
|
|
3645
|
+
// 如果是由于取消导致的错误，使用特定的错误消息
|
|
3646
|
+
if (internalController.signal.aborted && err_2 instanceof Error && err_2.message === 'Operation aborted') {
|
|
3647
|
+
if (onErrorCallback) {
|
|
3648
|
+
onErrorCallback(new Error('Operation cancelled by user'));
|
|
3649
|
+
}
|
|
3650
|
+
}
|
|
3651
|
+
else if (onErrorCallback) {
|
|
3532
3652
|
onErrorCallback(err_2);
|
|
3533
3653
|
}
|
|
3534
3654
|
else {
|
|
@@ -3539,18 +3659,26 @@
|
|
|
3539
3659
|
console.error('asyncCall error:', err_2);
|
|
3540
3660
|
}
|
|
3541
3661
|
}
|
|
3542
|
-
return [3 /*break*/,
|
|
3662
|
+
return [3 /*break*/, 43];
|
|
3543
3663
|
case 38:
|
|
3544
|
-
if (!stream) return [3 /*break*/,
|
|
3545
|
-
|
|
3664
|
+
if (!stream) return [3 /*break*/, 42];
|
|
3665
|
+
_j.label = 39;
|
|
3546
3666
|
case 39:
|
|
3667
|
+
_j.trys.push([39, 41, , 42]);
|
|
3668
|
+
return [4 /*yield*/, stream.close()];
|
|
3669
|
+
case 40:
|
|
3547
3670
|
_j.sent();
|
|
3548
|
-
|
|
3549
|
-
case
|
|
3550
|
-
|
|
3671
|
+
return [3 /*break*/, 42];
|
|
3672
|
+
case 41:
|
|
3673
|
+
err_3 = _j.sent();
|
|
3674
|
+
console.error('Error closing stream:', err_3);
|
|
3675
|
+
return [3 /*break*/, 42];
|
|
3676
|
+
case 42: return [7 /*endfinally*/];
|
|
3677
|
+
case 43: return [2 /*return*/];
|
|
3551
3678
|
}
|
|
3552
3679
|
});
|
|
3553
3680
|
}); })();
|
|
3681
|
+
// 执行操作并返回取消函数
|
|
3554
3682
|
return [2 /*return*/, Promise.race([operationPromise, timeoutPromise])];
|
|
3555
3683
|
});
|
|
3556
3684
|
});
|