awscodepipelineactions

package
v2.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 2, 2021 License: Apache-2.0 Imports: 18 Imported by: 2

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func BaseJenkinsProvider_IsConstruct 

func BaseJenkinsProvider_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Returns: true if `x` is an object created from a class which extends `Construct`. Deprecated: use `x instanceof Construct` instead

func JenkinsProvider_IsConstruct 

func JenkinsProvider_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Returns: true if `x` is an object created from a class which extends `Construct`. Deprecated: use `x instanceof Construct` instead

func NewAction_Override 

func NewAction_Override(a Action, actionProperties *awscodepipeline.ActionProperties)

func NewAlexaSkillDeployAction_Override 

func NewAlexaSkillDeployAction_Override(a AlexaSkillDeployAction, props *AlexaSkillDeployActionProps)

func NewBaseJenkinsProvider_Override 

func NewBaseJenkinsProvider_Override(b BaseJenkinsProvider, scope constructs.Construct, id *string, version *string)

func NewCloudFormationCreateReplaceChangeSetAction_Override 

func NewCloudFormationCreateReplaceChangeSetAction_Override(c CloudFormationCreateReplaceChangeSetAction, props *CloudFormationCreateReplaceChangeSetActionProps)

func NewCloudFormationCreateUpdateStackAction_Override 

func NewCloudFormationCreateUpdateStackAction_Override(c CloudFormationCreateUpdateStackAction, props *CloudFormationCreateUpdateStackActionProps)

func NewCloudFormationDeleteStackAction_Override 

func NewCloudFormationDeleteStackAction_Override(c CloudFormationDeleteStackAction, props *CloudFormationDeleteStackActionProps)

func NewCloudFormationExecuteChangeSetAction_Override 

func NewCloudFormationExecuteChangeSetAction_Override(c CloudFormationExecuteChangeSetAction, props *CloudFormationExecuteChangeSetActionProps)

func NewCodeBuildAction_Override 

func NewCodeBuildAction_Override(c CodeBuildAction, props *CodeBuildActionProps)

func NewCodeCommitSourceAction_Override 

func NewCodeCommitSourceAction_Override(c CodeCommitSourceAction, props *CodeCommitSourceActionProps)

func NewCodeDeployEcsDeployAction_Override 

func NewCodeDeployEcsDeployAction_Override(c CodeDeployEcsDeployAction, props *CodeDeployEcsDeployActionProps)

func NewCodeDeployServerDeployAction_Override 

func NewCodeDeployServerDeployAction_Override(c CodeDeployServerDeployAction, props *CodeDeployServerDeployActionProps)

func NewCodeStarConnectionsSourceAction_Override 

func NewCodeStarConnectionsSourceAction_Override(c CodeStarConnectionsSourceAction, props *CodeStarConnectionsSourceActionProps)

func NewEcrSourceAction_Override 

func NewEcrSourceAction_Override(e EcrSourceAction, props *EcrSourceActionProps)

func NewEcsDeployAction_Override 

func NewEcsDeployAction_Override(e EcsDeployAction, props *EcsDeployActionProps)

func NewGitHubSourceAction_Override 

func NewGitHubSourceAction_Override(g GitHubSourceAction, props *GitHubSourceActionProps)

func NewJenkinsAction_Override 

func NewJenkinsAction_Override(j JenkinsAction, props *JenkinsActionProps)

func NewJenkinsProvider_Override 

func NewJenkinsProvider_Override(j JenkinsProvider, scope constructs.Construct, id *string, props *JenkinsProviderProps)

func NewLambdaInvokeAction_Override 

func NewLambdaInvokeAction_Override(l LambdaInvokeAction, props *LambdaInvokeActionProps)

func NewManualApprovalAction_Override 

func NewManualApprovalAction_Override(m ManualApprovalAction, props *ManualApprovalActionProps)

func NewS3DeployAction_Override 

func NewS3DeployAction_Override(s S3DeployAction, props *S3DeployActionProps)

func NewS3SourceAction_Override 

func NewS3SourceAction_Override(s S3SourceAction, props *S3SourceActionProps)

func NewServiceCatalogDeployActionBeta1_Override 

func NewServiceCatalogDeployActionBeta1_Override(s ServiceCatalogDeployActionBeta1, props *ServiceCatalogDeployActionBeta1Props)

func NewStepFunctionInvokeAction_Override 

func NewStepFunctionInvokeAction_Override(s StepFunctionInvokeAction, props *StepFunctionsInvokeActionProps)

Types

type Action 

type Action interface {
	awscodepipeline.Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Low-level class for generic CodePipeline Actions.

If you're implementing your own IAction, prefer to use the Action class from the codepipeline module.

type AlexaSkillDeployAction 

type AlexaSkillDeployAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, _options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Deploys the skill to Alexa.

TODO: EXAMPLE

func NewAlexaSkillDeployAction 

func NewAlexaSkillDeployAction(props *AlexaSkillDeployActionProps) AlexaSkillDeployAction

type AlexaSkillDeployActionProps 

type AlexaSkillDeployActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The client id of the developer console token.
	ClientId *string `json:"clientId"`
	// The client secret of the developer console token.
	ClientSecret awscdk.SecretValue `json:"clientSecret"`
	// The source artifact containing the voice model and skill manifest.
	Input awscodepipeline.Artifact `json:"input"`
	// The refresh token of the developer console token.
	RefreshToken awscdk.SecretValue `json:"refreshToken"`
	// The Alexa skill id.
	SkillId *string `json:"skillId"`
	// An optional artifact containing overrides for the skill manifest.
	ParameterOverridesArtifact awscodepipeline.Artifact `json:"parameterOverridesArtifact"`
}

Construction properties of the {@link AlexaSkillDeployAction Alexa deploy Action}.

TODO: EXAMPLE

type BaseJenkinsProvider 

type BaseJenkinsProvider interface {
	constructs.Construct
	IJenkinsProvider
	Node() constructs.Node
	ProviderName() *string
	ServerUrl() *string
	Version() *string
	ToString() *string
}

type CacheControl 

type CacheControl interface {
	Value() *string
	SetValue(val *string)
}

Used for HTTP cache-control header, which influences downstream caches.

Use the provided static factory methods to construct instances of this class. Used in the {@link S3DeployActionProps.cacheControl} property.

TODO: EXAMPLE

See: https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9

func CacheControl_FromString 

func CacheControl_FromString(s *string) CacheControl

Allows you to create an arbitrary cache control directive, in case our support is missing a method for a particular directive.

func CacheControl_MaxAge 

func CacheControl_MaxAge(t awscdk.Duration) CacheControl

The 'max-age' cache control directive.

func CacheControl_MustRevalidate 

func CacheControl_MustRevalidate() CacheControl

The 'must-revalidate' cache control directive.

func CacheControl_NoCache 

func CacheControl_NoCache() CacheControl

The 'no-cache' cache control directive.

func CacheControl_NoTransform 

func CacheControl_NoTransform() CacheControl

The 'no-transform' cache control directive.

func CacheControl_ProxyRevalidate 

func CacheControl_ProxyRevalidate() CacheControl

The 'proxy-revalidate' cache control directive.

func CacheControl_SMaxAge 

func CacheControl_SMaxAge(t awscdk.Duration) CacheControl

The 's-max-age' cache control directive.

func CacheControl_SetPrivate 

func CacheControl_SetPrivate() CacheControl

The 'private' cache control directive.

