Merge pull request #1364 from murgatroid99/grpc-js_uri_parsing

grpc-js: Use a more structured representation of URIs internally

Author: murgatroid99

packages/grpc-js/src/channel.ts

@@ -39,6 +39,7 @@ import { trace, log } from './logging';
 import { SubchannelAddress } from './subchannel';
 import { MaxMessageSizeFilterFactory } from './max-message-size-filter';
 import { mapProxyName } from './http_proxy';
+import { GrpcUri, parseUri, uriToString } from './uri-parser';
 
 export enum ConnectivityState {
   CONNECTING,
@@ -136,8 +137,9 @@ export class ChannelImplementation implements Channel {
   private connectivityStateWatchers: ConnectivityStateWatcher[] = [];
   private defaultAuthority: string;
   private filterStackFactory: FilterStackFactory;
+  private target: GrpcUri;
   constructor(
-    private target: string,
+    target: string,
     private readonly credentials: ChannelCredentials,
     private readonly options: ChannelOptions
   ) {
@@ -164,14 +166,24 @@ export class ChannelImplementation implements Channel {
         );
       }
     }
+    const originalTargetUri = parseUri(target);
+    if (originalTargetUri === null) {
+      throw new Error(`Could not parse target name "${target}"`);
+    }
     if (this.options['grpc.default_authority']) {
       this.defaultAuthority = this.options['grpc.default_authority'] as string;
     } else {
-      this.defaultAuthority = getDefaultAuthority(target);
+      this.defaultAuthority = getDefaultAuthority(originalTargetUri);
     }
-    const proxyMapResult = mapProxyName(target, options);
+    const proxyMapResult = mapProxyName(originalTargetUri, options);
     this.target = proxyMapResult.target;
     this.options = Object.assign({}, this.options, proxyMapResult.extraOptions);
+
+    const targetUri = parseUri(target);
+    if (targetUri === null) {
+      throw new Error(`Could not parse target name "${target}"`);
+    }
+    this.target = targetUri;
     /* The global boolean parameter to getSubchannelPool has the inverse meaning to what
      * the grpc.use_local_subchannel_pool channel option means. */
     this.subchannelPool = getSubchannelPool(
@@ -422,7 +434,7 @@ export class ChannelImplementation implements Channel {
   }
 
   getTarget() {
-    return this.target;
+    return uriToString(this.target);
   }
 
   getConnectivityState(tryToConnect: boolean) {

packages/grpc-js/src/http_proxy.ts

@@ -15,11 +15,9 @@
  *
  */
 
-import { URL } from 'url';
 import { log } from './logging';
 import { LogVerbosity } from './constants';
 import { getDefaultAuthority } from './resolver';
-import { parseTarget } from './resolver-dns';
 import { Socket } from 'net';
 import * as http from 'http';
 import * as tls from 'tls';
@@ -30,6 +28,7 @@ import {
   subchannelAddressToString,
 } from './subchannel';
 import { ChannelOptions } from './channel-options';
+import { GrpcUri, parseUri, splitHostPort, uriToString } from './uri-parser';
 
 const TRACER_NAME = 'proxy';
 
@@ -61,31 +60,30 @@ function getProxyInfo(): ProxyInfo {
   } else {
     return {};
   }
-  let proxyUrl: URL;
-  try {
-    proxyUrl = new URL(proxyEnv);
-  } catch (e) {
+  const proxyUrl = parseUri(proxyEnv);
+  if (proxyUrl === null) {
     log(LogVerbosity.ERROR, `cannot parse value of "${envVar}" env var`);
     return {};
   }
-  if (proxyUrl.protocol !== 'http:') {
+  if (proxyUrl.scheme !== 'http') {
     log(
       LogVerbosity.ERROR,
-      `"${proxyUrl.protocol}" scheme not supported in proxy URI`
+      `"${proxyUrl.scheme}" scheme not supported in proxy URI`
     );
     return {};
   }
+  const splitPath = proxyUrl.path.split('@');
+  let host: string;
   let userCred: string | null = null;
-  if (proxyUrl.username) {
-    if (proxyUrl.password) {
-      log(LogVerbosity.INFO, 'userinfo found in proxy URI');
-      userCred = `${proxyUrl.username}:${proxyUrl.password}`;
-    } else {
-      userCred = proxyUrl.username;
-    }
+  if (splitPath.length === 2) {
+    log(LogVerbosity.INFO, 'userinfo found in proxy URI');
+    userCred = splitPath[0];
+    host = splitPath[1];
+  } else {
+    host = proxyUrl.path;
   }
   const result: ProxyInfo = {
-    address: proxyUrl.host,
+    address: host,
   };
   if (userCred) {
     result.creds = userCred;
@@ -113,12 +111,12 @@ function getNoProxyHostList(): string[] {
 }
 
 export interface ProxyMapResult {
-  target: string;
+  target: GrpcUri;
   extraOptions: ChannelOptions;
 }
 
 export function mapProxyName(
-  target: string,
+  target: GrpcUri,
   options: ChannelOptions
 ): ProxyMapResult {
   const noProxyResult: ProxyMapResult = {
@@ -129,32 +127,32 @@ export function mapProxyName(
   if (!proxyInfo.address) {
     return noProxyResult;
   }
-  const parsedTarget = parseTarget(target);
-  if (!parsedTarget) {
+  const hostPort = splitHostPort(target.path);
+  if (!hostPort) {
     return noProxyResult;
   }
-  const serverHost = parsedTarget.host;
+  const serverHost = hostPort.host;
   for (const host of getNoProxyHostList()) {
     if (host === serverHost) {
       trace('Not using proxy for target in no_proxy list: ' + target);
       return noProxyResult;
     }
   }
   const extraOptions: ChannelOptions = {
-    'grpc.http_connect_target': target,
+    'grpc.http_connect_target': uriToString(target),
   };
   if (proxyInfo.creds) {
     extraOptions['grpc.http_connect_creds'] = proxyInfo.creds;
   }
   return {
-    target: `dns:${proxyInfo.address}`,
+    target: { path: proxyInfo.address },
     extraOptions: extraOptions,
   };
 }
 
 export interface ProxyConnectionResult {
   socket?: Socket;
-  realTarget?: string;
+  realTarget?: GrpcUri;
 }
 
 export function getProxiedConnection(
@@ -166,9 +164,13 @@ export function getProxiedConnection(
     return Promise.resolve<ProxyConnectionResult>({});
   }
   const realTarget = channelOptions['grpc.http_connect_target'] as string;
-  const parsedTarget = parseTarget(realTarget)!;
+  const parsedTarget = parseUri(realTarget);
+  if (parsedTarget === null) {
+    return Promise.resolve<ProxyConnectionResult>({});
+  }
   const options: http.RequestOptions = {
     method: 'CONNECT',
+    path: parsedTarget.path,
   };
   // Connect to the subchannel address as a proxy
   if (isTcpSubchannelAddress(address)) {
@@ -177,11 +179,6 @@ export function getProxiedConnection(
   } else {
     options.socketPath = address.path;
   }
-  if (parsedTarget.port === undefined) {
-    options.path = parsedTarget.host;
-  } else {
-    options.path = `${parsedTarget.host}:${parsedTarget.port}`;
-  }
   if ('grpc.http_connect_creds' in channelOptions) {
     options.headers = {
       'Proxy-Authorization':
@@ -205,23 +202,27 @@ export function getProxiedConnection(
             ' through proxy ' +
             proxyAddressString
         );
+        resolve({
+          socket,
+          realTarget: parsedTarget,
+        });
         if ('secureContext' in connectionOptions) {
           /* The proxy is connecting to a TLS server, so upgrade this socket
            * connection to a TLS connection.
            * 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 cts = tls.connect({
               ...connectionOptions,
-              host: getDefaultAuthority(realTarget),
+              host: getDefaultAuthority(parsedTarget),
               socket: socket,
             }, () => {
-              resolve({ socket: cts, realTarget });
+              resolve({ socket: cts, realTarget: parsedTarget });
             }
           );
         } else {
           resolve({
             socket,
-            realTarget,
+            realTarget: parsedTarget,
           });
         }
       } else {