aws-cdk-lib 2.141.0__py3-none-any.whl → 2.142.0__py3-none-any.whl

aws_cdk/aws_codepipeline/__init__.py

@@ -576,12 +576,17 @@ rule = pipeline.notify_on_execution_state_change("NotifyOnExecutionStateChange",
 
 ## Trigger
 
-To trigger a pipeline with Git tags, specify the `triggers` property. When a Git tag is pushed,
-your pipeline starts. You can filter with glob patterns. The `tagsExcludes` takes priority over
-the `tagsIncludes`.
-
+To trigger a pipeline with Git tags or branches, specify the `triggers` property.
 The triggers can only be used with pipeline type V2.
 
+### Push filter
+
+Pipelines can be started based on push events. You can specify the `pushFilter` property to
+filter the push events. The `pushFilter` can specify Git tags.
+
+In the case of Git tags, your pipeline starts when a Git tag is pushed.
+You can filter with glob patterns. The `tagsExcludes` takes priority over the `tagsIncludes`.
+
 ```python
 # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
 # build_action: codepipeline_actions.CodeBuildAction
@@ -610,7 +615,110 @@ codepipeline.Pipeline(self, "Pipeline",
 )
 ```
 
-Or append a trigger to an existing pipeline:
+### Pull request filter
+
+Pipelines can be started based on pull request events. You can specify the `pullRequestFilter` property to
+filter the pull request events. The `pullRequestFilter` can specify branches, file paths, and event types.
+
+In the case of branches, your pipeline starts when a pull request event occurs on the specified branches.
+You can filter with glob patterns. The `branchesExcludes` takes priority over the `branchesIncludes`.
+
+```python
+# source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+# build_action: codepipeline_actions.CodeBuildAction
+
+
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2,
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        stage_name="Build",
+        actions=[build_action]
+    )
+    ],
+    triggers=[codepipeline.TriggerProps(
+        provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+        git_configuration=codepipeline.GitConfiguration(
+            source_action=source_action,
+            pull_request_filter=[codepipeline.GitPullRequestFilter(
+                branches_excludes=["exclude1", "exclude2"],
+                branches_includes=["include*"]
+            )]
+        )
+    )]
+)
+```
+
+File paths can also be specified along with the branches to start the pipeline.
+You can filter with glob patterns. The `filePathsExcludes` takes priority over the `filePathsIncludes`.
+
+```python
+# source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+# build_action: codepipeline_actions.CodeBuildAction
+
+
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2,
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        stage_name="Build",
+        actions=[build_action]
+    )
+    ],
+    triggers=[codepipeline.TriggerProps(
+        provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+        git_configuration=codepipeline.GitConfiguration(
+            source_action=source_action,
+            pull_request_filter=[codepipeline.GitPullRequestFilter(
+                branches_excludes=["exclude1", "exclude2"],
+                branches_includes=["include1", "include2"],
+                file_paths_excludes=["/path/to/exclude1", "/path/to/exclude2"],
+                file_paths_includes=["/path/to/include1", "/path/to/include1"]
+            )]
+        )
+    )]
+)
+```
+
+To filter types of pull request events for triggers, you can specify the `events` property.
+
+```python
+# source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+# build_action: codepipeline_actions.CodeBuildAction
+
+
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2,
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        stage_name="Build",
+        actions=[build_action]
+    )
+    ],
+    triggers=[codepipeline.TriggerProps(
+        provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+        git_configuration=codepipeline.GitConfiguration(
+            source_action=source_action,
+            pull_request_filter=[codepipeline.GitPullRequestFilter(
+                branches_excludes=["exclude1", "exclude2"],
+                branches_includes=["include1", "include2"],
+                events=[codepipeline.GitPullRequestEvent.OPEN, codepipeline.GitPullRequestEvent.CLOSED
+                ]
+            )]
+        )
+    )]
+)
+```
+
+### Append a trigger to an existing pipeline
+
+You can append a trigger to an existing pipeline:
 
 ```python
 # pipeline: codepipeline.Pipeline
@@ -6253,18 +6361,24 @@ class ExecutionMode(enum.Enum):
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_codepipeline.GitConfiguration",
     jsii_struct_bases=[],
-    name_mapping={"source_action": "sourceAction", "push_filter": "pushFilter"},
+    name_mapping={
+        "source_action": "sourceAction",
+        "pull_request_filter": "pullRequestFilter",
+        "push_filter": "pushFilter",
+    },
 )
 class GitConfiguration:
     def __init__(
         self,
         *,
         source_action: "IAction",
+        pull_request_filter: typing.Optional[typing.Sequence[typing.Union["GitPullRequestFilter", typing.Dict[builtins.str, typing.Any]]]] = None,
         push_filter: typing.Optional[typing.Sequence[typing.Union["GitPushFilter", typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''Git configuration for trigger.
 
         :param source_action: The pipeline source action where the trigger configuration, such as Git tags. The trigger configuration will start the pipeline upon the specified change only. You can only specify one trigger configuration per source action. Since the provider for ``sourceAction`` must be ``CodeStarSourceConnection``, you can use ``CodeStarConnectionsSourceAction`` construct in ``aws-codepipeline-actions`` module.
+        :param pull_request_filter: The field where the repository event that will start the pipeline is specified as pull requests. The length must be less than or equal to 3. Default: - no filter.
         :param push_filter: The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. Git tags is the only supported event type. The length must be less than or equal to 3. Default: - no filter.
 
         :exampleMetadata: infused
@@ -6300,10 +6414,13 @@ class GitConfiguration:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__9bf0379bb3fa72f7dc00a45de6a383d19d18294c73d73dabcbdb7240e76832bf)
             check_type(argname="argument source_action", value=source_action, expected_type=type_hints["source_action"])
+            check_type(argname="argument pull_request_filter", value=pull_request_filter, expected_type=type_hints["pull_request_filter"])
             check_type(argname="argument push_filter", value=push_filter, expected_type=type_hints["push_filter"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "source_action": source_action,
         }
+        if pull_request_filter is not None:
+            self._values["pull_request_filter"] = pull_request_filter
         if push_filter is not None:
             self._values["push_filter"] = push_filter
 
@@ -6321,6 +6438,19 @@ class GitConfiguration:
         assert result is not None, "Required property 'source_action' is missing"
         return typing.cast("IAction", result)
 
+    @builtins.property
+    def pull_request_filter(
+        self,
+    ) -> typing.Optional[typing.List["GitPullRequestFilter"]]:
+        '''The field where the repository event that will start the pipeline is specified as pull requests.
+
+        The length must be less than or equal to 3.
+
+        :default: - no filter.
+        '''
+        result = self._values.get("pull_request_filter")
+        return typing.cast(typing.Optional[typing.List["GitPullRequestFilter"]], result)
+
     @builtins.property
     def push_filter(self) -> typing.Optional[typing.List["GitPushFilter"]]:
         '''The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details.
@@ -6346,6 +6476,192 @@ class GitConfiguration:
         )
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_codepipeline.GitPullRequestEvent")
+class GitPullRequestEvent(enum.Enum):
+    '''Event for trigger with pull request filter.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+        # build_action: codepipeline_actions.CodeBuildAction
+        
+        
+        codepipeline.Pipeline(self, "Pipeline",
+            pipeline_type=codepipeline.PipelineType.V2,
+            stages=[codepipeline.StageProps(
+                stage_name="Source",
+                actions=[source_action]
+            ), codepipeline.StageProps(
+                stage_name="Build",
+                actions=[build_action]
+            )
+            ],
+            triggers=[codepipeline.TriggerProps(
+                provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+                git_configuration=codepipeline.GitConfiguration(
+                    source_action=source_action,
+                    pull_request_filter=[codepipeline.GitPullRequestFilter(
+                        branches_excludes=["exclude1", "exclude2"],
+                        branches_includes=["include1", "include2"],
+                        events=[codepipeline.GitPullRequestEvent.OPEN, codepipeline.GitPullRequestEvent.CLOSED
+                        ]
+                    )]
+                )
+            )]
+        )
+    '''
+
+    OPEN = "OPEN"
+    '''OPEN.'''
+    UPDATED = "UPDATED"
+    '''UPDATED.'''
+    CLOSED = "CLOSED"
+    '''CLOSED.'''
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.GitPullRequestFilter",
+    jsii_struct_bases=[],
+    name_mapping={
+        "branches_excludes": "branchesExcludes",
+        "branches_includes": "branchesIncludes",
+        "events": "events",
+        "file_paths_excludes": "filePathsExcludes",
+        "file_paths_includes": "filePathsIncludes",
+    },
+)
+class GitPullRequestFilter:
+    def __init__(
+        self,
+        *,
+        branches_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        branches_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        events: typing.Optional[typing.Sequence[GitPullRequestEvent]] = None,
+        file_paths_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        file_paths_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''Git pull request filter for trigger.
+
+        :param branches_excludes: The list of patterns of Git branches that, when pull request events occurs, are to be excluded from starting the pipeline. You can filter with glob patterns. The ``branchesExcludes`` takes priority over the ``branchesIncludes``. Maximum length of this array is 8. Default: - no branches.
+        :param branches_includes: The list of patterns of Git branches that, when pull request events occurs, are to be included as criteria that starts the pipeline. You can filter with glob patterns. The ``branchesExcludes`` takes priority over the ``branchesIncludes``. Maximum length of this array is 8. Default: - no branches.
+        :param events: The field that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration. Default: - all events.
+        :param file_paths_excludes: The list of patterns of Git repository file paths that, when pull request events occurs, are to be excluded from starting the pipeline. You can filter with glob patterns. The ``filePathsExcludes`` takes priority over the ``filePathsIncludes``. Maximum length of this array is 8. Default: - no filePaths.
+        :param file_paths_includes: The list of patterns of Git repository file paths that, when pull request events occurs, are to be included as criteria that starts the pipeline. You can filter with glob patterns. The ``filePathsExcludes`` takes priority over the ``filePathsIncludes``. Maximum length of this array is 8. Default: - no filePaths.
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_codepipeline as codepipeline
+            
+            git_pull_request_filter = codepipeline.GitPullRequestFilter(
+                branches_excludes=["branchesExcludes"],
+                branches_includes=["branchesIncludes"],
+                events=[codepipeline.GitPullRequestEvent.OPEN],
+                file_paths_excludes=["filePathsExcludes"],
+                file_paths_includes=["filePathsIncludes"]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__cd84a4c10c68eec597c7c17a163a758ee28d398b585c996c44eba7fd956ee279)
+            check_type(argname="argument branches_excludes", value=branches_excludes, expected_type=type_hints["branches_excludes"])
+            check_type(argname="argument branches_includes", value=branches_includes, expected_type=type_hints["branches_includes"])
+            check_type(argname="argument events", value=events, expected_type=type_hints["events"])
+            check_type(argname="argument file_paths_excludes", value=file_paths_excludes, expected_type=type_hints["file_paths_excludes"])
+            check_type(argname="argument file_paths_includes", value=file_paths_includes, expected_type=type_hints["file_paths_includes"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if branches_excludes is not None:
+            self._values["branches_excludes"] = branches_excludes
+        if branches_includes is not None:
+            self._values["branches_includes"] = branches_includes
+        if events is not None:
+            self._values["events"] = events
+        if file_paths_excludes is not None:
+            self._values["file_paths_excludes"] = file_paths_excludes
+        if file_paths_includes is not None:
+            self._values["file_paths_includes"] = file_paths_includes
+
+    @builtins.property
+    def branches_excludes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git branches that, when pull request events occurs, are to be excluded from starting the pipeline.
+
+        You can filter with glob patterns. The ``branchesExcludes`` takes priority
+        over the ``branchesIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no branches.
+        '''
+        result = self._values.get("branches_excludes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def branches_includes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git branches that, when pull request events occurs, are to be included as criteria that starts the pipeline.
+
+        You can filter with glob patterns. The ``branchesExcludes`` takes priority
+        over the ``branchesIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no branches.
+        '''
+        result = self._values.get("branches_includes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def events(self) -> typing.Optional[typing.List[GitPullRequestEvent]]:
+        '''The field that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration.
+
+        :default: - all events.
+        '''
+        result = self._values.get("events")
+        return typing.cast(typing.Optional[typing.List[GitPullRequestEvent]], result)
+
+    @builtins.property
+    def file_paths_excludes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git repository file paths that, when pull request events occurs, are to be excluded from starting the pipeline.
+
+        You can filter with glob patterns. The ``filePathsExcludes`` takes priority
+        over the ``filePathsIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no filePaths.
+        '''
+        result = self._values.get("file_paths_excludes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def file_paths_includes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git repository file paths that, when pull request events occurs, are to be included as criteria that starts the pipeline.
+
+        You can filter with glob patterns. The ``filePathsExcludes`` takes priority
+        over the ``filePathsIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no filePaths.
+        '''
+        result = self._values.get("file_paths_includes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "GitPullRequestFilter(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_codepipeline.GitPushFilter",
     jsii_struct_bases=[],
@@ -7919,35 +8235,35 @@ class PipelineProps:
 
         Example::
 
-            # project: codebuild.PipelineProject
+            # source_action: codepipeline_actions.S3SourceAction
+            # source_output: codepipeline.Artifact
+            # deploy_bucket: s3.Bucket
             
-            repository = codecommit.Repository(self, "MyRepository",
-                repository_name="MyRepository"
-            )
-            project = codebuild.PipelineProject(self, "MyProject")
             
-            source_output = codepipeline.Artifact()
-            source_action = codepipeline_actions.CodeCommitSourceAction(
-                action_name="CodeCommit",
-                repository=repository,
-                output=source_output
-            )
-            build_action = codepipeline_actions.CodeBuildAction(
-                action_name="CodeBuild",
-                project=project,
-                input=source_output,
-                outputs=[codepipeline.Artifact()],  # optional
-                execute_batch_build=True,  # optional, defaults to false
-                combine_batch_build_artifacts=True
+            # Pipeline-level variable
+            variable = codepipeline.Variable(
+                variable_name="bucket-var",
+                description="description",
+                default_value="sample"
             )
             
-            codepipeline.Pipeline(self, "MyPipeline",
+            codepipeline.Pipeline(self, "Pipeline",
+                pipeline_type=codepipeline.PipelineType.V2,
+                variables=[variable],
                 stages=[codepipeline.StageProps(
                     stage_name="Source",
                     actions=[source_action]
                 ), codepipeline.StageProps(
-                    stage_name="Build",
-                    actions=[build_action]
+                    stage_name="Deploy",
+                    actions=[
+                        codepipeline_actions.S3DeployAction(
+                            action_name="DeployAction",
+                            # can reference the variables
+                            object_key=f"{variable.reference()}.txt",
+                            input=source_output,
+                            bucket=deploy_bucket
+                        )
+                    ]
                 )
                 ]
             )
@@ -8450,6 +8766,13 @@ class Trigger(
                 source_action=action,
         
                 # the properties below are optional
+                pull_request_filter=[codepipeline.GitPullRequestFilter(
+                    branches_excludes=["branchesExcludes"],
+                    branches_includes=["branchesIncludes"],
+                    events=[codepipeline.GitPullRequestEvent.OPEN],
+                    file_paths_excludes=["filePathsExcludes"],
+                    file_paths_includes=["filePathsIncludes"]
+                )],
                 push_filter=[codepipeline.GitPushFilter(
                     tags_excludes=["tagsExcludes"],
                     tags_includes=["tagsIncludes"]
@@ -9064,6 +9387,8 @@ __all__ = [
     "CustomActionRegistrationProps",
     "ExecutionMode",
     "GitConfiguration",
+    "GitPullRequestEvent",
+    "GitPullRequestFilter",
     "GitPushFilter",
     "GlobalVariables",
     "IAction",
@@ -9761,11 +10086,23 @@ def _typecheckingstub__65e227e2024e22ec4a8340ba1d5e7057772fcde85f4031d00361f79aa
 def _typecheckingstub__9bf0379bb3fa72f7dc00a45de6a383d19d18294c73d73dabcbdb7240e76832bf(
     *,
     source_action: IAction,
+    pull_request_filter: typing.Optional[typing.Sequence[typing.Union[GitPullRequestFilter, typing.Dict[builtins.str, typing.Any]]]] = None,
     push_filter: typing.Optional[typing.Sequence[typing.Union[GitPushFilter, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__cd84a4c10c68eec597c7c17a163a758ee28d398b585c996c44eba7fd956ee279(
+    *,
+    branches_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    branches_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    events: typing.Optional[typing.Sequence[GitPullRequestEvent]] = None,
+    file_paths_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    file_paths_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__d2e5e6ae139c810aa752b8a8c7cd3040d883f9f3a67c8d3693f9ab842351804e(
     *,
     tags_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,