/******************************************************************************* * 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.Redshift; using Amazon.Redshift.Model; namespace Amazon.PowerShell.Cmdlets.RS { /// /// Creates a new cluster from a snapshot. By default, Amazon Redshift creates the resulting /// cluster with the same configuration as the original cluster from which the snapshot /// was created, except that the new cluster is created with the default cluster security /// and parameter groups. After Amazon Redshift creates the cluster, you can use the ModifyCluster /// API to associate a different security group and different parameter group with the /// restored cluster. If you are using a DS node type, you can also choose to change to /// another DS node type of the same size during restore. /// /// /// /// If you restore a cluster into a VPC, you must provide a cluster subnet group where /// you want the cluster restored. /// /// For more information about working with snapshots, go to Amazon /// Redshift Snapshots in the Amazon Redshift Cluster Management Guide. /// /// [Cmdlet("Restore", "RSFromClusterSnapshot", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)] [OutputType("Amazon.Redshift.Model.Cluster")] [AWSCmdlet("Calls the Amazon Redshift RestoreFromClusterSnapshot API operation.", Operation = new[] {"RestoreFromClusterSnapshot"}, SelectReturnType = typeof(Amazon.Redshift.Model.RestoreFromClusterSnapshotResponse))] [AWSCmdletOutput("Amazon.Redshift.Model.Cluster or Amazon.Redshift.Model.RestoreFromClusterSnapshotResponse", "This cmdlet returns an Amazon.Redshift.Model.Cluster object.", "The service call response (type Amazon.Redshift.Model.RestoreFromClusterSnapshotResponse) can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack." )] public partial class RestoreRSFromClusterSnapshotCmdlet : AmazonRedshiftClientCmdlet, IExecutor { #region Parameter AdditionalInfo /// /// /// Reserved. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String AdditionalInfo { get; set; } #endregion #region Parameter AllowVersionUpgrade /// /// /// If true, major version upgrades can be applied during the maintenance /// window to the Amazon Redshift engine that is running on the cluster. Default: true /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? AllowVersionUpgrade { get; set; } #endregion #region Parameter AquaConfigurationStatus /// /// /// This parameter is retired. It does not set the AQUA configuration status. Amazon Redshift /// automatically determines whether to use AQUA (Advanced Query Accelerator). /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [AWSConstantClassSource("Amazon.Redshift.AquaConfigurationStatus")] public Amazon.Redshift.AquaConfigurationStatus AquaConfigurationStatus { get; set; } #endregion #region Parameter AutomatedSnapshotRetentionPeriod /// /// /// The number of days that automated snapshots are retained. If the value is 0, automated /// snapshots are disabled. Even if automated snapshots are disabled, you can still create /// manual snapshots when you want with CreateClusterSnapshot. You can't disable automated snapshots for RA3 node types. Set the automated retention /// period from 1-35 days.Default: The value selected for the cluster from which the snapshot was taken.Constraints: Must be a value from 0 to 35. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? AutomatedSnapshotRetentionPeriod { get; set; } #endregion #region Parameter AvailabilityZone /// /// /// The Amazon EC2 Availability Zone in which to restore the cluster.Default: A random, system-chosen Availability Zone.Example: us-east-2a /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String AvailabilityZone { get; set; } #endregion #region Parameter AvailabilityZoneRelocation /// /// /// The option to enable relocation for an Amazon Redshift cluster between Availability /// Zones after the cluster is restored. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? AvailabilityZoneRelocation { get; set; } #endregion #region Parameter ClusterIdentifier /// /// /// The identifier of the cluster that will be created from restoring the snapshot.Constraints: /// /// #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.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String ClusterIdentifier { get; set; } #endregion #region Parameter ClusterParameterGroupName /// /// /// The name of the parameter group to be associated with this cluster.Default: The default Amazon Redshift cluster parameter group. For information about /// the default parameter group, go to Working /// with Amazon Redshift Parameter Groups.Constraints: /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ClusterParameterGroupName { get; set; } #endregion #region Parameter ClusterSecurityGroup /// /// /// A list of security groups to be associated with this cluster.Default: The default cluster security group for Amazon Redshift.Cluster security groups only apply to clusters outside of VPCs. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("ClusterSecurityGroups")] public System.String[] ClusterSecurityGroup { get; set; } #endregion #region Parameter ClusterSubnetGroupName /// /// /// The name of the subnet group where you want to cluster restored.A snapshot of cluster in VPC can be restored only in VPC. Therefore, you must provide /// subnet group name where you want the cluster restored. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ClusterSubnetGroupName { get; set; } #endregion #region Parameter DefaultIamRoleArn /// /// /// The Amazon Resource Name (ARN) for the IAM role that was set as default for the cluster /// when the cluster was last modified while it was restored from a snapshot. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String DefaultIamRoleArn { get; set; } #endregion #region Parameter ElasticIp /// /// /// The Elastic IP (EIP) address for the cluster. Don't specify the Elastic IP address /// for a publicly accessible cluster with availability zone relocation turned on. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ElasticIp { get; set; } #endregion #region Parameter Encrypted /// /// /// Enables support for restoring an unencrypted snapshot to a cluster encrypted with /// Key Management Service (KMS) and a customer managed key. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? Encrypted { get; set; } #endregion #region Parameter EnhancedVpcRouting /// /// /// An option that specifies whether to create the cluster with enhanced VPC routing enabled. /// To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. /// For more information, see Enhanced /// VPC Routing in the Amazon Redshift Cluster Management Guide.If this option is true, enhanced VPC routing is enabled. Default: false /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? EnhancedVpcRouting { get; set; } #endregion #region Parameter HsmClientCertificateIdentifier /// /// /// Specifies the name of the HSM client certificate the Amazon Redshift cluster uses /// to retrieve the data encryption keys stored in an HSM. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String HsmClientCertificateIdentifier { get; set; } #endregion #region Parameter HsmConfigurationIdentifier /// /// /// Specifies the name of the HSM configuration that contains the information the Amazon /// Redshift cluster can use to retrieve and store keys in an HSM. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String HsmConfigurationIdentifier { get; set; } #endregion #region Parameter IamRole /// /// /// A list of Identity and Access Management (IAM) roles that can be used by the cluster /// to access other Amazon Web Services services. You must supply the IAM roles in their /// Amazon Resource Name (ARN) format. The maximum number of IAM roles that you can associate is subject to a quota. For /// more information, go to Quotas /// and limits in the Amazon Redshift Cluster Management Guide. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("IamRoles")] public System.String[] IamRole { get; set; } #endregion #region Parameter KmsKeyId /// /// /// The Key Management Service (KMS) key ID of the encryption key that encrypts data in /// the cluster restored from a shared snapshot. You can also provide the key ID when /// you restore from an unencrypted snapshot to an encrypted cluster in the same account. /// Additionally, you can specify a new KMS key ID when you restore from an encrypted /// snapshot in the same account in order to change it. In that case, the restored cluster /// is encrypted with the new KMS key ID. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String KmsKeyId { get; set; } #endregion #region Parameter MaintenanceTrackName /// /// /// The name of the maintenance track for the restored cluster. When you take a snapshot, /// the snapshot inherits the MaintenanceTrack value from the cluster. The /// snapshot might be on a different track than the cluster that was the source for the /// snapshot. For example, suppose that you take a snapshot of a cluster that is on the /// current track and then change the cluster to be on the trailing track. In this case, /// the snapshot and the source cluster are on different tracks. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String MaintenanceTrackName { get; set; } #endregion #region Parameter ManualSnapshotRetentionPeriod /// /// /// The default number of days to retain a manual snapshot. If the value is -1, the snapshot /// is retained indefinitely. This setting doesn't change the retention period of existing /// snapshots.The value must be either -1 or an integer between 1 and 3,653. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? ManualSnapshotRetentionPeriod { get; set; } #endregion #region Parameter NodeType /// /// /// The node type that the restored cluster will be provisioned with.Default: The node type of the cluster from which the snapshot was taken. You can modify /// this if you are using any DS node type. In that case, you can choose to restore into /// another DS node type of the same size. For example, you can restore ds1.8xlarge into /// ds2.8xlarge, or ds1.xlarge into ds2.xlarge. If you have a DC instance type, you must /// restore into that same instance type and size. In other words, you can only restore /// a dc1.large instance type into another dc1.large instance type or dc2.large instance /// type. You can't restore dc1.8xlarge to dc2.8xlarge. First restore to a dc1.8xlarge /// cluster, then resize to a dc2.8large cluster. For more information about node types, /// see /// About Clusters and Nodes in the Amazon Redshift Cluster Management Guide. /// /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String NodeType { get; set; } #endregion #region Parameter NumberOfNode /// /// /// The number of nodes specified when provisioning the restored cluster. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("NumberOfNodes")] public System.Int32? NumberOfNode { get; set; } #endregion #region Parameter OwnerAccount /// /// /// The Amazon Web Services account used to create or copy the snapshot. Required if you /// are restoring a snapshot you do not own, optional if you own the snapshot. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String OwnerAccount { get; set; } #endregion #region Parameter Port /// /// /// The port number on which the cluster accepts connections.Default: The same port as the original cluster.Constraints: Must be between 1115 and 65535. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Int32? Port { get; set; } #endregion #region Parameter PreferredMaintenanceWindow /// /// /// The weekly time range (in UTC) during which automated cluster maintenance can occur. Format: ddd:hh24:mi-ddd:hh24:mi Default: The value selected for the cluster from which the snapshot was taken. For /// more information about the time blocks for each region, see Maintenance /// Windows in Amazon Redshift Cluster Management Guide. Valid Days: Mon | Tue | Wed | Thu | Fri | Sat | SunConstraints: Minimum 30-minute window. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String PreferredMaintenanceWindow { get; set; } #endregion #region Parameter PubliclyAccessible /// /// /// If true, the cluster can be accessed from a public network. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.Boolean? PubliclyAccessible { get; set; } #endregion #region Parameter ReservedNodeId /// /// /// The identifier of the target reserved node offering. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String ReservedNodeId { get; set; } #endregion #region Parameter SnapshotArn /// /// /// The Amazon Resource Name (ARN) of the snapshot associated with the message to restore /// from a cluster. You must specify this parameter or snapshotIdentifier, /// but not both. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String SnapshotArn { get; set; } #endregion #region Parameter SnapshotClusterIdentifier /// /// /// The name of the cluster the source snapshot was created from. This parameter is required /// if your IAM user has a policy containing a snapshot resource element that specifies /// anything other than * for the cluster name. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String SnapshotClusterIdentifier { get; set; } #endregion #region Parameter SnapshotIdentifier /// /// /// The name of the snapshot from which to create the new cluster. This parameter isn't /// case sensitive. You must specify this parameter or snapshotArn, but not /// both.Example: my-snapshot-id /// /// [System.Management.Automation.Parameter(Position = 1, ValueFromPipelineByPropertyName = true)] public System.String SnapshotIdentifier { get; set; } #endregion #region Parameter SnapshotScheduleIdentifier /// /// /// A unique identifier for the snapshot schedule. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String SnapshotScheduleIdentifier { get; set; } #endregion #region Parameter TargetReservedNodeOfferingId /// /// /// The identifier of the target reserved node offering. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String TargetReservedNodeOfferingId { get; set; } #endregion #region Parameter VpcSecurityGroupId /// /// /// A list of Virtual Private Cloud (VPC) security groups to be associated with the cluster.Default: The default VPC security group is associated with the cluster.VPC security groups only apply to clusters in VPCs. /// /// [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("VpcSecurityGroupIds")] public System.String[] VpcSecurityGroupId { get; set; } #endregion #region Parameter Select /// /// Use the -Select parameter to control the cmdlet output. The default value is 'Cluster'. /// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.Redshift.Model.RestoreFromClusterSnapshotResponse). /// Specifying the name of a property of type Amazon.Redshift.Model.RestoreFromClusterSnapshotResponse 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; } = "Cluster"; #endregion #region Parameter PassThru /// /// Changes the cmdlet behavior to return the value passed to the ClusterIdentifier parameter. /// The -PassThru parameter is deprecated, use -Select '^ClusterIdentifier' instead. This parameter will be removed in a future version. /// [System.Obsolete("The -PassThru parameter is deprecated, use -Select '^ClusterIdentifier' 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.SnapshotIdentifier), MyInvocation.BoundParameters); if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Restore-RSFromClusterSnapshot (RestoreFromClusterSnapshot)")) { 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.ClusterIdentifier; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.AdditionalInfo = this.AdditionalInfo; context.AllowVersionUpgrade = this.AllowVersionUpgrade; context.AquaConfigurationStatus = this.AquaConfigurationStatus; context.AutomatedSnapshotRetentionPeriod = this.AutomatedSnapshotRetentionPeriod; context.AvailabilityZone = this.AvailabilityZone; context.AvailabilityZoneRelocation = this.AvailabilityZoneRelocation; context.ClusterIdentifier = this.ClusterIdentifier; #if MODULAR if (this.ClusterIdentifier == null && ParameterWasBound(nameof(this.ClusterIdentifier))) { WriteWarning("You are passing $null as a value for parameter ClusterIdentifier 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.ClusterParameterGroupName = this.ClusterParameterGroupName; if (this.ClusterSecurityGroup != null) { context.ClusterSecurityGroup = new List(this.ClusterSecurityGroup); } context.ClusterSubnetGroupName = this.ClusterSubnetGroupName; context.DefaultIamRoleArn = this.DefaultIamRoleArn; context.ElasticIp = this.ElasticIp; context.Encrypted = this.Encrypted; context.EnhancedVpcRouting = this.EnhancedVpcRouting; context.HsmClientCertificateIdentifier = this.HsmClientCertificateIdentifier; context.HsmConfigurationIdentifier = this.HsmConfigurationIdentifier; if (this.IamRole != null) { context.IamRole = new List(this.IamRole); } context.KmsKeyId = this.KmsKeyId; context.MaintenanceTrackName = this.MaintenanceTrackName; context.ManualSnapshotRetentionPeriod = this.ManualSnapshotRetentionPeriod; context.NodeType = this.NodeType; context.NumberOfNode = this.NumberOfNode; context.OwnerAccount = this.OwnerAccount; context.Port = this.Port; context.PreferredMaintenanceWindow = this.PreferredMaintenanceWindow; context.PubliclyAccessible = this.PubliclyAccessible; context.ReservedNodeId = this.ReservedNodeId; context.SnapshotArn = this.SnapshotArn; context.SnapshotClusterIdentifier = this.SnapshotClusterIdentifier; context.SnapshotIdentifier = this.SnapshotIdentifier; context.SnapshotScheduleIdentifier = this.SnapshotScheduleIdentifier; context.TargetReservedNodeOfferingId = this.TargetReservedNodeOfferingId; if (this.VpcSecurityGroupId != null) { context.VpcSecurityGroupId = new List(this.VpcSecurityGroupId); } // 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.Redshift.Model.RestoreFromClusterSnapshotRequest(); if (cmdletContext.AdditionalInfo != null) { request.AdditionalInfo = cmdletContext.AdditionalInfo; } if (cmdletContext.AllowVersionUpgrade != null) { request.AllowVersionUpgrade = cmdletContext.AllowVersionUpgrade.Value; } if (cmdletContext.AquaConfigurationStatus != null) { request.AquaConfigurationStatus = cmdletContext.AquaConfigurationStatus; } if (cmdletContext.AutomatedSnapshotRetentionPeriod != null) { request.AutomatedSnapshotRetentionPeriod = cmdletContext.AutomatedSnapshotRetentionPeriod.Value; } if (cmdletContext.AvailabilityZone != null) { request.AvailabilityZone = cmdletContext.AvailabilityZone; } if (cmdletContext.AvailabilityZoneRelocation != null) { request.AvailabilityZoneRelocation = cmdletContext.AvailabilityZoneRelocation.Value; } if (cmdletContext.ClusterIdentifier != null) { request.ClusterIdentifier = cmdletContext.ClusterIdentifier; } if (cmdletContext.ClusterParameterGroupName != null) { request.ClusterParameterGroupName = cmdletContext.ClusterParameterGroupName; } if (cmdletContext.ClusterSecurityGroup != null) { request.ClusterSecurityGroups = cmdletContext.ClusterSecurityGroup; } if (cmdletContext.ClusterSubnetGroupName != null) { request.ClusterSubnetGroupName = cmdletContext.ClusterSubnetGroupName; } if (cmdletContext.DefaultIamRoleArn != null) { request.DefaultIamRoleArn = cmdletContext.DefaultIamRoleArn; } if (cmdletContext.ElasticIp != null) { request.ElasticIp = cmdletContext.ElasticIp; } if (cmdletContext.Encrypted != null) { request.Encrypted = cmdletContext.Encrypted.Value; } if (cmdletContext.EnhancedVpcRouting != null) { request.EnhancedVpcRouting = cmdletContext.EnhancedVpcRouting.Value; } if (cmdletContext.HsmClientCertificateIdentifier != null) { request.HsmClientCertificateIdentifier = cmdletContext.HsmClientCertificateIdentifier; } if (cmdletContext.HsmConfigurationIdentifier != null) { request.HsmConfigurationIdentifier = cmdletContext.HsmConfigurationIdentifier; } if (cmdletContext.IamRole != null) { request.IamRoles = cmdletContext.IamRole; } if (cmdletContext.KmsKeyId != null) { request.KmsKeyId = cmdletContext.KmsKeyId; } if (cmdletContext.MaintenanceTrackName != null) { request.MaintenanceTrackName = cmdletContext.MaintenanceTrackName; } if (cmdletContext.ManualSnapshotRetentionPeriod != null) { request.ManualSnapshotRetentionPeriod = cmdletContext.ManualSnapshotRetentionPeriod.Value; } if (cmdletContext.NodeType != null) { request.NodeType = cmdletContext.NodeType; } if (cmdletContext.NumberOfNode != null) { request.NumberOfNodes = cmdletContext.NumberOfNode.Value; } if (cmdletContext.OwnerAccount != null) { request.OwnerAccount = cmdletContext.OwnerAccount; } if (cmdletContext.Port != null) { request.Port = cmdletContext.Port.Value; } if (cmdletContext.PreferredMaintenanceWindow != null) { request.PreferredMaintenanceWindow = cmdletContext.PreferredMaintenanceWindow; } if (cmdletContext.PubliclyAccessible != null) { request.PubliclyAccessible = cmdletContext.PubliclyAccessible.Value; } if (cmdletContext.ReservedNodeId != null) { request.ReservedNodeId = cmdletContext.ReservedNodeId; } if (cmdletContext.SnapshotArn != null) { request.SnapshotArn = cmdletContext.SnapshotArn; } if (cmdletContext.SnapshotClusterIdentifier != null) { request.SnapshotClusterIdentifier = cmdletContext.SnapshotClusterIdentifier; } if (cmdletContext.SnapshotIdentifier != null) { request.SnapshotIdentifier = cmdletContext.SnapshotIdentifier; } if (cmdletContext.SnapshotScheduleIdentifier != null) { request.SnapshotScheduleIdentifier = cmdletContext.SnapshotScheduleIdentifier; } if (cmdletContext.TargetReservedNodeOfferingId != null) { request.TargetReservedNodeOfferingId = cmdletContext.TargetReservedNodeOfferingId; } if (cmdletContext.VpcSecurityGroupId != null) { request.VpcSecurityGroupIds = cmdletContext.VpcSecurityGroupId; } 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.Redshift.Model.RestoreFromClusterSnapshotResponse CallAWSServiceOperation(IAmazonRedshift client, Amazon.Redshift.Model.RestoreFromClusterSnapshotRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Redshift", "RestoreFromClusterSnapshot"); try { #if DESKTOP return client.RestoreFromClusterSnapshot(request); #elif CORECLR return client.RestoreFromClusterSnapshotAsync(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 AdditionalInfo { get; set; } public System.Boolean? AllowVersionUpgrade { get; set; } public Amazon.Redshift.AquaConfigurationStatus AquaConfigurationStatus { get; set; } public System.Int32? AutomatedSnapshotRetentionPeriod { get; set; } public System.String AvailabilityZone { get; set; } public System.Boolean? AvailabilityZoneRelocation { get; set; } public System.String ClusterIdentifier { get; set; } public System.String ClusterParameterGroupName { get; set; } public List ClusterSecurityGroup { get; set; } public System.String ClusterSubnetGroupName { get; set; } public System.String DefaultIamRoleArn { get; set; } public System.String ElasticIp { get; set; } public System.Boolean? Encrypted { get; set; } public System.Boolean? EnhancedVpcRouting { get; set; } public System.String HsmClientCertificateIdentifier { get; set; } public System.String HsmConfigurationIdentifier { get; set; } public List IamRole { get; set; } public System.String KmsKeyId { get; set; } public System.String MaintenanceTrackName { get; set; } public System.Int32? ManualSnapshotRetentionPeriod { get; set; } public System.String NodeType { get; set; } public System.Int32? NumberOfNode { get; set; } public System.String OwnerAccount { get; set; } public System.Int32? Port { get; set; } public System.String PreferredMaintenanceWindow { get; set; } public System.Boolean? PubliclyAccessible { get; set; } public System.String ReservedNodeId { get; set; } public System.String SnapshotArn { get; set; } public System.String SnapshotClusterIdentifier { get; set; } public System.String SnapshotIdentifier { get; set; } public System.String SnapshotScheduleIdentifier { get; set; } public System.String TargetReservedNodeOfferingId { get; set; } public List VpcSecurityGroupId { get; set; } public System.Func Select { get; set; } = (response, cmdlet) => response.Cluster; } } }