func CacheControl_SetPublic 

func CacheControl_SetPublic() CacheControl

The 'public' cache control directive.

type CloudFormationCreateReplaceChangeSetAction 

type CloudFormationCreateReplaceChangeSetAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	DeploymentRole() awsiam.IRole
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	AddToDeploymentRolePolicy(statement awsiam.PolicyStatement) *bool
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

CodePipeline action to prepare a change set.

Creates the change set if it doesn't exist based on the stack name and template that you submit. If the change set exists, AWS CloudFormation deletes it, and then creates a new one.

TODO: EXAMPLE

func NewCloudFormationCreateReplaceChangeSetAction 

func NewCloudFormationCreateReplaceChangeSetAction(props *CloudFormationCreateReplaceChangeSetActionProps) CloudFormationCreateReplaceChangeSetAction

type CloudFormationCreateReplaceChangeSetActionProps 

type CloudFormationCreateReplaceChangeSetActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The AWS account this Action is supposed to operate in.
	//
	// **Note**: if you specify the `role` property,
	// this is ignored - the action will operate in the same region the passed role does.
	Account *string `json:"account"`
	// Whether to grant full permissions to CloudFormation while deploying this template.
	//
	// Setting this to `true` affects the defaults for `role` and `capabilities`, if you
	// don't specify any alternatives.
	//
	// The default role that will be created for you will have full (i.e., `*`)
	// permissions on all resources, and the deployment will have named IAM
	// capabilities (i.e., able to create all IAM resources).
	//
	// This is a shorthand that you can use if you fully trust the templates that
	// are deployed in this pipeline. If you want more fine-grained permissions,
	// use `addToRolePolicy` and `capabilities` to control what the CloudFormation
	// deployment is allowed to do.
	AdminPermissions *bool `json:"adminPermissions"`
	// Acknowledge certain changes made as part of deployment.
	//
	// For stacks that contain certain resources,
	// explicit acknowledgement is required that AWS CloudFormation might create or update those resources.
	// For example, you must specify `ANONYMOUS_IAM` or `NAMED_IAM` if your stack template contains AWS
	// Identity and Access Management (IAM) resources.
	// For more information, see the link below.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities
	//
	CfnCapabilities *[]awscdk.CfnCapabilities `json:"cfnCapabilities"`
	// Name of the change set to create or update.
	ChangeSetName *string `json:"changeSetName"`
	// IAM role to assume when deploying changes.
	//
	// If not specified, a fresh role is created. The role is created with zero
	// permissions unless `adminPermissions` is true, in which case the role will have
	// full permissions.
	DeploymentRole awsiam.IRole `json:"deploymentRole"`
	// The list of additional input Artifacts for this Action.
	//
	// This is especially useful when used in conjunction with the `parameterOverrides` property.
	// For example, if you have:
	//
	//    parameterOverrides: {
	//      'Param1': action1.outputArtifact.bucketName,
	//      'Param2': action2.outputArtifact.objectKey,
	//    }
	//
	// , if the output Artifacts of `action1` and `action2` were not used to
	// set either the `templateConfiguration` or the `templatePath` properties,
	// you need to make sure to include them in the `extraInputs` -
	// otherwise, you'll get an "unrecognized Artifact" error during your Pipeline's execution.
	ExtraInputs *[]awscodepipeline.Artifact `json:"extraInputs"`
	// The name of the output artifact to generate.
	//
	// Only applied if `outputFileName` is set as well.
	Output awscodepipeline.Artifact `json:"output"`
	// A name for the filename in the output artifact to store the AWS CloudFormation call's result.
	//
	// The file will contain the result of the call to AWS CloudFormation (for example
	// the call to UpdateStack or CreateChangeSet).
	//
	// AWS CodePipeline adds the file to the output artifact after performing
	// the specified action.
	OutputFileName *string `json:"outputFileName"`
	// Additional template parameters.
	//
	// Template parameters specified here take precedence over template parameters
	// found in the artifact specified by the `templateConfiguration` property.
	//
	// We recommend that you use the template configuration file to specify
	// most of your parameter values. Use parameter overrides to specify only
	// dynamic parameter values (values that are unknown until you run the
	// pipeline).
	//
	// All parameter names must be present in the stack template.
	//
	// Note: the entire object cannot be more than 1kB.
	ParameterOverrides *map[string]interface{} `json:"parameterOverrides"`
	// The AWS region the given Action resides in.
	//
	// Note that a cross-region Pipeline requires replication buckets to function correctly.
	// You can provide their names with the {@link PipelineProps#crossRegionReplicationBuckets} property.
	// If you don't, the CodePipeline Construct will create new Stacks in your CDK app containing those buckets,
	// that you will need to `cdk deploy` before deploying the main, Pipeline-containing Stack.
	Region *string `json:"region"`
	// The name of the stack to apply this action to.
	StackName *string `json:"stackName"`
	// Input artifact to use for template parameters values and stack policy.
	//
	// The template configuration file should contain a JSON object that should look like this:
	// `{ "Parameters": {...}, "Tags": {...}, "StackPolicy": {... }}`. For more information,
	// see [AWS CloudFormation Artifacts](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html).
	//
	// Note that if you include sensitive information, such as passwords, restrict access to this
	// file.
	TemplateConfiguration awscodepipeline.ArtifactPath `json:"templateConfiguration"`
	// Input artifact with the ChangeSet's CloudFormation template.
	TemplatePath awscodepipeline.ArtifactPath `json:"templatePath"`
}

Properties for the CloudFormationCreateReplaceChangeSetAction.

TODO: EXAMPLE

type CloudFormationCreateUpdateStackAction 

type CloudFormationCreateUpdateStackAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	DeploymentRole() awsiam.IRole
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	AddToDeploymentRolePolicy(statement awsiam.PolicyStatement) *bool
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

CodePipeline action to deploy a stack.

Creates the stack if the specified stack doesn't exist. If the stack exists, AWS CloudFormation updates the stack. Use this action to update existing stacks.

AWS CodePipeline won't replace the stack, and will fail deployment if the stack is in a failed state. Use `ReplaceOnFailure` for an action that will delete and recreate the stack to try and recover from failed states.

Use this action to automatically replace failed stacks without recovering or troubleshooting them. You would typically choose this mode for testing.

TODO: EXAMPLE

func NewCloudFormationCreateUpdateStackAction 

func NewCloudFormationCreateUpdateStackAction(props *CloudFormationCreateUpdateStackActionProps) CloudFormationCreateUpdateStackAction

type CloudFormationCreateUpdateStackActionProps 

type CloudFormationCreateUpdateStackActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// Whether to grant full permissions to CloudFormation while deploying this template.
	//
	// Setting this to `true` affects the defaults for `role` and `capabilities`, if you
	// don't specify any alternatives.
	//
	// The default role that will be created for you will have full (i.e., `*`)
	// permissions on all resources, and the deployment will have named IAM
	// capabilities (i.e., able to create all IAM resources).
	//
	// This is a shorthand that you can use if you fully trust the templates that
	// are deployed in this pipeline. If you want more fine-grained permissions,
	// use `addToRolePolicy` and `capabilities` to control what the CloudFormation
	// deployment is allowed to do.
	AdminPermissions *bool `json:"adminPermissions"`
	// The name of the stack to apply this action to.
	StackName *string `json:"stackName"`
	// Input artifact with the CloudFormation template to deploy.
	TemplatePath awscodepipeline.ArtifactPath `json:"templatePath"`
	// The AWS account this Action is supposed to operate in.
	//
	// **Note**: if you specify the `role` property,
	// this is ignored - the action will operate in the same region the passed role does.
	Account *string `json:"account"`
	// Acknowledge certain changes made as part of deployment.
	//
	// For stacks that contain certain resources,
	// explicit acknowledgement is required that AWS CloudFormation might create or update those resources.
	// For example, you must specify `ANONYMOUS_IAM` or `NAMED_IAM` if your stack template contains AWS
	// Identity and Access Management (IAM) resources.
	// For more information, see the link below.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities
	//
	CfnCapabilities *[]awscdk.CfnCapabilities `json:"cfnCapabilities"`
	// IAM role to assume when deploying changes.
	//
	// If not specified, a fresh role is created. The role is created with zero
	// permissions unless `adminPermissions` is true, in which case the role will have
	// full permissions.
	DeploymentRole awsiam.IRole `json:"deploymentRole"`
	// The list of additional input Artifacts for this Action.
	//
	// This is especially useful when used in conjunction with the `parameterOverrides` property.
	// For example, if you have:
	//
	//    parameterOverrides: {
	//      'Param1': action1.outputArtifact.bucketName,
	//      'Param2': action2.outputArtifact.objectKey,
	//    }
	//
	// , if the output Artifacts of `action1` and `action2` were not used to
	// set either the `templateConfiguration` or the `templatePath` properties,
	// you need to make sure to include them in the `extraInputs` -
	// otherwise, you'll get an "unrecognized Artifact" error during your Pipeline's execution.
	ExtraInputs *[]awscodepipeline.Artifact `json:"extraInputs"`
	// The name of the output artifact to generate.
	//
	// Only applied if `outputFileName` is set as well.
	Output awscodepipeline.Artifact `json:"output"`
	// A name for the filename in the output artifact to store the AWS CloudFormation call's result.
	//
	// The file will contain the result of the call to AWS CloudFormation (for example
	// the call to UpdateStack or CreateChangeSet).
	//
	// AWS CodePipeline adds the file to the output artifact after performing
	// the specified action.
	OutputFileName *string `json:"outputFileName"`
	// Additional template parameters.
	//
	// Template parameters specified here take precedence over template parameters
	// found in the artifact specified by the `templateConfiguration` property.
	//
	// We recommend that you use the template configuration file to specify
	// most of your parameter values. Use parameter overrides to specify only
	// dynamic parameter values (values that are unknown until you run the
	// pipeline).
	//
	// All parameter names must be present in the stack template.
	//
	// Note: the entire object cannot be more than 1kB.
	ParameterOverrides *map[string]interface{} `json:"parameterOverrides"`
	// The AWS region the given Action resides in.
	//
	// Note that a cross-region Pipeline requires replication buckets to function correctly.
	// You can provide their names with the {@link PipelineProps#crossRegionReplicationBuckets} property.
	// If you don't, the CodePipeline Construct will create new Stacks in your CDK app containing those buckets,
	// that you will need to `cdk deploy` before deploying the main, Pipeline-containing Stack.
	Region *string `json:"region"`
	// Replace the stack if it's in a failed state.
	//
	// If this is set to true and the stack is in a failed state (one of
	// ROLLBACK_COMPLETE, ROLLBACK_FAILED, CREATE_FAILED, DELETE_FAILED, or
	// UPDATE_ROLLBACK_FAILED), AWS CloudFormation deletes the stack and then
	// creates a new stack.
	//
	// If this is not set to true and the stack is in a failed state,
	// the deployment fails.
	ReplaceOnFailure *bool `json:"replaceOnFailure"`
	// Input artifact to use for template parameters values and stack policy.
	//
	// The template configuration file should contain a JSON object that should look like this:
	// `{ "Parameters": {...}, "Tags": {...}, "StackPolicy": {... }}`. For more information,
	// see [AWS CloudFormation Artifacts](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html).
	//
	// Note that if you include sensitive information, such as passwords, restrict access to this
	// file.
	TemplateConfiguration awscodepipeline.ArtifactPath `json:"templateConfiguration"`
}

Properties for the CloudFormationCreateUpdateStackAction.

TODO: EXAMPLE

type CloudFormationDeleteStackAction 

type CloudFormationDeleteStackAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	DeploymentRole() awsiam.IRole
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	AddToDeploymentRolePolicy(statement awsiam.PolicyStatement) *bool
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

CodePipeline action to delete a stack.

Deletes a stack. If you specify a stack that doesn't exist, the action completes successfully without deleting a stack.

TODO: EXAMPLE

func NewCloudFormationDeleteStackAction 

func NewCloudFormationDeleteStackAction(props *CloudFormationDeleteStackActionProps) CloudFormationDeleteStackAction

type CloudFormationDeleteStackActionProps 

type CloudFormationDeleteStackActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The AWS account this Action is supposed to operate in.
	//
	// **Note**: if you specify the `role` property,
	// this is ignored - the action will operate in the same region the passed role does.
	Account *string `json:"account"`
	// Whether to grant full permissions to CloudFormation while deploying this template.
	//
	// Setting this to `true` affects the defaults for `role` and `capabilities`, if you
	// don't specify any alternatives.
	//
	// The default role that will be created for you will have full (i.e., `*`)
	// permissions on all resources, and the deployment will have named IAM
	// capabilities (i.e., able to create all IAM resources).
	//
	// This is a shorthand that you can use if you fully trust the templates that
	// are deployed in this pipeline. If you want more fine-grained permissions,
	// use `addToRolePolicy` and `capabilities` to control what the CloudFormation
	// deployment is allowed to do.
	AdminPermissions *bool `json:"adminPermissions"`
	// Acknowledge certain changes made as part of deployment.
	//
	// For stacks that contain certain resources,
	// explicit acknowledgement is required that AWS CloudFormation might create or update those resources.
	// For example, you must specify `ANONYMOUS_IAM` or `NAMED_IAM` if your stack template contains AWS
	// Identity and Access Management (IAM) resources.
	// For more information, see the link below.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities
	//
	CfnCapabilities *[]awscdk.CfnCapabilities `json:"cfnCapabilities"`
	// IAM role to assume when deploying changes.
	//
	// If not specified, a fresh role is created. The role is created with zero
	// permissions unless `adminPermissions` is true, in which case the role will have
	// full permissions.
	DeploymentRole awsiam.IRole `json:"deploymentRole"`
	// The list of additional input Artifacts for this Action.
	//
	// This is especially useful when used in conjunction with the `parameterOverrides` property.
	// For example, if you have:
	//
	//    parameterOverrides: {
	//      'Param1': action1.outputArtifact.bucketName,
	//      'Param2': action2.outputArtifact.objectKey,
	//    }
	//
	// , if the output Artifacts of `action1` and `action2` were not used to
	// set either the `templateConfiguration` or the `templatePath` properties,
	// you need to make sure to include them in the `extraInputs` -
	// otherwise, you'll get an "unrecognized Artifact" error during your Pipeline's execution.
	ExtraInputs *[]awscodepipeline.Artifact `json:"extraInputs"`
	// The name of the output artifact to generate.
	//
	// Only applied if `outputFileName` is set as well.
	Output awscodepipeline.Artifact `json:"output"`
	// A name for the filename in the output artifact to store the AWS CloudFormation call's result.
	//
	// The file will contain the result of the call to AWS CloudFormation (for example
	// the call to UpdateStack or CreateChangeSet).
	//
	// AWS CodePipeline adds the file to the output artifact after performing
	// the specified action.
	OutputFileName *string `json:"outputFileName"`
	// Additional template parameters.
	//
	// Template parameters specified here take precedence over template parameters
	// found in the artifact specified by the `templateConfiguration` property.
	//
	// We recommend that you use the template configuration file to specify
	// most of your parameter values. Use parameter overrides to specify only
	// dynamic parameter values (values that are unknown until you run the
	// pipeline).
	//
	// All parameter names must be present in the stack template.
	//
	// Note: the entire object cannot be more than 1kB.
	ParameterOverrides *map[string]interface{} `json:"parameterOverrides"`
	// The AWS region the given Action resides in.
	//
	// Note that a cross-region Pipeline requires replication buckets to function correctly.
	// You can provide their names with the {@link PipelineProps#crossRegionReplicationBuckets} property.
	// If you don't, the CodePipeline Construct will create new Stacks in your CDK app containing those buckets,
	// that you will need to `cdk deploy` before deploying the main, Pipeline-containing Stack.
	Region *string `json:"region"`
	// The name of the stack to apply this action to.
	StackName *string `json:"stackName"`
	// Input artifact to use for template parameters values and stack policy.
	//
	// The template configuration file should contain a JSON object that should look like this:
	// `{ "Parameters": {...}, "Tags": {...}, "StackPolicy": {... }}`. For more information,
	// see [AWS CloudFormation Artifacts](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html).
	//
	// Note that if you include sensitive information, such as passwords, restrict access to this
	// file.
	TemplateConfiguration awscodepipeline.ArtifactPath `json:"templateConfiguration"`
}

