pulumi-gcp 8.1.0a1726293903__py3-none-any.whl → 8.2.0__py3-none-any.whl

pulumi_gcp/datastream/stream.py

@@ -47,7 +47,9 @@ class StreamArgs:
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, 'NOT_STARTED' to create the stream without
+               starting and 'PAUSED' to pause the stream from a 'RUNNING' state. Possible values: NOT_STARTED, RUNNING, PAUSED.
+               Default: NOT_STARTED
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Labels. **Note**: This field is non-authoritative, and will only manage the labels present in your configuration. Please
                refer to the field 'effective_labels' for all of the labels present on the resource.
         """
@@ -186,7 +188,9 @@ class StreamArgs:
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, 'NOT_STARTED' to create the stream without
+        starting and 'PAUSED' to pause the stream from a 'RUNNING' state. Possible values: NOT_STARTED, RUNNING, PAUSED.
+        Default: NOT_STARTED
         """
         return pulumi.get(self, "desired_state")
 
@@ -243,7 +247,9 @@ class _StreamState:
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, 'NOT_STARTED' to create the stream without
+               starting and 'PAUSED' to pause the stream from a 'RUNNING' state. Possible values: NOT_STARTED, RUNNING, PAUSED.
+               Default: NOT_STARTED
         :param pulumi.Input['StreamDestinationConfigArgs'] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -345,7 +351,9 @@ class _StreamState:
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, 'NOT_STARTED' to create the stream without
+        starting and 'PAUSED' to pause the stream from a 'RUNNING' state. Possible values: NOT_STARTED, RUNNING, PAUSED.
+        Default: NOT_STARTED
         """
         return pulumi.get(self, "desired_state")
 
@@ -924,6 +932,96 @@ class Stream(pulumi.CustomResource):
                             }],
                         }],
                     },
+                    "transaction_logs": {},
+                },
+            },
+            destination_config={
+                "destination_connection_profile": destination.id,
+                "bigquery_destination_config": {
+                    "data_freshness": "900s",
+                    "source_hierarchy_datasets": {
+                        "dataset_template": {
+                            "location": "us-central1",
+                        },
+                    },
+                },
+            },
+            backfill_none={})
+        ```
+        ### Datastream Stream Sql Server Change Tables
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        instance = gcp.sql.DatabaseInstance("instance",
+            name="sql-server",
+            database_version="SQLSERVER_2019_STANDARD",
+            region="us-central1",
+            root_password="root-password",
+            deletion_protection=True,
+            settings={
+                "tier": "db-custom-2-4096",
+                "ip_configuration": {
+                    "authorized_networks": [
+                        {
+                            "value": "34.71.242.81",
+                        },
+                        {
+                            "value": "34.72.28.29",
+                        },
+                        {
+                            "value": "34.67.6.157",
+                        },
+                        {
+                            "value": "34.67.234.134",
+                        },
+                        {
+                            "value": "34.72.239.218",
+                        },
+                    ],
+                },
+            })
+        user = gcp.sql.User("user",
+            name="user",
+            instance=instance.name,
+            password="password")
+        db = gcp.sql.Database("db",
+            name="db",
+            instance=instance.name,
+            opts = pulumi.ResourceOptions(depends_on=[user]))
+        source = gcp.datastream.ConnectionProfile("source",
+            display_name="SQL Server Source",
+            location="us-central1",
+            connection_profile_id="source-profile",
+            sql_server_profile={
+                "hostname": instance.public_ip_address,
+                "port": 1433,
+                "username": user.name,
+                "password": user.password,
+                "database": db.name,
+            })
+        destination = gcp.datastream.ConnectionProfile("destination",
+            display_name="BigQuery Destination",
+            location="us-central1",
+            connection_profile_id="destination-profile",
+            bigquery_profile={})
+        default = gcp.datastream.Stream("default",
+            display_name="SQL Server to BigQuery",
+            location="us-central1",
+            stream_id="stream",
+            source_config={
+                "source_connection_profile": source.id,
+                "sql_server_source_config": {
+                    "include_objects": {
+                        "schemas": [{
+                            "schema": "schema",
+                            "tables": [{
+                                "table": "table",
+                            }],
+                        }],
+                    },
+                    "change_tables": {},
                 },
             },
             destination_config={
@@ -1234,7 +1332,9 @@ class Stream(pulumi.CustomResource):
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, 'NOT_STARTED' to create the stream without
+               starting and 'PAUSED' to pause the stream from a 'RUNNING' state. Possible values: NOT_STARTED, RUNNING, PAUSED.
+               Default: NOT_STARTED
         :param pulumi.Input[Union['StreamDestinationConfigArgs', 'StreamDestinationConfigArgsDict']] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -1670,6 +1770,96 @@ class Stream(pulumi.CustomResource):
                             }],
                         }],
                     },
+                    "transaction_logs": {},
+                },
+            },
+            destination_config={
+                "destination_connection_profile": destination.id,
+                "bigquery_destination_config": {
+                    "data_freshness": "900s",
+                    "source_hierarchy_datasets": {
+                        "dataset_template": {
+                            "location": "us-central1",
+                        },
+                    },
+                },
+            },
+            backfill_none={})
+        ```
+        ### Datastream Stream Sql Server Change Tables
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        instance = gcp.sql.DatabaseInstance("instance",
+            name="sql-server",
+            database_version="SQLSERVER_2019_STANDARD",
+            region="us-central1",
+            root_password="root-password",
+            deletion_protection=True,
+            settings={
+                "tier": "db-custom-2-4096",
+                "ip_configuration": {
+                    "authorized_networks": [
+                        {
+                            "value": "34.71.242.81",
+                        },
+                        {
+                            "value": "34.72.28.29",
+                        },
+                        {
+                            "value": "34.67.6.157",
+                        },
+                        {
+                            "value": "34.67.234.134",
+                        },
+                        {
+                            "value": "34.72.239.218",
+                        },
+                    ],
+                },
+            })
+        user = gcp.sql.User("user",
+            name="user",
+            instance=instance.name,
+            password="password")
+        db = gcp.sql.Database("db",
+            name="db",
+            instance=instance.name,
+            opts = pulumi.ResourceOptions(depends_on=[user]))
+        source = gcp.datastream.ConnectionProfile("source",
+            display_name="SQL Server Source",
+            location="us-central1",
+            connection_profile_id="source-profile",
+            sql_server_profile={
+                "hostname": instance.public_ip_address,
+                "port": 1433,
+                "username": user.name,
+                "password": user.password,
+                "database": db.name,
+            })
+        destination = gcp.datastream.ConnectionProfile("destination",
+            display_name="BigQuery Destination",
+            location="us-central1",
+            connection_profile_id="destination-profile",
+            bigquery_profile={})
+        default = gcp.datastream.Stream("default",
+            display_name="SQL Server to BigQuery",
+            location="us-central1",
+            stream_id="stream",
+            source_config={
+                "source_connection_profile": source.id,
+                "sql_server_source_config": {
+                    "include_objects": {
+                        "schemas": [{
+                            "schema": "schema",
+                            "tables": [{
+                                "table": "table",
+                            }],
+                        }],
+                    },
+                    "change_tables": {},
                 },
             },
             destination_config={
@@ -2075,7 +2265,9 @@ class Stream(pulumi.CustomResource):
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, 'NOT_STARTED' to create the stream without
+               starting and 'PAUSED' to pause the stream from a 'RUNNING' state. Possible values: NOT_STARTED, RUNNING, PAUSED.
+               Default: NOT_STARTED
         :param pulumi.Input[Union['StreamDestinationConfigArgs', 'StreamDestinationConfigArgsDict']] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -2150,7 +2342,9 @@ class Stream(pulumi.CustomResource):
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> pulumi.Output[Optional[str]]:
         """
