/*******************************************************************************
* 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.Proton;
using Amazon.Proton.Model;
namespace Amazon.PowerShell.Cmdlets.PRO
{
///
/// Update an environment.
///
///
///
/// If the environment is associated with an environment account connection, don't
/// update or include the protonServiceRoleArn and provisioningRepository
/// parameter to update or connect to an environment account connection.
///
/// You can only update to a new environment account connection if that connection was
/// created in the same environment account that the current environment account connection
/// was created in. The account connection must also be associated with the current environment.
///
/// If the environment isn't associated with an environment account connection,
/// don't update or include the environmentAccountConnectionId parameter.
/// You can't update or connect the environment to an environment account connection
/// if it isn't already associated with an environment connection.
///
/// You can update either the environmentAccountConnectionId or protonServiceRoleArn
/// parameter and value. You can’t update both.
///
/// If the environment was configured for Amazon Web Services-managed provisioning, omit
/// the provisioningRepository parameter.
///
/// If the environment was configured for self-managed provisioning, specify the provisioningRepository
/// parameter and omit the protonServiceRoleArn and environmentAccountConnectionId
/// parameters.
///
/// For more information, see Environments
/// and Provisioning
/// methods in the Proton User Guide.
///
/// There are four modes for updating an environment. The deploymentType
/// field defines the mode.
/// NONE
/// In this mode, a deployment doesn't occur. Only the requested metadata parameters
/// are updated.
/// CURRENT_VERSION
/// In this mode, the environment is deployed and updated with the new spec that you provide.
/// Only requested parameters are updated. Don’t include minor or major version
/// parameters when you use this deployment-type.
/// MINOR_VERSION
/// In this mode, the environment is deployed and updated with the published, recommended
/// (latest) minor version of the current major version in use, by default. You can also
/// specify a different minor version of the current major version in use.
/// MAJOR_VERSION
/// In this mode, the environment is deployed and updated with the published, recommended
/// (latest) major and minor version of the current template, by default. You can also
/// specify a different major version that's higher than the major version in use and
/// a minor version.
///
///
[Cmdlet("Update", "PROEnvironment", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)]
[OutputType("Amazon.Proton.Model.Environment")]
[AWSCmdlet("Calls the AWS Proton UpdateEnvironment API operation.", Operation = new[] {"UpdateEnvironment"}, SelectReturnType = typeof(Amazon.Proton.Model.UpdateEnvironmentResponse))]
[AWSCmdletOutput("Amazon.Proton.Model.Environment or Amazon.Proton.Model.UpdateEnvironmentResponse",
"This cmdlet returns an Amazon.Proton.Model.Environment object.",
"The service call response (type Amazon.Proton.Model.UpdateEnvironmentResponse) can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack."
)]
public partial class UpdatePROEnvironmentCmdlet : AmazonProtonClientCmdlet, IExecutor
{
protected override bool IsSensitiveRequest { get; set; } = true;
protected override bool IsSensitiveResponse { get; set; } = true;
#region Parameter ProvisioningRepository_Branch
///
///
/// The repository branch.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String ProvisioningRepository_Branch { get; set; }
#endregion
#region Parameter CodebuildRoleArn
///
///
/// The Amazon Resource Name (ARN) of the IAM service role that allows Proton to provision
/// infrastructure using CodeBuild-based provisioning on your behalf.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String CodebuildRoleArn { get; set; }
#endregion
#region Parameter ComponentRoleArn
///
///
/// The Amazon Resource Name (ARN) of the IAM service role that Proton uses when provisioning
/// directly defined components in this environment. It determines the scope of infrastructure
/// that a component can provision.The environment must have a componentRoleArn to allow directly defined
/// components to be associated with the environment.For more information about components, see Proton
/// components in the Proton User Guide.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String ComponentRoleArn { get; set; }
#endregion
#region Parameter DeploymentType
///
///
/// There are four modes for updating an environment. The deploymentType
/// field defines the mode.NONEIn this mode, a deployment doesn't occur. Only the requested metadata parameters
/// are updated.CURRENT_VERSIONIn this mode, the environment is deployed and updated with the new spec that you provide.
/// Only requested parameters are updated. Don’t include major or minor version
/// parameters when you use this deployment-type.MINOR_VERSIONIn this mode, the environment is deployed and updated with the published, recommended
/// (latest) minor version of the current major version in use, by default. You can also
/// specify a different minor version of the current major version in use.MAJOR_VERSIONIn this mode, the environment is deployed and updated with the published, recommended
/// (latest) major and minor version of the current template, by default. You can also
/// specify a different major version that is higher than the major version in use and
/// a minor version (optional).
///
///
#if !MODULAR
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
#else
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true, Mandatory = true)]
[System.Management.Automation.AllowNull]
#endif
[Amazon.PowerShell.Common.AWSRequiredParameter]
[AWSConstantClassSource("Amazon.Proton.DeploymentUpdateType")]
public Amazon.Proton.DeploymentUpdateType DeploymentType { get; set; }
#endregion
#region Parameter Description
///
///
/// A description of the environment update.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String Description { get; set; }
#endregion
#region Parameter EnvironmentAccountConnectionId
///
///
/// The ID of the environment account connection.You can only update to a new environment account connection if it was created in the
/// same environment account that the current environment account connection was created
/// in and is associated with the current environment.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String EnvironmentAccountConnectionId { get; set; }
#endregion
#region Parameter Name
///
///
/// The name of the environment to update.
///
///
#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 Name { get; set; }
#endregion
#region Parameter ProvisioningRepository_Name
///
///
/// The repository name.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String ProvisioningRepository_Name { get; set; }
#endregion
#region Parameter ProtonServiceRoleArn
///
///
/// The Amazon Resource Name (ARN) of the Proton service role that allows Proton to make
/// API calls to other services your behalf.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String ProtonServiceRoleArn { get; set; }
#endregion
#region Parameter ProvisioningRepository_Provider
///
///
/// The repository provider.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
[AWSConstantClassSource("Amazon.Proton.RepositoryProvider")]
public Amazon.Proton.RepositoryProvider ProvisioningRepository_Provider { get; set; }
#endregion
#region Parameter Spec
///
///
/// The formatted specification that defines the update.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String Spec { get; set; }
#endregion
#region Parameter TemplateMajorVersion
///
///
/// The major version of the environment to update.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String TemplateMajorVersion { get; set; }
#endregion
#region Parameter TemplateMinorVersion
///
///
/// The minor version of the environment to update.
///
///
[System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)]
public System.String TemplateMinorVersion { get; set; }
#endregion
#region Parameter Select
///
/// Use the -Select parameter to control the cmdlet output. The default value is 'Environment'.
/// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.Proton.Model.UpdateEnvironmentResponse).
/// Specifying the name of a property of type Amazon.Proton.Model.UpdateEnvironmentResponse 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; } = "Environment";
#endregion
#region Parameter PassThru
///
/// Changes the cmdlet behavior to return the value passed to the Name parameter.
/// The -PassThru parameter is deprecated, use -Select '^Name' instead. This parameter will be removed in a future version.
///
[System.Obsolete("The -PassThru parameter is deprecated, use -Select '^Name' 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.Name), MyInvocation.BoundParameters);
if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "Update-PROEnvironment (UpdateEnvironment)"))
{
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.Name;
}
#pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute
context.CodebuildRoleArn = this.CodebuildRoleArn;
context.ComponentRoleArn = this.ComponentRoleArn;
context.DeploymentType = this.DeploymentType;
#if MODULAR
if (this.DeploymentType == null && ParameterWasBound(nameof(this.DeploymentType)))
{
WriteWarning("You are passing $null as a value for parameter DeploymentType 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.Description = this.Description;
context.EnvironmentAccountConnectionId = this.EnvironmentAccountConnectionId;
context.Name = this.Name;
#if MODULAR
if (this.Name == null && ParameterWasBound(nameof(this.Name)))
{
WriteWarning("You are passing $null as a value for parameter Name 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.ProtonServiceRoleArn = this.ProtonServiceRoleArn;
context.ProvisioningRepository_Branch = this.ProvisioningRepository_Branch;
context.ProvisioningRepository_Name = this.ProvisioningRepository_Name;
context.ProvisioningRepository_Provider = this.ProvisioningRepository_Provider;
context.Spec = this.Spec;
context.TemplateMajorVersion = this.TemplateMajorVersion;
context.TemplateMinorVersion = this.TemplateMinorVersion;
// 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.Proton.Model.UpdateEnvironmentRequest();
if (cmdletContext.CodebuildRoleArn != null)
{
request.CodebuildRoleArn = cmdletContext.CodebuildRoleArn;
}
if (cmdletContext.ComponentRoleArn != null)
{
request.ComponentRoleArn = cmdletContext.ComponentRoleArn;
}
if (cmdletContext.DeploymentType != null)
{
request.DeploymentType = cmdletContext.DeploymentType;
}
if (cmdletContext.Description != null)
{
request.Description = cmdletContext.Description;
}
if (cmdletContext.EnvironmentAccountConnectionId != null)
{
request.EnvironmentAccountConnectionId = cmdletContext.EnvironmentAccountConnectionId;
}
if (cmdletContext.Name != null)
{
request.Name = cmdletContext.Name;
}
if (cmdletContext.ProtonServiceRoleArn != null)
{
request.ProtonServiceRoleArn = cmdletContext.ProtonServiceRoleArn;
}
// populate ProvisioningRepository
var requestProvisioningRepositoryIsNull = true;
request.ProvisioningRepository = new Amazon.Proton.Model.RepositoryBranchInput();
System.String requestProvisioningRepository_provisioningRepository_Branch = null;
if (cmdletContext.ProvisioningRepository_Branch != null)
{
requestProvisioningRepository_provisioningRepository_Branch = cmdletContext.ProvisioningRepository_Branch;
}
if (requestProvisioningRepository_provisioningRepository_Branch != null)
{
request.ProvisioningRepository.Branch = requestProvisioningRepository_provisioningRepository_Branch;
requestProvisioningRepositoryIsNull = false;
}
System.String requestProvisioningRepository_provisioningRepository_Name = null;
if (cmdletContext.ProvisioningRepository_Name != null)
{
requestProvisioningRepository_provisioningRepository_Name = cmdletContext.ProvisioningRepository_Name;
}
if (requestProvisioningRepository_provisioningRepository_Name != null)
{
request.ProvisioningRepository.Name = requestProvisioningRepository_provisioningRepository_Name;
requestProvisioningRepositoryIsNull = false;
}
Amazon.Proton.RepositoryProvider requestProvisioningRepository_provisioningRepository_Provider = null;
if (cmdletContext.ProvisioningRepository_Provider != null)
{
requestProvisioningRepository_provisioningRepository_Provider = cmdletContext.ProvisioningRepository_Provider;
}
if (requestProvisioningRepository_provisioningRepository_Provider != null)
{
request.ProvisioningRepository.Provider = requestProvisioningRepository_provisioningRepository_Provider;
requestProvisioningRepositoryIsNull = false;
}
// determine if request.ProvisioningRepository should be set to null
if (requestProvisioningRepositoryIsNull)
{
request.ProvisioningRepository = null;
}
if (cmdletContext.Spec != null)
{
request.Spec = cmdletContext.Spec;
}
if (cmdletContext.TemplateMajorVersion != null)
{
request.TemplateMajorVersion = cmdletContext.TemplateMajorVersion;
}
if (cmdletContext.TemplateMinorVersion != null)
{
request.TemplateMinorVersion = cmdletContext.TemplateMinorVersion;
}
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.Proton.Model.UpdateEnvironmentResponse CallAWSServiceOperation(IAmazonProton client, Amazon.Proton.Model.UpdateEnvironmentRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "AWS Proton", "UpdateEnvironment");
try
{
#if DESKTOP
return client.UpdateEnvironment(request);
#elif CORECLR
return client.UpdateEnvironmentAsync(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 CodebuildRoleArn { get; set; }
public System.String ComponentRoleArn { get; set; }
public Amazon.Proton.DeploymentUpdateType DeploymentType { get; set; }
public System.String Description { get; set; }
public System.String EnvironmentAccountConnectionId { get; set; }
public System.String Name { get; set; }
public System.String ProtonServiceRoleArn { get; set; }
public System.String ProvisioningRepository_Branch { get; set; }
public System.String ProvisioningRepository_Name { get; set; }
public Amazon.Proton.RepositoryProvider ProvisioningRepository_Provider { get; set; }
public System.String Spec { get; set; }
public System.String TemplateMajorVersion { get; set; }
public System.String TemplateMinorVersion { get; set; }
public System.Func Select { get; set; } =
(response, cmdlet) => response.Environment;
}
}
}