Properties for the CloudFormationDeleteStackAction.

TODO: EXAMPLE

type CloudFormationExecuteChangeSetAction 

type CloudFormationExecuteChangeSetAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

CodePipeline action to execute a prepared change set.

TODO: EXAMPLE

func NewCloudFormationExecuteChangeSetAction 

func NewCloudFormationExecuteChangeSetAction(props *CloudFormationExecuteChangeSetActionProps) CloudFormationExecuteChangeSetAction

type CloudFormationExecuteChangeSetActionProps 

type CloudFormationExecuteChangeSetActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// Name of the change set to execute.
	ChangeSetName *string `json:"changeSetName"`
	// The name of the stack to apply this action to.
	StackName *string `json:"stackName"`
	// The AWS account this Action is supposed to operate in.
	//
	// **Note**: if you specify the `role` property,
	// this is ignored - the action will operate in the same region the passed role does.
	Account *string `json:"account"`
	// The name of the output artifact to generate.
	//
	// Only applied if `outputFileName` is set as well.
	Output awscodepipeline.Artifact `json:"output"`
	// A name for the filename in the output artifact to store the AWS CloudFormation call's result.
	//
	// The file will contain the result of the call to AWS CloudFormation (for example
	// the call to UpdateStack or CreateChangeSet).
	//
	// AWS CodePipeline adds the file to the output artifact after performing
	// the specified action.
	OutputFileName *string `json:"outputFileName"`
	// The AWS region the given Action resides in.
	//
	// Note that a cross-region Pipeline requires replication buckets to function correctly.
	// You can provide their names with the {@link PipelineProps#crossRegionReplicationBuckets} property.
	// If you don't, the CodePipeline Construct will create new Stacks in your CDK app containing those buckets,
	// that you will need to `cdk deploy` before deploying the main, Pipeline-containing Stack.
	Region *string `json:"region"`
}

Properties for the CloudFormationExecuteChangeSetAction.

TODO: EXAMPLE

type CodeBuildAction 

type CodeBuildAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	Variable(variableName *string) *string
	VariableExpression(variableName *string) *string
}

CodePipeline build action that uses AWS CodeBuild.

TODO: EXAMPLE

func NewCodeBuildAction 

func NewCodeBuildAction(props *CodeBuildActionProps) CodeBuildAction

type CodeBuildActionProps 

type CodeBuildActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The source to use as input for this action.
	Input awscodepipeline.Artifact `json:"input"`
	// The action's Project.
	Project awscodebuild.IProject `json:"project"`
	// Whether to check for the presence of any secrets in the environment variables of the default type, BuildEnvironmentVariableType.PLAINTEXT. Since using a secret for the value of that kind of variable would result in it being displayed in plain text in the AWS Console, the construct will throw an exception if it detects a secret was passed there. Pass this property as false if you want to skip this validation, and keep using a secret in a plain text environment variable.
	CheckSecretsInPlainTextEnvVariables *bool `json:"checkSecretsInPlainTextEnvVariables"`
	// Combine the build artifacts for a batch builds.
	//
	// Enabling this will combine the build artifacts into the same location for batch builds.
	// If `executeBatchBuild` is not set to `true`, this property is ignored.
	CombineBatchBuildArtifacts *bool `json:"combineBatchBuildArtifacts"`
	// The environment variables to pass to the CodeBuild project when this action executes.
	//
	// If a variable with the same name was set both on the project level, and here,
	// this value will take precedence.
	EnvironmentVariables *map[string]*awscodebuild.BuildEnvironmentVariable `json:"environmentVariables"`
	// Trigger a batch build.
	//
	// Enabling this will enable batch builds on the CodeBuild project.
	ExecuteBatchBuild *bool `json:"executeBatchBuild"`
	// The list of additional input Artifacts for this action.
	//
	// The directories the additional inputs will be available at are available
	// during the project's build in the CODEBUILD_SRC_DIR_<artifact-name> environment variables.
	// The project's build always starts in the directory with the primary input artifact checked out,
	// the one pointed to by the {@link input} property.
	// For more information,
	// see https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html .
	ExtraInputs *[]awscodepipeline.Artifact `json:"extraInputs"`
	// The list of output Artifacts for this action.
	//
	// **Note**: if you specify more than one output Artifact here,
	// you cannot use the primary 'artifacts' section of the buildspec;
	// you have to use the 'secondary-artifacts' section instead.
	// See https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html
	// for details.
	Outputs *[]awscodepipeline.Artifact `json:"outputs"`
	// The type of the action that determines its CodePipeline Category - Build, or Test.
	Type CodeBuildActionType `json:"type"`
}

Construction properties of the {@link CodeBuildAction CodeBuild build CodePipeline action}.

TODO: EXAMPLE

type CodeBuildActionType 

type CodeBuildActionType string

The type of the CodeBuild action that determines its CodePipeline Category - Build, or Test.

The default is Build.

TODO: EXAMPLE 

const (
	CodeBuildActionType_BUILD CodeBuildActionType = "BUILD"
	CodeBuildActionType_TEST  CodeBuildActionType = "TEST"
)

type CodeCommitSourceAction 

type CodeCommitSourceAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Variables() *CodeCommitSourceVariables
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

CodePipeline Source that is provided by an AWS CodeCommit repository.

If the CodeCommit repository is in a different account, you must use `CodeCommitTrigger.EVENTS` to trigger the pipeline.

