diff --git a/protos/google/spanner/admin/instance/v1/spanner_instance_admin.proto b/protos/google/spanner/admin/instance/v1/spanner_instance_admin.proto index 0893c33fd..d16ab2ca5 100644 --- a/protos/google/spanner/admin/instance/v1/spanner_instance_admin.proto +++ b/protos/google/spanner/admin/instance/v1/spanner_instance_admin.proto @@ -933,12 +933,25 @@ message AutoscalingConfig { // The autoscaling targets for an instance. message AutoscalingTargets { - // Required. The target high priority cpu utilization percentage that the + // Optional. The target high priority cpu utilization percentage that the // autoscaler should be trying to achieve for the instance. This number is // on a scale from 0 (no utilization) to 100 (full utilization). The valid - // range is [10, 90] inclusive. + // range is [10, 90] inclusive. If not specified or set to 0, the autoscaler + // skips scaling based on high priority CPU utilization. int32 high_priority_cpu_utilization_percent = 1 - [(google.api.field_behavior) = REQUIRED]; + [(google.api.field_behavior) = OPTIONAL]; + + // Optional. The target total CPU utilization percentage that the autoscaler + // should be trying to achieve for the instance. This number is on a scale + // from 0 (no utilization) to 100 (full utilization). The valid range is + // [10, 90] inclusive. If not specified or set to 0, the autoscaler skips + // scaling based on total CPU utilization. If both + // `high_priority_cpu_utilization_percent` and + // `total_cpu_utilization_percent` are specified, the autoscaler provisions + // the larger of the two required compute capacities to satisfy both + // targets. + int32 total_cpu_utilization_percent = 4 + [(google.api.field_behavior) = OPTIONAL]; // Required. The target storage utilization percentage that the autoscaler // should be trying to achieve for the instance. This number is on a scale @@ -966,6 +979,60 @@ message AutoscalingConfig { // configuration for the selected replicas. int32 autoscaling_target_high_priority_cpu_utilization_percent = 2 [(google.api.field_behavior) = OPTIONAL]; + + // Optional. If specified, overrides the + // autoscaling target `total_cpu_utilization_percent` + // in the top-level autoscaling configuration for the selected replicas. + int32 autoscaling_target_total_cpu_utilization_percent = 4 + [(google.api.field_behavior) = OPTIONAL]; + + // Optional. If true, disables high priority CPU autoscaling for the + // selected replicas and ignores + // [high_priority_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.high_priority_cpu_utilization_percent] + // in the top-level autoscaling configuration. + // + // When setting this field to true, setting + // [autoscaling_target_high_priority_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.autoscaling_target_high_priority_cpu_utilization_percent] + // field to a non-zero value for the same replica is not supported. + // + // If false, the + // [autoscaling_target_high_priority_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.autoscaling_target_high_priority_cpu_utilization_percent] + // field in the replica will be used if set to a non-zero value. + // Otherwise, the + // [high_priority_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.high_priority_cpu_utilization_percent] + // field in the top-level autoscaling configuration will be used. + // + // Setting both + // [disable_high_priority_cpu_autoscaling][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.disable_high_priority_cpu_autoscaling] + // and + // [disable_total_cpu_autoscaling][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.disable_total_cpu_autoscaling] + // to true for the same replica is not supported. + bool disable_high_priority_cpu_autoscaling = 5 + [(google.api.field_behavior) = OPTIONAL]; + + // Optional. If true, disables total CPU autoscaling for the selected + // replicas and ignores + // [total_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.total_cpu_utilization_percent] + // in the top-level autoscaling configuration. + // + // When setting this field to true, setting + // [autoscaling_target_total_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.autoscaling_target_total_cpu_utilization_percent] + // field to a non-zero value for the same replica is not supported. + // + // If false, the + // [autoscaling_target_total_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.autoscaling_target_total_cpu_utilization_percent] + // field in the replica will be used if set to a non-zero value. + // Otherwise, the + // [total_cpu_utilization_percent][google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.total_cpu_utilization_percent] + // field in the top-level autoscaling configuration will be used. + // + // Setting both + // [disable_high_priority_cpu_autoscaling][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.disable_high_priority_cpu_autoscaling] + // and + // [disable_total_cpu_autoscaling][google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides.disable_total_cpu_autoscaling] + // to true for the same replica is not supported. + bool disable_total_cpu_autoscaling = 6 + [(google.api.field_behavior) = OPTIONAL]; } // Required. Selects the replicas to which this AsymmetricAutoscalingOption diff --git a/protos/protos.d.ts b/protos/protos.d.ts index 8c87a6928..530ac861b 100644 --- a/protos/protos.d.ts +++ b/protos/protos.d.ts @@ -15472,6 +15472,9 @@ export namespace google { /** AutoscalingTargets highPriorityCpuUtilizationPercent */ highPriorityCpuUtilizationPercent?: (number|null); + /** AutoscalingTargets totalCpuUtilizationPercent */ + totalCpuUtilizationPercent?: (number|null); + /** AutoscalingTargets storageUtilizationPercent */ storageUtilizationPercent?: (number|null); } @@ -15488,6 +15491,9 @@ export namespace google { /** AutoscalingTargets highPriorityCpuUtilizationPercent. */ public highPriorityCpuUtilizationPercent: number; + /** AutoscalingTargets totalCpuUtilizationPercent. */ + public totalCpuUtilizationPercent: number; + /** AutoscalingTargets storageUtilizationPercent. */ public storageUtilizationPercent: number; @@ -15682,6 +15688,15 @@ export namespace google { /** AutoscalingConfigOverrides autoscalingTargetHighPriorityCpuUtilizationPercent */ autoscalingTargetHighPriorityCpuUtilizationPercent?: (number|null); + + /** AutoscalingConfigOverrides autoscalingTargetTotalCpuUtilizationPercent */ + autoscalingTargetTotalCpuUtilizationPercent?: (number|null); + + /** AutoscalingConfigOverrides disableHighPriorityCpuAutoscaling */ + disableHighPriorityCpuAutoscaling?: (boolean|null); + + /** AutoscalingConfigOverrides disableTotalCpuAutoscaling */ + disableTotalCpuAutoscaling?: (boolean|null); } /** Represents an AutoscalingConfigOverrides. */ @@ -15699,6 +15714,15 @@ export namespace google { /** AutoscalingConfigOverrides autoscalingTargetHighPriorityCpuUtilizationPercent. */ public autoscalingTargetHighPriorityCpuUtilizationPercent: number; + /** AutoscalingConfigOverrides autoscalingTargetTotalCpuUtilizationPercent. */ + public autoscalingTargetTotalCpuUtilizationPercent: number; + + /** AutoscalingConfigOverrides disableHighPriorityCpuAutoscaling. */ + public disableHighPriorityCpuAutoscaling: boolean; + + /** AutoscalingConfigOverrides disableTotalCpuAutoscaling. */ + public disableTotalCpuAutoscaling: boolean; + /** * Creates a new AutoscalingConfigOverrides instance using the specified properties. * @param [properties] Properties to set diff --git a/protos/protos.js b/protos/protos.js index f406cca5d..9f8e03cad 100644 --- a/protos/protos.js +++ b/protos/protos.js @@ -39770,6 +39770,7 @@ * @memberof google.spanner.admin.instance.v1.AutoscalingConfig * @interface IAutoscalingTargets * @property {number|null} [highPriorityCpuUtilizationPercent] AutoscalingTargets highPriorityCpuUtilizationPercent + * @property {number|null} [totalCpuUtilizationPercent] AutoscalingTargets totalCpuUtilizationPercent * @property {number|null} [storageUtilizationPercent] AutoscalingTargets storageUtilizationPercent */ @@ -39796,6 +39797,14 @@ */ AutoscalingTargets.prototype.highPriorityCpuUtilizationPercent = 0; + /** + * AutoscalingTargets totalCpuUtilizationPercent. + * @member {number} totalCpuUtilizationPercent + * @memberof google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets + * @instance + */ + AutoscalingTargets.prototype.totalCpuUtilizationPercent = 0; + /** * AutoscalingTargets storageUtilizationPercent. * @member {number} storageUtilizationPercent @@ -39832,6 +39841,8 @@ writer.uint32(/* id 1, wireType 0 =*/8).int32(message.highPriorityCpuUtilizationPercent); if (message.storageUtilizationPercent != null && Object.hasOwnProperty.call(message, "storageUtilizationPercent")) writer.uint32(/* id 2, wireType 0 =*/16).int32(message.storageUtilizationPercent); + if (message.totalCpuUtilizationPercent != null && Object.hasOwnProperty.call(message, "totalCpuUtilizationPercent")) + writer.uint32(/* id 4, wireType 0 =*/32).int32(message.totalCpuUtilizationPercent); return writer; }; @@ -39872,6 +39883,10 @@ message.highPriorityCpuUtilizationPercent = reader.int32(); break; } + case 4: { + message.totalCpuUtilizationPercent = reader.int32(); + break; + } case 2: { message.storageUtilizationPercent = reader.int32(); break; @@ -39914,6 +39929,9 @@ if (message.highPriorityCpuUtilizationPercent != null && message.hasOwnProperty("highPriorityCpuUtilizationPercent")) if (!$util.isInteger(message.highPriorityCpuUtilizationPercent)) return "highPriorityCpuUtilizationPercent: integer expected"; + if (message.totalCpuUtilizationPercent != null && message.hasOwnProperty("totalCpuUtilizationPercent")) + if (!$util.isInteger(message.totalCpuUtilizationPercent)) + return "totalCpuUtilizationPercent: integer expected"; if (message.storageUtilizationPercent != null && message.hasOwnProperty("storageUtilizationPercent")) if (!$util.isInteger(message.storageUtilizationPercent)) return "storageUtilizationPercent: integer expected"; @@ -39934,6 +39952,8 @@ var message = new $root.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets(); if (object.highPriorityCpuUtilizationPercent != null) message.highPriorityCpuUtilizationPercent = object.highPriorityCpuUtilizationPercent | 0; + if (object.totalCpuUtilizationPercent != null) + message.totalCpuUtilizationPercent = object.totalCpuUtilizationPercent | 0; if (object.storageUtilizationPercent != null) message.storageUtilizationPercent = object.storageUtilizationPercent | 0; return message; @@ -39955,11 +39975,14 @@ if (options.defaults) { object.highPriorityCpuUtilizationPercent = 0; object.storageUtilizationPercent = 0; + object.totalCpuUtilizationPercent = 0; } if (message.highPriorityCpuUtilizationPercent != null && message.hasOwnProperty("highPriorityCpuUtilizationPercent")) object.highPriorityCpuUtilizationPercent = message.highPriorityCpuUtilizationPercent; if (message.storageUtilizationPercent != null && message.hasOwnProperty("storageUtilizationPercent")) object.storageUtilizationPercent = message.storageUtilizationPercent; + if (message.totalCpuUtilizationPercent != null && message.hasOwnProperty("totalCpuUtilizationPercent")) + object.totalCpuUtilizationPercent = message.totalCpuUtilizationPercent; return object; }; @@ -40236,6 +40259,9 @@ * @interface IAutoscalingConfigOverrides * @property {google.spanner.admin.instance.v1.AutoscalingConfig.IAutoscalingLimits|null} [autoscalingLimits] AutoscalingConfigOverrides autoscalingLimits * @property {number|null} [autoscalingTargetHighPriorityCpuUtilizationPercent] AutoscalingConfigOverrides autoscalingTargetHighPriorityCpuUtilizationPercent + * @property {number|null} [autoscalingTargetTotalCpuUtilizationPercent] AutoscalingConfigOverrides autoscalingTargetTotalCpuUtilizationPercent + * @property {boolean|null} [disableHighPriorityCpuAutoscaling] AutoscalingConfigOverrides disableHighPriorityCpuAutoscaling + * @property {boolean|null} [disableTotalCpuAutoscaling] AutoscalingConfigOverrides disableTotalCpuAutoscaling */ /** @@ -40269,6 +40295,30 @@ */ AutoscalingConfigOverrides.prototype.autoscalingTargetHighPriorityCpuUtilizationPercent = 0; + /** + * AutoscalingConfigOverrides autoscalingTargetTotalCpuUtilizationPercent. + * @member {number} autoscalingTargetTotalCpuUtilizationPercent + * @memberof google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides + * @instance + */ + AutoscalingConfigOverrides.prototype.autoscalingTargetTotalCpuUtilizationPercent = 0; + + /** + * AutoscalingConfigOverrides disableHighPriorityCpuAutoscaling. + * @member {boolean} disableHighPriorityCpuAutoscaling + * @memberof google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides + * @instance + */ + AutoscalingConfigOverrides.prototype.disableHighPriorityCpuAutoscaling = false; + + /** + * AutoscalingConfigOverrides disableTotalCpuAutoscaling. + * @member {boolean} disableTotalCpuAutoscaling + * @memberof google.spanner.admin.instance.v1.AutoscalingConfig.AsymmetricAutoscalingOption.AutoscalingConfigOverrides + * @instance + */ + AutoscalingConfigOverrides.prototype.disableTotalCpuAutoscaling = false; + /** * Creates a new AutoscalingConfigOverrides instance using the specified properties. * @function create @@ -40297,6 +40347,12 @@ $root.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingLimits.encode(message.autoscalingLimits, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); if (message.autoscalingTargetHighPriorityCpuUtilizationPercent != null && Object.hasOwnProperty.call(message, "autoscalingTargetHighPriorityCpuUtilizationPercent")) writer.uint32(/* id 2, wireType 0 =*/16).int32(message.autoscalingTargetHighPriorityCpuUtilizationPercent); + if (message.autoscalingTargetTotalCpuUtilizationPercent != null && Object.hasOwnProperty.call(message, "autoscalingTargetTotalCpuUtilizationPercent")) + writer.uint32(/* id 4, wireType 0 =*/32).int32(message.autoscalingTargetTotalCpuUtilizationPercent); + if (message.disableHighPriorityCpuAutoscaling != null && Object.hasOwnProperty.call(message, "disableHighPriorityCpuAutoscaling")) + writer.uint32(/* id 5, wireType 0 =*/40).bool(message.disableHighPriorityCpuAutoscaling); + if (message.disableTotalCpuAutoscaling != null && Object.hasOwnProperty.call(message, "disableTotalCpuAutoscaling")) + writer.uint32(/* id 6, wireType 0 =*/48).bool(message.disableTotalCpuAutoscaling); return writer; }; @@ -40341,6 +40397,18 @@ message.autoscalingTargetHighPriorityCpuUtilizationPercent = reader.int32(); break; } + case 4: { + message.autoscalingTargetTotalCpuUtilizationPercent = reader.int32(); + break; + } + case 5: { + message.disableHighPriorityCpuAutoscaling = reader.bool(); + break; + } + case 6: { + message.disableTotalCpuAutoscaling = reader.bool(); + break; + } default: reader.skipType(tag & 7); break; @@ -40384,6 +40452,15 @@ if (message.autoscalingTargetHighPriorityCpuUtilizationPercent != null && message.hasOwnProperty("autoscalingTargetHighPriorityCpuUtilizationPercent")) if (!$util.isInteger(message.autoscalingTargetHighPriorityCpuUtilizationPercent)) return "autoscalingTargetHighPriorityCpuUtilizationPercent: integer expected"; + if (message.autoscalingTargetTotalCpuUtilizationPercent != null && message.hasOwnProperty("autoscalingTargetTotalCpuUtilizationPercent")) + if (!$util.isInteger(message.autoscalingTargetTotalCpuUtilizationPercent)) + return "autoscalingTargetTotalCpuUtilizationPercent: integer expected"; + if (message.disableHighPriorityCpuAutoscaling != null && message.hasOwnProperty("disableHighPriorityCpuAutoscaling")) + if (typeof message.disableHighPriorityCpuAutoscaling !== "boolean") + return "disableHighPriorityCpuAutoscaling: boolean expected"; + if (message.disableTotalCpuAutoscaling != null && message.hasOwnProperty("disableTotalCpuAutoscaling")) + if (typeof message.disableTotalCpuAutoscaling !== "boolean") + return "disableTotalCpuAutoscaling: boolean expected"; return null; }; @@ -40406,6 +40483,12 @@ } if (object.autoscalingTargetHighPriorityCpuUtilizationPercent != null) message.autoscalingTargetHighPriorityCpuUtilizationPercent = object.autoscalingTargetHighPriorityCpuUtilizationPercent | 0; + if (object.autoscalingTargetTotalCpuUtilizationPercent != null) + message.autoscalingTargetTotalCpuUtilizationPercent = object.autoscalingTargetTotalCpuUtilizationPercent | 0; + if (object.disableHighPriorityCpuAutoscaling != null) + message.disableHighPriorityCpuAutoscaling = Boolean(object.disableHighPriorityCpuAutoscaling); + if (object.disableTotalCpuAutoscaling != null) + message.disableTotalCpuAutoscaling = Boolean(object.disableTotalCpuAutoscaling); return message; }; @@ -40425,11 +40508,20 @@ if (options.defaults) { object.autoscalingLimits = null; object.autoscalingTargetHighPriorityCpuUtilizationPercent = 0; + object.autoscalingTargetTotalCpuUtilizationPercent = 0; + object.disableHighPriorityCpuAutoscaling = false; + object.disableTotalCpuAutoscaling = false; } if (message.autoscalingLimits != null && message.hasOwnProperty("autoscalingLimits")) object.autoscalingLimits = $root.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingLimits.toObject(message.autoscalingLimits, options); if (message.autoscalingTargetHighPriorityCpuUtilizationPercent != null && message.hasOwnProperty("autoscalingTargetHighPriorityCpuUtilizationPercent")) object.autoscalingTargetHighPriorityCpuUtilizationPercent = message.autoscalingTargetHighPriorityCpuUtilizationPercent; + if (message.autoscalingTargetTotalCpuUtilizationPercent != null && message.hasOwnProperty("autoscalingTargetTotalCpuUtilizationPercent")) + object.autoscalingTargetTotalCpuUtilizationPercent = message.autoscalingTargetTotalCpuUtilizationPercent; + if (message.disableHighPriorityCpuAutoscaling != null && message.hasOwnProperty("disableHighPriorityCpuAutoscaling")) + object.disableHighPriorityCpuAutoscaling = message.disableHighPriorityCpuAutoscaling; + if (message.disableTotalCpuAutoscaling != null && message.hasOwnProperty("disableTotalCpuAutoscaling")) + object.disableTotalCpuAutoscaling = message.disableTotalCpuAutoscaling; return object; }; diff --git a/protos/protos.json b/protos/protos.json index f0a284a6d..2f8d035ac 100644 --- a/protos/protos.json +++ b/protos/protos.json @@ -4704,7 +4704,14 @@ "type": "int32", "id": 1, "options": { - "(google.api.field_behavior)": "REQUIRED" + "(google.api.field_behavior)": "OPTIONAL" + } + }, + "totalCpuUtilizationPercent": { + "type": "int32", + "id": 4, + "options": { + "(google.api.field_behavior)": "OPTIONAL" } }, "storageUtilizationPercent": { @@ -4749,6 +4756,27 @@ "options": { "(google.api.field_behavior)": "OPTIONAL" } + }, + "autoscalingTargetTotalCpuUtilizationPercent": { + "type": "int32", + "id": 4, + "options": { + "(google.api.field_behavior)": "OPTIONAL" + } + }, + "disableHighPriorityCpuAutoscaling": { + "type": "bool", + "id": 5, + "options": { + "(google.api.field_behavior)": "OPTIONAL" + } + }, + "disableTotalCpuAutoscaling": { + "type": "bool", + "id": 6, + "options": { + "(google.api.field_behavior)": "OPTIONAL" + } } } }