@tdxvolt/volt-client-grpc 0.1.1 → 0.1.2

package/src/grpc-utils.js

@@ -1,70 +1,82 @@
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable no-param-reassign */
 import lodash from "lodash";
-import {createSecureContextOptions} from "./utils.js";
+import { createSecureContextOptions } from "./utils.js";
 
-const {forEach, isEmpty} = lodash;
+const { forEach, isEmpty } = lodash;
 
 const serialiseNOP = (arg) => {
-  return arg;
+	return arg;
 };
 
-export function createClient(grpc, serviceDescriptors, address, cryptoOptions, noSerialise, voltId, serviceId) {
-  let credentials;
-  if (cryptoOptions) {
-    const ca = cryptoOptions.tunnel_ca_pem || cryptoOptions.ca;
-    const cert = cryptoOptions.cloud_cert || cryptoOptions.cert;
-    const {key} = cryptoOptions;
-
-    if (key && cert) {
-      const cryyptoOptions = {ca, cert, key};
-      const tlsOptions = createSecureContextOptions(cryyptoOptions);
-      credentials = grpc.credentials.createSsl(tlsOptions.ca, tlsOptions.key, tlsOptions.cert);
-    } else {
-      // Cache has no private key, this implies we are connecting without supplying a client certificate.
-      // Simply connect using the CA certificate.
-      credentials = grpc.credentials.createSsl(Buffer.from(ca));
-    }
-  } else {
-    credentials = grpc.credentials.createInsecure();
-  }
-
-  // Force all methods to appear bi-directional, since we manually handle the call flow (see grpc-call.js).
-  forEach(serviceDescriptors, (method) => {
-    method.requestStream = true;
-    method.responseStream = true;
-  });
-
-  if (noSerialise || voltId) {
-    if (voltId && !serviceId) {
-      // We must have a service identifier id when tunnelling in order to be able to route the rpc.
-      throw new Error("createClient - no serviceId given");
-    }
-    forEach(serviceDescriptors, (method) => {
-      if (voltId) {
-        // Prepend the resource id to the method path if tunnelling.
-        if (voltId === serviceId) {
-          method.path = `/${voltId}${method.path}`;
-        } else {
-          method.path = `/${voltId}/${serviceId}${method.path}`;
-        }
-      }
-      if (noSerialise) {
-        // Save original serialisation methods so we can encrypt/decrypt in the tunnel.
-        method.requestSerializeOriginal = method.requestSerialize;
-        method.responseDeserializeOriginal = method.responseDeserialize;
-
-        // Replace default serialisation with NOP, since when tunnelling we encrypt the payload
-        // before sending it to the channel, so we want it to be treated as a pure byte array (pass-through).
-        method.requestSerialize = serialiseNOP;
-        method.responseDeserialize = serialiseNOP;
-      }
-    });
-  }
-
-  const SubClass = grpc.makeGenericClientConstructor(serviceDescriptors);
-
-  return new SubClass(address, credentials);
+export function createClient(
+	grpc,
+	serviceDescriptors,
+	address,
+	credentials,
+	noSerialise,
+	voltId,
+	serviceId,
+) {
+	let grpcCredentials;
+	if (credentials) {
+		const ca = credentials.config?.relay?.ca_pem || credentials.cache.ca;
+		const cert = credentials.cache.cloud_cert || credentials.cache.cert;
+		const { key } = credentials.cache;
+
+		if (key && cert) {
+			const cryyptoOptions = { ca, cert, key };
+			const tlsOptions = createSecureContextOptions(cryyptoOptions);
+			grpcCredentials = grpc.credentials.createSsl(
+				tlsOptions.ca,
+				tlsOptions.key,
+				tlsOptions.cert,
+			);
+		} else {
+			// Cache has no private key, this implies we are connecting without supplying a client certificate.
+			// Simply connect using the CA certificate.
+			grpcCredentials = grpc.credentials.createSsl(Buffer.from(ca));
+		}
+	} else {
+		grpcCredentials = grpc.credentials.createInsecure();
+	}
+
+	// Force all methods to appear bi-directional, since we manually handle the call flow (see grpc-call.js).
+	forEach(serviceDescriptors, (method) => {
+		method.requestStream = true;
+		method.responseStream = true;
+	});
+
+	if (noSerialise || voltId) {
+		if (voltId && !serviceId) {
+			// We must have a service identifier id when tunnelling in order to be able to route the rpc.
+			throw new Error("createClient - no serviceId given");
+		}
+		forEach(serviceDescriptors, (method) => {
+			if (voltId) {
+				// Prepend the resource id to the method path if tunnelling.
+				if (voltId === serviceId) {
+					method.path = `/${voltId}${method.path}`;
+				} else {
+					method.path = `/${voltId}/${serviceId}${method.path}`;
+				}
+			}
+			if (noSerialise) {
+				// Save original serialisation methods so we can encrypt/decrypt in the tunnel.
+				method.requestSerializeOriginal = method.requestSerialize;
+				method.responseDeserializeOriginal = method.responseDeserialize;
+
+				// Replace default serialisation with NOP, since when tunnelling we encrypt the payload
+				// before sending it to the channel, so we want it to be treated as a pure byte array (pass-through).
+				method.requestSerialize = serialiseNOP;
+				method.responseDeserialize = serialiseNOP;
+			}
+		});
+	}
+
+	const SubClass = grpc.makeGenericClientConstructor(serviceDescriptors);
+
+	return new SubClass(address, grpcCredentials);
 }
 
 /**
@@ -72,126 +84,150 @@ export function createClient(grpc, serviceDescriptors, address, cryptoOptions, n
  * @param {*} api
  */
 const grpcWrap = (api) => {
-  const grpcRoutes = {};
-
-  // Don't bother trying to wrap class constructors.
-  const ignoreMethods = ["constructor"];
-
-  // Support class instances and PoJos
-  const isClass = api.constructor !== Object;
-  const iterate = Object.getOwnPropertyNames(isClass ? api.constructor.prototype : api);
-
-  // Wrap each method on the api.
-  forEach(iterate, (name) => {
-    if (!ignoreMethods.includes(name)) {
-      const method = api[name];
-      grpcRoutes[name] = (call, callback) => {
-        // Execute the method in the context of the api.
-        const resultPromise = method.call(api, call.request, call);
-
-        // Enforce promise results.
-        if (!resultPromise || !resultPromise.then || !resultPromise.catch) {
-          throw new Error(`implementation methods must return a Promise [${name}]`);
-        }
-
-        resultPromise
-          .then((response) => {
-            if (callback) {
-              callback(null, response);
-            }
-          })
-          .catch((err) => {
-            if (callback) {
-              callback(err);
-            } else {
-              // TODO - verify this => how to send error to stream clients?
-              // Destroy stream on error.
-              call.destroy(err);
-            }
-          });
-      };
-    }
-  });
-
-  return grpcRoutes;
+	const grpcRoutes = {};
+
+	// Don't bother trying to wrap class constructors.
+	const ignoreMethods = ["constructor"];
+
+	// Support class instances and PoJos
+	const isClass = api.constructor !== Object;
+	const iterate = Object.getOwnPropertyNames(
+		isClass ? api.constructor.prototype : api,
+	);
+
+	// Wrap each method on the api.
+	forEach(iterate, (name) => {
+		if (!ignoreMethods.includes(name)) {
+			const method = api[name];
+			grpcRoutes[name] = (call, callback) => {
+				// Execute the method in the context of the api.
+				const resultPromise = method.call(api, call.request, call);
+
+				// Enforce promise results.
+				if (!(resultPromise?.then && resultPromise?.catch)) {
+					throw new Error(
+						`implementation methods must return a Promise [${name}]`,
+					);
+				}
+
+				resultPromise
+					.then((response) => {
+						if (callback) {
+							callback(null, response);
+						}
+					})
+					.catch((err) => {
+						if (callback) {
+							callback(err);
+						} else {
+							// TODO - verify this => how to send error to stream clients?
+							// Destroy stream on error.
+							call.destroy(err);
+						}
+					});
+			};
+		}
+	});
+
+	return grpcRoutes;
 };
 
 class GrpcServer {
-  constructor(options) {
-    const {grpc, serviceDescriptors, routes, tlsOptions, requireClientCert} = options;
-    this._grpc = grpc;
-    this._server = new this._grpc.Server();
-
-    if (tlsOptions) {
-      const caList = [];
-      const certChains = [];
-      [].concat(tlsOptions).forEach((tlsOption) => {
-        caList.push(tlsOption.ca);
-        certChains.push({
-          private_key: tlsOption.key,
-          cert_chain: tlsOption.cert,
-        });
-      });
-
-      // Create credentials from the volt CA and our own pub/priv key.
-      this._credentials = grpc.ServerCredentials.createSsl(
-        // The root CAs we trust when verifying client certificates.
-        Buffer.concat(caList),
-        // The certificate chain(s) we present to the client.
-        certChains,
-        // Flag indicating if we insist on a client certificate.
-        requireClientCert
-      );
-    } else {
-      this._credentials = grpc.ServerCredentials.createInsecure();
-    }
-
-    if (serviceDescriptors && !isEmpty(routes)) {
-      // Enforce decoupling of the service implementation.
-      const router = grpcWrap(routes);
-      this._server.addService(serviceDescriptors, router);
-    }
-  }
-
-  close(force = false) {
-    return new Promise((resolve) => {
-      if (force) {
-        resolve(this._server.forceShutdown());
-      } else {
-        this._server.tryShutdown(resolve);
-      }
-    });
-  }
-
-  listen(address) {
-    return new Promise((resolve, reject) => {
-      // If no port is specified, grpc will return the port number assigned.
-      this._server.bindAsync(address, this._credentials, (err, port) => {
-        if (err) {
-          reject(err);
-        } else {
-          this._port = port;
-          this._server.start();
-          resolve(port);
-        }
-      });
-    });
-  }
-
-  get server() {
-    return this._server;
-  }
-
-  get port() {
-    return this._port;
-  }
+	constructor(options) {
+		const { grpc, serviceDescriptors, routes, tlsOptions, requireClientCert } =
+			options;
+		this._grpc = grpc;
+		this._server = new this._grpc.Server({
+			"grpc.keepalive_time_ms": 500,
+			"grpc.keepalive_timeout_ms": 5000,
+			"grpc.http2.max_pings_without_data": 0,
+			"grpc.keepalive_permit_without_calls": 1,
+			"grpc.http2.min_ping_interval_without_data_ms": 250,
+			"grpc.http2.max_ping_strikes": 0,
+		});
+
+		if (tlsOptions) {
+			const caList = [];
+			const certChains = [];
+			[].concat(tlsOptions).forEach((tlsOption) => {
+				caList.push(tlsOption.ca);
+				certChains.push({
+					private_key: tlsOption.key,
+					cert_chain: tlsOption.cert,
+				});
+			});
+
+			// Create credentials from the volt CA and our own pub/priv key.
+			this._credentials = grpc.ServerCredentials.createSsl(
+				// The root CAs we trust when verifying client certificates.
+				Buffer.concat(caList),
+				// The certificate chain(s) we present to the client.
+				certChains,
+				// Flag indicating if we insist on a client certificate.
+				requireClientCert,
+			);
+		} else {
+			this._credentials = grpc.ServerCredentials.createInsecure();
+		}
+
+		if (serviceDescriptors && !isEmpty(routes)) {
+			// Enforce decoupling of the service implementation.
+			const router = grpcWrap(routes);
+			this._server.addService(serviceDescriptors, router);
+		}
+	}
+
+	close(force = false) {
+		return new Promise((resolve) => {
+			if (force) {
+				resolve(this._server.forceShutdown());
+			} else {
+				this._server.tryShutdown(resolve);
+			}
+		});
+	}
+
+	listen(address) {
+		return new Promise((resolve, reject) => {
+			// If no port is specified, grpc will return the port number assigned.
+			this._server.bindAsync(address, this._credentials, (err, port) => {
+				if (err) {
+					reject(err);
+				} else {
+					this._port = port;
+					this._server.start();
+					resolve(port);
+				}
+			});
+		});
+	}
+
+	get server() {
+		return this._server;
+	}
+
+	get port() {
+		return this._port;
+	}
 }
 
-export function createServer(grpc, serviceDescriptors, routes, cryptoCache, requireClientCert) {
-  let tlsOptions;
-  if (cryptoCache) {
-    tlsOptions = createSecureContextOptions(cryptoCache);
-  }
-  const serverArgs = {grpc, serviceDescriptors, routes, tlsOptions, requireClientCert};
-  return new GrpcServer(serverArgs);
+export function createServer(
+	grpc,
+	serviceDescriptors,
+	routes,
+	cryptoCache,
+	requireClientCert,
+) {
+	let tlsOptions;
+	if (cryptoCache) {
+		tlsOptions = createSecureContextOptions(cryptoCache);
+	}
+	const serverArgs = {
+		grpc,
+		serviceDescriptors,
+		routes,
+		tlsOptions,
+		requireClientCert,
+	};
+	return new GrpcServer(serverArgs);
 }

package/src/index.js

@@ -2,6 +2,6 @@ export {constants} from "./constants.js";
 export * as grpcUtils from "./grpc-utils.js";
 export * as utils from "./utils.js";
 export {VoltClient} from "./volt-client.js";
-export * from "./volt-crypto.js";
+export * from "./volt-credential.js";
 export * as protoUtils from "./proto-utils.js";
 export {v4 as generateId} from "uuid";

package/src/proto-utils.js

@@ -1,81 +1,98 @@
 import protoLoader from "@grpc/proto-loader";
 import lodash from "lodash";
-import {dirname, join} from "path";
-import {fileURLToPath} from "url";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 
-const {get: getProp, snakeCase} = lodash;
+const { get: getProp, snakeCase } = lodash;
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const defaultProtoPath = join(__dirname, "../protobuf");
 
 const defaultLoaderOptions = {
-  keepCase: true,
-  longs: String,
-  enums: String,
-  defaults: true,
-  oneofs: true,
-  includeDirs: [defaultProtoPath],
+	keepCase: true,
+	longs: String,
+	enums: String,
+	defaults: true,
+	oneofs: true,
+	includeDirs: [defaultProtoPath],
 };
 
 const getProtoDescriptors = (grpc, protoPath, opts) => {
-  const definition = protoLoader.loadSync(protoPath, opts || defaultLoaderOptions);
-  const descriptors = grpc.loadPackageDefinition(definition);
-  return descriptors;
+	const definition = protoLoader.loadSync(
+		protoPath,
+		opts || defaultLoaderOptions,
+	);
+	const descriptors = grpc.loadPackageDefinition(definition);
+	return descriptors;
 };
 
 const getProtoService = (descriptors, servicePath) => {
-  const serviceDef = getProp(descriptors, servicePath);
-  if (serviceDef && serviceDef.service) {
-    return serviceDef.service;
-  } else {
-    return null;
-  }
+	const serviceDef = getProp(descriptors, servicePath);
+	if (serviceDef?.service) {
+		return serviceDef.service;
+	} else {
+		return null;
+	}
 };
 
-function getServiceDescriptorsFromPath(grpc, protoPath, servicePackageName, opts) {
-  let serviceDescriptors;
-  const descriptors = getProtoDescriptors(grpc, protoPath, opts);
-  if (descriptors) {
-    serviceDescriptors = getProtoService(descriptors, servicePackageName);
-  }
+function getServiceDescriptorsFromPath(
+	grpc,
+	protoPath,
+	servicePackageName,
+	opts,
+) {
+	let serviceDescriptors;
+	const descriptors = getProtoDescriptors(grpc, protoPath, opts);
+	if (descriptors) {
+		serviceDescriptors = getProtoService(descriptors, servicePackageName);
+	}
 
-  return serviceDescriptors;
+	return serviceDescriptors;
 }
 
 function getServiceDescriptors(grpc, servicePackageName, opts) {
-  // Extract the package components of the service proto package. The package name should be of the
-  // fully qualified proto path, e.g. tdx.volt_api.webcam.v1.WebcamControlAPI.
-  const protoServiceComponents = servicePackageName.split(".");
+	// Extract the package components of the service proto package. The package name should be of the
+	// fully qualified proto path, e.g. tdx.volt_api.webcam.v1.WebcamControlAPI.
+	const protoServiceComponents = servicePackageName.split(".");
 
-  // The service name is the last component of the path.
-  const protoServiceName = protoServiceComponents.pop();
+	// The service name is the last component of the path.
+	const protoServiceName = protoServiceComponents.pop();
 
-  // The actual file name should match the snake case of the service name.
-  const protoFileName = snakeCase(protoServiceName).toLowerCase() + ".proto";
+	// The actual file name should match the snake case of the service name.
+	const protoFileName = `${snakeCase(protoServiceName).toLowerCase()}.proto`;
 
-  // The path to the proto file should match each component of the package name.
-  const protoPath = join(defaultProtoPath, ...protoServiceComponents, protoFileName);
+	// The path to the proto file should match each component of the package name.
+	const protoPath = join(
+		defaultProtoPath,
+		...protoServiceComponents,
+		protoFileName,
+	);
 
-  let serviceDescriptors;
-  const descriptors = getProtoDescriptors(grpc, protoPath, opts);
-  if (descriptors) {
-    serviceDescriptors = getProtoService(descriptors, servicePackageName);
-  }
+	let serviceDescriptors;
+	const descriptors = getProtoDescriptors(grpc, protoPath, opts);
+	if (descriptors) {
+		serviceDescriptors = getProtoService(descriptors, servicePackageName);
+	}
 
-  return serviceDescriptors;
+	return serviceDescriptors;
 }
 
 function getProtoDescriptorMethods(protoDescriptor) {
-  const methods = [];
-  Object.keys(protoDescriptor).forEach((methodName) => {
-    const method = protoDescriptor[methodName];
-    methods.push({
-      path: method.path,
-      client_streaming: method.requestStream,
-      server_streaming: method.responseStream,
-    });
-  });
-  return methods;
+	const methods = [];
+	Object.keys(protoDescriptor).forEach((methodName) => {
+		const method = protoDescriptor[methodName];
+		methods.push({
+			path: method.path,
+			client_streaming: method.requestStream,
+			server_streaming: method.responseStream,
+		});
+	});
+	return methods;
 }
 
-export {getServiceDescriptors, getProtoDescriptors, getProtoDescriptorMethods, getServiceDescriptorsFromPath};
+export {
+	getServiceDescriptors,
+	getProtoDescriptors,
+	getProtoDescriptorMethods,
+	getServiceDescriptorsFromPath,
+};