(That is because the Pipeline structure normally only has a `RepositoryName` field, and that is not enough for the pipeline to locate the repository's source account. However, if the pipeline is triggered via an EventBridge event, the event itself has the full repository ARN in there, allowing the pipeline to locate the repository).

TODO: EXAMPLE

func NewCodeCommitSourceAction 

func NewCodeCommitSourceAction(props *CodeCommitSourceActionProps) CodeCommitSourceAction

type CodeCommitSourceActionProps 

type CodeCommitSourceActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role   awsiam.IRole             `json:"role"`
	Output awscodepipeline.Artifact `json:"output"`
	// The CodeCommit repository.
	Repository awscodecommit.IRepository `json:"repository"`
	Branch     *string                   `json:"branch"`
	// Whether the output should be the contents of the repository (which is the default), or a link that allows CodeBuild to clone the repository before building.
	//
	// **Note**: if this option is true,
	// then only CodeBuild actions can use the resulting {@link output}.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodeCommit.html
	//
	CodeBuildCloneOutput *bool `json:"codeBuildCloneOutput"`
	// Role to be used by on commit event rule.
	//
	// Used only when trigger value is CodeCommitTrigger.EVENTS.
	EventRole awsiam.IRole `json:"eventRole"`
	// How should CodePipeline detect source changes for this Action.
	Trigger CodeCommitTrigger `json:"trigger"`
}

Construction properties of the {@link CodeCommitSourceAction CodeCommit source CodePipeline Action}.

TODO: EXAMPLE

type CodeCommitSourceVariables 

type CodeCommitSourceVariables struct {
	// The date the currently last commit on the tracked branch was authored, in ISO-8601 format.
	AuthorDate *string `json:"authorDate"`
	// The name of the branch this action tracks.
	BranchName *string `json:"branchName"`
	// The SHA1 hash of the currently last commit on the tracked branch.
	CommitId *string `json:"commitId"`
	// The message of the currently last commit on the tracked branch.
	CommitMessage *string `json:"commitMessage"`
	// The date the currently last commit on the tracked branch was committed, in ISO-8601 format.
	CommitterDate *string `json:"committerDate"`
	// The name of the repository this action points to.
	RepositoryName *string `json:"repositoryName"`
}

The CodePipeline variables emitted by the CodeCommit source Action.

TODO: EXAMPLE

type CodeCommitTrigger 

type CodeCommitTrigger string

How should the CodeCommit Action detect changes.

This is the type of the {@link CodeCommitSourceAction.trigger} property. 

const (
	CodeCommitTrigger_EVENTS CodeCommitTrigger = "EVENTS"
	CodeCommitTrigger_NONE   CodeCommitTrigger = "NONE"
	CodeCommitTrigger_POLL   CodeCommitTrigger = "POLL"
)

type CodeDeployEcsContainerImageInput 

type CodeDeployEcsContainerImageInput struct {
	// The artifact that contains an `imageDetails.json` file with the image URI.
	//
	// The artifact's `imageDetails.json` file must be a JSON file containing an
	// `ImageURI` property.  For example:
	// `{ "ImageURI": "ACCOUNTID.dkr.ecr.us-west-2.amazonaws.com/dk-image-repo@sha256:example3" }`
	Input awscodepipeline.Artifact `json:"input"`
	// The placeholder string in the ECS task definition template file that will be replaced with the image URI.
	//
	// The placeholder string must be surrounded by angle brackets in the template file.
	// For example, if the task definition template file contains a placeholder like
	// `"image": "<PLACEHOLDER>"`, then the `taskDefinitionPlaceholder` value should
	// be `PLACEHOLDER`.
	TaskDefinitionPlaceholder *string `json:"taskDefinitionPlaceholder"`
}

Configuration for replacing a placeholder string in the ECS task definition template file with an image URI.

TODO: EXAMPLE

type CodeDeployEcsDeployAction 

type CodeDeployEcsDeployAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

TODO: EXAMPLE

func NewCodeDeployEcsDeployAction 

func NewCodeDeployEcsDeployAction(props *CodeDeployEcsDeployActionProps) CodeDeployEcsDeployAction

type CodeDeployEcsDeployActionProps 

type CodeDeployEcsDeployActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The name of the CodeDeploy AppSpec file.
	//
	// During deployment, a new task definition will be registered
	// with ECS, and the new task definition ID will be inserted into
	// the CodeDeploy AppSpec file.  The AppSpec file contents will be
	// provided to CodeDeploy for the deployment.
	//
	// Use this property if you want to use a different name for this file than the default 'appspec.yaml'.
	// If you use this property, you don't need to specify the `appSpecTemplateInput` property.
	AppSpecTemplateFile awscodepipeline.ArtifactPath `json:"appSpecTemplateFile"`
	// The artifact containing the CodeDeploy AppSpec file.
	//
	// During deployment, a new task definition will be registered
	// with ECS, and the new task definition ID will be inserted into
	// the CodeDeploy AppSpec file.  The AppSpec file contents will be
	// provided to CodeDeploy for the deployment.
	//
	// If you use this property, it's assumed the file is called 'appspec.yaml'.
	// If your AppSpec file uses a different filename, leave this property empty,
	// and use the `appSpecTemplateFile` property instead.
	AppSpecTemplateInput awscodepipeline.Artifact `json:"appSpecTemplateInput"`
	// Configuration for dynamically updated images in the task definition.
	//
	// Provide pairs of an image details input artifact and a placeholder string
	// that will be used to dynamically update the ECS task definition template
	// file prior to deployment. A maximum of 4 images can be given.
	ContainerImageInputs *[]*CodeDeployEcsContainerImageInput `json:"containerImageInputs"`
	// The CodeDeploy ECS Deployment Group to deploy to.
	DeploymentGroup awscodedeploy.IEcsDeploymentGroup `json:"deploymentGroup"`
	// The name of the ECS task definition template file.
	//
	// During deployment, the task definition template file contents
	// will be registered with ECS.
	//
	// Use this property if you want to use a different name for this file than the default 'taskdef.json'.
	// If you use this property, you don't need to specify the `taskDefinitionTemplateInput` property.
	TaskDefinitionTemplateFile awscodepipeline.ArtifactPath `json:"taskDefinitionTemplateFile"`
	// The artifact containing the ECS task definition template file.
	//
	// During deployment, the task definition template file contents
	// will be registered with ECS.
	//
	// If you use this property, it's assumed the file is called 'taskdef.json'.
	// If your task definition template uses a different filename, leave this property empty,
	// and use the `taskDefinitionTemplateFile` property instead.
	TaskDefinitionTemplateInput awscodepipeline.Artifact `json:"taskDefinitionTemplateInput"`
}

Construction properties of the {@link CodeDeployEcsDeployAction CodeDeploy ECS deploy CodePipeline Action}.

TODO: EXAMPLE

type CodeDeployServerDeployAction 

type CodeDeployServerDeployAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

TODO: EXAMPLE

func NewCodeDeployServerDeployAction 

func NewCodeDeployServerDeployAction(props *CodeDeployServerDeployActionProps) CodeDeployServerDeployAction

type CodeDeployServerDeployActionProps 

type CodeDeployServerDeployActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The CodeDeploy server Deployment Group to deploy to.
	DeploymentGroup awscodedeploy.IServerDeploymentGroup `json:"deploymentGroup"`
	// The source to use as input for deployment.
	Input awscodepipeline.Artifact `json:"input"`
}

Construction properties of the {@link CodeDeployServerDeployAction CodeDeploy server deploy CodePipeline Action}.

TODO: EXAMPLE

type CodeStarConnectionsSourceAction 

type CodeStarConnectionsSourceAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

A CodePipeline source action for the CodeStar Connections source, which allows connecting to GitHub and BitBucket.

