/*******************************************************************************
* 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.FSx;
using Amazon.FSx.Model;
namespace Amazon.PowerShell.Cmdlets.FSX
{
/// <summary>
/// Updates the configuration of an Amazon FSx for NetApp ONTAP or Amazon FSx for OpenZFS
/// volume.
/// </summary>
[Cmdlet("Update", "FSXVolume", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)]
[OutputType("Amazon.FSx.Model.Volume")]
[AWSCmdlet("Calls the Amazon FSx UpdateVolume API operation.", Operation = new[] {"UpdateVolume"}, SelectReturnType = typeof(Amazon.FSx.Model.UpdateVolumeResponse))]
[AWSCmdletOutput("Amazon.FSx.Model.Volume or Amazon.FSx.Model.UpdateVolumeResponse",
"This cmdlet returns an Amazon.FSx.Model.Volume object.",
"The service call response (type Amazon.FSx.Model.UpdateVolumeResponse) can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack."
)]
public partial class UpdateFSXVolumeCmdlet : AmazonFSxClientCmdlet, IExecutor
{
protected override bool IsSensitiveResponse { get; set; } = true;
#region Parameter SnaplockConfiguration_AuditLogVolume
/// <summary>
/// <para>
/// <para>Enables or disables the audit log volume for an FSx for ONTAP SnapLock volume. The
/// default value is <code>false</code>. If you set <code>AuditLogVolume</code> to <code>true</code>,
/// the SnapLock volume is created as an audit log volume. The minimum retention period
/// for an audit log volume is six months. </para><para>For more information, see <a href="https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/how-snaplock-works.html#snaplock-audit-log-volume">
/// SnapLock audit log volumes</a>. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_AuditLogVolume")]
public System.Boolean? SnaplockConfiguration_AuditLogVolume { get; set; }
#endregion
#region Parameter ClientRequestToken
/// <summary>
/// <para>
/// The service has not provided documentation for this parameter; please refer to the service's API reference documentation for the latest available information.
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String ClientRequestToken { get; set; }
#endregion
#region Parameter TieringPolicy_CoolingPeriod
/// <summary>
/// <para>
/// <para>Specifies the number of days that user data in a volume must remain inactive before
/// it is considered "cold" and moved to the capacity pool. Used with the <code>AUTO</code>
/// and <code>SNAPSHOT_ONLY</code> tiering policies. Enter a whole number between 2 and
/// 183. Default values are 31 days for <code>AUTO</code> and 2 days for <code>SNAPSHOT_ONLY</code>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_TieringPolicy_CoolingPeriod")]
public System.Int32? TieringPolicy_CoolingPeriod { get; set; }
#endregion
#region Parameter OntapConfiguration_CopyTagsToBackup
/// <summary>
/// <para>
/// <para>A boolean flag indicating whether tags for the volume should be copied to backups.
/// This value defaults to false. If it's set to true, all tags for the volume are copied
/// to all automatic and user-initiated backups where the user doesn't specify tags. If
/// this value is true, and you specify one or more tags, only the specified tags are
/// copied to backups. If you specify one or more tags when creating a user-initiated
/// backup, no tags are copied from the volume, regardless of this value.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_CopyTagsToBackups")]
public System.Boolean? OntapConfiguration_CopyTagsToBackup { get; set; }
#endregion
#region Parameter OpenZFSConfiguration_DataCompressionType
/// <summary>
/// <para>
/// <para>Specifies the method used to compress the data on the volume. The compression type
/// is <code>NONE</code> by default.</para><ul><li><para><code>NONE</code> - Doesn't compress the data on the volume. <code>NONE</code> is
/// the default.</para></li><li><para><code>ZSTD</code> - Compresses the data in the volume using the Zstandard (ZSTD)
/// compression algorithm. Compared to LZ4, Z-Standard provides a better compression ratio
/// to minimize on-disk storage utilization.</para></li><li><para><code>LZ4</code> - Compresses the data in the volume using the LZ4 compression algorithm.
/// Compared to Z-Standard, LZ4 is less compute-intensive and delivers higher write throughput
/// speeds.</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[AWSConstantClassSource("Amazon.FSx.OpenZFSDataCompressionType")]
public Amazon.FSx.OpenZFSDataCompressionType OpenZFSConfiguration_DataCompressionType { get; set; }
#endregion
#region Parameter OntapConfiguration_JunctionPath
/// <summary>
/// <para>
/// <para>Specifies the location in the SVM's namespace where the volume is mounted. The <code>JunctionPath</code>
/// must have a leading forward slash, such as <code>/vol3</code>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String OntapConfiguration_JunctionPath { get; set; }
#endregion
#region Parameter Name
/// <summary>
/// <para>
/// <para>The name of the OpenZFS volume. OpenZFS root volumes are automatically named <code>FSX</code>.
/// Child volume names must be unique among their parent volume's children. The name of
/// the volume is part of the mount string for the OpenZFS volume. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String Name { get; set; }
#endregion
#region Parameter TieringPolicy_Name
/// <summary>
/// <para>
/// <para>Specifies the tiering policy used to transition data. Default value is <code>SNAPSHOT_ONLY</code>.</para><ul><li><para><code>SNAPSHOT_ONLY</code> - moves cold snapshots to the capacity pool storage tier.</para></li><li><para><code>AUTO</code> - moves cold user data and snapshots to the capacity pool storage
/// tier based on your access patterns.</para></li><li><para><code>ALL</code> - moves all user data blocks in both the active file system and
/// Snapshot copies to the storage pool tier.</para></li><li><para><code>NONE</code> - keeps a volume's data in the primary storage tier, preventing
/// it from being moved to the capacity pool tier.</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_TieringPolicy_Name")]
[AWSConstantClassSource("Amazon.FSx.TieringPolicyName")]
public Amazon.FSx.TieringPolicyName TieringPolicy_Name { get; set; }
#endregion
#region Parameter OpenZFSConfiguration_NfsExport
/// <summary>
/// <para>
/// <para>The configuration object for mounting a Network File System (NFS) file system.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OpenZFSConfiguration_NfsExports")]
public Amazon.FSx.Model.OpenZFSNfsExport[] OpenZFSConfiguration_NfsExport { get; set; }
#endregion
#region Parameter SnaplockConfiguration_PrivilegedDelete
/// <summary>
/// <para>
/// <para>Enables, disables, or permanently disables privileged delete on an FSx for ONTAP SnapLock
/// Enterprise volume. Enabling privileged delete allows SnapLock administrators to delete
/// write once, read many (WORM) files even if they have active retention periods. <code>PERMANENTLY_DISABLED</code>
/// is a terminal state. If privileged delete is permanently disabled on a SnapLock volume,
/// you can't re-enable it. The default value is <code>DISABLED</code>. </para><para>For more information, see <a href="https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/how-snaplock-works.html#privileged-delete">Privileged
/// delete</a>. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_PrivilegedDelete")]
[AWSConstantClassSource("Amazon.FSx.PrivilegedDelete")]
public Amazon.FSx.PrivilegedDelete SnaplockConfiguration_PrivilegedDelete { get; set; }
#endregion
#region Parameter OpenZFSConfiguration_ReadOnly
/// <summary>
/// <para>
/// <para>A Boolean value indicating whether the volume is read-only.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Boolean? OpenZFSConfiguration_ReadOnly { get; set; }
#endregion
#region Parameter OpenZFSConfiguration_RecordSizeKiB
/// <summary>
/// <para>
/// <para>Specifies the record size of an OpenZFS volume, in kibibytes (KiB). Valid values are
/// 4, 8, 16, 32, 64, 128, 256, 512, or 1024 KiB. The default is 128 KiB. Most workloads
/// should use the default record size. Database workflows can benefit from a smaller
/// record size, while streaming workflows can benefit from a larger record size. For
/// additional guidance on when to set a custom record size, see <a href="https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/performance.html#performance-tips-zfs">
/// Tips for maximizing performance</a> in the <i>Amazon FSx for OpenZFS User Guide</i>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? OpenZFSConfiguration_RecordSizeKiB { get; set; }
#endregion
#region Parameter OntapConfiguration_SecurityStyle
/// <summary>
/// <para>
/// <para>The security style for the volume, which can be <code>UNIX</code>, <code>NTFS</code>,
/// or <code>MIXED</code>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[AWSConstantClassSource("Amazon.FSx.SecurityStyle")]
public Amazon.FSx.SecurityStyle OntapConfiguration_SecurityStyle { get; set; }
#endregion
#region Parameter OntapConfiguration_SizeInMegabyte
/// <summary>
/// <para>
/// <para>Specifies the size of the volume in megabytes.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SizeInMegabytes")]
public System.Int32? OntapConfiguration_SizeInMegabyte { get; set; }
#endregion
#region Parameter OntapConfiguration_SnapshotPolicy
/// <summary>
/// <para>
/// <para>Specifies the snapshot policy for the volume. There are three built-in snapshot policies:</para><ul><li><para><code>default</code>: This is the default policy. A maximum of six hourly snapshots
/// taken five minutes past the hour. A maximum of two daily snapshots taken Monday through
/// Saturday at 10 minutes after midnight. A maximum of two weekly snapshots taken every
/// Sunday at 15 minutes after midnight.</para></li><li><para><code>default-1weekly</code>: This policy is the same as the <code>default</code>
/// policy except that it only retains one snapshot from the weekly schedule.</para></li><li><para><code>none</code>: This policy does not take any snapshots. This policy can be assigned
/// to volumes to prevent automatic snapshots from being taken.</para></li></ul><para>You can also provide the name of a custom policy that you created with the ONTAP CLI
/// or REST API.</para><para>For more information, see <a href="https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/snapshots-ontap.html#snapshot-policies">Snapshot
/// policies</a> in the <i>Amazon FSx for NetApp ONTAP User Guide</i>.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String OntapConfiguration_SnapshotPolicy { get; set; }
#endregion
#region Parameter OpenZFSConfiguration_StorageCapacityQuotaGiB
/// <summary>
/// <para>
/// <para>The maximum amount of storage in gibibytes (GiB) that the volume can use from its
/// parent. You can specify a quota larger than the storage on the parent volume. You
/// can specify a value of <code>-1</code> to unset a volume's storage capacity quota.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? OpenZFSConfiguration_StorageCapacityQuotaGiB { get; set; }
#endregion
#region Parameter OpenZFSConfiguration_StorageCapacityReservationGiB
/// <summary>
/// <para>
/// <para>The amount of storage in gibibytes (GiB) to reserve from the parent volume. You can't
/// reserve more storage than the parent volume has reserved. You can specify a value
/// of <code>-1</code> to unset a volume's storage capacity reservation.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Int32? OpenZFSConfiguration_StorageCapacityReservationGiB { get; set; }
#endregion
#region Parameter OntapConfiguration_StorageEfficiencyEnabled
/// <summary>
/// <para>
/// <para>Default is <code>false</code>. Set to true to enable the deduplication, compression,
/// and compaction storage efficiency features on the volume.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.Boolean? OntapConfiguration_StorageEfficiencyEnabled { get; set; }
#endregion
#region Parameter AutocommitPeriod_Type
/// <summary>
/// <para>
/// <para>Defines the type of time for the autocommit period of a file in an FSx for ONTAP SnapLock
/// volume. Setting this value to <code>NONE</code> disables autocommit. The default value
/// is <code>NONE</code>. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_AutocommitPeriod_Type")]
[AWSConstantClassSource("Amazon.FSx.AutocommitPeriodType")]
public Amazon.FSx.AutocommitPeriodType AutocommitPeriod_Type { get; set; }
#endregion
#region Parameter DefaultRetention_Type
/// <summary>
/// <para>
/// <para>Defines the type of time for the retention period of an FSx for ONTAP SnapLock volume.
/// Set it to one of the valid types. If you set it to <code>INFINITE</code>, the files
/// are retained forever. If you set it to <code>UNSPECIFIED</code>, the files are retained
/// until you set an explicit retention period. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_Type")]
[AWSConstantClassSource("Amazon.FSx.RetentionPeriodType")]
public Amazon.FSx.RetentionPeriodType DefaultRetention_Type { get; set; }
#endregion
#region Parameter MaximumRetention_Type
/// <summary>
/// <para>
/// <para>Defines the type of time for the retention period of an FSx for ONTAP SnapLock volume.
/// Set it to one of the valid types. If you set it to <code>INFINITE</code>, the files
/// are retained forever. If you set it to <code>UNSPECIFIED</code>, the files are retained
/// until you set an explicit retention period. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_Type")]
[AWSConstantClassSource("Amazon.FSx.RetentionPeriodType")]
public Amazon.FSx.RetentionPeriodType MaximumRetention_Type { get; set; }
#endregion
#region Parameter MinimumRetention_Type
/// <summary>
/// <para>
/// <para>Defines the type of time for the retention period of an FSx for ONTAP SnapLock volume.
/// Set it to one of the valid types. If you set it to <code>INFINITE</code>, the files
/// are retained forever. If you set it to <code>UNSPECIFIED</code>, the files are retained
/// until you set an explicit retention period. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_Type")]
[AWSConstantClassSource("Amazon.FSx.RetentionPeriodType")]
public Amazon.FSx.RetentionPeriodType MinimumRetention_Type { get; set; }
#endregion
#region Parameter OpenZFSConfiguration_UserAndGroupQuota
/// <summary>
/// <para>
/// <para>An object specifying how much storage users or groups can use on the volume.</para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OpenZFSConfiguration_UserAndGroupQuotas")]
public Amazon.FSx.Model.OpenZFSUserOrGroupQuota[] OpenZFSConfiguration_UserAndGroupQuota { get; set; }
#endregion
#region Parameter AutocommitPeriod_Value
/// <summary>
/// <para>
/// <para>Defines the amount of time for the autocommit period of a file in an FSx for ONTAP
/// SnapLock volume. The following ranges are valid: </para><ul><li><para><code>Minutes</code>: 5 - 65,535</para></li><li><para><code>Hours</code>: 1 - 65,535</para></li><li><para><code>Days</code>: 1 - 3,650</para></li><li><para><code>Months</code>: 1 - 120</para></li><li><para><code>Years</code>: 1 - 10</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_AutocommitPeriod_Value")]
public System.Int32? AutocommitPeriod_Value { get; set; }
#endregion
#region Parameter DefaultRetention_Value
/// <summary>
/// <para>
/// <para>Defines the amount of time for the retention period of an FSx for ONTAP SnapLock volume.
/// You can't set a value for <code>INFINITE</code> or <code>UNSPECIFIED</code>. For all
/// other options, the following ranges are valid: </para><ul><li><para><code>Seconds</code>: 0 - 65,535</para></li><li><para><code>Minutes</code>: 0 - 65,535</para></li><li><para><code>Hours</code>: 0 - 24</para></li><li><para><code>Days</code>: 0 - 365</para></li><li><para><code>Months</code>: 0 - 12</para></li><li><para><code>Years</code>: 0 - 100</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_Value")]
public System.Int32? DefaultRetention_Value { get; set; }
#endregion
#region Parameter MaximumRetention_Value
/// <summary>
/// <para>
/// <para>Defines the amount of time for the retention period of an FSx for ONTAP SnapLock volume.
/// You can't set a value for <code>INFINITE</code> or <code>UNSPECIFIED</code>. For all
/// other options, the following ranges are valid: </para><ul><li><para><code>Seconds</code>: 0 - 65,535</para></li><li><para><code>Minutes</code>: 0 - 65,535</para></li><li><para><code>Hours</code>: 0 - 24</para></li><li><para><code>Days</code>: 0 - 365</para></li><li><para><code>Months</code>: 0 - 12</para></li><li><para><code>Years</code>: 0 - 100</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_Value")]
public System.Int32? MaximumRetention_Value { get; set; }
#endregion
#region Parameter MinimumRetention_Value
/// <summary>
/// <para>
/// <para>Defines the amount of time for the retention period of an FSx for ONTAP SnapLock volume.
/// You can't set a value for <code>INFINITE</code> or <code>UNSPECIFIED</code>. For all
/// other options, the following ranges are valid: </para><ul><li><para><code>Seconds</code>: 0 - 65,535</para></li><li><para><code>Minutes</code>: 0 - 65,535</para></li><li><para><code>Hours</code>: 0 - 24</para></li><li><para><code>Days</code>: 0 - 365</para></li><li><para><code>Months</code>: 0 - 12</para></li><li><para><code>Years</code>: 0 - 100</para></li></ul>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_Value")]
public System.Int32? MinimumRetention_Value { get; set; }
#endregion
#region Parameter SnaplockConfiguration_VolumeAppendModeEnabled
/// <summary>
/// <para>
/// <para>Enables or disables volume-append mode on an FSx for ONTAP SnapLock volume. Volume-append
/// mode allows you to create WORM-appendable files and write data to them incrementally.
/// The default value is <code>false</code>. </para><para>For more information, see <a href="https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/worm-state.html#worm-state-append">Volume-append
/// mode</a>. </para>
/// </para>
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[Alias("OntapConfiguration_SnaplockConfiguration_VolumeAppendModeEnabled")]
public System.Boolean? SnaplockConfiguration_VolumeAppendModeEnabled { get; set; }
#endregion
#region Parameter VolumeId
/// <summary>
/// <para>
/// <para>The ID of the volume that you want to update, in the format <code>fsvol-0123456789abcdef0</code>.</para>
/// </para>
/// </summary>
#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 VolumeId { get; set; }
#endregion
#region Parameter Select
/// <summary>
/// Use the -Select parameter to control the cmdlet output. The default value is 'Volume'.
/// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.FSx.Model.UpdateVolumeResponse).
/// Specifying the name of a property of type Amazon.FSx.Model.UpdateVolumeResponse will result in that property being returned.
/// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value.
/// </summary>
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public string Select { get; set; } = "Volume";
#endregion
#region Parameter PassThru
/// <summary>
/// Changes the cmdlet behavior to return the value passed to the VolumeId parameter.
/// The -PassThru parameter is deprecated, use -Select '^VolumeId' instead. This parameter will be removed in a future version.
/// </summary>
[System.Obsolete("The -PassThru parameter is deprecated, use -Select '^VolumeId' 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
/// <summary>
/// This parameter overrides confirmation prompts to force
/// the cmdlet to continue its operation. This parameter should always
/// be used with caution.
/// </summary>
[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.VolumeId), MyInvocation.BoundParameters);
if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Update-FSXVolume (UpdateVolume)"))
{
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<Amazon.FSx.Model.UpdateVolumeResponse, UpdateFSXVolumeCmdlet>(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.VolumeId;
}
#pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
context.ClientRequestToken = this.ClientRequestToken;
context.Name = this.Name;
context.OntapConfiguration_CopyTagsToBackup = this.OntapConfiguration_CopyTagsToBackup;
context.OntapConfiguration_JunctionPath = this.OntapConfiguration_JunctionPath;
context.OntapConfiguration_SecurityStyle = this.OntapConfiguration_SecurityStyle;
context.OntapConfiguration_SizeInMegabyte = this.OntapConfiguration_SizeInMegabyte;
context.SnaplockConfiguration_AuditLogVolume = this.SnaplockConfiguration_AuditLogVolume;
context.AutocommitPeriod_Type = this.AutocommitPeriod_Type;
context.AutocommitPeriod_Value = this.AutocommitPeriod_Value;
context.SnaplockConfiguration_PrivilegedDelete = this.SnaplockConfiguration_PrivilegedDelete;
context.DefaultRetention_Type = this.DefaultRetention_Type;
context.DefaultRetention_Value = this.DefaultRetention_Value;
context.MaximumRetention_Type = this.MaximumRetention_Type;
context.MaximumRetention_Value = this.MaximumRetention_Value;
context.MinimumRetention_Type = this.MinimumRetention_Type;
context.MinimumRetention_Value = this.MinimumRetention_Value;
context.SnaplockConfiguration_VolumeAppendModeEnabled = this.SnaplockConfiguration_VolumeAppendModeEnabled;
context.OntapConfiguration_SnapshotPolicy = this.OntapConfiguration_SnapshotPolicy;
context.OntapConfiguration_StorageEfficiencyEnabled = this.OntapConfiguration_StorageEfficiencyEnabled;
context.TieringPolicy_CoolingPeriod = this.TieringPolicy_CoolingPeriod;
context.TieringPolicy_Name = this.TieringPolicy_Name;
context.OpenZFSConfiguration_DataCompressionType = this.OpenZFSConfiguration_DataCompressionType;
if (this.OpenZFSConfiguration_NfsExport != null)
{
context.OpenZFSConfiguration_NfsExport = new List<Amazon.FSx.Model.OpenZFSNfsExport>(this.OpenZFSConfiguration_NfsExport);
}
context.OpenZFSConfiguration_ReadOnly = this.OpenZFSConfiguration_ReadOnly;
context.OpenZFSConfiguration_RecordSizeKiB = this.OpenZFSConfiguration_RecordSizeKiB;
context.OpenZFSConfiguration_StorageCapacityQuotaGiB = this.OpenZFSConfiguration_StorageCapacityQuotaGiB;
context.OpenZFSConfiguration_StorageCapacityReservationGiB = this.OpenZFSConfiguration_StorageCapacityReservationGiB;
if (this.OpenZFSConfiguration_UserAndGroupQuota != null)
{
context.OpenZFSConfiguration_UserAndGroupQuota = new List<Amazon.FSx.Model.OpenZFSUserOrGroupQuota>(this.OpenZFSConfiguration_UserAndGroupQuota);
}
context.VolumeId = this.VolumeId;
#if MODULAR
if (this.VolumeId == null && ParameterWasBound(nameof(this.VolumeId)))
{
WriteWarning("You are passing $null as a value for parameter VolumeId 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
// 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.FSx.Model.UpdateVolumeRequest();
if (cmdletContext.ClientRequestToken != null)
{
request.ClientRequestToken = cmdletContext.ClientRequestToken;
}
if (cmdletContext.Name != null)
{
request.Name = cmdletContext.Name;
}
// populate OntapConfiguration
var requestOntapConfigurationIsNull = true;
request.OntapConfiguration = new Amazon.FSx.Model.UpdateOntapVolumeConfiguration();
System.Boolean? requestOntapConfiguration_ontapConfiguration_CopyTagsToBackup = null;
if (cmdletContext.OntapConfiguration_CopyTagsToBackup != null)
{
requestOntapConfiguration_ontapConfiguration_CopyTagsToBackup = cmdletContext.OntapConfiguration_CopyTagsToBackup.Value;
}
if (requestOntapConfiguration_ontapConfiguration_CopyTagsToBackup != null)
{
request.OntapConfiguration.CopyTagsToBackups = requestOntapConfiguration_ontapConfiguration_CopyTagsToBackup.Value;
requestOntapConfigurationIsNull = false;
}
System.String requestOntapConfiguration_ontapConfiguration_JunctionPath = null;
if (cmdletContext.OntapConfiguration_JunctionPath != null)
{
requestOntapConfiguration_ontapConfiguration_JunctionPath = cmdletContext.OntapConfiguration_JunctionPath;
}
if (requestOntapConfiguration_ontapConfiguration_JunctionPath != null)
{
request.OntapConfiguration.JunctionPath = requestOntapConfiguration_ontapConfiguration_JunctionPath;
requestOntapConfigurationIsNull = false;
}
Amazon.FSx.SecurityStyle requestOntapConfiguration_ontapConfiguration_SecurityStyle = null;
if (cmdletContext.OntapConfiguration_SecurityStyle != null)
{
requestOntapConfiguration_ontapConfiguration_SecurityStyle = cmdletContext.OntapConfiguration_SecurityStyle;
}
if (requestOntapConfiguration_ontapConfiguration_SecurityStyle != null)
{
request.OntapConfiguration.SecurityStyle = requestOntapConfiguration_ontapConfiguration_SecurityStyle;
requestOntapConfigurationIsNull = false;
}
System.Int32? requestOntapConfiguration_ontapConfiguration_SizeInMegabyte = null;
if (cmdletContext.OntapConfiguration_SizeInMegabyte != null)
{
requestOntapConfiguration_ontapConfiguration_SizeInMegabyte = cmdletContext.OntapConfiguration_SizeInMegabyte.Value;
}
if (requestOntapConfiguration_ontapConfiguration_SizeInMegabyte != null)
{
request.OntapConfiguration.SizeInMegabytes = requestOntapConfiguration_ontapConfiguration_SizeInMegabyte.Value;
requestOntapConfigurationIsNull = false;
}
System.String requestOntapConfiguration_ontapConfiguration_SnapshotPolicy = null;
if (cmdletContext.OntapConfiguration_SnapshotPolicy != null)
{
requestOntapConfiguration_ontapConfiguration_SnapshotPolicy = cmdletContext.OntapConfiguration_SnapshotPolicy;
}
if (requestOntapConfiguration_ontapConfiguration_SnapshotPolicy != null)
{
request.OntapConfiguration.SnapshotPolicy = requestOntapConfiguration_ontapConfiguration_SnapshotPolicy;
requestOntapConfigurationIsNull = false;
}
System.Boolean? requestOntapConfiguration_ontapConfiguration_StorageEfficiencyEnabled = null;
if (cmdletContext.OntapConfiguration_StorageEfficiencyEnabled != null)
{
requestOntapConfiguration_ontapConfiguration_StorageEfficiencyEnabled = cmdletContext.OntapConfiguration_StorageEfficiencyEnabled.Value;
}
if (requestOntapConfiguration_ontapConfiguration_StorageEfficiencyEnabled != null)
{
request.OntapConfiguration.StorageEfficiencyEnabled = requestOntapConfiguration_ontapConfiguration_StorageEfficiencyEnabled.Value;
requestOntapConfigurationIsNull = false;
}
Amazon.FSx.Model.TieringPolicy requestOntapConfiguration_ontapConfiguration_TieringPolicy = null;
// populate TieringPolicy
var requestOntapConfiguration_ontapConfiguration_TieringPolicyIsNull = true;
requestOntapConfiguration_ontapConfiguration_TieringPolicy = new Amazon.FSx.Model.TieringPolicy();
System.Int32? requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_CoolingPeriod = null;
if (cmdletContext.TieringPolicy_CoolingPeriod != null)
{
requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_CoolingPeriod = cmdletContext.TieringPolicy_CoolingPeriod.Value;
}
if (requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_CoolingPeriod != null)
{
requestOntapConfiguration_ontapConfiguration_TieringPolicy.CoolingPeriod = requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_CoolingPeriod.Value;
requestOntapConfiguration_ontapConfiguration_TieringPolicyIsNull = false;
}
Amazon.FSx.TieringPolicyName requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_Name = null;
if (cmdletContext.TieringPolicy_Name != null)
{
requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_Name = cmdletContext.TieringPolicy_Name;
}
if (requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_Name != null)
{
requestOntapConfiguration_ontapConfiguration_TieringPolicy.Name = requestOntapConfiguration_ontapConfiguration_TieringPolicy_tieringPolicy_Name;
requestOntapConfiguration_ontapConfiguration_TieringPolicyIsNull = false;
}
// determine if requestOntapConfiguration_ontapConfiguration_TieringPolicy should be set to null
if (requestOntapConfiguration_ontapConfiguration_TieringPolicyIsNull)
{
requestOntapConfiguration_ontapConfiguration_TieringPolicy = null;
}
if (requestOntapConfiguration_ontapConfiguration_TieringPolicy != null)
{
request.OntapConfiguration.TieringPolicy = requestOntapConfiguration_ontapConfiguration_TieringPolicy;
requestOntapConfigurationIsNull = false;
}
Amazon.FSx.Model.UpdateSnaplockConfiguration requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration = null;
// populate SnaplockConfiguration
var requestOntapConfiguration_ontapConfiguration_SnaplockConfigurationIsNull = true;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration = new Amazon.FSx.Model.UpdateSnaplockConfiguration();
System.Boolean? requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_AuditLogVolume = null;
if (cmdletContext.SnaplockConfiguration_AuditLogVolume != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_AuditLogVolume = cmdletContext.SnaplockConfiguration_AuditLogVolume.Value;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_AuditLogVolume != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration.AuditLogVolume = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_AuditLogVolume.Value;
requestOntapConfiguration_ontapConfiguration_SnaplockConfigurationIsNull = false;
}
Amazon.FSx.PrivilegedDelete requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_PrivilegedDelete = null;
if (cmdletContext.SnaplockConfiguration_PrivilegedDelete != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_PrivilegedDelete = cmdletContext.SnaplockConfiguration_PrivilegedDelete;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_PrivilegedDelete != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration.PrivilegedDelete = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_PrivilegedDelete;
requestOntapConfiguration_ontapConfiguration_SnaplockConfigurationIsNull = false;
}
System.Boolean? requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_VolumeAppendModeEnabled = null;
if (cmdletContext.SnaplockConfiguration_VolumeAppendModeEnabled != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_VolumeAppendModeEnabled = cmdletContext.SnaplockConfiguration_VolumeAppendModeEnabled.Value;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_VolumeAppendModeEnabled != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration.VolumeAppendModeEnabled = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_snaplockConfiguration_VolumeAppendModeEnabled.Value;
requestOntapConfiguration_ontapConfiguration_SnaplockConfigurationIsNull = false;
}
Amazon.FSx.Model.AutocommitPeriod requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod = null;
// populate AutocommitPeriod
var requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriodIsNull = true;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod = new Amazon.FSx.Model.AutocommitPeriod();
Amazon.FSx.AutocommitPeriodType requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Type = null;
if (cmdletContext.AutocommitPeriod_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Type = cmdletContext.AutocommitPeriod_Type;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod.Type = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Type;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriodIsNull = false;
}
System.Int32? requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Value = null;
if (cmdletContext.AutocommitPeriod_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Value = cmdletContext.AutocommitPeriod_Value.Value;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod.Value = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod_autocommitPeriod_Value.Value;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriodIsNull = false;
}
// determine if requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod should be set to null
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriodIsNull)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod = null;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration.AutocommitPeriod = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_AutocommitPeriod;
requestOntapConfiguration_ontapConfiguration_SnaplockConfigurationIsNull = false;
}
Amazon.FSx.Model.SnaplockRetentionPeriod requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod = null;
// populate RetentionPeriod
var requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriodIsNull = true;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod = new Amazon.FSx.Model.SnaplockRetentionPeriod();
Amazon.FSx.Model.RetentionPeriod requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention = null;
// populate DefaultRetention
var requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetentionIsNull = true;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention = new Amazon.FSx.Model.RetentionPeriod();
Amazon.FSx.RetentionPeriodType requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Type = null;
if (cmdletContext.DefaultRetention_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Type = cmdletContext.DefaultRetention_Type;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention.Type = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Type;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetentionIsNull = false;
}
System.Int32? requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Value = null;
if (cmdletContext.DefaultRetention_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Value = cmdletContext.DefaultRetention_Value.Value;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention.Value = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention_defaultRetention_Value.Value;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetentionIsNull = false;
}
// determine if requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention should be set to null
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetentionIsNull)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention = null;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod.DefaultRetention = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_DefaultRetention;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriodIsNull = false;
}
Amazon.FSx.Model.RetentionPeriod requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention = null;
// populate MaximumRetention
var requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetentionIsNull = true;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention = new Amazon.FSx.Model.RetentionPeriod();
Amazon.FSx.RetentionPeriodType requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Type = null;
if (cmdletContext.MaximumRetention_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Type = cmdletContext.MaximumRetention_Type;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention.Type = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Type;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetentionIsNull = false;
}
System.Int32? requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Value = null;
if (cmdletContext.MaximumRetention_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Value = cmdletContext.MaximumRetention_Value.Value;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention.Value = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention_maximumRetention_Value.Value;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetentionIsNull = false;
}
// determine if requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention should be set to null
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetentionIsNull)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention = null;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod.MaximumRetention = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MaximumRetention;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriodIsNull = false;
}
Amazon.FSx.Model.RetentionPeriod requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention = null;
// populate MinimumRetention
var requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetentionIsNull = true;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention = new Amazon.FSx.Model.RetentionPeriod();
Amazon.FSx.RetentionPeriodType requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Type = null;
if (cmdletContext.MinimumRetention_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Type = cmdletContext.MinimumRetention_Type;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Type != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention.Type = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Type;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetentionIsNull = false;
}
System.Int32? requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Value = null;
if (cmdletContext.MinimumRetention_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Value = cmdletContext.MinimumRetention_Value.Value;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Value != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention.Value = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention_minimumRetention_Value.Value;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetentionIsNull = false;
}
// determine if requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention should be set to null
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetentionIsNull)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention = null;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod.MinimumRetention = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_ontapConfiguration_SnaplockConfiguration_RetentionPeriod_MinimumRetention;
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriodIsNull = false;
}
// determine if requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod should be set to null
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriodIsNull)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod = null;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod != null)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration.RetentionPeriod = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration_ontapConfiguration_SnaplockConfiguration_RetentionPeriod;
requestOntapConfiguration_ontapConfiguration_SnaplockConfigurationIsNull = false;
}
// determine if requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration should be set to null
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfigurationIsNull)
{
requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration = null;
}
if (requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration != null)
{
request.OntapConfiguration.SnaplockConfiguration = requestOntapConfiguration_ontapConfiguration_SnaplockConfiguration;
requestOntapConfigurationIsNull = false;
}
// determine if request.OntapConfiguration should be set to null
if (requestOntapConfigurationIsNull)
{
request.OntapConfiguration = null;
}
// populate OpenZFSConfiguration
var requestOpenZFSConfigurationIsNull = true;
request.OpenZFSConfiguration = new Amazon.FSx.Model.UpdateOpenZFSVolumeConfiguration();
Amazon.FSx.OpenZFSDataCompressionType requestOpenZFSConfiguration_openZFSConfiguration_DataCompressionType = null;
if (cmdletContext.OpenZFSConfiguration_DataCompressionType != null)
{
requestOpenZFSConfiguration_openZFSConfiguration_DataCompressionType = cmdletContext.OpenZFSConfiguration_DataCompressionType;
}
if (requestOpenZFSConfiguration_openZFSConfiguration_DataCompressionType != null)
{
request.OpenZFSConfiguration.DataCompressionType = requestOpenZFSConfiguration_openZFSConfiguration_DataCompressionType;
requestOpenZFSConfigurationIsNull = false;
}
List<Amazon.FSx.Model.OpenZFSNfsExport> requestOpenZFSConfiguration_openZFSConfiguration_NfsExport = null;
if (cmdletContext.OpenZFSConfiguration_NfsExport != null)
{
requestOpenZFSConfiguration_openZFSConfiguration_NfsExport = cmdletContext.OpenZFSConfiguration_NfsExport;
}
if (requestOpenZFSConfiguration_openZFSConfiguration_NfsExport != null)
{
request.OpenZFSConfiguration.NfsExports = requestOpenZFSConfiguration_openZFSConfiguration_NfsExport;
requestOpenZFSConfigurationIsNull = false;
}
System.Boolean? requestOpenZFSConfiguration_openZFSConfiguration_ReadOnly = null;
if (cmdletContext.OpenZFSConfiguration_ReadOnly != null)
{
requestOpenZFSConfiguration_openZFSConfiguration_ReadOnly = cmdletContext.OpenZFSConfiguration_ReadOnly.Value;
}
if (requestOpenZFSConfiguration_openZFSConfiguration_ReadOnly != null)
{
request.OpenZFSConfiguration.ReadOnly = requestOpenZFSConfiguration_openZFSConfiguration_ReadOnly.Value;
requestOpenZFSConfigurationIsNull = false;
}
System.Int32? requestOpenZFSConfiguration_openZFSConfiguration_RecordSizeKiB = null;
if (cmdletContext.OpenZFSConfiguration_RecordSizeKiB != null)
{
requestOpenZFSConfiguration_openZFSConfiguration_RecordSizeKiB = cmdletContext.OpenZFSConfiguration_RecordSizeKiB.Value;
}
if (requestOpenZFSConfiguration_openZFSConfiguration_RecordSizeKiB != null)
{
request.OpenZFSConfiguration.RecordSizeKiB = requestOpenZFSConfiguration_openZFSConfiguration_RecordSizeKiB.Value;
requestOpenZFSConfigurationIsNull = false;
}
System.Int32? requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityQuotaGiB = null;
if (cmdletContext.OpenZFSConfiguration_StorageCapacityQuotaGiB != null)
{
requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityQuotaGiB = cmdletContext.OpenZFSConfiguration_StorageCapacityQuotaGiB.Value;
}
if (requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityQuotaGiB != null)
{
request.OpenZFSConfiguration.StorageCapacityQuotaGiB = requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityQuotaGiB.Value;
requestOpenZFSConfigurationIsNull = false;
}
System.Int32? requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityReservationGiB = null;
if (cmdletContext.OpenZFSConfiguration_StorageCapacityReservationGiB != null)
{
requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityReservationGiB = cmdletContext.OpenZFSConfiguration_StorageCapacityReservationGiB.Value;
}
if (requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityReservationGiB != null)
{
request.OpenZFSConfiguration.StorageCapacityReservationGiB = requestOpenZFSConfiguration_openZFSConfiguration_StorageCapacityReservationGiB.Value;
requestOpenZFSConfigurationIsNull = false;
}
List<Amazon.FSx.Model.OpenZFSUserOrGroupQuota> requestOpenZFSConfiguration_openZFSConfiguration_UserAndGroupQuota = null;
if (cmdletContext.OpenZFSConfiguration_UserAndGroupQuota != null)
{
requestOpenZFSConfiguration_openZFSConfiguration_UserAndGroupQuota = cmdletContext.OpenZFSConfiguration_UserAndGroupQuota;
}
if (requestOpenZFSConfiguration_openZFSConfiguration_UserAndGroupQuota != null)
{
request.OpenZFSConfiguration.UserAndGroupQuotas = requestOpenZFSConfiguration_openZFSConfiguration_UserAndGroupQuota;
requestOpenZFSConfigurationIsNull = false;
}
// determine if request.OpenZFSConfiguration should be set to null
if (requestOpenZFSConfigurationIsNull)
{
request.OpenZFSConfiguration = null;
}
if (cmdletContext.VolumeId != null)
{
request.VolumeId = cmdletContext.VolumeId;
}
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.FSx.Model.UpdateVolumeResponse CallAWSServiceOperation(IAmazonFSx client, Amazon.FSx.Model.UpdateVolumeRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon FSx", "UpdateVolume");
try
{
#if DESKTOP
return client.UpdateVolume(request);
#elif CORECLR
return client.UpdateVolumeAsync(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 ClientRequestToken { get; set; }
public System.String Name { get; set; }
public System.Boolean? OntapConfiguration_CopyTagsToBackup { get; set; }
public System.String OntapConfiguration_JunctionPath { get; set; }
public Amazon.FSx.SecurityStyle OntapConfiguration_SecurityStyle { get; set; }
public System.Int32? OntapConfiguration_SizeInMegabyte { get; set; }
public System.Boolean? SnaplockConfiguration_AuditLogVolume { get; set; }
public Amazon.FSx.AutocommitPeriodType AutocommitPeriod_Type { get; set; }
public System.Int32? AutocommitPeriod_Value { get; set; }
public Amazon.FSx.PrivilegedDelete SnaplockConfiguration_PrivilegedDelete { get; set; }
public Amazon.FSx.RetentionPeriodType DefaultRetention_Type { get; set; }
public System.Int32? DefaultRetention_Value { get; set; }
public Amazon.FSx.RetentionPeriodType MaximumRetention_Type { get; set; }
public System.Int32? MaximumRetention_Value { get; set; }
public Amazon.FSx.RetentionPeriodType MinimumRetention_Type { get; set; }
public System.Int32? MinimumRetention_Value { get; set; }
public System.Boolean? SnaplockConfiguration_VolumeAppendModeEnabled { get; set; }
public System.String OntapConfiguration_SnapshotPolicy { get; set; }
public System.Boolean? OntapConfiguration_StorageEfficiencyEnabled { get; set; }
public System.Int32? TieringPolicy_CoolingPeriod { get; set; }
public Amazon.FSx.TieringPolicyName TieringPolicy_Name { get; set; }
public Amazon.FSx.OpenZFSDataCompressionType OpenZFSConfiguration_DataCompressionType { get; set; }
public List<Amazon.FSx.Model.OpenZFSNfsExport> OpenZFSConfiguration_NfsExport { get; set; }
public System.Boolean? OpenZFSConfiguration_ReadOnly { get; set; }
public System.Int32? OpenZFSConfiguration_RecordSizeKiB { get; set; }
public System.Int32? OpenZFSConfiguration_StorageCapacityQuotaGiB { get; set; }
public System.Int32? OpenZFSConfiguration_StorageCapacityReservationGiB { get; set; }
public List<Amazon.FSx.Model.OpenZFSUserOrGroupQuota> OpenZFSConfiguration_UserAndGroupQuota { get; set; }
public System.String VolumeId { get; set; }
public System.Func<Amazon.FSx.Model.UpdateVolumeResponse, UpdateFSXVolumeCmdlet, object> Select { get; set; } =
(response, cmdlet) => response.Volume;
}
}
}