@aptpod/iscp-ts
Version:
iSCP 2.0 client library for TypeScript
532 lines • 27.7 kB
JavaScript
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Upstream_instances, _Upstream_logger, _Upstream_id, _Upstream_idAlias, _Upstream_serverTime, _Upstream_sessionId, _Upstream_ackInterval, _Upstream_expiryInterval, _Upstream_qos, _Upstream_persist, _Upstream_flushPolicy, _Upstream_closeTimeout, _Upstream_closeSession, _Upstream_event, _Upstream_totalDataPoints, _Upstream_resolver, _Upstream_sendBuffer, _Upstream_lock, _Upstream_aliasMap, _Upstream_sequenceNumber, _Upstream_requester, _Upstream_sender, _Upstream_streamReader, _Upstream_abortController, _Upstream_start, _Upstream_readAckLoop, _Upstream_readReopenLoop, _Upstream_flushBufferSizeLoop, _Upstream_flushIntervalLoop, _Upstream_flush, _Upstream_close;
import AwaitLock from 'await-lock';
import { ISCPException, ISCPFailedMessageError, ISCPTimeoutError, ISCPTransportClosedError } from './exceptions';
import { LOGGER_TAG, MAX_UINT64 } from './constant';
import { FlushPolicyHelper } from './flush-policy';
import { UpstreamState, UpstreamChunk as Model$UpstreamChunk, UpstreamChunkAck as Model$UpstreamChunkAck, UpstreamChunkResult as Model$UpstreamChunkResult, DataPointGroup as Model$DataPointGroup, } from './model';
import { DataId, DataPointGroup, DataPoint, UpstreamResumeRequest, UpstreamResumeRequestExtensionFields, UpstreamCloseRequest, UpstreamCloseRequestExtensionFields, UpstreamChunk, UpstreamChunkExtensionFields, StreamChunk, RESULT_CODE, } from './message';
import { Sequence } from './sequence';
import { AliasMap } from './utils/alias-map';
import { Resolver } from './utils/resolver';
import { Condition } from './utils/condition';
import { Timeout } from './utils/timeout';
import { TypedEvent } from './utils/typed-event';
import { StreamReaderIterator } from './utils/stream-reader-iterator';
/**
* アップストリームをクローズした時に呼び出されるイベントです。
* @category Upstream
*/
export class UpstreamClosedEvent {
constructor(init) {
this.state = init.state;
this.error = init.error;
}
}
/**
* データポイントを送信する直前に呼び出されるイベントです。
* @category Upstream
*/
export class UpstreamBeforeSendDataPointsEvent {
constructor(init) {
this.streamId = init.streamId;
this.chunk = init.chunk;
}
}
/**
* アップストリームチャンクに対する確認応答を受信した時に呼び出されるイベントです。
* @category Upstream
*/
export class UpstreamAfterReceiveAckEvent {
constructor(init) {
this.streamId = init.streamId;
this.chunkAck = init.chunkAck;
}
}
/**
* アップストリームを表すクラスです。
*
* @attention このクラスのオブジェクトは、必ず{@link Conn}の{@link Conn.openUpstream}を使用して生成してください。
*
* @category Upstream
*/
export class Upstream {
/**
* @internal
*/
constructor(config) {
_Upstream_instances.add(this);
_Upstream_logger.set(this, void 0);
_Upstream_id.set(this, void 0);
_Upstream_idAlias.set(this, void 0);
_Upstream_serverTime.set(this, void 0);
_Upstream_sessionId.set(this, void 0);
_Upstream_ackInterval.set(this, void 0);
_Upstream_expiryInterval.set(this, void 0);
_Upstream_qos.set(this, void 0);
_Upstream_persist.set(this, void 0);
_Upstream_flushPolicy.set(this, void 0);
_Upstream_closeTimeout.set(this, void 0);
_Upstream_closeSession.set(this, void 0);
_Upstream_event.set(this, void 0);
_Upstream_totalDataPoints.set(this, void 0);
_Upstream_resolver.set(this, void 0);
_Upstream_sendBuffer.set(this, void 0);
_Upstream_lock.set(this, void 0);
_Upstream_aliasMap.set(this, void 0);
_Upstream_sequenceNumber.set(this, void 0);
_Upstream_requester.set(this, void 0);
_Upstream_sender.set(this, void 0);
_Upstream_streamReader.set(this, void 0);
_Upstream_abortController.set(this, void 0);
__classPrivateFieldSet(this, _Upstream_logger, config.logger, "f");
__classPrivateFieldSet(this, _Upstream_id, config.id, "f");
__classPrivateFieldSet(this, _Upstream_idAlias, config.idAlias, "f");
__classPrivateFieldSet(this, _Upstream_serverTime, config.serverTime, "f");
__classPrivateFieldSet(this, _Upstream_sessionId, config.sessionId, "f");
__classPrivateFieldSet(this, _Upstream_ackInterval, config.ackInterval, "f");
__classPrivateFieldSet(this, _Upstream_expiryInterval, config.expiryInterval, "f");
__classPrivateFieldSet(this, _Upstream_qos, config.qos, "f");
__classPrivateFieldSet(this, _Upstream_persist, config.persist, "f");
__classPrivateFieldSet(this, _Upstream_flushPolicy, config.flushPolicy, "f");
__classPrivateFieldSet(this, _Upstream_closeTimeout, config.closeTimeout, "f");
__classPrivateFieldSet(this, _Upstream_closeSession, config.closeSession, "f");
__classPrivateFieldSet(this, _Upstream_event, {
[Upstream.EVENT.BEFORE_SEND_DATA_POINTS]: new TypedEvent(),
[Upstream.EVENT.AFTER_RECEIVE_ACK]: new TypedEvent(),
[Upstream.EVENT.CLOSED]: new TypedEvent(),
}, "f");
__classPrivateFieldSet(this, _Upstream_totalDataPoints, 0n, "f");
__classPrivateFieldSet(this, _Upstream_resolver, {
didAllTask: new Resolver(),
isDraining: new Resolver(),
receivedAllAck: new Resolver(),
isClosed: new Resolver(),
}, "f");
__classPrivateFieldSet(this, _Upstream_sendBuffer, {
dataPointsMap: new Map(),
size: 0,
condition: new Condition(),
}, "f");
__classPrivateFieldSet(this, _Upstream_lock, {
sendBuffer: new AwaitLock(),
flush: new AwaitLock(),
}, "f");
__classPrivateFieldSet(this, _Upstream_aliasMap, {
dataId: AliasMap.fromAliases(config.dataIdAliases),
}, "f");
__classPrivateFieldSet(this, _Upstream_sequenceNumber, {
sequence: Sequence.forSequenceNumber(),
final: 0,
waitingNumbers: new Set(),
}, "f");
__classPrivateFieldSet(this, _Upstream_requester, {
resume: config.resumeRequester,
close: config.closeRequester,
}, "f");
__classPrivateFieldSet(this, _Upstream_sender, {
chunk: config.chunkSender,
}, "f");
__classPrivateFieldSet(this, _Upstream_streamReader, {
chunkAck: config.chunkAckStreamReader,
reopen: config.reopenStreamReader,
}, "f");
__classPrivateFieldSet(this, _Upstream_abortController, new AbortController(), "f");
}
/**
* ストリームIDを取得します。
* @returns ストリームID
*/
get id() {
return __classPrivateFieldGet(this, _Upstream_id, "f");
}
/**
* アップストリームを開いた時のサーバー時刻（ナノ秒）を取得します。
* @returns アップストリームを開いた時のサーバー時刻（ナノ秒）
*/
get serverTime() {
return __classPrivateFieldGet(this, _Upstream_serverTime, "f");
}
/**
* ストリームの状態を取得します。
* @returns アップストリームの状態
*/
get state() {
return new UpstreamState({
dataIdAliases: __classPrivateFieldGet(this, _Upstream_aliasMap, "f").dataId.toAliases(),
totalDataPoints: __classPrivateFieldGet(this, _Upstream_totalDataPoints, "f"),
lastIssuedSequenceNumber: __classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").sequence.current,
dataPointsBuffer: [...__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").dataPointsMap].map(([serializedDataId, dataPoints]) => {
return new Model$DataPointGroup({
dataId: DataId.parse(serializedDataId),
dataPoints: dataPoints.map((dataPoint) => {
return new DataPoint({
elapsedTime: dataPoint.elapsedTime,
payload: dataPoint.payload.slice(),
});
}),
});
}),
});
}
/**
* セッションIDを取得します。
* @returns セッションID
*/
get sessionId() {
return __classPrivateFieldGet(this, _Upstream_sessionId, "f");
}
/**
* Ackの返却間隔を取得します。
* @returns Ackの返却間隔（秒）
*/
get ackInterval() {
return __classPrivateFieldGet(this, _Upstream_ackInterval, "f");
}
/**
* 有効期限を取得します。
* @returns ストリームの有効期限（秒）
*/
get expiryInterval() {
return __classPrivateFieldGet(this, _Upstream_expiryInterval, "f");
}
/**
* QoSを取得します。
* @returns QoS
*/
get qos() {
return __classPrivateFieldGet(this, _Upstream_qos, "f");
}
/**
* 永続化フラグを取得します。
* @returns 永続化フラグ
*/
get persist() {
return __classPrivateFieldGet(this, _Upstream_persist, "f");
}
/**
* フラッシュポリシーを取得します。
* @returns フラッシュポリシー
*/
get flushPolicy() {
return __classPrivateFieldGet(this, _Upstream_flushPolicy, "f");
}
/**
* クローズタイムアウト（秒）を取得します。
* @returns クローズタイムアウト（秒）
*/
get closeTimeout() {
return __classPrivateFieldGet(this, _Upstream_closeTimeout, "f");
}
/**
* クローズ時にセッションをクローズするかどうかを取得します。
* @returns クローズ時にセッションをクローズするかどうか
*/
get closeSession() {
return __classPrivateFieldGet(this, _Upstream_closeSession, "f");
}
/**
* @internal
*/
static async start(config) {
const upstream = new Upstream(config);
__classPrivateFieldGet(upstream, _Upstream_instances, "m", _Upstream_start).call(upstream);
return upstream;
}
/**
* アップストリームを閉じます。
* @param options アップストリームに指定するオプションです。
*/
async close(options) {
await __classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_close).call(this, {
overwriteCloseSession: options?.overwriteCloseSession,
});
}
/**
* アップストリームが閉じるまで待機します。
*/
async waitClosed() {
await __classPrivateFieldGet(this, _Upstream_resolver, "f").isClosed.wait();
}
/**
* データポイントの内部バッファをUpstreamChunkとしてサーバーへ送信します。
*/
async flush() {
await __classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_flush).call(this);
}
/**
* データポイントを送信します。
* @param dataId データID。
* @param dataPoints データポイントのリスト。
*/
async writeDataPoints(dataId, dataPoints) {
await __classPrivateFieldGet(this, _Upstream_lock, "f").sendBuffer.acquireAsync();
if (__classPrivateFieldGet(this, _Upstream_resolver, "f").isDraining.isDone) {
throw new ISCPTransportClosedError('already closed.');
}
//
// update sendBuffer
//
const serializedDataId = dataId.toString();
const sendBuffer = __classPrivateFieldGet(this, _Upstream_sendBuffer, "f").dataPointsMap.get(serializedDataId) ?? [];
sendBuffer.push(...dataPoints);
__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").dataPointsMap.set(serializedDataId, sendBuffer);
//
// update sendBufferSize
//
const dataPointSize = dataPoints.reduce((prev, cur) => prev + cur.payload.byteLength, 0);
__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").size += dataPointSize;
__classPrivateFieldGet(this, _Upstream_lock, "f").sendBuffer.release();
//
// Notify
//
__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").condition.notify();
}
addEventListener(name, listener, options) {
if (name in __classPrivateFieldGet(this, _Upstream_event, "f")) {
const event = __classPrivateFieldGet(this, _Upstream_event, "f")[name];
options?.once ? event.once(listener) : event.on(listener);
return;
}
throw new ISCPException('Unrecognized EventName.');
}
removeEventListener(name, listener) {
if (name in __classPrivateFieldGet(this, _Upstream_event, "f")) {
__classPrivateFieldGet(this, _Upstream_event, "f")[name].off(listener);
return;
}
throw new ISCPException('Unrecognized EventName.');
}
}
_Upstream_logger = new WeakMap(), _Upstream_id = new WeakMap(), _Upstream_idAlias = new WeakMap(), _Upstream_serverTime = new WeakMap(), _Upstream_sessionId = new WeakMap(), _Upstream_ackInterval = new WeakMap(), _Upstream_expiryInterval = new WeakMap(), _Upstream_qos = new WeakMap(), _Upstream_persist = new WeakMap(), _Upstream_flushPolicy = new WeakMap(), _Upstream_closeTimeout = new WeakMap(), _Upstream_closeSession = new WeakMap(), _Upstream_event = new WeakMap(), _Upstream_totalDataPoints = new WeakMap(), _Upstream_resolver = new WeakMap(), _Upstream_sendBuffer = new WeakMap(), _Upstream_lock = new WeakMap(), _Upstream_aliasMap = new WeakMap(), _Upstream_sequenceNumber = new WeakMap(), _Upstream_requester = new WeakMap(), _Upstream_sender = new WeakMap(), _Upstream_streamReader = new WeakMap(), _Upstream_abortController = new WeakMap(), _Upstream_instances = new WeakSet(), _Upstream_start = async function _Upstream_start() {
Promise.all([__classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_readAckLoop).call(this), __classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_readReopenLoop).call(this), __classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_flushBufferSizeLoop).call(this), __classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_flushIntervalLoop).call(this)])
.catch((error) => {
const overwriteError = error instanceof Error ? error : new Error(String(error));
__classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_close).call(this, {
overwriteError,
});
})
.finally(() => {
__classPrivateFieldGet(this, _Upstream_resolver, "f").didAllTask.resolve();
});
}, _Upstream_readAckLoop = async function _Upstream_readAckLoop() {
__classPrivateFieldGet(this, _Upstream_abortController, "f").signal.addEventListener('abort', () => {
__classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").waitingNumbers.clear();
__classPrivateFieldGet(this, _Upstream_streamReader, "f").chunkAck.cancel();
});
const resolveReceivedAllAckIfComplete = () => {
if (__classPrivateFieldGet(this, _Upstream_resolver, "f").isDraining.isDone && __classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").waitingNumbers.size === 0) {
__classPrivateFieldGet(this, _Upstream_resolver, "f").receivedAllAck.resolve();
}
};
__classPrivateFieldGet(this, _Upstream_resolver, "f").isDraining.wait().then(() => {
resolveReceivedAllAckIfComplete();
});
for (;;) {
const chunkAckResult = await __classPrivateFieldGet(this, _Upstream_streamReader, "f").chunkAck.read();
if (chunkAckResult.done) {
resolveReceivedAllAckIfComplete();
break;
}
const chunkAck = chunkAckResult.value;
for (const [maybeDataIdAlias, dataId] of Object.entries(chunkAck.dataIdAliases)) {
__classPrivateFieldGet(this, _Upstream_aliasMap, "f").dataId.set(Number(maybeDataIdAlias), dataId);
}
const afterReceiveAckEvent = new UpstreamAfterReceiveAckEvent({
streamId: __classPrivateFieldGet(this, _Upstream_id, "f"),
chunkAck: new Model$UpstreamChunkAck({
results: chunkAck.results.map((result) => {
return new Model$UpstreamChunkResult({
sequenceNumber: result.sequenceNumber,
resultCode: result.resultCode,
resultString: result.resultString,
});
}),
}),
});
__classPrivateFieldGet(this, _Upstream_event, "f")[Upstream.EVENT.AFTER_RECEIVE_ACK].emit(afterReceiveAckEvent);
for (const { sequenceNumber } of chunkAck.results) {
__classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").waitingNumbers.delete(sequenceNumber);
}
resolveReceivedAllAckIfComplete();
}
}, _Upstream_readReopenLoop = async function _Upstream_readReopenLoop() {
const reopenIterator = new StreamReaderIterator(__classPrivateFieldGet(this, _Upstream_streamReader, "f").reopen);
__classPrivateFieldGet(this, _Upstream_abortController, "f").signal.addEventListener('abort', () => {
reopenIterator.cancel();
});
// eslint-disable-next-line @typescript-eslint/no-unused-vars
for await (const _ of reopenIterator) {
const response = await __classPrivateFieldGet(this, _Upstream_requester, "f").resume(new UpstreamResumeRequest({
requestId: 0,
streamId: __classPrivateFieldGet(this, _Upstream_id, "f"),
extensionFields: new UpstreamResumeRequestExtensionFields(),
}));
if (response.resultCode !== RESULT_CODE.SUCCEEDED) {
throw new ISCPFailedMessageError(response);
}
}
}, _Upstream_flushBufferSizeLoop = async function _Upstream_flushBufferSizeLoop() {
for (;;) {
// @memo wait の promise を先に取得しておき、loopの最後にawaitで評価する
const sendBufferConditionWait = __classPrivateFieldGet(this, _Upstream_sendBuffer, "f").condition.wait();
if (__classPrivateFieldGet(this, _Upstream_abortController, "f").signal.aborted) {
break;
}
if (__classPrivateFieldGet(this, _Upstream_resolver, "f").isDraining.isDone) {
break;
}
const isFlush = FlushPolicyHelper.isFlush(__classPrivateFieldGet(this, _Upstream_flushPolicy, "f"), __classPrivateFieldGet(this, _Upstream_sendBuffer, "f").size);
if (isFlush) {
await __classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_flush).call(this);
}
await sendBufferConditionWait;
}
}, _Upstream_flushIntervalLoop = async function _Upstream_flushIntervalLoop() {
const ticker = FlushPolicyHelper.ticker(__classPrivateFieldGet(this, _Upstream_flushPolicy, "f"), __classPrivateFieldGet(this, _Upstream_abortController, "f").signal);
if (!ticker) {
return;
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
for await (const _ of ticker) {
// @memo wait の promise を先に取得しておき、loopの最後にawaitで評価する
const sendBufferConditionWait = __classPrivateFieldGet(this, _Upstream_sendBuffer, "f").condition.wait();
if (__classPrivateFieldGet(this, _Upstream_abortController, "f").signal.aborted) {
break;
}
if (__classPrivateFieldGet(this, _Upstream_resolver, "f").isDraining.isDone) {
break;
}
await __classPrivateFieldGet(this, _Upstream_instances, "m", _Upstream_flush).call(this);
await sendBufferConditionWait;
}
}, _Upstream_flush = async function _Upstream_flush() {
const dataIds = [];
const dataPointGroups = [];
const modelDataPointGroups = [];
try {
await __classPrivateFieldGet(this, _Upstream_lock, "f").flush.acquireAsync();
await __classPrivateFieldGet(this, _Upstream_lock, "f").sendBuffer.acquireAsync();
if (__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").dataPointsMap.size === 0) {
return;
}
for (const [serializedDataId, dataPoints] of __classPrivateFieldGet(this, _Upstream_sendBuffer, "f").dataPointsMap.entries()) {
const dataId = DataId.parse(serializedDataId);
modelDataPointGroups.push(new Model$DataPointGroup({ dataId, dataPoints }));
__classPrivateFieldSet(this, _Upstream_totalDataPoints, __classPrivateFieldGet(this, _Upstream_totalDataPoints, "f") + BigInt(dataPoints.length), "f");
if (__classPrivateFieldGet(this, _Upstream_totalDataPoints, "f") > MAX_UINT64) {
throw new ISCPException('maximum total_data_points exceeded.');
}
const dataIdAlias = __classPrivateFieldGet(this, _Upstream_aliasMap, "f").dataId.findAlias(dataId);
if (typeof dataIdAlias === 'undefined') {
dataIds.push(dataId);
dataPointGroups.push(new DataPointGroup({ dataIdOrAlias: dataId, dataPoints }));
continue;
}
dataPointGroups.push(new DataPointGroup({ dataIdOrAlias: dataIdAlias, dataPoints }));
}
const sequenceNumber = __classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").sequence.next();
const chunk = new UpstreamChunk({
streamIdAlias: __classPrivateFieldGet(this, _Upstream_idAlias, "f"),
streamChunk: new StreamChunk({
sequenceNumber,
dataPointGroups,
}),
dataIds,
extensionFields: new UpstreamChunkExtensionFields(),
});
__classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").final = sequenceNumber;
__classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").waitingNumbers.add(sequenceNumber);
const beforeSendDataPointsEvent = new UpstreamBeforeSendDataPointsEvent({
streamId: __classPrivateFieldGet(this, _Upstream_id, "f"),
chunk: new Model$UpstreamChunk({
sequenceNumber,
dataPointGroups: modelDataPointGroups,
}),
});
__classPrivateFieldGet(this, _Upstream_event, "f")[Upstream.EVENT.BEFORE_SEND_DATA_POINTS].emit(beforeSendDataPointsEvent);
await __classPrivateFieldGet(this, _Upstream_sender, "f").chunk(chunk);
__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").dataPointsMap.clear();
__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").size = 0;
}
finally {
__classPrivateFieldGet(this, _Upstream_lock, "f").flush.release();
__classPrivateFieldGet(this, _Upstream_lock, "f").sendBuffer.release();
}
}, _Upstream_close = async function _Upstream_close(config) {
const { overwriteError, overwriteCloseSession } = config;
let finalError = overwriteError;
if (__classPrivateFieldGet(this, _Upstream_resolver, "f").isClosed.isDone) {
return;
}
if (__classPrivateFieldGet(this, _Upstream_resolver, "f").isDraining.isDone) {
throw new ISCPException('already draining.');
}
__classPrivateFieldGet(this, _Upstream_resolver, "f").isDraining.resolve();
try {
__classPrivateFieldGet(this, _Upstream_sendBuffer, "f").condition.notify();
const receivedAllAckTimeout = new Timeout();
const waitingSendBufferResult = await Promise.race([
__classPrivateFieldGet(this, _Upstream_resolver, "f").receivedAllAck.wait(),
receivedAllAckTimeout.run(new ISCPTimeoutError(), __classPrivateFieldGet(this, _Upstream_closeTimeout, "f") * 1e3),
]).finally(() => {
receivedAllAckTimeout.cancel();
});
if (waitingSendBufferResult instanceof ISCPTimeoutError) {
__classPrivateFieldGet(this, _Upstream_logger, "f").warn(LOGGER_TAG.UPSTREAM, waitingSendBufferResult);
}
__classPrivateFieldGet(this, _Upstream_abortController, "f").abort();
await __classPrivateFieldGet(this, _Upstream_resolver, "f").didAllTask.wait();
}
catch (error) {
__classPrivateFieldGet(this, _Upstream_logger, "f").warn(LOGGER_TAG.UPSTREAM, error);
if (typeof finalError === 'undefined') {
finalError = error instanceof Error ? error : new Error(String(error));
}
}
try {
const response = await __classPrivateFieldGet(this, _Upstream_requester, "f").close(new UpstreamCloseRequest({
requestId: 0,
streamId: __classPrivateFieldGet(this, _Upstream_id, "f"),
totalDataPoints: __classPrivateFieldGet(this, _Upstream_totalDataPoints, "f"),
finalSequenceNumber: __classPrivateFieldGet(this, _Upstream_sequenceNumber, "f").final,
extensionFields: new UpstreamCloseRequestExtensionFields({
closeSession: overwriteCloseSession ?? __classPrivateFieldGet(this, _Upstream_closeSession, "f"),
}),
}));
if (response.resultCode !== RESULT_CODE.SUCCEEDED) {
__classPrivateFieldGet(this, _Upstream_logger, "f").error(LOGGER_TAG.UPSTREAM, `Failed to close a upstream. streamId ${__classPrivateFieldGet(this, _Upstream_id, "f")} msg=${response.resultString}`);
}
}
finally {
__classPrivateFieldGet(this, _Upstream_resolver, "f").isClosed.resolve();
const closedEvent = new UpstreamClosedEvent({ state: this.state, error: finalError });
__classPrivateFieldGet(this, _Upstream_event, "f")[Upstream.EVENT.CLOSED].emit(closedEvent);
}
try {
;
[...Object.values(__classPrivateFieldGet(this, _Upstream_event, "f"))].forEach((event) => event.dispose());
}
catch (error) {
__classPrivateFieldGet(this, _Upstream_logger, "f").warn(LOGGER_TAG.UPSTREAM, `Failed to close a upstream dispose. streamId ${__classPrivateFieldGet(this, _Upstream_id, "f")}`);
}
};
Upstream.EVENT = {
/** データポイントを送信する直前に呼び出されるイベントです。 */
BEFORE_SEND_DATA_POINTS: 'beforeSendDataPoints',
/** アップストリームチャンクに対する確認応答を受信した時に呼び出されるイベントです。 */
AFTER_RECEIVE_ACK: 'afterReceiveAck',
/** アップストリームチャンクに対する確認応答を受信した時に呼び出されるイベントです。 */
CLOSED: 'closed',
};
//# sourceMappingURL=upstream.js.map