TODO: EXAMPLE

func NewCodeStarConnectionsSourceAction 

func NewCodeStarConnectionsSourceAction(props *CodeStarConnectionsSourceActionProps) CodeStarConnectionsSourceAction

type CodeStarConnectionsSourceActionProps 

type CodeStarConnectionsSourceActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The ARN of the CodeStar Connection created in the AWS console that has permissions to access this GitHub or BitBucket repository.
	//
	// TODO: EXAMPLE
	//
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-create.html
	//
	ConnectionArn *string `json:"connectionArn"`
	// The output artifact that this action produces.
	//
	// Can be used as input for further pipeline actions.
	Output awscodepipeline.Artifact `json:"output"`
	// The owning user or organization of the repository.
	//
	// TODO: EXAMPLE
	//
	Owner *string `json:"owner"`
	// The name of the repository.
	//
	// TODO: EXAMPLE
	//
	Repo *string `json:"repo"`
	// The branch to build.
	Branch *string `json:"branch"`
	// Whether the output should be the contents of the repository (which is the default), or a link that allows CodeBuild to clone the repository before building.
	//
	// **Note**: if this option is true,
	// then only CodeBuild actions can use the resulting {@link output}.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html#action-reference-CodestarConnectionSource-config
	//
	CodeBuildCloneOutput *bool `json:"codeBuildCloneOutput"`
	// Controls automatically starting your pipeline when a new commit is made on the configured repository and branch.
	//
	// If unspecified,
	// the default value is true, and the field does not display by default.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html
	//
	TriggerOnPush *bool `json:"triggerOnPush"`
}

Construction properties for {@link CodeStarConnectionsSourceAction}.

TODO: EXAMPLE

type EcrSourceAction 

type EcrSourceAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Variables() *EcrSourceVariables
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

The ECR Repository source CodePipeline Action.

Will trigger the pipeline as soon as the target tag in the repository changes, but only if there is a CloudTrail Trail in the account that captures the ECR event.

TODO: EXAMPLE

func NewEcrSourceAction 

func NewEcrSourceAction(props *EcrSourceActionProps) EcrSourceAction

type EcrSourceActionProps 

type EcrSourceActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role   awsiam.IRole             `json:"role"`
	Output awscodepipeline.Artifact `json:"output"`
	// The repository that will be watched for changes.
	Repository awsecr.IRepository `json:"repository"`
	// The image tag that will be checked for changes.
	ImageTag *string `json:"imageTag"`
}

Construction properties of {@link EcrSourceAction}.

TODO: EXAMPLE

type EcrSourceVariables 

type EcrSourceVariables struct {
	// The digest of the current image, in the form '<digest type>:<digest value>'.
	ImageDigest *string `json:"imageDigest"`
	// The Docker tag of the current image.
	ImageTag *string `json:"imageTag"`
	// The full ECR Docker URI of the current image.
	ImageUri *string `json:"imageUri"`
	// The identifier of the registry.
	//
	// In ECR, this is usually the ID of the AWS account owning it.
	RegistryId *string `json:"registryId"`
	// The physical name of the repository that this action tracks.
	RepositoryName *string `json:"repositoryName"`
}

The CodePipeline variables emitted by the ECR source Action.

TODO: EXAMPLE

type EcsDeployAction 

type EcsDeployAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

CodePipeline Action to deploy an ECS Service.

TODO: EXAMPLE

func NewEcsDeployAction 

func NewEcsDeployAction(props *EcsDeployActionProps) EcsDeployAction

type EcsDeployActionProps 

type EcsDeployActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The ECS Service to deploy.
	Service awsecs.IBaseService `json:"service"`
	// Timeout for the ECS deployment in minutes.
	//
	// Value must be between 1-60.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-ECS.html
	//
	DeploymentTimeout awscdk.Duration `json:"deploymentTimeout"`
	// The name of the JSON image definitions file to use for deployments.
	//
	// The JSON file is a list of objects,
	// each with 2 keys: `name` is the name of the container in the Task Definition,
	// and `imageUri` is the Docker image URI you want to update your service with.
	// Use this property if you want to use a different name for this file than the default 'imagedefinitions.json'.
	// If you use this property, you don't need to specify the `input` property.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create.html#pipelines-create-image-definitions
	//
	ImageFile awscodepipeline.ArtifactPath `json:"imageFile"`
	// The input artifact that contains the JSON image definitions file to use for deployments.
	//
	// The JSON file is a list of objects,
	// each with 2 keys: `name` is the name of the container in the Task Definition,
	// and `imageUri` is the Docker image URI you want to update your service with.
	// If you use this property, it's assumed the file is called 'imagedefinitions.json'.
	// If your build uses a different file, leave this property empty,
	// and use the `imageFile` property instead.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create.html#pipelines-create-image-definitions
	//
	Input awscodepipeline.Artifact `json:"input"`
}

Construction properties of {@link EcsDeployAction}.

TODO: EXAMPLE

type GitHubSourceAction 

type GitHubSourceAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Variables() *GitHubSourceVariables
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, stage awscodepipeline.IStage, _options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Source that is provided by a GitHub repository.

TODO: EXAMPLE

func NewGitHubSourceAction 

func NewGitHubSourceAction(props *GitHubSourceActionProps) GitHubSourceAction

type GitHubSourceActionProps 

type GitHubSourceActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// A GitHub OAuth token to use for authentication.
	//
	// It is recommended to use a Secrets Manager `Secret` to obtain the token:
	//
	//    const oauth = cdk.SecretValue.secretsManager('my-github-token');
	//    new GitHubSource(this, 'GitHubAction', { oauthToken: oauth, ... });
	//
	// The GitHub Personal Access Token should have these scopes:
	//
	// * **repo** - to read the repository
	// * **admin:repo_hook** - if you plan to use webhooks (true by default)
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/appendix-github-oauth.html#GitHub-create-personal-token-CLI
	//
	OauthToken awscdk.SecretValue       `json:"oauthToken"`
	Output     awscodepipeline.Artifact `json:"output"`
	// The GitHub account/user that owns the repo.
	Owner *string `json:"owner"`
	// The name of the repo, without the username.
	Repo *string `json:"repo"`
	// The branch to use.
	Branch *string `json:"branch"`
	// How AWS CodePipeline should be triggered.
	//
	// With the default value "WEBHOOK", a webhook is created in GitHub that triggers the action
	// With "POLL", CodePipeline periodically checks the source for changes
	// With "None", the action is not triggered through changes in the source
	//
	// To use `WEBHOOK`, your GitHub Personal Access Token should have
	// **admin:repo_hook** scope (in addition to the regular **repo** scope).
	Trigger GitHubTrigger `json:"trigger"`
}

Construction properties of the {@link GitHubSourceAction GitHub source action}.

TODO: EXAMPLE

type GitHubSourceVariables 

type GitHubSourceVariables struct {
	// The date the currently last commit on the tracked branch was authored, in ISO-8601 format.
	AuthorDate *string `json:"authorDate"`
	// The name of the branch this action tracks.
	BranchName *string `json:"branchName"`
	// The SHA1 hash of the currently last commit on the tracked branch.
	CommitId *string `json:"commitId"`
	// The message of the currently last commit on the tracked branch.
	CommitMessage *string `json:"commitMessage"`
	// The date the currently last commit on the tracked branch was committed, in ISO-8601 format.
	CommitterDate *string `json:"committerDate"`
	// The GitHub API URL of the currently last commit on the tracked branch.
	CommitUrl *string `json:"commitUrl"`
	// The name of the repository this action points to.
	RepositoryName *string `json:"repositoryName"`
}

