diff options
| author | altaf-creator <dev@altafcreator.com> | 2025-11-16 19:08:29 +0800 |
|---|---|---|
| committer | altaf-creator <dev@altafcreator.com> | 2025-11-16 19:08:29 +0800 |
| commit | 434aa8343fdcbb4d5002f934979913c099489bee (patch) | |
| tree | 55bab4ec5a6151be57797d34f61faf5ea744471b /frontend-old/node_modules/@grpc/grpc-js/src/transport.ts | |
| parent | 893c388d4e99442a36005e5971a87730623f946e (diff) | |
sdk, del
Diffstat (limited to 'frontend-old/node_modules/@grpc/grpc-js/src/transport.ts')
| -rw-r--r-- | frontend-old/node_modules/@grpc/grpc-js/src/transport.ts | 829 |
1 files changed, 0 insertions, 829 deletions
diff --git a/frontend-old/node_modules/@grpc/grpc-js/src/transport.ts b/frontend-old/node_modules/@grpc/grpc-js/src/transport.ts deleted file mode 100644 index fe9a813..0000000 --- a/frontend-old/node_modules/@grpc/grpc-js/src/transport.ts +++ /dev/null @@ -1,829 +0,0 @@ -/* - * Copyright 2023 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. - * - */ - -import * as http2 from 'http2'; -import { - checkServerIdentity, - CipherNameAndProtocol, - ConnectionOptions, - PeerCertificate, - TLSSocket, -} from 'tls'; -import { StatusObject } from './call-interface'; -import { ChannelCredentials } from './channel-credentials'; -import { ChannelOptions } from './channel-options'; -import { - ChannelzCallTracker, - registerChannelzSocket, - SocketInfo, - SocketRef, - TlsInfo, - unregisterChannelzRef, -} from './channelz'; -import { LogVerbosity } from './constants'; -import { getProxiedConnection, ProxyConnectionResult } from './http_proxy'; -import * as logging from './logging'; -import { getDefaultAuthority } from './resolver'; -import { - stringToSubchannelAddress, - SubchannelAddress, - subchannelAddressToString, -} from './subchannel-address'; -import { GrpcUri, parseUri, splitHostPort, uriToString } from './uri-parser'; -import * as net from 'net'; -import { - Http2SubchannelCall, - SubchannelCall, - SubchannelCallInterceptingListener, -} from './subchannel-call'; -import { Metadata } from './metadata'; -import { getNextCallNumber } from './call-number'; - -const TRACER_NAME = 'transport'; -const FLOW_CONTROL_TRACER_NAME = 'transport_flowctrl'; - -const clientVersion = require('../../package.json').version; - -const { - HTTP2_HEADER_AUTHORITY, - HTTP2_HEADER_CONTENT_TYPE, - HTTP2_HEADER_METHOD, - HTTP2_HEADER_PATH, - HTTP2_HEADER_TE, - HTTP2_HEADER_USER_AGENT, -} = http2.constants; - -const KEEPALIVE_TIMEOUT_MS = 20000; - -export interface CallEventTracker { - addMessageSent(): void; - addMessageReceived(): void; - onCallEnd(status: StatusObject): void; - onStreamEnd(success: boolean): void; -} - -export interface TransportDisconnectListener { - (tooManyPings: boolean): void; -} - -export interface Transport { - getChannelzRef(): SocketRef; - getPeerName(): string; - getOptions(): ChannelOptions; - createCall( - metadata: Metadata, - host: string, - method: string, - listener: SubchannelCallInterceptingListener, - subchannelCallStatsTracker: Partial<CallEventTracker> - ): SubchannelCall; - addDisconnectListener(listener: TransportDisconnectListener): void; - shutdown(): void; -} - -const tooManyPingsData: Buffer = Buffer.from('too_many_pings', 'ascii'); - -class Http2Transport implements Transport { - /** - * The amount of time in between sending pings - */ - private keepaliveTimeMs = -1; - /** - * The amount of time to wait for an acknowledgement after sending a ping - */ - private keepaliveTimeoutMs: number = KEEPALIVE_TIMEOUT_MS; - /** - * Timer reference for timeout that indicates when to send the next ping - */ - private keepaliveTimerId: NodeJS.Timeout | null = null; - /** - * Indicates that the keepalive timer ran out while there were no active - * calls, and a ping should be sent the next time a call starts. - */ - private pendingSendKeepalivePing = false; - /** - * Timer reference tracking when the most recent ping will be considered lost - */ - private keepaliveTimeoutId: NodeJS.Timeout | null = null; - /** - * Indicates whether keepalive pings should be sent without any active calls - */ - private keepaliveWithoutCalls = false; - - private userAgent: string; - - private activeCalls: Set<Http2SubchannelCall> = new Set(); - - private subchannelAddressString: string; - - private disconnectListeners: TransportDisconnectListener[] = []; - - private disconnectHandled = false; - - // Channelz info - private channelzRef: SocketRef; - private readonly channelzEnabled: boolean = true; - private streamTracker = new ChannelzCallTracker(); - private keepalivesSent = 0; - private messagesSent = 0; - private messagesReceived = 0; - private lastMessageSentTimestamp: Date | null = null; - private lastMessageReceivedTimestamp: Date | null = null; - - constructor( - private session: http2.ClientHttp2Session, - subchannelAddress: SubchannelAddress, - private options: ChannelOptions, - /** - * Name of the remote server, if it is not the same as the subchannel - * address, i.e. if connecting through an HTTP CONNECT proxy. - */ - private remoteName: string | null - ) { - /* Populate subchannelAddressString and channelzRef before doing anything - * else, because they are used in the trace methods. */ - this.subchannelAddressString = subchannelAddressToString(subchannelAddress); - - if (options['grpc.enable_channelz'] === 0) { - this.channelzEnabled = false; - } - this.channelzRef = registerChannelzSocket( - this.subchannelAddressString, - () => this.getChannelzInfo(), - this.channelzEnabled - ); - // Build user-agent string. - this.userAgent = [ - options['grpc.primary_user_agent'], - `grpc-node-js/${clientVersion}`, - options['grpc.secondary_user_agent'], - ] - .filter(e => e) - .join(' '); // remove falsey values first - - if ('grpc.keepalive_time_ms' in options) { - this.keepaliveTimeMs = options['grpc.keepalive_time_ms']!; - } - if ('grpc.keepalive_timeout_ms' in options) { - this.keepaliveTimeoutMs = options['grpc.keepalive_timeout_ms']!; - } - if ('grpc.keepalive_permit_without_calls' in options) { - this.keepaliveWithoutCalls = - options['grpc.keepalive_permit_without_calls'] === 1; - } else { - this.keepaliveWithoutCalls = false; - } - - session.once('close', () => { - this.trace('session closed'); - this.stopKeepalivePings(); - this.handleDisconnect(); - }); - session.once( - 'goaway', - (errorCode: number, lastStreamID: number, opaqueData?: Buffer) => { - let tooManyPings = false; - /* See the last paragraph of - * https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md#basic-keepalive */ - if ( - errorCode === http2.constants.NGHTTP2_ENHANCE_YOUR_CALM && - opaqueData && - opaqueData.equals(tooManyPingsData) - ) { - tooManyPings = true; - } - this.trace('connection closed by GOAWAY with code ' + errorCode + ' and data ' + opaqueData?.toString()); - this.reportDisconnectToOwner(tooManyPings); - } - ); - session.once('error', error => { - /* Do nothing here. Any error should also trigger a close event, which is - * where we want to handle that. */ - this.trace('connection closed with error ' + (error as Error).message); - }); - if (logging.isTracerEnabled(TRACER_NAME)) { - session.on('remoteSettings', (settings: http2.Settings) => { - this.trace( - 'new settings received' + - (this.session !== session ? ' on the old connection' : '') + - ': ' + - JSON.stringify(settings) - ); - }); - session.on('localSettings', (settings: http2.Settings) => { - this.trace( - 'local settings acknowledged by remote' + - (this.session !== session ? ' on the old connection' : '') + - ': ' + - JSON.stringify(settings) - ); - }); - } - /* Start the keepalive timer last, because this can trigger trace logs, - * which should only happen after everything else is set up. */ - if (this.keepaliveWithoutCalls) { - this.maybeStartKeepalivePingTimer(); - } - } - - private getChannelzInfo(): SocketInfo { - const sessionSocket = this.session.socket; - const remoteAddress = sessionSocket.remoteAddress - ? stringToSubchannelAddress( - sessionSocket.remoteAddress, - sessionSocket.remotePort - ) - : null; - const localAddress = sessionSocket.localAddress - ? stringToSubchannelAddress( - sessionSocket.localAddress, - sessionSocket.localPort - ) - : null; - let tlsInfo: TlsInfo | null; - if (this.session.encrypted) { - const tlsSocket: TLSSocket = sessionSocket as TLSSocket; - const cipherInfo: CipherNameAndProtocol & { standardName?: string } = - tlsSocket.getCipher(); - const certificate = tlsSocket.getCertificate(); - const peerCertificate = tlsSocket.getPeerCertificate(); - tlsInfo = { - cipherSuiteStandardName: cipherInfo.standardName ?? null, - cipherSuiteOtherName: cipherInfo.standardName ? null : cipherInfo.name, - localCertificate: - certificate && 'raw' in certificate ? certificate.raw : null, - remoteCertificate: - peerCertificate && 'raw' in peerCertificate - ? peerCertificate.raw - : null, - }; - } else { - tlsInfo = null; - } - const socketInfo: SocketInfo = { - remoteAddress: remoteAddress, - localAddress: localAddress, - security: tlsInfo, - remoteName: this.remoteName, - streamsStarted: this.streamTracker.callsStarted, - streamsSucceeded: this.streamTracker.callsSucceeded, - streamsFailed: this.streamTracker.callsFailed, - messagesSent: this.messagesSent, - messagesReceived: this.messagesReceived, - keepAlivesSent: this.keepalivesSent, - lastLocalStreamCreatedTimestamp: - this.streamTracker.lastCallStartedTimestamp, - lastRemoteStreamCreatedTimestamp: null, - lastMessageSentTimestamp: this.lastMessageSentTimestamp, - lastMessageReceivedTimestamp: this.lastMessageReceivedTimestamp, - localFlowControlWindow: this.session.state.localWindowSize ?? null, - remoteFlowControlWindow: this.session.state.remoteWindowSize ?? null, - }; - return socketInfo; - } - - private trace(text: string): void { - logging.trace( - LogVerbosity.DEBUG, - TRACER_NAME, - '(' + - this.channelzRef.id + - ') ' + - this.subchannelAddressString + - ' ' + - text - ); - } - - private keepaliveTrace(text: string): void { - logging.trace( - LogVerbosity.DEBUG, - 'keepalive', - '(' + - this.channelzRef.id + - ') ' + - this.subchannelAddressString + - ' ' + - text - ); - } - - private flowControlTrace(text: string): void { - logging.trace( - LogVerbosity.DEBUG, - FLOW_CONTROL_TRACER_NAME, - '(' + - this.channelzRef.id + - ') ' + - this.subchannelAddressString + - ' ' + - text - ); - } - - private internalsTrace(text: string): void { - logging.trace( - LogVerbosity.DEBUG, - 'transport_internals', - '(' + - this.channelzRef.id + - ') ' + - this.subchannelAddressString + - ' ' + - text - ); - } - - /** - * Indicate to the owner of this object that this transport should no longer - * be used. That happens if the connection drops, or if the server sends a - * GOAWAY. - * @param tooManyPings If true, this was triggered by a GOAWAY with data - * indicating that the session was closed becaues the client sent too many - * pings. - * @returns - */ - private reportDisconnectToOwner(tooManyPings: boolean) { - if (this.disconnectHandled) { - return; - } - this.disconnectHandled = true; - this.disconnectListeners.forEach(listener => listener(tooManyPings)); - } - - /** - * Handle connection drops, but not GOAWAYs. - */ - private handleDisconnect() { - this.reportDisconnectToOwner(false); - /* Give calls an event loop cycle to finish naturally before reporting the - * disconnnection to them. */ - setImmediate(() => { - for (const call of this.activeCalls) { - call.onDisconnect(); - } - }); - } - - addDisconnectListener(listener: TransportDisconnectListener): void { - this.disconnectListeners.push(listener); - } - - private clearKeepaliveTimer() { - if (!this.keepaliveTimerId) { - return; - } - clearTimeout(this.keepaliveTimerId); - this.keepaliveTimerId = null; - } - - private clearKeepaliveTimeout() { - if (!this.keepaliveTimeoutId) { - return; - } - clearTimeout(this.keepaliveTimeoutId); - this.keepaliveTimeoutId = null; - } - - private canSendPing() { - return ( - this.keepaliveTimeMs > 0 && - (this.keepaliveWithoutCalls || this.activeCalls.size > 0) - ); - } - - private maybeSendPing() { - this.clearKeepaliveTimer(); - if (!this.canSendPing()) { - this.pendingSendKeepalivePing = true; - return; - } - if (this.channelzEnabled) { - this.keepalivesSent += 1; - } - this.keepaliveTrace( - 'Sending ping with timeout ' + this.keepaliveTimeoutMs + 'ms' - ); - if (!this.keepaliveTimeoutId) { - this.keepaliveTimeoutId = setTimeout(() => { - this.keepaliveTrace('Ping timeout passed without response'); - this.handleDisconnect(); - }, this.keepaliveTimeoutMs); - this.keepaliveTimeoutId.unref?.(); - } - try { - this.session!.ping( - (err: Error | null, duration: number, payload: Buffer) => { - if (err) { - this.keepaliveTrace('Ping failed with error ' + err.message); - this.handleDisconnect(); - } - this.keepaliveTrace('Received ping response'); - this.clearKeepaliveTimeout(); - this.maybeStartKeepalivePingTimer(); - } - ); - } catch (e) { - /* If we fail to send a ping, the connection is no longer functional, so - * we should discard it. */ - this.handleDisconnect(); - } - } - - /** - * Starts the keepalive ping timer if appropriate. If the timer already ran - * out while there were no active requests, instead send a ping immediately. - * If the ping timer is already running or a ping is currently in flight, - * instead do nothing and wait for them to resolve. - */ - private maybeStartKeepalivePingTimer() { - if (!this.canSendPing()) { - return; - } - if (this.pendingSendKeepalivePing) { - this.pendingSendKeepalivePing = false; - this.maybeSendPing(); - } else if (!this.keepaliveTimerId && !this.keepaliveTimeoutId) { - this.keepaliveTrace( - 'Starting keepalive timer for ' + this.keepaliveTimeMs + 'ms' - ); - this.keepaliveTimerId = setTimeout(() => { - this.maybeSendPing(); - }, this.keepaliveTimeMs).unref?.(); - } - /* Otherwise, there is already either a keepalive timer or a ping pending, - * wait for those to resolve. */ - } - - private stopKeepalivePings() { - if (this.keepaliveTimerId) { - clearTimeout(this.keepaliveTimerId); - this.keepaliveTimerId = null; - } - this.clearKeepaliveTimeout(); - } - - private removeActiveCall(call: Http2SubchannelCall) { - this.activeCalls.delete(call); - if (this.activeCalls.size === 0) { - this.session.unref(); - } - } - - private addActiveCall(call: Http2SubchannelCall) { - this.activeCalls.add(call); - if (this.activeCalls.size === 1) { - this.session.ref(); - if (!this.keepaliveWithoutCalls) { - this.maybeStartKeepalivePingTimer(); - } - } - } - - createCall( - metadata: Metadata, - host: string, - method: string, - listener: SubchannelCallInterceptingListener, - subchannelCallStatsTracker: Partial<CallEventTracker> - ): Http2SubchannelCall { - const headers = metadata.toHttp2Headers(); - headers[HTTP2_HEADER_AUTHORITY] = host; - headers[HTTP2_HEADER_USER_AGENT] = this.userAgent; - headers[HTTP2_HEADER_CONTENT_TYPE] = 'application/grpc'; - headers[HTTP2_HEADER_METHOD] = 'POST'; - headers[HTTP2_HEADER_PATH] = method; - headers[HTTP2_HEADER_TE] = 'trailers'; - let http2Stream: http2.ClientHttp2Stream; - /* In theory, if an error is thrown by session.request because session has - * become unusable (e.g. because it has received a goaway), this subchannel - * should soon see the corresponding close or goaway event anyway and leave - * READY. But we have seen reports that this does not happen - * (https://github.com/googleapis/nodejs-firestore/issues/1023#issuecomment-653204096) - * so for defense in depth, we just discard the session when we see an - * error here. - */ - try { - http2Stream = this.session!.request(headers); - } catch (e) { - this.handleDisconnect(); - throw e; - } - this.flowControlTrace( - 'local window size: ' + - this.session.state.localWindowSize + - ' remote window size: ' + - this.session.state.remoteWindowSize - ); - this.internalsTrace( - 'session.closed=' + - this.session.closed + - ' session.destroyed=' + - this.session.destroyed + - ' session.socket.destroyed=' + - this.session.socket.destroyed - ); - let eventTracker: CallEventTracker; - // eslint-disable-next-line prefer-const - let call: Http2SubchannelCall; - if (this.channelzEnabled) { - this.streamTracker.addCallStarted(); - eventTracker = { - addMessageSent: () => { - this.messagesSent += 1; - this.lastMessageSentTimestamp = new Date(); - subchannelCallStatsTracker.addMessageSent?.(); - }, - addMessageReceived: () => { - this.messagesReceived += 1; - this.lastMessageReceivedTimestamp = new Date(); - subchannelCallStatsTracker.addMessageReceived?.(); - }, - onCallEnd: status => { - subchannelCallStatsTracker.onCallEnd?.(status); - this.removeActiveCall(call); - }, - onStreamEnd: success => { - if (success) { - this.streamTracker.addCallSucceeded(); - } else { - this.streamTracker.addCallFailed(); - } - subchannelCallStatsTracker.onStreamEnd?.(success); - }, - }; - } else { - eventTracker = { - addMessageSent: () => { - subchannelCallStatsTracker.addMessageSent?.(); - }, - addMessageReceived: () => { - subchannelCallStatsTracker.addMessageReceived?.(); - }, - onCallEnd: status => { - subchannelCallStatsTracker.onCallEnd?.(status); - this.removeActiveCall(call); - }, - onStreamEnd: success => { - subchannelCallStatsTracker.onStreamEnd?.(success); - }, - }; - } - call = new Http2SubchannelCall( - http2Stream, - eventTracker, - listener, - this, - getNextCallNumber() - ); - this.addActiveCall(call); - return call; - } - - getChannelzRef(): SocketRef { - return this.channelzRef; - } - - getPeerName() { - return this.subchannelAddressString; - } - - getOptions() { - return this.options; - } - - shutdown() { - this.session.close(); - unregisterChannelzRef(this.channelzRef); - } -} - -export interface SubchannelConnector { - connect( - address: SubchannelAddress, - credentials: ChannelCredentials, - options: ChannelOptions - ): Promise<Transport>; - shutdown(): void; -} - -export class Http2SubchannelConnector implements SubchannelConnector { - private session: http2.ClientHttp2Session | null = null; - private isShutdown = false; - constructor(private channelTarget: GrpcUri) {} - private trace(text: string) { - logging.trace( - LogVerbosity.DEBUG, - TRACER_NAME, - uriToString(this.channelTarget) + ' ' + text - ); - } - private createSession( - address: SubchannelAddress, - credentials: ChannelCredentials, - options: ChannelOptions, - proxyConnectionResult: ProxyConnectionResult - ): Promise<Http2Transport> { - if (this.isShutdown) { - return Promise.reject(); - } - return new Promise<Http2Transport>((resolve, reject) => { - let remoteName: string | null; - if (proxyConnectionResult.realTarget) { - remoteName = uriToString(proxyConnectionResult.realTarget); - this.trace( - 'creating HTTP/2 session through proxy to ' + - uriToString(proxyConnectionResult.realTarget) - ); - } else { - remoteName = null; - this.trace( - 'creating HTTP/2 session to ' + subchannelAddressToString(address) - ); - } - const targetAuthority = getDefaultAuthority( - proxyConnectionResult.realTarget ?? this.channelTarget - ); - let connectionOptions: http2.SecureClientSessionOptions = - credentials._getConnectionOptions() || {}; - connectionOptions.maxSendHeaderBlockLength = Number.MAX_SAFE_INTEGER; - if ('grpc-node.max_session_memory' in options) { - connectionOptions.maxSessionMemory = - options['grpc-node.max_session_memory']; - } else { - /* By default, set a very large max session memory limit, to effectively - * disable enforcement of the limit. Some testing indicates that Node's - * behavior degrades badly when this limit is reached, so we solve that - * by disabling the check entirely. */ - connectionOptions.maxSessionMemory = Number.MAX_SAFE_INTEGER; - } - let addressScheme = 'http://'; - if ('secureContext' in connectionOptions) { - addressScheme = 'https://'; - // If provided, the value of grpc.ssl_target_name_override should be used - // to override the target hostname when checking server identity. - // This option is used for testing only. - if (options['grpc.ssl_target_name_override']) { - const sslTargetNameOverride = - options['grpc.ssl_target_name_override']!; - connectionOptions.checkServerIdentity = ( - host: string, - cert: PeerCertificate - ): Error | undefined => { - return checkServerIdentity(sslTargetNameOverride, cert); - }; - connectionOptions.servername = sslTargetNameOverride; - } else { - const authorityHostname = - splitHostPort(targetAuthority)?.host ?? 'localhost'; - // We want to always set servername to support SNI - connectionOptions.servername = authorityHostname; - } - if (proxyConnectionResult.socket) { - /* This is part of the workaround for - * https://github.com/nodejs/node/issues/32922. Without that bug, - * proxyConnectionResult.socket would always be a plaintext socket and - * this would say - * connectionOptions.socket = proxyConnectionResult.socket; */ - connectionOptions.createConnection = (authority, option) => { - return proxyConnectionResult.socket!; - }; - } - } else { - /* In all but the most recent versions of Node, http2.connect does not use - * the options when establishing plaintext connections, so we need to - * establish that connection explicitly. */ - connectionOptions.createConnection = (authority, option) => { - if (proxyConnectionResult.socket) { - return proxyConnectionResult.socket; - } else { - /* net.NetConnectOpts is declared in a way that is more restrictive - * than what net.connect will actually accept, so we use the type - * assertion to work around that. */ - return net.connect(address); - } - }; - } - - connectionOptions = { - ...connectionOptions, - ...address, - enableTrace: options['grpc-node.tls_enable_trace'] === 1, - }; - - /* http2.connect uses the options here: - * https://github.com/nodejs/node/blob/70c32a6d190e2b5d7b9ff9d5b6a459d14e8b7d59/lib/internal/http2/core.js#L3028-L3036 - * The spread operator overides earlier values with later ones, so any port - * or host values in the options will be used rather than any values extracted - * from the first argument. In addition, the path overrides the host and port, - * as documented for plaintext connections here: - * https://nodejs.org/api/net.html#net_socket_connect_options_connectlistener - * and for TLS connections here: - * https://nodejs.org/api/tls.html#tls_tls_connect_options_callback. In - * earlier versions of Node, http2.connect passes these options to - * tls.connect but not net.connect, so in the insecure case we still need - * to set the createConnection option above to create the connection - * explicitly. We cannot do that in the TLS case because http2.connect - * passes necessary additional options to tls.connect. - * The first argument just needs to be parseable as a URL and the scheme - * determines whether the connection will be established over TLS or not. - */ - const session = http2.connect( - addressScheme + targetAuthority, - connectionOptions - ); - this.session = session; - let errorMessage = 'Failed to connect'; - session.unref(); - session.once('connect', () => { - session.removeAllListeners(); - resolve(new Http2Transport(session, address, options, remoteName)); - this.session = null; - }); - session.once('close', () => { - this.session = null; - // Leave time for error event to happen before rejecting - setImmediate(() => { - reject(`${errorMessage} (${new Date().toISOString()})`); - }); - }); - session.once('error', error => { - errorMessage = (error as Error).message; - this.trace('connection failed with error ' + errorMessage); - }); - }); - } - connect( - address: SubchannelAddress, - credentials: ChannelCredentials, - options: ChannelOptions - ): Promise<Http2Transport> { - if (this.isShutdown) { - return Promise.reject(); - } - /* Pass connection options through to the proxy so that it's able to - * upgrade it's connection to support tls if needed. - * This is a workaround for https://github.com/nodejs/node/issues/32922 - * See https://github.com/grpc/grpc-node/pull/1369 for more info. */ - const connectionOptions: ConnectionOptions = - credentials._getConnectionOptions() || {}; - - if ('secureContext' in connectionOptions) { - connectionOptions.ALPNProtocols = ['h2']; - // If provided, the value of grpc.ssl_target_name_override should be used - // to override the target hostname when checking server identity. - // This option is used for testing only. - if (options['grpc.ssl_target_name_override']) { - const sslTargetNameOverride = options['grpc.ssl_target_name_override']!; - connectionOptions.checkServerIdentity = ( - host: string, - cert: PeerCertificate - ): Error | undefined => { - return checkServerIdentity(sslTargetNameOverride, cert); - }; - connectionOptions.servername = sslTargetNameOverride; - } else { - if ('grpc.http_connect_target' in options) { - /* This is more or less how servername will be set in createSession - * if a connection is successfully established through the proxy. - * If the proxy is not used, these connectionOptions are discarded - * anyway */ - const targetPath = getDefaultAuthority( - parseUri(options['grpc.http_connect_target'] as string) ?? { - path: 'localhost', - } - ); - const hostPort = splitHostPort(targetPath); - connectionOptions.servername = hostPort?.host ?? targetPath; - } - } - if (options['grpc-node.tls_enable_trace']) { - connectionOptions.enableTrace = true; - } - } - - return getProxiedConnection(address, options, connectionOptions).then( - result => this.createSession(address, credentials, options, result) - ); - } - - shutdown(): void { - this.isShutdown = true; - this.session?.close(); - this.session = null; - } -} |