-        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, 'NOT_STARTED' to create the stream without
+        starting and 'PAUSED' to pause the stream from a 'RUNNING' state. Possible values: NOT_STARTED, RUNNING, PAUSED.
+        Default: NOT_STARTED
         """
         return pulumi.get(self, "desired_state")
 

pulumi_gcp/developerconnect/__init__.py

@@ -0,0 +1,11 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+from .. import _utilities
+import typing
+# Export this package's modules as members:
+from .connection import *
+from .git_repository_link import *
+from ._inputs import *
+from . import outputs

pulumi_gcp/developerconnect/_inputs.py

@@ -0,0 +1,301 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from .. import _utilities
+
+__all__ = [
+    'ConnectionGithubConfigArgs',
+    'ConnectionGithubConfigArgsDict',
+    'ConnectionGithubConfigAuthorizerCredentialArgs',
+    'ConnectionGithubConfigAuthorizerCredentialArgsDict',
+    'ConnectionInstallationStateArgs',
+    'ConnectionInstallationStateArgsDict',
+]
+
+MYPY = False
+
+if not MYPY:
+    class ConnectionGithubConfigArgsDict(TypedDict):
+        github_app: pulumi.Input[str]
+        """
+        Required. Immutable. The GitHub Application that was installed to the GitHub user or
+        organization.
+        Possible values:
+        GIT_HUB_APP_UNSPECIFIED
+        DEVELOPER_CONNECT
+        FIREBASE
+        """
+        app_installation_id: NotRequired[pulumi.Input[str]]
+        """
+        Optional. GitHub App installation id.
+        """
+        authorizer_credential: NotRequired[pulumi.Input['ConnectionGithubConfigAuthorizerCredentialArgsDict']]
+        """
+        Represents an OAuth token of the account that authorized the Connection,
+        and associated metadata.
+        Structure is documented below.
+        """
+        installation_uri: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Output only. The URI to navigate to in order to manage the installation associated
+        with this GitHubConfig.
+        """
+elif False:
+    ConnectionGithubConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectionGithubConfigArgs:
+    def __init__(__self__, *,
+                 github_app: pulumi.Input[str],
+                 app_installation_id: Optional[pulumi.Input[str]] = None,
+                 authorizer_credential: Optional[pulumi.Input['ConnectionGithubConfigAuthorizerCredentialArgs']] = None,
+                 installation_uri: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] github_app: Required. Immutable. The GitHub Application that was installed to the GitHub user or
+               organization.
+               Possible values:
+               GIT_HUB_APP_UNSPECIFIED
+               DEVELOPER_CONNECT
+               FIREBASE
+        :param pulumi.Input[str] app_installation_id: Optional. GitHub App installation id.
+        :param pulumi.Input['ConnectionGithubConfigAuthorizerCredentialArgs'] authorizer_credential: Represents an OAuth token of the account that authorized the Connection,
+               and associated metadata.
+               Structure is documented below.
+        :param pulumi.Input[str] installation_uri: (Output)
+               Output only. The URI to navigate to in order to manage the installation associated
+               with this GitHubConfig.
+        """
+        pulumi.set(__self__, "github_app", github_app)
+        if app_installation_id is not None:
+            pulumi.set(__self__, "app_installation_id", app_installation_id)
+        if authorizer_credential is not None:
+            pulumi.set(__self__, "authorizer_credential", authorizer_credential)
+        if installation_uri is not None:
+            pulumi.set(__self__, "installation_uri", installation_uri)
+
+    @property
+    @pulumi.getter(name="githubApp")
+    def github_app(self) -> pulumi.Input[str]:
+        """
+        Required. Immutable. The GitHub Application that was installed to the GitHub user or
+        organization.
+        Possible values:
+        GIT_HUB_APP_UNSPECIFIED
+        DEVELOPER_CONNECT
+        FIREBASE
+        """
+        return pulumi.get(self, "github_app")
+
+    @github_app.setter
+    def github_app(self, value: pulumi.Input[str]):
+        pulumi.set(self, "github_app", value)
+
+    @property
+    @pulumi.getter(name="appInstallationId")
+    def app_installation_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Optional. GitHub App installation id.
+        """
+        return pulumi.get(self, "app_installation_id")
+
+    @app_installation_id.setter
+    def app_installation_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "app_installation_id", value)
+
+    @property
+    @pulumi.getter(name="authorizerCredential")
+    def authorizer_credential(self) -> Optional[pulumi.Input['ConnectionGithubConfigAuthorizerCredentialArgs']]:
+        """
+        Represents an OAuth token of the account that authorized the Connection,
+        and associated metadata.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "authorizer_credential")
+
+    @authorizer_credential.setter
+    def authorizer_credential(self, value: Optional[pulumi.Input['ConnectionGithubConfigAuthorizerCredentialArgs']]):
+        pulumi.set(self, "authorizer_credential", value)
+
+    @property
+    @pulumi.getter(name="installationUri")
+    def installation_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        Output only. The URI to navigate to in order to manage the installation associated
+        with this GitHubConfig.
+        """
+        return pulumi.get(self, "installation_uri")
+
+    @installation_uri.setter
+    def installation_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "installation_uri", value)
+
+
+if not MYPY:
+    class ConnectionGithubConfigAuthorizerCredentialArgsDict(TypedDict):
+        oauth_token_secret_version: pulumi.Input[str]
+        """
+        Required. A SecretManager resource containing the OAuth token that authorizes
+        the connection. Format: `projects/*/secrets/*/versions/*`.
+        """
+        username: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Output only. The username associated with this token.
+        """
+elif False:
+    ConnectionGithubConfigAuthorizerCredentialArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectionGithubConfigAuthorizerCredentialArgs:
+    def __init__(__self__, *,
+                 oauth_token_secret_version: pulumi.Input[str],
+                 username: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] oauth_token_secret_version: Required. A SecretManager resource containing the OAuth token that authorizes
+               the connection. Format: `projects/*/secrets/*/versions/*`.
+        :param pulumi.Input[str] username: (Output)
+               Output only. The username associated with this token.
+        """
+        pulumi.set(__self__, "oauth_token_secret_version", oauth_token_secret_version)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter(name="oauthTokenSecretVersion")
+    def oauth_token_secret_version(self) -> pulumi.Input[str]:
+        """
+        Required. A SecretManager resource containing the OAuth token that authorizes
+        the connection. Format: `projects/*/secrets/*/versions/*`.
+        """
+        return pulumi.get(self, "oauth_token_secret_version")
+
+    @oauth_token_secret_version.setter
+    def oauth_token_secret_version(self, value: pulumi.Input[str]):
+        pulumi.set(self, "oauth_token_secret_version", value)
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        Output only. The username associated with this token.
+        """
+        return pulumi.get(self, "username")
+
+    @username.setter
+    def username(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "username", value)
+
+
+if not MYPY:
+    class ConnectionInstallationStateArgsDict(TypedDict):
+        action_uri: NotRequired[pulumi.Input[str]]
+        """
+        Output only. Link to follow for next action. Empty string if the installation is already
+        complete.
+        """
+        message: NotRequired[pulumi.Input[str]]
+        """
+        Output only. Message of what the user should do next to continue the installation.
+        Empty string if the installation is already complete.
+        """
+        stage: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        Output only. Current step of the installation process.
+        Possible values:
+        STAGE_UNSPECIFIED
+        PENDING_CREATE_APP
+        PENDING_USER_OAUTH
+        PENDING_INSTALL_APP
+        COMPLETE
+        """
+elif False:
+    ConnectionInstallationStateArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectionInstallationStateArgs:
+    def __init__(__self__, *,
+                 action_uri: Optional[pulumi.Input[str]] = None,
+                 message: Optional[pulumi.Input[str]] = None,
+                 stage: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] action_uri: Output only. Link to follow for next action. Empty string if the installation is already
+               complete.
+        :param pulumi.Input[str] message: Output only. Message of what the user should do next to continue the installation.
+               Empty string if the installation is already complete.
+        :param pulumi.Input[str] stage: (Output)
+               Output only. Current step of the installation process.
+               Possible values:
+               STAGE_UNSPECIFIED
+               PENDING_CREATE_APP
+               PENDING_USER_OAUTH
+               PENDING_INSTALL_APP
+               COMPLETE
+        """
+        if action_uri is not None:
+            pulumi.set(__self__, "action_uri", action_uri)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+        if stage is not None:
+            pulumi.set(__self__, "stage", stage)
+
+    @property
+    @pulumi.getter(name="actionUri")
+    def action_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Output only. Link to follow for next action. Empty string if the installation is already
+        complete.
+        """
+        return pulumi.get(self, "action_uri")
+
+    @action_uri.setter
+    def action_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "action_uri", value)
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[pulumi.Input[str]]:
+        """
+        Output only. Message of what the user should do next to continue the installation.
+        Empty string if the installation is already complete.
+        """
+        return pulumi.get(self, "message")
+
+    @message.setter
+    def message(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "message", value)
+
+    @property
+    @pulumi.getter
+    def stage(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        Output only. Current step of the installation process.
+        Possible values:
+        STAGE_UNSPECIFIED
+        PENDING_CREATE_APP
+        PENDING_USER_OAUTH
+        PENDING_INSTALL_APP
+        COMPLETE
+        """
+        return pulumi.get(self, "stage")
+
+    @stage.setter
+    def stage(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "stage", value)
+
+