The CodePipeline variables emitted by GitHub source Action.

TODO: EXAMPLE

type GitHubTrigger 

type GitHubTrigger string

If and how the GitHub source action should be triggered. 

const (
	GitHubTrigger_NONE    GitHubTrigger = "NONE"
	GitHubTrigger_POLL    GitHubTrigger = "POLL"
	GitHubTrigger_WEBHOOK GitHubTrigger = "WEBHOOK"
)

type IJenkinsProvider 

type IJenkinsProvider interface {
	constructs.IConstruct
	ProviderName() *string
	ServerUrl() *string
	Version() *string
}

A Jenkins provider.

If you want to create a new Jenkins provider managed alongside your CDK code, instantiate the {@link JenkinsProvider} class directly.

If you want to reference an already registered provider, use the {@link JenkinsProvider#fromJenkinsProviderAttributes} method.

func JenkinsProvider_FromJenkinsProviderAttributes 

func JenkinsProvider_FromJenkinsProviderAttributes(scope constructs.Construct, id *string, attrs *JenkinsProviderAttributes) IJenkinsProvider

Import a Jenkins provider registered either outside the CDK, or in a different CDK Stack.

Returns: a new Construct representing a reference to an existing Jenkins provider

type JenkinsAction 

type JenkinsAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, _options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Jenkins build CodePipeline Action.

TODO: EXAMPLE

See: https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-four-stage-pipeline.html

func NewJenkinsAction 

func NewJenkinsAction(props *JenkinsActionProps) JenkinsAction

type JenkinsActionProps 

type JenkinsActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Jenkins Provider for this Action.
	JenkinsProvider IJenkinsProvider `json:"jenkinsProvider"`
	// The name of the project (sometimes also called job, or task) on your Jenkins installation that will be invoked by this Action.
	//
	// TODO: EXAMPLE
	//
	ProjectName *string `json:"projectName"`
	// The type of the Action - Build, or Test.
	Type JenkinsActionType `json:"type"`
	// The source to use as input for this build.
	Inputs  *[]awscodepipeline.Artifact `json:"inputs"`
	Outputs *[]awscodepipeline.Artifact `json:"outputs"`
}

Construction properties of {@link JenkinsAction}.

TODO: EXAMPLE

type JenkinsActionType 

type JenkinsActionType string

The type of the Jenkins Action that determines its CodePipeline Category - Build, or Test.

Note that a Jenkins provider, even if it has the same name, must be separately registered for each type.

TODO: EXAMPLE 

const (
	JenkinsActionType_BUILD JenkinsActionType = "BUILD"
	JenkinsActionType_TEST  JenkinsActionType = "TEST"
)

type JenkinsProvider 

type JenkinsProvider interface {
	BaseJenkinsProvider
	Node() constructs.Node
	ProviderName() *string
	ServerUrl() *string
	Version() *string
	ToString() *string
}

A class representing Jenkins providers.

TODO: EXAMPLE

See: #import

func NewJenkinsProvider 

func NewJenkinsProvider(scope constructs.Construct, id *string, props *JenkinsProviderProps) JenkinsProvider

type JenkinsProviderAttributes 

type JenkinsProviderAttributes struct {
	// The name of the Jenkins provider that you set in the AWS CodePipeline plugin configuration of your Jenkins project.
	//
	// TODO: EXAMPLE
	//
	ProviderName *string `json:"providerName"`
	// The base URL of your Jenkins server.
	//
	// TODO: EXAMPLE
	//
	ServerUrl *string `json:"serverUrl"`
	// The version of your provider.
	Version *string `json:"version"`
}

Properties for importing an existing Jenkins provider.

TODO: EXAMPLE

type JenkinsProviderProps 

type JenkinsProviderProps struct {
	// The name of the Jenkins provider that you set in the AWS CodePipeline plugin configuration of your Jenkins project.
	//
	// TODO: EXAMPLE
	//
	ProviderName *string `json:"providerName"`
	// The base URL of your Jenkins server.
	//
	// TODO: EXAMPLE
	//
	ServerUrl *string `json:"serverUrl"`
	// Whether to immediately register a Jenkins Provider for the build category.
	//
	// The Provider will always be registered if you create a {@link JenkinsAction}.
	ForBuild *bool `json:"forBuild"`
	// Whether to immediately register a Jenkins Provider for the test category.
	//
	// The Provider will always be registered if you create a {@link JenkinsTestAction}.
	ForTest *bool `json:"forTest"`
	// The version of your provider.
	Version *string `json:"version"`
}

TODO: EXAMPLE

type LambdaInvokeAction 

type LambdaInvokeAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	Variable(variableName *string) *string
	VariableExpression(variableName *string) *string
}

CodePipeline invoke Action that is provided by an AWS Lambda function.

TODO: EXAMPLE

See: https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-invoke-lambda-function.html

func NewLambdaInvokeAction 

func NewLambdaInvokeAction(props *LambdaInvokeActionProps) LambdaInvokeAction

type LambdaInvokeActionProps 

type LambdaInvokeActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The lambda function to invoke.
	Lambda awslambda.IFunction `json:"lambda"`
	// The optional input Artifacts of the Action.
	//
	// A Lambda Action can have up to 5 inputs.
	// The inputs will appear in the event passed to the Lambda,
	// under the `'CodePipeline.job'.data.inputArtifacts` path.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-invoke-lambda-function.html#actions-invoke-lambda-function-json-event-example
	//
	Inputs *[]awscodepipeline.Artifact `json:"inputs"`
	// The optional names of the output Artifacts of the Action.
	//
	// A Lambda Action can have up to 5 outputs.
	// The outputs will appear in the event passed to the Lambda,
	// under the `'CodePipeline.job'.data.outputArtifacts` path.
	// It is the responsibility of the Lambda to upload ZIP files with the Artifact contents to the provided locations.
	Outputs *[]awscodepipeline.Artifact `json:"outputs"`
	// A set of key-value pairs that will be accessible to the invoked Lambda inside the event that the Pipeline will call it with.
	//
	// Only one of `userParameters` or `userParametersString` can be specified.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-invoke-lambda-function.html#actions-invoke-lambda-function-json-event-example
	//
	UserParameters *map[string]interface{} `json:"userParameters"`
	// The string representation of the user parameters that will be accessible to the invoked Lambda inside the event that the Pipeline will call it with.
	//
	// Only one of `userParametersString` or `userParameters` can be specified.
	UserParametersString *string `json:"userParametersString"`
}

Construction properties of the {@link LambdaInvokeAction Lambda invoke CodePipeline Action}.

TODO: EXAMPLE

type ManualApprovalAction 

type ManualApprovalAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	NotificationTopic() awssns.ITopic
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	GrantManualApproval(grantable awsiam.IGrantable)
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Manual approval action.

TODO: EXAMPLE

func NewManualApprovalAction 

func NewManualApprovalAction(props *ManualApprovalActionProps) ManualApprovalAction

type ManualApprovalActionProps 

type ManualApprovalActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// Any additional information that you want to include in the notification email message.
	AdditionalInformation *string `json:"additionalInformation"`
	// URL you want to provide to the reviewer as part of the approval request.
	ExternalEntityLink *string `json:"externalEntityLink"`
	// Optional SNS topic to send notifications to when an approval is pending.
	NotificationTopic awssns.ITopic `json:"notificationTopic"`
	// A list of email addresses to subscribe to notifications when this Action is pending approval.
	//
	// If this has been provided, but not `notificationTopic`,
	// a new Topic will be created.
	NotifyEmails *[]*string `json:"notifyEmails"`
}

Construction properties of the {@link ManualApprovalAction}.

TODO: EXAMPLE

type S3DeployAction 

type S3DeployAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Deploys the sourceArtifact to Amazon S3.

TODO: EXAMPLE

func NewS3DeployAction 

func NewS3DeployAction(props *S3DeployActionProps) S3DeployAction

type S3DeployActionProps 

type S3DeployActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The Amazon S3 bucket that is the deploy target.
	Bucket awss3.IBucket `json:"bucket"`
	// The input Artifact to deploy to Amazon S3.
	Input awscodepipeline.Artifact `json:"input"`
	// The specified canned ACL to objects deployed to Amazon S3.
	//
	// This overwrites any existing ACL that was applied to the object.
	AccessControl awss3.BucketAccessControl `json:"accessControl"`
	// The caching behavior for requests/responses for objects in the bucket.
	//
	// The final cache control property will be the result of joining all of the provided array elements with a comma
	// (plus a space after the comma).
	CacheControl *[]CacheControl `json:"cacheControl"`
	// Should the deploy action extract the artifact before deploying to Amazon S3.
	Extract *bool `json:"extract"`
	// The key of the target object.
	//
	// This is required if extract is false.
	ObjectKey *string `json:"objectKey"`
}

Construction properties of the {@link S3DeployAction S3 deploy Action}.

TODO: EXAMPLE

type S3SourceAction 

type S3SourceAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Variables() *S3SourceVariables
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Source that is provided by a specific Amazon S3 object.

Will trigger the pipeline as soon as the S3 object changes, but only if there is a CloudTrail Trail in the account that captures the S3 event.

TODO: EXAMPLE

func NewS3SourceAction 

func NewS3SourceAction(props *S3SourceActionProps) S3SourceAction

type S3SourceActionProps 

type S3SourceActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The Amazon S3 bucket that stores the source code.
	//
	// If you import an encrypted bucket in your stack, please specify
	// the encryption key at import time by using `Bucket.fromBucketAttributes()` method.
	Bucket awss3.IBucket `json:"bucket"`
	// The key within the S3 bucket that stores the source code.
	//
	// TODO: EXAMPLE
	//
	BucketKey *string                  `json:"bucketKey"`
	Output    awscodepipeline.Artifact `json:"output"`
	// How should CodePipeline detect source changes for this Action.
	//
	// Note that if this is S3Trigger.EVENTS, you need to make sure to include the source Bucket in a CloudTrail Trail,
	// as otherwise the CloudWatch Events will not be emitted.
	// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/log-s3-data-events.html
	//
	Trigger S3Trigger `json:"trigger"`
}

Construction properties of the {@link S3SourceAction S3 source Action}.

TODO: EXAMPLE

type S3SourceVariables 

type S3SourceVariables struct {
	// The e-tag of the S3 version of the object that triggered the build.
	ETag *string `json:"eTag"`
	// The identifier of the S3 version of the object that triggered the build.
	VersionId *string `json:"versionId"`
}

The CodePipeline variables emitted by the S3 source Action.

TODO: EXAMPLE

type S3Trigger 

type S3Trigger string

How should the S3 Action detect changes.

This is the type of the {@link S3SourceAction.trigger} property.

TODO: EXAMPLE 

const (
	S3Trigger_EVENTS S3Trigger = "EVENTS"
	S3Trigger_NONE   S3Trigger = "NONE"
	S3Trigger_POLL   S3Trigger = "POLL"
)

type ServiceCatalogDeployActionBeta1 

type ServiceCatalogDeployActionBeta1 interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

CodePipeline action to connect to an existing ServiceCatalog product.

**Note**: this class is still experimental, and may have breaking changes in the future!

TODO: EXAMPLE

func NewServiceCatalogDeployActionBeta1 

func NewServiceCatalogDeployActionBeta1(props *ServiceCatalogDeployActionBeta1Props) ServiceCatalogDeployActionBeta1

type ServiceCatalogDeployActionBeta1Props 

type ServiceCatalogDeployActionBeta1Props struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The identifier of the product in the Service Catalog.
	//
	// This product must already exist.
	ProductId *string `json:"productId"`
	// The name of the version of the Service Catalog product to be deployed.
	ProductVersionName *string `json:"productVersionName"`
	// The path to the cloudformation artifact.
	TemplatePath awscodepipeline.ArtifactPath `json:"templatePath"`
	// The optional description of this version of the Service Catalog product.
	ProductVersionDescription *string `json:"productVersionDescription"`
}

Construction properties of the {@link ServiceCatalogDeployActionBeta1 ServiceCatalog deploy CodePipeline Action}.

TODO: EXAMPLE

type StateMachineInput 

type StateMachineInput interface {
	Input() interface{}
	InputArtifact() awscodepipeline.Artifact
	InputType() *string
}

Represents the input for the StateMachine.

TODO: EXAMPLE

func StateMachineInput_FilePath 

func StateMachineInput_FilePath(inputFile awscodepipeline.ArtifactPath) StateMachineInput

When the input type is FilePath, input artifact and filepath must be specified.

func StateMachineInput_Literal 

func StateMachineInput_Literal(object *map[string]interface{}) StateMachineInput

When the input type is Literal, input value is passed directly to the state machine input.

type StepFunctionInvokeAction 

type StepFunctionInvokeAction interface {
	Action
	ActionProperties() *awscodepipeline.ActionProperties
	ProvidedActionProperties() *awscodepipeline.ActionProperties
	Bind(scope constructs.Construct, stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	Bound(_scope constructs.Construct, _stage awscodepipeline.IStage, options *awscodepipeline.ActionBindOptions) *awscodepipeline.ActionConfig
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

StepFunctionInvokeAction that is provided by an AWS CodePipeline.

TODO: EXAMPLE

func NewStepFunctionInvokeAction 

func NewStepFunctionInvokeAction(props *StepFunctionsInvokeActionProps) StepFunctionInvokeAction

type StepFunctionsInvokeActionProps 

type StepFunctionsInvokeActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `json:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	RunOrder *float64 `json:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	VariablesNamespace *string `json:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your {@link IAction.bind}
	// method in the {@link ActionBindOptions.role} property.
	Role awsiam.IRole `json:"role"`
	// The state machine to invoke.
	StateMachine awsstepfunctions.IStateMachine `json:"stateMachine"`
	// Prefix (optional).
	//
	// By default, the action execution ID is used as the state machine execution name.
	// If a prefix is provided, it is prepended to the action execution ID with a hyphen and
	// together used as the state machine execution name.
	ExecutionNamePrefix *string `json:"executionNamePrefix"`
	// The optional output Artifact of the Action.
	Output awscodepipeline.Artifact `json:"output"`
	// Represents the input to the StateMachine.
	//
	// This includes input artifact, input type and the statemachine input.
	StateMachineInput StateMachineInput `json:"stateMachineInput"`
}

Construction properties of the {@link StepFunctionsInvokeAction StepFunction Invoke Action}.

TODO: EXAMPLE

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.