summaryrefslogtreecommitdiff
path: root/frontend-old/node_modules/@grpc/grpc-js/build/src/server-call.js
diff options
context:
space:
mode:
authoraltaf-creator <dev@altafcreator.com>2025-11-09 11:15:19 +0800
committeraltaf-creator <dev@altafcreator.com>2025-11-09 11:15:19 +0800
commit8eff962cab608341a6f2fedc640a0e32d96f26e2 (patch)
tree05534d1a720ddc3691d346c69b4972555820a061 /frontend-old/node_modules/@grpc/grpc-js/build/src/server-call.js
pain
Diffstat (limited to 'frontend-old/node_modules/@grpc/grpc-js/build/src/server-call.js')
-rw-r--r--frontend-old/node_modules/@grpc/grpc-js/build/src/server-call.js695
1 files changed, 695 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@grpc/grpc-js/build/src/server-call.js b/frontend-old/node_modules/@grpc/grpc-js/build/src/server-call.js
new file mode 100644
index 0000000..05ca531
--- /dev/null
+++ b/frontend-old/node_modules/@grpc/grpc-js/build/src/server-call.js
@@ -0,0 +1,695 @@
+"use strict";
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Http2ServerCallStream = exports.ServerDuplexStreamImpl = exports.ServerWritableStreamImpl = exports.ServerReadableStreamImpl = exports.ServerUnaryCallImpl = void 0;
+const events_1 = require("events");
+const http2 = require("http2");
+const stream_1 = require("stream");
+const zlib = require("zlib");
+const constants_1 = require("./constants");
+const metadata_1 = require("./metadata");
+const stream_decoder_1 = require("./stream-decoder");
+const logging = require("./logging");
+const error_1 = require("./error");
+const TRACER_NAME = 'server_call';
+function trace(text) {
+ logging.trace(constants_1.LogVerbosity.DEBUG, TRACER_NAME, text);
+}
+const GRPC_ACCEPT_ENCODING_HEADER = 'grpc-accept-encoding';
+const GRPC_ENCODING_HEADER = 'grpc-encoding';
+const GRPC_MESSAGE_HEADER = 'grpc-message';
+const GRPC_STATUS_HEADER = 'grpc-status';
+const GRPC_TIMEOUT_HEADER = 'grpc-timeout';
+const DEADLINE_REGEX = /(\d{1,8})\s*([HMSmun])/;
+const deadlineUnitsToMs = {
+ H: 3600000,
+ M: 60000,
+ S: 1000,
+ m: 1,
+ u: 0.001,
+ n: 0.000001,
+};
+const defaultCompressionHeaders = {
+ // TODO(cjihrig): Remove these encoding headers from the default response
+ // once compression is integrated.
+ [GRPC_ACCEPT_ENCODING_HEADER]: 'identity,deflate,gzip',
+ [GRPC_ENCODING_HEADER]: 'identity',
+};
+const defaultResponseHeaders = {
+ [http2.constants.HTTP2_HEADER_STATUS]: http2.constants.HTTP_STATUS_OK,
+ [http2.constants.HTTP2_HEADER_CONTENT_TYPE]: 'application/grpc+proto',
+};
+const defaultResponseOptions = {
+ waitForTrailers: true,
+};
+class ServerUnaryCallImpl extends events_1.EventEmitter {
+ constructor(call, metadata, request) {
+ super();
+ this.call = call;
+ this.metadata = metadata;
+ this.request = request;
+ this.cancelled = false;
+ this.call.setupSurfaceCall(this);
+ }
+ getPeer() {
+ return this.call.getPeer();
+ }
+ sendMetadata(responseMetadata) {
+ this.call.sendMetadata(responseMetadata);
+ }
+ getDeadline() {
+ return this.call.getDeadline();
+ }
+ getPath() {
+ return this.call.getPath();
+ }
+}
+exports.ServerUnaryCallImpl = ServerUnaryCallImpl;
+class ServerReadableStreamImpl extends stream_1.Readable {
+ constructor(call, metadata, deserialize, encoding) {
+ super({ objectMode: true });
+ this.call = call;
+ this.metadata = metadata;
+ this.deserialize = deserialize;
+ this.cancelled = false;
+ this.call.setupSurfaceCall(this);
+ this.call.setupReadable(this, encoding);
+ }
+ _read(size) {
+ if (!this.call.consumeUnpushedMessages(this)) {
+ return;
+ }
+ this.call.resume();
+ }
+ getPeer() {
+ return this.call.getPeer();
+ }
+ sendMetadata(responseMetadata) {
+ this.call.sendMetadata(responseMetadata);
+ }
+ getDeadline() {
+ return this.call.getDeadline();
+ }
+ getPath() {
+ return this.call.getPath();
+ }
+}
+exports.ServerReadableStreamImpl = ServerReadableStreamImpl;
+class ServerWritableStreamImpl extends stream_1.Writable {
+ constructor(call, metadata, serialize, request) {
+ super({ objectMode: true });
+ this.call = call;
+ this.metadata = metadata;
+ this.serialize = serialize;
+ this.request = request;
+ this.cancelled = false;
+ this.trailingMetadata = new metadata_1.Metadata();
+ this.call.setupSurfaceCall(this);
+ this.on('error', err => {
+ this.call.sendError(err);
+ this.end();
+ });
+ }
+ getPeer() {
+ return this.call.getPeer();
+ }
+ sendMetadata(responseMetadata) {
+ this.call.sendMetadata(responseMetadata);
+ }
+ getDeadline() {
+ return this.call.getDeadline();
+ }
+ getPath() {
+ return this.call.getPath();
+ }
+ _write(chunk, encoding,
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ callback) {
+ try {
+ const response = this.call.serializeMessage(chunk);
+ if (!this.call.write(response)) {
+ this.call.once('drain', callback);
+ return;
+ }
+ }
+ catch (err) {
+ this.emit('error', {
+ details: (0, error_1.getErrorMessage)(err),
+ code: constants_1.Status.INTERNAL,
+ });
+ }
+ callback();
+ }
+ _final(callback) {
+ this.call.sendStatus({
+ code: constants_1.Status.OK,
+ details: 'OK',
+ metadata: this.trailingMetadata,
+ });
+ callback(null);
+ }
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ end(metadata) {
+ if (metadata) {
+ this.trailingMetadata = metadata;
+ }
+ return super.end();
+ }
+}
+exports.ServerWritableStreamImpl = ServerWritableStreamImpl;
+class ServerDuplexStreamImpl extends stream_1.Duplex {
+ constructor(call, metadata, serialize, deserialize, encoding) {
+ super({ objectMode: true });
+ this.call = call;
+ this.metadata = metadata;
+ this.serialize = serialize;
+ this.deserialize = deserialize;
+ this.cancelled = false;
+ this.trailingMetadata = new metadata_1.Metadata();
+ this.call.setupSurfaceCall(this);
+ this.call.setupReadable(this, encoding);
+ this.on('error', err => {
+ this.call.sendError(err);
+ this.end();
+ });
+ }
+ getPeer() {
+ return this.call.getPeer();
+ }
+ sendMetadata(responseMetadata) {
+ this.call.sendMetadata(responseMetadata);
+ }
+ getDeadline() {
+ return this.call.getDeadline();
+ }
+ getPath() {
+ return this.call.getPath();
+ }
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ end(metadata) {
+ if (metadata) {
+ this.trailingMetadata = metadata;
+ }
+ return super.end();
+ }
+}
+exports.ServerDuplexStreamImpl = ServerDuplexStreamImpl;
+ServerDuplexStreamImpl.prototype._read =
+ ServerReadableStreamImpl.prototype._read;
+ServerDuplexStreamImpl.prototype._write =
+ ServerWritableStreamImpl.prototype._write;
+ServerDuplexStreamImpl.prototype._final =
+ ServerWritableStreamImpl.prototype._final;
+// Internal class that wraps the HTTP2 request.
+class Http2ServerCallStream extends events_1.EventEmitter {
+ constructor(stream, handler, options) {
+ super();
+ this.stream = stream;
+ this.handler = handler;
+ this.cancelled = false;
+ this.deadlineTimer = null;
+ this.statusSent = false;
+ this.deadline = Infinity;
+ this.wantTrailers = false;
+ this.metadataSent = false;
+ this.canPush = false;
+ this.isPushPending = false;
+ this.bufferedMessages = [];
+ this.messagesToPush = [];
+ this.maxSendMessageSize = constants_1.DEFAULT_MAX_SEND_MESSAGE_LENGTH;
+ this.maxReceiveMessageSize = constants_1.DEFAULT_MAX_RECEIVE_MESSAGE_LENGTH;
+ this.stream.once('error', (err) => {
+ /* We need an error handler to avoid uncaught error event exceptions, but
+ * there is nothing we can reasonably do here. Any error event should
+ * have a corresponding close event, which handles emitting the cancelled
+ * event. And the stream is now in a bad state, so we can't reasonably
+ * expect to be able to send an error over it. */
+ });
+ this.stream.once('close', () => {
+ var _a;
+ trace('Request to method ' +
+ ((_a = this.handler) === null || _a === void 0 ? void 0 : _a.path) +
+ ' stream closed with rstCode ' +
+ this.stream.rstCode);
+ if (!this.statusSent) {
+ this.cancelled = true;
+ this.emit('cancelled', 'cancelled');
+ this.emit('streamEnd', false);
+ this.sendStatus({
+ code: constants_1.Status.CANCELLED,
+ details: 'Cancelled by client',
+ metadata: null,
+ });
+ if (this.deadlineTimer)
+ clearTimeout(this.deadlineTimer);
+ }
+ });
+ this.stream.on('drain', () => {
+ this.emit('drain');
+ });
+ if ('grpc.max_send_message_length' in options) {
+ this.maxSendMessageSize = options['grpc.max_send_message_length'];
+ }
+ if ('grpc.max_receive_message_length' in options) {
+ this.maxReceiveMessageSize = options['grpc.max_receive_message_length'];
+ }
+ }
+ checkCancelled() {
+ /* In some cases the stream can become destroyed before the close event
+ * fires. That creates a race condition that this check works around */
+ if (this.stream.destroyed || this.stream.closed) {
+ this.cancelled = true;
+ }
+ return this.cancelled;
+ }
+ getDecompressedMessage(message, encoding) {
+ const messageContents = message.subarray(5);
+ if (encoding === 'identity') {
+ return messageContents;
+ }
+ else if (encoding === 'deflate' || encoding === 'gzip') {
+ let decompresser;
+ if (encoding === 'deflate') {
+ decompresser = zlib.createInflate();
+ }
+ else {
+ decompresser = zlib.createGunzip();
+ }
+ return new Promise((resolve, reject) => {
+ let totalLength = 0;
+ const messageParts = [];
+ decompresser.on('data', (chunk) => {
+ messageParts.push(chunk);
+ totalLength += chunk.byteLength;
+ if (this.maxReceiveMessageSize !== -1 && totalLength > this.maxReceiveMessageSize) {
+ decompresser.destroy();
+ reject({
+ code: constants_1.Status.RESOURCE_EXHAUSTED,
+ details: `Received message that decompresses to a size larger than ${this.maxReceiveMessageSize}`
+ });
+ }
+ });
+ decompresser.on('end', () => {
+ resolve(Buffer.concat(messageParts));
+ });
+ decompresser.write(messageContents);
+ decompresser.end();
+ });
+ }
+ else {
+ return Promise.reject({
+ code: constants_1.Status.UNIMPLEMENTED,
+ details: `Received message compressed with unsupported encoding "${encoding}"`,
+ });
+ }
+ }
+ sendMetadata(customMetadata) {
+ if (this.checkCancelled()) {
+ return;
+ }
+ if (this.metadataSent) {
+ return;
+ }
+ this.metadataSent = true;
+ const custom = customMetadata ? customMetadata.toHttp2Headers() : null;
+ // TODO(cjihrig): Include compression headers.
+ const headers = Object.assign(Object.assign(Object.assign({}, defaultResponseHeaders), defaultCompressionHeaders), custom);
+ this.stream.respond(headers, defaultResponseOptions);
+ }
+ receiveMetadata(headers) {
+ const metadata = metadata_1.Metadata.fromHttp2Headers(headers);
+ if (logging.isTracerEnabled(TRACER_NAME)) {
+ trace('Request to ' +
+ this.handler.path +
+ ' received headers ' +
+ JSON.stringify(metadata.toJSON()));
+ }
+ // TODO(cjihrig): Receive compression metadata.
+ const timeoutHeader = metadata.get(GRPC_TIMEOUT_HEADER);
+ if (timeoutHeader.length > 0) {
+ const match = timeoutHeader[0].toString().match(DEADLINE_REGEX);
+ if (match === null) {
+ const err = new Error('Invalid deadline');
+ err.code = constants_1.Status.OUT_OF_RANGE;
+ this.sendError(err);
+ return metadata;
+ }
+ const timeout = (+match[1] * deadlineUnitsToMs[match[2]]) | 0;
+ const now = new Date();
+ this.deadline = now.setMilliseconds(now.getMilliseconds() + timeout);
+ this.deadlineTimer = setTimeout(handleExpiredDeadline, timeout, this);
+ metadata.remove(GRPC_TIMEOUT_HEADER);
+ }
+ // Remove several headers that should not be propagated to the application
+ metadata.remove(http2.constants.HTTP2_HEADER_ACCEPT_ENCODING);
+ metadata.remove(http2.constants.HTTP2_HEADER_TE);
+ metadata.remove(http2.constants.HTTP2_HEADER_CONTENT_TYPE);
+ metadata.remove('grpc-accept-encoding');
+ return metadata;
+ }
+ receiveUnaryMessage(encoding) {
+ return new Promise((resolve, reject) => {
+ const { stream } = this;
+ let receivedLength = 0;
+ // eslint-disable-next-line @typescript-eslint/no-this-alias
+ const call = this;
+ const body = [];
+ const limit = this.maxReceiveMessageSize;
+ this.stream.on('data', onData);
+ this.stream.on('end', onEnd);
+ this.stream.on('error', onEnd);
+ function onData(chunk) {
+ receivedLength += chunk.byteLength;
+ if (limit !== -1 && receivedLength > limit) {
+ stream.removeListener('data', onData);
+ stream.removeListener('end', onEnd);
+ stream.removeListener('error', onEnd);
+ reject({
+ code: constants_1.Status.RESOURCE_EXHAUSTED,
+ details: `Received message larger than max (${receivedLength} vs. ${limit})`,
+ });
+ return;
+ }
+ body.push(chunk);
+ }
+ function onEnd(err) {
+ stream.removeListener('data', onData);
+ stream.removeListener('end', onEnd);
+ stream.removeListener('error', onEnd);
+ if (err !== undefined) {
+ reject({ code: constants_1.Status.INTERNAL, details: err.message });
+ return;
+ }
+ if (receivedLength === 0) {
+ reject({
+ code: constants_1.Status.INTERNAL,
+ details: 'received empty unary message',
+ });
+ return;
+ }
+ call.emit('receiveMessage');
+ const requestBytes = Buffer.concat(body, receivedLength);
+ const compressed = requestBytes.readUInt8(0) === 1;
+ const compressedMessageEncoding = compressed ? encoding : 'identity';
+ const decompressedMessage = call.getDecompressedMessage(requestBytes, compressedMessageEncoding);
+ if (Buffer.isBuffer(decompressedMessage)) {
+ resolve(call.deserializeMessageWithInternalError(decompressedMessage));
+ return;
+ }
+ decompressedMessage.then(decompressed => resolve(call.deserializeMessageWithInternalError(decompressed)), (err) => reject(err.code
+ ? err
+ : {
+ code: constants_1.Status.INTERNAL,
+ details: `Received "grpc-encoding" header "${encoding}" but ${encoding} decompression failed`,
+ }));
+ }
+ });
+ }
+ async deserializeMessageWithInternalError(buffer) {
+ try {
+ return this.deserializeMessage(buffer);
+ }
+ catch (err) {
+ throw {
+ details: (0, error_1.getErrorMessage)(err),
+ code: constants_1.Status.INTERNAL,
+ };
+ }
+ }
+ serializeMessage(value) {
+ const messageBuffer = this.handler.serialize(value);
+ // TODO(cjihrig): Call compression aware serializeMessage().
+ const byteLength = messageBuffer.byteLength;
+ const output = Buffer.allocUnsafe(byteLength + 5);
+ output.writeUInt8(0, 0);
+ output.writeUInt32BE(byteLength, 1);
+ messageBuffer.copy(output, 5);
+ return output;
+ }
+ deserializeMessage(bytes) {
+ return this.handler.deserialize(bytes);
+ }
+ async sendUnaryMessage(err, value, metadata, flags) {
+ if (this.checkCancelled()) {
+ return;
+ }
+ if (metadata === undefined) {
+ metadata = null;
+ }
+ if (err) {
+ if (!Object.prototype.hasOwnProperty.call(err, 'metadata') && metadata) {
+ err.metadata = metadata;
+ }
+ this.sendError(err);
+ return;
+ }
+ try {
+ const response = this.serializeMessage(value);
+ this.write(response);
+ this.sendStatus({ code: constants_1.Status.OK, details: 'OK', metadata });
+ }
+ catch (err) {
+ this.sendError({
+ details: (0, error_1.getErrorMessage)(err),
+ code: constants_1.Status.INTERNAL,
+ });
+ }
+ }
+ sendStatus(statusObj) {
+ var _a, _b;
+ this.emit('callEnd', statusObj.code);
+ this.emit('streamEnd', statusObj.code === constants_1.Status.OK);
+ if (this.checkCancelled()) {
+ return;
+ }
+ trace('Request to method ' +
+ ((_a = this.handler) === null || _a === void 0 ? void 0 : _a.path) +
+ ' ended with status code: ' +
+ constants_1.Status[statusObj.code] +
+ ' details: ' +
+ statusObj.details);
+ if (this.deadlineTimer)
+ clearTimeout(this.deadlineTimer);
+ if (this.stream.headersSent) {
+ if (!this.wantTrailers) {
+ this.wantTrailers = true;
+ this.stream.once('wantTrailers', () => {
+ var _a;
+ const trailersToSend = Object.assign({ [GRPC_STATUS_HEADER]: statusObj.code, [GRPC_MESSAGE_HEADER]: encodeURI(statusObj.details) }, (_a = statusObj.metadata) === null || _a === void 0 ? void 0 : _a.toHttp2Headers());
+ this.stream.sendTrailers(trailersToSend);
+ this.statusSent = true;
+ });
+ this.stream.end();
+ }
+ }
+ else {
+ // Trailers-only response
+ const trailersToSend = Object.assign(Object.assign({ [GRPC_STATUS_HEADER]: statusObj.code, [GRPC_MESSAGE_HEADER]: encodeURI(statusObj.details) }, defaultResponseHeaders), (_b = statusObj.metadata) === null || _b === void 0 ? void 0 : _b.toHttp2Headers());
+ this.stream.respond(trailersToSend, { endStream: true });
+ this.statusSent = true;
+ }
+ }
+ sendError(error) {
+ const status = {
+ code: constants_1.Status.UNKNOWN,
+ details: 'message' in error ? error.message : 'Unknown Error',
+ metadata: 'metadata' in error && error.metadata !== undefined
+ ? error.metadata
+ : null,
+ };
+ if ('code' in error &&
+ typeof error.code === 'number' &&
+ Number.isInteger(error.code)) {
+ status.code = error.code;
+ if ('details' in error && typeof error.details === 'string') {
+ status.details = error.details;
+ }
+ }
+ this.sendStatus(status);
+ }
+ write(chunk) {
+ if (this.checkCancelled()) {
+ return;
+ }
+ if (this.maxSendMessageSize !== -1 &&
+ chunk.length > this.maxSendMessageSize) {
+ this.sendError({
+ code: constants_1.Status.RESOURCE_EXHAUSTED,
+ details: `Sent message larger than max (${chunk.length} vs. ${this.maxSendMessageSize})`,
+ });
+ return;
+ }
+ this.sendMetadata();
+ this.emit('sendMessage');
+ return this.stream.write(chunk);
+ }
+ resume() {
+ this.stream.resume();
+ }
+ setupSurfaceCall(call) {
+ this.once('cancelled', reason => {
+ call.cancelled = true;
+ call.emit('cancelled', reason);
+ });
+ this.once('callEnd', status => call.emit('callEnd', status));
+ }
+ setupReadable(readable, encoding) {
+ const decoder = new stream_decoder_1.StreamDecoder(this.maxReceiveMessageSize);
+ let readsDone = false;
+ let pendingMessageProcessing = false;
+ let pushedEnd = false;
+ const maybePushEnd = async () => {
+ if (!pushedEnd && readsDone && !pendingMessageProcessing) {
+ pushedEnd = true;
+ await this.pushOrBufferMessage(readable, null);
+ }
+ };
+ this.stream.on('data', async (data) => {
+ let messages;
+ try {
+ messages = decoder.write(data);
+ }
+ catch (e) {
+ this.sendError({
+ code: constants_1.Status.RESOURCE_EXHAUSTED,
+ details: e.message
+ });
+ return;
+ }
+ pendingMessageProcessing = true;
+ this.stream.pause();
+ for (const message of messages) {
+ this.emit('receiveMessage');
+ const compressed = message.readUInt8(0) === 1;
+ const compressedMessageEncoding = compressed ? encoding : 'identity';
+ let decompressedMessage;
+ try {
+ decompressedMessage = await this.getDecompressedMessage(message, compressedMessageEncoding);
+ }
+ catch (e) {
+ this.sendError(e);
+ return;
+ }
+ // Encountered an error with decompression; it'll already have been propogated back
+ // Just return early
+ if (!decompressedMessage)
+ return;
+ await this.pushOrBufferMessage(readable, decompressedMessage);
+ }
+ pendingMessageProcessing = false;
+ this.stream.resume();
+ await maybePushEnd();
+ });
+ this.stream.once('end', async () => {
+ readsDone = true;
+ await maybePushEnd();
+ });
+ }
+ consumeUnpushedMessages(readable) {
+ this.canPush = true;
+ while (this.messagesToPush.length > 0) {
+ const nextMessage = this.messagesToPush.shift();
+ const canPush = readable.push(nextMessage);
+ if (nextMessage === null || canPush === false) {
+ this.canPush = false;
+ break;
+ }
+ }
+ return this.canPush;
+ }
+ async pushOrBufferMessage(readable, messageBytes) {
+ if (this.isPushPending) {
+ this.bufferedMessages.push(messageBytes);
+ }
+ else {
+ await this.pushMessage(readable, messageBytes);
+ }
+ }
+ async pushMessage(readable, messageBytes) {
+ if (messageBytes === null) {
+ trace('Received end of stream');
+ if (this.canPush) {
+ readable.push(null);
+ }
+ else {
+ this.messagesToPush.push(null);
+ }
+ return;
+ }
+ trace('Received message of length ' + messageBytes.length);
+ this.isPushPending = true;
+ try {
+ const deserialized = await this.deserializeMessage(messageBytes);
+ if (this.canPush) {
+ if (!readable.push(deserialized)) {
+ this.canPush = false;
+ this.stream.pause();
+ }
+ }
+ else {
+ this.messagesToPush.push(deserialized);
+ }
+ }
+ catch (error) {
+ // Ignore any remaining messages when errors occur.
+ this.bufferedMessages.length = 0;
+ let code = (0, error_1.getErrorCode)(error);
+ if (code === null || code < constants_1.Status.OK || code > constants_1.Status.UNAUTHENTICATED) {
+ code = constants_1.Status.INTERNAL;
+ }
+ readable.emit('error', {
+ details: (0, error_1.getErrorMessage)(error),
+ code: code,
+ });
+ }
+ this.isPushPending = false;
+ if (this.bufferedMessages.length > 0) {
+ await this.pushMessage(readable, this.bufferedMessages.shift());
+ }
+ }
+ getPeer() {
+ var _a;
+ const socket = (_a = this.stream.session) === null || _a === void 0 ? void 0 : _a.socket;
+ if (socket === null || socket === void 0 ? void 0 : socket.remoteAddress) {
+ if (socket.remotePort) {
+ return `${socket.remoteAddress}:${socket.remotePort}`;
+ }
+ else {
+ return socket.remoteAddress;
+ }
+ }
+ else {
+ return 'unknown';
+ }
+ }
+ getDeadline() {
+ return this.deadline;
+ }
+ getPath() {
+ return this.handler.path;
+ }
+}
+exports.Http2ServerCallStream = Http2ServerCallStream;
+function handleExpiredDeadline(call) {
+ const err = new Error('Deadline exceeded');
+ err.code = constants_1.Status.DEADLINE_EXCEEDED;
+ call.sendError(err);
+ call.cancelled = true;
+ call.emit('cancelled', 'deadline');
+}
+//# sourceMappingURL=server-call.js.map \ No newline at end of file