/******************************************************************************* * Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"). You may not use * this file except in compliance with the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. * This file 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. * ***************************************************************************** * * AWS Tools for Windows (TM) PowerShell (TM) * */ using System; using System.Collections.Generic; using System.Linq; using System.Management.Automation; using System.Text; using Amazon.PowerShell.Common; using Amazon.Runtime; using Amazon.ApplicationAutoScaling; using Amazon.ApplicationAutoScaling.Model; namespace Amazon.PowerShell.Cmdlets.AAS { /// /// Creates or updates a scaling policy for an Application Auto Scaling scalable target. /// /// /// /// Each scalable target is identified by a service namespace, resource ID, and scalable /// dimension. A scaling policy applies to the scalable target identified by those three /// attributes. You cannot create a scaling policy until you have registered the resource /// as a scalable target. /// /// Multiple scaling policies can be in force at the same time for the same scalable target. /// You can have one or more target tracking scaling policies, one or more step scaling /// policies, or both. However, there is a chance that multiple policies could conflict, /// instructing the scalable target to scale out or in at the same time. Application Auto /// Scaling gives precedence to the policy that provides the largest capacity for both /// scale out and scale in. For example, if one policy increases capacity by 3, another /// policy increases capacity by 200 percent, and the current capacity is 10, Application /// Auto Scaling uses the policy with the highest calculated capacity (200% of 10 = 20) /// and scales out to 30. /// /// We recommend caution, however, when using target tracking scaling policies with step /// scaling policies because conflicts between these policies can cause undesirable behavior. /// For example, if the step scaling policy initiates a scale-in activity before the target /// tracking policy is ready to scale in, the scale-in activity will not be blocked. After /// the scale-in activity completes, the target tracking policy could instruct the scalable /// target to scale out again. /// /// For more information, see Target /// tracking scaling policies and Step /// scaling policies in the Application Auto Scaling User Guide. /// /// If a scalable target is deregistered, the scalable target is no longer available to /// use scaling policies. Any scaling policies that were specified for the scalable target /// are deleted. /// /// [Cmdlet("Set", "AASScalingPolicy", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)] [OutputType("Amazon.ApplicationAutoScaling.Model.PutScalingPolicyResponse")] [AWSCmdlet("Calls the Application Auto Scaling PutScalingPolicy API operation.", Operation = new[] {"PutScalingPolicy"}, SelectReturnType = typeof(Amazon.ApplicationAutoScaling.Model.PutScalingPolicyResponse), LegacyAlias="Write-AASScalingPolicy")] [AWSCmdletOutput("Amazon.ApplicationAutoScaling.Model.PutScalingPolicyResponse", "This cmdlet returns an Amazon.ApplicationAutoScaling.Model.PutScalingPolicyResponse object containing multiple properties. The object can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack." )] public partial class SetAASScalingPolicyCmdlet : AmazonApplicationAutoScalingClientCmdlet, IExecutor { #region Parameter StepScalingPolicyConfiguration_AdjustmentType /// /// /// Specifies how the ScalingAdjustment value in a StepAdjustment /// is interpreted (for example, an absolute number or a percentage). The valid values /// are ChangeInCapacity, ExactCapacity, and PercentChangeInCapacity. /// AdjustmentType is required if you are adding a new step scaling policy /// configuration. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.ApplicationAutoScaling.AdjustmentType")] public Amazon.ApplicationAutoScaling.AdjustmentType StepScalingPolicyConfiguration_AdjustmentType { get; set; } #endregion #region Parameter StepScalingPolicyConfiguration_Cooldown /// /// /// The amount of time, in seconds, to wait for a previous scaling activity to take effect. /// If not specified, the default value is 300. For more information, see Cooldown /// period in the Application Auto Scaling User Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? StepScalingPolicyConfiguration_Cooldown { get; set; } #endregion #region Parameter CustomizedMetricSpecification_Dimension /// /// /// The dimensions of the metric. Conditional: If you published your metric with dimensions, you must specify the same /// dimensions in your scaling policy. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_Dimensions")] public Amazon.ApplicationAutoScaling.Model.MetricDimension[] CustomizedMetricSpecification_Dimension { get; set; } #endregion #region Parameter TargetTrackingScalingPolicyConfiguration_DisableScaleIn /// /// /// Indicates whether scale in by the target tracking scaling policy is disabled. If the /// value is true, scale in is disabled and the target tracking scaling policy /// won't remove capacity from the scalable target. Otherwise, scale in is enabled and /// the target tracking scaling policy can remove capacity from the scalable target. The /// default value is false. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? TargetTrackingScalingPolicyConfiguration_DisableScaleIn { get; set; } #endregion #region Parameter StepScalingPolicyConfiguration_MetricAggregationType /// /// /// The aggregation type for the CloudWatch metrics. Valid values are Minimum, /// Maximum, and Average. If the aggregation type is null, the /// value is treated as Average. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.ApplicationAutoScaling.MetricAggregationType")] public Amazon.ApplicationAutoScaling.MetricAggregationType StepScalingPolicyConfiguration_MetricAggregationType { get; set; } #endregion #region Parameter CustomizedMetricSpecification_MetricName /// /// /// The name of the metric. To get the exact metric name, namespace, and dimensions, inspect /// the Metric /// object that's returned by a call to ListMetrics. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_MetricName")] public System.String CustomizedMetricSpecification_MetricName { get; set; } #endregion #region Parameter CustomizedMetricSpecification_Metric /// /// /// The metrics to include in the target tracking scaling policy, as a metric data query. /// This can include both raw metric and metric math expressions. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_Metrics")] public Amazon.ApplicationAutoScaling.Model.TargetTrackingMetricDataQuery[] CustomizedMetricSpecification_Metric { get; set; } #endregion #region Parameter StepScalingPolicyConfiguration_MinAdjustmentMagnitude /// /// /// The minimum value to scale by when the adjustment type is PercentChangeInCapacity. /// For example, suppose that you create a step scaling policy to scale out an Amazon /// ECS service by 25 percent and you specify a MinAdjustmentMagnitude of /// 2. If the service has 4 tasks and the scaling policy is performed, 25 percent of 4 /// is 1. However, because you specified a MinAdjustmentMagnitude of 2, Application /// Auto Scaling scales out the service by 2 tasks. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? StepScalingPolicyConfiguration_MinAdjustmentMagnitude { get; set; } #endregion #region Parameter CustomizedMetricSpecification_Namespace /// /// /// The namespace of the metric. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_Namespace")] public System.String CustomizedMetricSpecification_Namespace { get; set; } #endregion #region Parameter PolicyName /// /// /// The name of the scaling policy.You cannot change the name of a scaling policy, but you can delete the original scaling /// policy and create a new scaling policy with the same settings and a different name. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String PolicyName { get; set; } #endregion #region Parameter PolicyType /// /// /// The scaling policy type. This parameter is required if you are creating a scaling /// policy.The following policy types are supported: TargetTrackingScaling—Not supported for Amazon EMRStepScaling—Not supported for DynamoDB, Amazon Comprehend, Lambda, Amazon /// Keyspaces, Amazon MSK, Amazon ElastiCache, or Neptune.For more information, see Target /// tracking scaling policies and Step /// scaling policies in the Application Auto Scaling User Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.ApplicationAutoScaling.PolicyType")] public Amazon.ApplicationAutoScaling.PolicyType PolicyType { get; set; } #endregion #region Parameter PredefinedMetricSpecification_PredefinedMetricType /// /// /// The metric type. The ALBRequestCountPerTarget metric type applies only /// to Spot Fleets and ECS services. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_PredefinedMetricType")] [AWSConstantClassSource("Amazon.ApplicationAutoScaling.MetricType")] public Amazon.ApplicationAutoScaling.MetricType PredefinedMetricSpecification_PredefinedMetricType { get; set; } #endregion #region Parameter ResourceId /// /// /// The identifier of the resource associated with the scaling policy. This string consists /// of the resource type and unique identifier. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String ResourceId { get; set; } #endregion #region Parameter PredefinedMetricSpecification_ResourceLabel /// /// /// Identifies the resource associated with the metric type. You can't specify a resource /// label unless the metric type is ALBRequestCountPerTarget and there is /// a target group attached to the Spot Fleet or ECS service.You create the resource label by appending the final portion of the load balancer /// ARN and the final portion of the target group ARN into a single value, separated by /// a forward slash (/). The format of the resource label is:app/my-alb/778d41231b141a0f/targetgroup/my-alb-target-group/943f017f100becff.Where:To find the ARN for an Application Load Balancer, use the DescribeLoadBalancers /// API operation. To find the ARN for the target group, use the DescribeTargetGroups /// API operation. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_ResourceLabel")] public System.String PredefinedMetricSpecification_ResourceLabel { get; set; } #endregion #region Parameter ScalableDimension /// /// /// The scalable dimension. This string consists of the service namespace, resource type, /// and scaling property. /// /// #if !MODULAR [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [AWSConstantClassSource("Amazon.ApplicationAutoScaling.ScalableDimension")] public Amazon.ApplicationAutoScaling.ScalableDimension ScalableDimension { get; set; } #endregion #region Parameter TargetTrackingScalingPolicyConfiguration_ScaleInCooldown /// /// /// The amount of time, in seconds, after a scale-in activity completes before another /// scale-in activity can start. For more information and for default values, see Define /// cooldown periods in the Application Auto Scaling User Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? TargetTrackingScalingPolicyConfiguration_ScaleInCooldown { get; set; } #endregion #region Parameter TargetTrackingScalingPolicyConfiguration_ScaleOutCooldown /// /// /// The amount of time, in seconds, to wait for a previous scale-out activity to take /// effect. For more information and for default values, see Define /// cooldown periods in the Application Auto Scaling User Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? TargetTrackingScalingPolicyConfiguration_ScaleOutCooldown { get; set; } #endregion #region Parameter ServiceNamespace /// /// /// The namespace of the Amazon Web Services service that provides the resource. For a /// resource provided by your own application or service, use custom-resource /// instead. /// /// #if !MODULAR [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true)] #else [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true, Mandatory = true)] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] [AWSConstantClassSource("Amazon.ApplicationAutoScaling.ServiceNamespace")] public Amazon.ApplicationAutoScaling.ServiceNamespace ServiceNamespace { get; set; } #endregion #region Parameter CustomizedMetricSpecification_Statistic /// /// /// The statistic of the metric. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_Statistic")] [AWSConstantClassSource("Amazon.ApplicationAutoScaling.MetricStatistic")] public Amazon.ApplicationAutoScaling.MetricStatistic CustomizedMetricSpecification_Statistic { get; set; } #endregion #region Parameter StepScalingPolicyConfiguration_StepAdjustment /// /// /// A set of adjustments that enable you to scale based on the size of the alarm breach.At least one step adjustment is required if you are adding a new step scaling policy /// configuration. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("StepScalingPolicyConfiguration_StepAdjustments")] public Amazon.ApplicationAutoScaling.Model.StepAdjustment[] StepScalingPolicyConfiguration_StepAdjustment { get; set; } #endregion #region Parameter TargetTrackingScalingPolicyConfiguration_TargetValue /// /// /// The target value for the metric. Although this property accepts numbers of type Double, /// it won't accept values that are either too small or too large. Values must be in the /// range of -2^360 to 2^360. The value must be a valid number based on the choice of /// metric. For example, if the metric is CPU utilization, then the target value is a /// percent value that represents how much of the CPU can be used before scaling out. /// If the scaling policy specifies the ALBRequestCountPerTarget predefined /// metric, specify the target utilization as the optimal average request count per target /// during any one-minute interval. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Double? TargetTrackingScalingPolicyConfiguration_TargetValue { get; set; } #endregion #region Parameter CustomizedMetricSpecification_Unit /// /// /// The unit of the metric. For a complete list of the units that CloudWatch supports, /// see the MetricDatum /// data type in the Amazon CloudWatch API Reference. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("TargetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_Unit")] public System.String CustomizedMetricSpecification_Unit { get; set; } #endregion #region Parameter Select /// /// Use the -Select parameter to control the cmdlet output. The default value is '*'. /// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.ApplicationAutoScaling.Model.PutScalingPolicyResponse). /// Specifying the name of a property of type Amazon.ApplicationAutoScaling.Model.PutScalingPolicyResponse will result in that property being returned. /// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public string Select { get; set; } = "*"; #endregion #region Parameter PassThru /// /// Changes the cmdlet behavior to return the value passed to the ServiceNamespace parameter. /// The -PassThru parameter is deprecated, use -Select '^ServiceNamespace' instead. This parameter will be removed in a future version. /// [System.Obsolete("The -PassThru parameter is deprecated, use -Select '^ServiceNamespace' instead. This parameter will be removed in a future version.")] [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter PassThru { get; set; } #endregion #region Parameter Force /// /// This parameter overrides confirmation prompts to force /// the cmdlet to continue its operation. This parameter should always /// be used with caution. /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter Force { get; set; } #endregion protected override void ProcessRecord() { this._AWSSignerType = "v4"; base.ProcessRecord(); var resourceIdentifiersText = FormatParameterValuesForConfirmationMsg(nameof(this.PolicyName), MyInvocation.BoundParameters); if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Set-AASScalingPolicy (PutScalingPolicy)")) { return; } var context = new CmdletContext(); // allow for manipulation of parameters prior to loading into context PreExecutionContextLoad(context); #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute if (ParameterWasBound(nameof(this.Select))) { context.Select = CreateSelectDelegate(Select) ?? throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select)); if (this.PassThru.IsPresent) { throw new System.ArgumentException("-PassThru cannot be used when -Select is specified.", nameof(this.Select)); } } else if (this.PassThru.IsPresent) { context.Select = (response, cmdlet) => this.ServiceNamespace; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.PolicyName = this.PolicyName; #if MODULAR if (this.PolicyName == null && ParameterWasBound(nameof(this.PolicyName))) { WriteWarning("You are passing $null as a value for parameter PolicyName which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.PolicyType = this.PolicyType; context.ResourceId = this.ResourceId; #if MODULAR if (this.ResourceId == null && ParameterWasBound(nameof(this.ResourceId))) { WriteWarning("You are passing $null as a value for parameter ResourceId which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.ScalableDimension = this.ScalableDimension; #if MODULAR if (this.ScalableDimension == null && ParameterWasBound(nameof(this.ScalableDimension))) { WriteWarning("You are passing $null as a value for parameter ScalableDimension which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.ServiceNamespace = this.ServiceNamespace; #if MODULAR if (this.ServiceNamespace == null && ParameterWasBound(nameof(this.ServiceNamespace))) { WriteWarning("You are passing $null as a value for parameter ServiceNamespace which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.StepScalingPolicyConfiguration_AdjustmentType = this.StepScalingPolicyConfiguration_AdjustmentType; context.StepScalingPolicyConfiguration_Cooldown = this.StepScalingPolicyConfiguration_Cooldown; context.StepScalingPolicyConfiguration_MetricAggregationType = this.StepScalingPolicyConfiguration_MetricAggregationType; context.StepScalingPolicyConfiguration_MinAdjustmentMagnitude = this.StepScalingPolicyConfiguration_MinAdjustmentMagnitude; if (this.StepScalingPolicyConfiguration_StepAdjustment != null) { context.StepScalingPolicyConfiguration_StepAdjustment = new List(this.StepScalingPolicyConfiguration_StepAdjustment); } if (this.CustomizedMetricSpecification_Dimension != null) { context.CustomizedMetricSpecification_Dimension = new List(this.CustomizedMetricSpecification_Dimension); } context.CustomizedMetricSpecification_MetricName = this.CustomizedMetricSpecification_MetricName; if (this.CustomizedMetricSpecification_Metric != null) { context.CustomizedMetricSpecification_Metric = new List(this.CustomizedMetricSpecification_Metric); } context.CustomizedMetricSpecification_Namespace = this.CustomizedMetricSpecification_Namespace; context.CustomizedMetricSpecification_Statistic = this.CustomizedMetricSpecification_Statistic; context.CustomizedMetricSpecification_Unit = this.CustomizedMetricSpecification_Unit; context.TargetTrackingScalingPolicyConfiguration_DisableScaleIn = this.TargetTrackingScalingPolicyConfiguration_DisableScaleIn; context.PredefinedMetricSpecification_PredefinedMetricType = this.PredefinedMetricSpecification_PredefinedMetricType; context.PredefinedMetricSpecification_ResourceLabel = this.PredefinedMetricSpecification_ResourceLabel; context.TargetTrackingScalingPolicyConfiguration_ScaleInCooldown = this.TargetTrackingScalingPolicyConfiguration_ScaleInCooldown; context.TargetTrackingScalingPolicyConfiguration_ScaleOutCooldown = this.TargetTrackingScalingPolicyConfiguration_ScaleOutCooldown; context.TargetTrackingScalingPolicyConfiguration_TargetValue = this.TargetTrackingScalingPolicyConfiguration_TargetValue; // allow further manipulation of loaded context prior to processing PostExecutionContextLoad(context); var output = Execute(context) as CmdletOutput; ProcessOutput(output); } #region IExecutor Members public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.ApplicationAutoScaling.Model.PutScalingPolicyRequest(); if (cmdletContext.PolicyName != null) { request.PolicyName = cmdletContext.PolicyName; } if (cmdletContext.PolicyType != null) { request.PolicyType = cmdletContext.PolicyType; } if (cmdletContext.ResourceId != null) { request.ResourceId = cmdletContext.ResourceId; } if (cmdletContext.ScalableDimension != null) { request.ScalableDimension = cmdletContext.ScalableDimension; } if (cmdletContext.ServiceNamespace != null) { request.ServiceNamespace = cmdletContext.ServiceNamespace; } // populate StepScalingPolicyConfiguration var requestStepScalingPolicyConfigurationIsNull = true; request.StepScalingPolicyConfiguration = new Amazon.ApplicationAutoScaling.Model.StepScalingPolicyConfiguration(); Amazon.ApplicationAutoScaling.AdjustmentType requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_AdjustmentType = null; if (cmdletContext.StepScalingPolicyConfiguration_AdjustmentType != null) { requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_AdjustmentType = cmdletContext.StepScalingPolicyConfiguration_AdjustmentType; } if (requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_AdjustmentType != null) { request.StepScalingPolicyConfiguration.AdjustmentType = requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_AdjustmentType; requestStepScalingPolicyConfigurationIsNull = false; } System.Int32? requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_Cooldown = null; if (cmdletContext.StepScalingPolicyConfiguration_Cooldown != null) { requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_Cooldown = cmdletContext.StepScalingPolicyConfiguration_Cooldown.Value; } if (requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_Cooldown != null) { request.StepScalingPolicyConfiguration.Cooldown = requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_Cooldown.Value; requestStepScalingPolicyConfigurationIsNull = false; } Amazon.ApplicationAutoScaling.MetricAggregationType requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MetricAggregationType = null; if (cmdletContext.StepScalingPolicyConfiguration_MetricAggregationType != null) { requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MetricAggregationType = cmdletContext.StepScalingPolicyConfiguration_MetricAggregationType; } if (requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MetricAggregationType != null) { request.StepScalingPolicyConfiguration.MetricAggregationType = requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MetricAggregationType; requestStepScalingPolicyConfigurationIsNull = false; } System.Int32? requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MinAdjustmentMagnitude = null; if (cmdletContext.StepScalingPolicyConfiguration_MinAdjustmentMagnitude != null) { requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MinAdjustmentMagnitude = cmdletContext.StepScalingPolicyConfiguration_MinAdjustmentMagnitude.Value; } if (requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MinAdjustmentMagnitude != null) { request.StepScalingPolicyConfiguration.MinAdjustmentMagnitude = requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_MinAdjustmentMagnitude.Value; requestStepScalingPolicyConfigurationIsNull = false; } List requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_StepAdjustment = null; if (cmdletContext.StepScalingPolicyConfiguration_StepAdjustment != null) { requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_StepAdjustment = cmdletContext.StepScalingPolicyConfiguration_StepAdjustment; } if (requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_StepAdjustment != null) { request.StepScalingPolicyConfiguration.StepAdjustments = requestStepScalingPolicyConfiguration_stepScalingPolicyConfiguration_StepAdjustment; requestStepScalingPolicyConfigurationIsNull = false; } // determine if request.StepScalingPolicyConfiguration should be set to null if (requestStepScalingPolicyConfigurationIsNull) { request.StepScalingPolicyConfiguration = null; } // populate TargetTrackingScalingPolicyConfiguration var requestTargetTrackingScalingPolicyConfigurationIsNull = true; request.TargetTrackingScalingPolicyConfiguration = new Amazon.ApplicationAutoScaling.Model.TargetTrackingScalingPolicyConfiguration(); System.Boolean? requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_DisableScaleIn = null; if (cmdletContext.TargetTrackingScalingPolicyConfiguration_DisableScaleIn != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_DisableScaleIn = cmdletContext.TargetTrackingScalingPolicyConfiguration_DisableScaleIn.Value; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_DisableScaleIn != null) { request.TargetTrackingScalingPolicyConfiguration.DisableScaleIn = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_DisableScaleIn.Value; requestTargetTrackingScalingPolicyConfigurationIsNull = false; } System.Int32? requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleInCooldown = null; if (cmdletContext.TargetTrackingScalingPolicyConfiguration_ScaleInCooldown != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleInCooldown = cmdletContext.TargetTrackingScalingPolicyConfiguration_ScaleInCooldown.Value; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleInCooldown != null) { request.TargetTrackingScalingPolicyConfiguration.ScaleInCooldown = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleInCooldown.Value; requestTargetTrackingScalingPolicyConfigurationIsNull = false; } System.Int32? requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleOutCooldown = null; if (cmdletContext.TargetTrackingScalingPolicyConfiguration_ScaleOutCooldown != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleOutCooldown = cmdletContext.TargetTrackingScalingPolicyConfiguration_ScaleOutCooldown.Value; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleOutCooldown != null) { request.TargetTrackingScalingPolicyConfiguration.ScaleOutCooldown = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_ScaleOutCooldown.Value; requestTargetTrackingScalingPolicyConfigurationIsNull = false; } System.Double? requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_TargetValue = null; if (cmdletContext.TargetTrackingScalingPolicyConfiguration_TargetValue != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_TargetValue = cmdletContext.TargetTrackingScalingPolicyConfiguration_TargetValue.Value; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_TargetValue != null) { request.TargetTrackingScalingPolicyConfiguration.TargetValue = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_TargetValue.Value; requestTargetTrackingScalingPolicyConfigurationIsNull = false; } Amazon.ApplicationAutoScaling.Model.PredefinedMetricSpecification requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification = null; // populate PredefinedMetricSpecification var requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecificationIsNull = true; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification = new Amazon.ApplicationAutoScaling.Model.PredefinedMetricSpecification(); Amazon.ApplicationAutoScaling.MetricType requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_PredefinedMetricType = null; if (cmdletContext.PredefinedMetricSpecification_PredefinedMetricType != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_PredefinedMetricType = cmdletContext.PredefinedMetricSpecification_PredefinedMetricType; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_PredefinedMetricType != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification.PredefinedMetricType = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_PredefinedMetricType; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecificationIsNull = false; } System.String requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_ResourceLabel = null; if (cmdletContext.PredefinedMetricSpecification_ResourceLabel != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_ResourceLabel = cmdletContext.PredefinedMetricSpecification_ResourceLabel; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_ResourceLabel != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification.ResourceLabel = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification_predefinedMetricSpecification_ResourceLabel; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecificationIsNull = false; } // determine if requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification should be set to null if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecificationIsNull) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification = null; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification != null) { request.TargetTrackingScalingPolicyConfiguration.PredefinedMetricSpecification = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_PredefinedMetricSpecification; requestTargetTrackingScalingPolicyConfigurationIsNull = false; } Amazon.ApplicationAutoScaling.Model.CustomizedMetricSpecification requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification = null; // populate CustomizedMetricSpecification var requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull = true; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification = new Amazon.ApplicationAutoScaling.Model.CustomizedMetricSpecification(); List requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Dimension = null; if (cmdletContext.CustomizedMetricSpecification_Dimension != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Dimension = cmdletContext.CustomizedMetricSpecification_Dimension; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Dimension != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification.Dimensions = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Dimension; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull = false; } System.String requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_MetricName = null; if (cmdletContext.CustomizedMetricSpecification_MetricName != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_MetricName = cmdletContext.CustomizedMetricSpecification_MetricName; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_MetricName != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification.MetricName = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_MetricName; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull = false; } List requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Metric = null; if (cmdletContext.CustomizedMetricSpecification_Metric != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Metric = cmdletContext.CustomizedMetricSpecification_Metric; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Metric != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification.Metrics = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Metric; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull = false; } System.String requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Namespace = null; if (cmdletContext.CustomizedMetricSpecification_Namespace != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Namespace = cmdletContext.CustomizedMetricSpecification_Namespace; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Namespace != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification.Namespace = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Namespace; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull = false; } Amazon.ApplicationAutoScaling.MetricStatistic requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Statistic = null; if (cmdletContext.CustomizedMetricSpecification_Statistic != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Statistic = cmdletContext.CustomizedMetricSpecification_Statistic; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Statistic != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification.Statistic = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Statistic; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull = false; } System.String requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Unit = null; if (cmdletContext.CustomizedMetricSpecification_Unit != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Unit = cmdletContext.CustomizedMetricSpecification_Unit; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Unit != null) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification.Unit = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification_customizedMetricSpecification_Unit; requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull = false; } // determine if requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification should be set to null if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecificationIsNull) { requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification = null; } if (requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification != null) { request.TargetTrackingScalingPolicyConfiguration.CustomizedMetricSpecification = requestTargetTrackingScalingPolicyConfiguration_targetTrackingScalingPolicyConfiguration_CustomizedMetricSpecification; requestTargetTrackingScalingPolicyConfigurationIsNull = false; } // determine if request.TargetTrackingScalingPolicyConfiguration should be set to null if (requestTargetTrackingScalingPolicyConfigurationIsNull) { request.TargetTrackingScalingPolicyConfiguration = null; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return output; } public ExecutorContext CreateContext() { return new CmdletContext(); } #endregion #region AWS Service Operation Call private Amazon.ApplicationAutoScaling.Model.PutScalingPolicyResponse CallAWSServiceOperation(IAmazonApplicationAutoScaling client, Amazon.ApplicationAutoScaling.Model.PutScalingPolicyRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Application Auto Scaling", "PutScalingPolicy"); try { #if DESKTOP return client.PutScalingPolicy(request); #elif CORECLR return client.PutScalingPolicyAsync(request).GetAwaiter().GetResult(); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } } #endregion internal partial class CmdletContext : ExecutorContext { public System.String PolicyName { get; set; } public Amazon.ApplicationAutoScaling.PolicyType PolicyType { get; set; } public System.String ResourceId { get; set; } public Amazon.ApplicationAutoScaling.ScalableDimension ScalableDimension { get; set; } public Amazon.ApplicationAutoScaling.ServiceNamespace ServiceNamespace { get; set; } public Amazon.ApplicationAutoScaling.AdjustmentType StepScalingPolicyConfiguration_AdjustmentType { get; set; } public System.Int32? StepScalingPolicyConfiguration_Cooldown { get; set; } public Amazon.ApplicationAutoScaling.MetricAggregationType StepScalingPolicyConfiguration_MetricAggregationType { get; set; } public System.Int32? StepScalingPolicyConfiguration_MinAdjustmentMagnitude { get; set; } public List StepScalingPolicyConfiguration_StepAdjustment { get; set; } public List CustomizedMetricSpecification_Dimension { get; set; } public System.String CustomizedMetricSpecification_MetricName { get; set; } public List CustomizedMetricSpecification_Metric { get; set; } public System.String CustomizedMetricSpecification_Namespace { get; set; } public Amazon.ApplicationAutoScaling.MetricStatistic CustomizedMetricSpecification_Statistic { get; set; } public System.String CustomizedMetricSpecification_Unit { get; set; } public System.Boolean? TargetTrackingScalingPolicyConfiguration_DisableScaleIn { get; set; } public Amazon.ApplicationAutoScaling.MetricType PredefinedMetricSpecification_PredefinedMetricType { get; set; } public System.String PredefinedMetricSpecification_ResourceLabel { get; set; } public System.Int32? TargetTrackingScalingPolicyConfiguration_ScaleInCooldown { get; set; } public System.Int32? TargetTrackingScalingPolicyConfiguration_ScaleOutCooldown { get; set; } public System.Double? TargetTrackingScalingPolicyConfiguration_TargetValue { get; set; } public System.Func Select { get; set; } = (response, cmdlet) => response; } } }