grpc-js: Return LB policy configs from resolvers in JSON form

Author: murgatroid99

packages/grpc-js/src/experimental.ts

@@ -8,16 +8,15 @@ export {
 } from './resolver';
 export { GrpcUri, uriToString } from './uri-parser';
 export { Duration, durationToMs } from './duration';
-export { ServiceConfig, MethodConfig, RetryPolicy } from './service-config';
 export { BackoffTimeout } from './backoff-timeout';
 export {
   LoadBalancer,
-  LoadBalancingConfig,
+  TypedLoadBalancingConfig,
   ChannelControlHelper,
   createChildChannelControlHelper,
   registerLoadBalancerType,
-  getFirstUsableConfig,
-  validateLoadBalancingConfig,
+  selectLbConfigFromList,
+  parseLoadBalancingConfig
 } from './load-balancer';
 export {
   SubchannelAddress,
@@ -42,7 +41,7 @@ export {
   ConnectivityStateListener,
 } from './subchannel-interface';
 export {
-  OutlierDetectionLoadBalancingConfig,
+  OutlierDetectionRawConfig,
   SuccessRateEjectionConfig,
   FailurePercentageEjectionConfig,
 } from './load-balancer-outlier-detection';

packages/grpc-js/src/index.ts

@@ -261,6 +261,8 @@ export { getChannelzServiceDefinition, getChannelzHandlers } from './channelz';
 
 export { addAdminServicesToServer } from './admin';
 
+export { ServiceConfig, LoadBalancingConfig, MethodConfig, RetryPolicy } from './service-config';
+
 import * as experimental from './experimental';
 export { experimental };
 

packages/grpc-js/src/load-balancer-child-handler.ts

@@ -18,7 +18,7 @@
 import {
   LoadBalancer,
   ChannelControlHelper,
-  LoadBalancingConfig,
+  TypedLoadBalancingConfig,
   createLoadBalancer,
 } from './load-balancer';
 import { SubchannelAddress } from './subchannel-address';
@@ -33,7 +33,7 @@ const TYPE_NAME = 'child_load_balancer_helper';
 export class ChildLoadBalancerHandler implements LoadBalancer {
   private currentChild: LoadBalancer | null = null;
   private pendingChild: LoadBalancer | null = null;
-  private latestConfig: LoadBalancingConfig | null = null;
+  private latestConfig: TypedLoadBalancingConfig | null = null;
 
   private ChildPolicyHelper = class {
     private child: LoadBalancer | null = null;
@@ -87,8 +87,8 @@ export class ChildLoadBalancerHandler implements LoadBalancer {
   constructor(private readonly channelControlHelper: ChannelControlHelper) {}
 
   protected configUpdateRequiresNewPolicyInstance(
-    oldConfig: LoadBalancingConfig,
-    newConfig: LoadBalancingConfig
+    oldConfig: TypedLoadBalancingConfig,
+    newConfig: TypedLoadBalancingConfig
   ): boolean {
     return oldConfig.getLoadBalancerName() !== newConfig.getLoadBalancerName();
   }
@@ -101,7 +101,7 @@ export class ChildLoadBalancerHandler implements LoadBalancer {
    */
   updateAddressList(
     addressList: SubchannelAddress[],
-    lbConfig: LoadBalancingConfig,
+    lbConfig: TypedLoadBalancingConfig,
     attributes: { [key: string]: unknown }
   ): void {
     let childToUpdate: LoadBalancer;

packages/grpc-js/src/load-balancer-outlier-detection.ts

@@ -18,17 +18,16 @@
 import { ChannelOptions } from './channel-options';
 import { ConnectivityState } from './connectivity-state';
 import { LogVerbosity, Status } from './constants';
-import { durationToMs, isDuration, msToDuration } from './duration';
+import { Duration, durationToMs, isDuration, msToDuration } from './duration';
 import {
   ChannelControlHelper,
   createChildChannelControlHelper,
   registerLoadBalancerType,
 } from './experimental';
 import {
-  getFirstUsableConfig,
+  selectLbConfigFromList,
   LoadBalancer,
-  LoadBalancingConfig,
-  validateLoadBalancingConfig,
+  TypedLoadBalancingConfig,
 } from './load-balancer';
 import { ChildLoadBalancerHandler } from './load-balancer-child-handler';
 import { PickArgs, Picker, PickResult, PickResultType } from './picker';
@@ -42,6 +41,7 @@ import {
   SubchannelInterface,
 } from './subchannel-interface';
 import * as logging from './logging';
+import { LoadBalancingConfig } from './service-config';
 
 const TRACER_NAME = 'outlier_detection';
 
@@ -68,6 +68,16 @@ export interface FailurePercentageEjectionConfig {
   readonly request_volume: number;
 }
 
+export interface OutlierDetectionRawConfig {
+  interval?: Duration;
+  base_ejection_time?: Duration;
+  max_ejection_time?: Duration;
+  max_ejection_percent?: number;
+  success_rate_ejection?: Partial<SuccessRateEjectionConfig>;
+  failure_percentage_ejection?: Partial<FailurePercentageEjectionConfig>;
+  child_policy: LoadBalancingConfig[];
+}
+
 const defaultSuccessRateEjectionConfig: SuccessRateEjectionConfig = {
   stdev_factor: 1900,
   enforcement_percentage: 100,
@@ -147,7 +157,7 @@ function validatePercentage(obj: any, fieldName: string, objectName?: string) {
 }
 
 export class OutlierDetectionLoadBalancingConfig
-  implements LoadBalancingConfig
+  implements TypedLoadBalancingConfig
 {
   private readonly intervalMs: number;
   private readonly baseEjectionTimeMs: number;
@@ -163,11 +173,10 @@ export class OutlierDetectionLoadBalancingConfig
     maxEjectionPercent: number | null,
     successRateEjection: Partial<SuccessRateEjectionConfig> | null,
     failurePercentageEjection: Partial<FailurePercentageEjectionConfig> | null,
-    private readonly childPolicy: LoadBalancingConfig[]
+    private readonly childPolicy: TypedLoadBalancingConfig
   ) {
     if (
-      childPolicy.length > 0 &&
-      childPolicy[0].getLoadBalancerName() === 'pick_first'
+      childPolicy.getLoadBalancerName() === 'pick_first'
     ) {
       throw new Error(
         'outlier_detection LB policy cannot have a pick_first child policy'
@@ -198,7 +207,7 @@ export class OutlierDetectionLoadBalancingConfig
       max_ejection_percent: this.maxEjectionPercent,
       success_rate_ejection: this.successRateEjection,
       failure_percentage_ejection: this.failurePercentageEjection,
-      child_policy: this.childPolicy.map(policy => policy.toJsonObject()),
+      child_policy: [this.childPolicy.toJsonObject()]
     };
   }
 
@@ -220,24 +229,10 @@ export class OutlierDetectionLoadBalancingConfig
   getFailurePercentageEjectionConfig(): FailurePercentageEjectionConfig | null {
     return this.failurePercentageEjection;
   }
-  getChildPolicy(): LoadBalancingConfig[] {
+  getChildPolicy(): TypedLoadBalancingConfig {
     return this.childPolicy;
   }
 
-  copyWithChildPolicy(
-    childPolicy: LoadBalancingConfig[]
-  ): OutlierDetectionLoadBalancingConfig {
-    return new OutlierDetectionLoadBalancingConfig(
-      this.intervalMs,
-      this.baseEjectionTimeMs,
-      this.maxEjectionTimeMs,
-      this.maxEjectionPercent,
-      this.successRateEjection,
-      this.failurePercentageEjection,
-      childPolicy
-    );
-  }
-
   static createFromJson(obj: any): OutlierDetectionLoadBalancingConfig {
     validatePositiveDuration(obj, 'interval');
     validatePositiveDuration(obj, 'base_ejection_time');
@@ -303,14 +298,22 @@ export class OutlierDetectionLoadBalancingConfig
       );
     }
 
+    if (!('child_policy' in obj) || !Array.isArray(obj.child_policy)) {
+      throw new Error('outlier detection config child_policy must be an array');
+    }
+    const childPolicy = selectLbConfigFromList(obj.child_policy);
+    if (!childPolicy) {
+      throw new Error('outlier detection config child_policy: no valid recognized policy found');
+    }
+
     return new OutlierDetectionLoadBalancingConfig(
       obj.interval ? durationToMs(obj.interval) : null,
       obj.base_ejection_time ? durationToMs(obj.base_ejection_time) : null,
       obj.max_ejection_time ? durationToMs(obj.max_ejection_time) : null,
       obj.max_ejection_percent ?? null,
       obj.success_rate_ejection,
       obj.failure_percentage_ejection,
-      obj.child_policy.map(validateLoadBalancingConfig)
+      childPolicy
     );
   }
 }
@@ -794,7 +797,7 @@ export class OutlierDetectionLoadBalancer implements LoadBalancer {
 
   updateAddressList(
     addressList: SubchannelAddress[],
-    lbConfig: LoadBalancingConfig,
+    lbConfig: TypedLoadBalancingConfig,
     attributes: { [key: string]: unknown }
   ): void {
     if (!(lbConfig instanceof OutlierDetectionLoadBalancingConfig)) {
@@ -821,10 +824,7 @@ export class OutlierDetectionLoadBalancer implements LoadBalancer {
         this.addressMap.delete(key);
       }
     }
-    const childPolicy: LoadBalancingConfig = getFirstUsableConfig(
-      lbConfig.getChildPolicy(),
-      true
-    );
+    const childPolicy = lbConfig.getChildPolicy();
     this.childBalancer.updateAddressList(addressList, childPolicy, attributes);
 
     if (

packages/grpc-js/src/load-balancer-pick-first.ts

@@ -18,7 +18,7 @@
 import {
   LoadBalancer,
   ChannelControlHelper,
-  LoadBalancingConfig,
+  TypedLoadBalancingConfig,
   registerDefaultLoadBalancerType,
   registerLoadBalancerType,
 } from './load-balancer';
@@ -53,7 +53,7 @@ const TYPE_NAME = 'pick_first';
  */
 const CONNECTION_DELAY_INTERVAL_MS = 250;
 
-export class PickFirstLoadBalancingConfig implements LoadBalancingConfig {
+export class PickFirstLoadBalancingConfig implements TypedLoadBalancingConfig {
   constructor(private readonly shuffleAddressList: boolean) {}
 
   getLoadBalancerName(): string {
@@ -374,7 +374,7 @@ export class PickFirstLoadBalancer implements LoadBalancer {
 
   updateAddressList(
     addressList: SubchannelAddress[],
-    lbConfig: LoadBalancingConfig
+    lbConfig: TypedLoadBalancingConfig
   ): void {
     if (!(lbConfig instanceof PickFirstLoadBalancingConfig)) {
       return;

packages/grpc-js/src/load-balancer-round-robin.ts

@@ -18,7 +18,7 @@
 import {
   LoadBalancer,
   ChannelControlHelper,
-  LoadBalancingConfig,
+  TypedLoadBalancingConfig,
   registerLoadBalancerType,
 } from './load-balancer';
 import { ConnectivityState } from './connectivity-state';
@@ -49,7 +49,7 @@ function trace(text: string): void {
 
 const TYPE_NAME = 'round_robin';
 
-class RoundRobinLoadBalancingConfig implements LoadBalancingConfig {
+class RoundRobinLoadBalancingConfig implements TypedLoadBalancingConfig {
   getLoadBalancerName(): string {
     return TYPE_NAME;
   }
@@ -192,7 +192,7 @@ export class RoundRobinLoadBalancer implements LoadBalancer {
 
   updateAddressList(
     addressList: SubchannelAddress[],
-    lbConfig: LoadBalancingConfig
+    lbConfig: TypedLoadBalancingConfig
   ): void {
     this.resetSubchannelList();
     trace(