snowflake.OpenflowConnector

import * as pulumi from "@pulumi/pulumi";
import * as snowflake from "@pulumi/snowflake";

// from a Snowflake-managed connector definition; the connector carries no configuration yet, so it cannot be
// started until one is supplied
const fromDefinition = new snowflake.OpenflowConnector("from_definition", {
    database: "my_database",
    schema: "my_schema",
    name: "my_connector",
    runtime: example.fullyQualifiedName,
    from: {
        definition: "OPENFLOW_POSTGRES_CDC",
    },
});
// from a connector bundle on a stage; the connector arrives already configured. A git repository is a stage,
// so `stage` takes one of those too
const fromStage = new snowflake.OpenflowConnector("from_stage", {
    database: "my_database",
    schema: "my_schema",
    name: "my_configured_connector",
    runtime: example.fullyQualifiedName,
    from: {
        stage: exampleSnowflakeStage.fullyQualifiedName,
        path: "connectors/postgres",
    },
});
// uploading the bundle yourself, then creating the connector from it. Snowflake reads config.json from the
// location and checks that the connector definition it names matches, so that file has to be there; the same
// PUT pattern uploads anything else the bundle needs, such as a driver jar.
//
// PUT runs from the machine executing Terraform, so the local file has to exist there. That rules it out for
// runners that do not have your bundle checked out, where a git repository stage is the better route.
const bundles = new snowflake.Stage("bundles", {
    database: "my_database",
    schema: "my_schema",
    name: "my_connector_bundles",
});
const uploadConfig = new snowflake.Execute("upload_config", {
    execute: pulumi.interpolate`PUT file:///path/to/bundle/config.json @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE`,
    revert: pulumi.interpolate`REMOVE @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/config.json`,
});
const uploadDriver = new snowflake.Execute("upload_driver", {
    execute: pulumi.interpolate`PUT file:///path/to/bundle/postgresql.jar @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE`,
    revert: pulumi.interpolate`REMOVE @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/postgresql.jar`,
});
const fromUploadedBundle = new snowflake.OpenflowConnector("from_uploaded_bundle", {
    database: "my_database",
    schema: "my_schema",
    name: "my_uploaded_connector",
    runtime: example.fullyQualifiedName,
    from: {
        stage: bundles.fullyQualifiedName,
        path: "orders",
    },
}, {
    dependsOn: [
        uploadConfig,
        uploadDriver,
    ],
});
// from a git repository, which is a stage as far as Snowflake is concerned. Preferred when the bundle is
// version controlled, since nothing has to be uploaded from the machine running Terraform.
const fromGit = new snowflake.OpenflowConnector("from_git", {
    database: "my_database",
    schema: "my_schema",
    name: "my_git_connector",
    runtime: example.fullyQualifiedName,
    from: {
        stage: exampleSnowflakeGitRepository.fullyQualifiedName,
        path: "branches/main/connectors/orders",
    },
});
// complete resource
const complete = new snowflake.OpenflowConnector("complete", {
    database: "my_database",
    schema: "my_schema",
    name: "my_connector_complete",
    runtime: example.fullyQualifiedName,
    from: {
        definition: "OPENFLOW_POSTGRES_CDC",
    },
    displayName: "My connector",
    comment: "Managed by Terraform.",
});

import pulumi
import pulumi_snowflake as snowflake

# from a Snowflake-managed connector definition; the connector carries no configuration yet, so it cannot be
# started until one is supplied
from_definition = snowflake.OpenflowConnector("from_definition",
    database="my_database",
    schema="my_schema",
    name="my_connector",
    runtime=example["fullyQualifiedName"],
    from_={
        "definition": "OPENFLOW_POSTGRES_CDC",
    })
# from a connector bundle on a stage; the connector arrives already configured. A git repository is a stage,
# so `stage` takes one of those too
from_stage = snowflake.OpenflowConnector("from_stage",
    database="my_database",
    schema="my_schema",
    name="my_configured_connector",
    runtime=example["fullyQualifiedName"],
    from_={
        "stage": example_snowflake_stage["fullyQualifiedName"],
        "path": "connectors/postgres",
    })
# uploading the bundle yourself, then creating the connector from it. Snowflake reads config.json from the
# location and checks that the connector definition it names matches, so that file has to be there; the same
# PUT pattern uploads anything else the bundle needs, such as a driver jar.
#
# PUT runs from the machine executing Terraform, so the local file has to exist there. That rules it out for
# runners that do not have your bundle checked out, where a git repository stage is the better route.
bundles = snowflake.Stage("bundles",
    database="my_database",
    schema="my_schema",
    name="my_connector_bundles")
upload_config = snowflake.Execute("upload_config",
    execute=pulumi.Output.all(
        database=bundles.database,
        schema=bundles.schema,
        name=bundles.name
).apply(lambda resolved_outputs: f"PUT file:///path/to/bundle/config.json @\"{resolved_outputs['database']}\".\"{resolved_outputs['schema']}\".\"{resolved_outputs['name']}\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE")
,
    revert=pulumi.Output.all(
        database=bundles.database,
        schema=bundles.schema,
        name=bundles.name
).apply(lambda resolved_outputs: f"REMOVE @\"{resolved_outputs['database']}\".\"{resolved_outputs['schema']}\".\"{resolved_outputs['name']}\"/orders/config.json")
)
upload_driver = snowflake.Execute("upload_driver",
    execute=pulumi.Output.all(
        database=bundles.database,
        schema=bundles.schema,
        name=bundles.name
).apply(lambda resolved_outputs: f"PUT file:///path/to/bundle/postgresql.jar @\"{resolved_outputs['database']}\".\"{resolved_outputs['schema']}\".\"{resolved_outputs['name']}\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE")
,
    revert=pulumi.Output.all(
        database=bundles.database,
        schema=bundles.schema,
        name=bundles.name
).apply(lambda resolved_outputs: f"REMOVE @\"{resolved_outputs['database']}\".\"{resolved_outputs['schema']}\".\"{resolved_outputs['name']}\"/orders/postgresql.jar")
)
from_uploaded_bundle = snowflake.OpenflowConnector("from_uploaded_bundle",
    database="my_database",
    schema="my_schema",
    name="my_uploaded_connector",
    runtime=example["fullyQualifiedName"],
    from_={
        "stage": bundles.fully_qualified_name,
        "path": "orders",
    },
    opts = pulumi.ResourceOptions(depends_on=[
            upload_config,
            upload_driver,
        ]))
# from a git repository, which is a stage as far as Snowflake is concerned. Preferred when the bundle is
# version controlled, since nothing has to be uploaded from the machine running Terraform.
from_git = snowflake.OpenflowConnector("from_git",
    database="my_database",
    schema="my_schema",
    name="my_git_connector",
    runtime=example["fullyQualifiedName"],
    from_={
        "stage": example_snowflake_git_repository["fullyQualifiedName"],
        "path": "branches/main/connectors/orders",
    })
# complete resource
complete = snowflake.OpenflowConnector("complete",
    database="my_database",
    schema="my_schema",
    name="my_connector_complete",
    runtime=example["fullyQualifiedName"],
    from_={
        "definition": "OPENFLOW_POSTGRES_CDC",
    },
    display_name="My connector",
    comment="Managed by Terraform.")

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-snowflake/sdk/v2/go/snowflake"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// from a Snowflake-managed connector definition; the connector carries no configuration yet, so it cannot be
		// started until one is supplied
		_, err := snowflake.NewOpenflowConnector(ctx, "from_definition", &snowflake.OpenflowConnectorArgs{
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			Name:     pulumi.String("my_connector"),
			Runtime:  pulumi.Any(example.FullyQualifiedName),
			From: &snowflake.OpenflowConnectorFromArgs{
				Definition: pulumi.String("OPENFLOW_POSTGRES_CDC"),
			},
		})
		if err != nil {
			return err
		}
		// from a connector bundle on a stage; the connector arrives already configured. A git repository is a stage,
		// so `stage` takes one of those too
		_, err = snowflake.NewOpenflowConnector(ctx, "from_stage", &snowflake.OpenflowConnectorArgs{
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			Name:     pulumi.String("my_configured_connector"),
			Runtime:  pulumi.Any(example.FullyQualifiedName),
			From: &snowflake.OpenflowConnectorFromArgs{
				Stage: pulumi.Any(exampleSnowflakeStage.FullyQualifiedName),
				Path:  pulumi.String("connectors/postgres"),
			},
		})
		if err != nil {
			return err
		}
		// uploading the bundle yourself, then creating the connector from it. Snowflake reads config.json from the
		// location and checks that the connector definition it names matches, so that file has to be there; the same
		// PUT pattern uploads anything else the bundle needs, such as a driver jar.
		//
		// PUT runs from the machine executing Terraform, so the local file has to exist there. That rules it out for
		// runners that do not have your bundle checked out, where a git repository stage is the better route.
		bundles, err := snowflake.NewStage(ctx, "bundles", &snowflake.StageArgs{
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			Name:     pulumi.String("my_connector_bundles"),
		})
		if err != nil {
			return err
		}
		uploadConfig, err := snowflake.NewExecute(ctx, "upload_config", &snowflake.ExecuteArgs{
			Execute: pulumi.All(bundles.Database, bundles.Schema, bundles.Name).ApplyT(func(_args []interface{}) (string, error) {
				database := _args[0].(string)
				schema := _args[1].(string)
				name := _args[2].(string)
				return fmt.Sprintf("PUT file:///path/to/bundle/config.json @\"%v\".\"%v\".\"%v\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE", database, schema, name), nil
			}).(pulumi.StringOutput),
			Revert: pulumi.All(bundles.Database, bundles.Schema, bundles.Name).ApplyT(func(_args []interface{}) (string, error) {
				database := _args[0].(string)
				schema := _args[1].(string)
				name := _args[2].(string)
				return fmt.Sprintf("REMOVE @\"%v\".\"%v\".\"%v\"/orders/config.json", database, schema, name), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		uploadDriver, err := snowflake.NewExecute(ctx, "upload_driver", &snowflake.ExecuteArgs{
			Execute: pulumi.All(bundles.Database, bundles.Schema, bundles.Name).ApplyT(func(_args []interface{}) (string, error) {
				database := _args[0].(string)
				schema := _args[1].(string)
				name := _args[2].(string)
				return fmt.Sprintf("PUT file:///path/to/bundle/postgresql.jar @\"%v\".\"%v\".\"%v\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE", database, schema, name), nil
			}).(pulumi.StringOutput),
			Revert: pulumi.All(bundles.Database, bundles.Schema, bundles.Name).ApplyT(func(_args []interface{}) (string, error) {
				database := _args[0].(string)
				schema := _args[1].(string)
				name := _args[2].(string)
				return fmt.Sprintf("REMOVE @\"%v\".\"%v\".\"%v\"/orders/postgresql.jar", database, schema, name), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = snowflake.NewOpenflowConnector(ctx, "from_uploaded_bundle", &snowflake.OpenflowConnectorArgs{
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			Name:     pulumi.String("my_uploaded_connector"),
			Runtime:  pulumi.Any(example.FullyQualifiedName),
			From: &snowflake.OpenflowConnectorFromArgs{
				Stage: bundles.FullyQualifiedName,
				Path:  pulumi.String("orders"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			uploadConfig,
			uploadDriver,
		}))
		if err != nil {
			return err
		}
		// from a git repository, which is a stage as far as Snowflake is concerned. Preferred when the bundle is
		// version controlled, since nothing has to be uploaded from the machine running Terraform.
		_, err = snowflake.NewOpenflowConnector(ctx, "from_git", &snowflake.OpenflowConnectorArgs{
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			Name:     pulumi.String("my_git_connector"),
			Runtime:  pulumi.Any(example.FullyQualifiedName),
			From: &snowflake.OpenflowConnectorFromArgs{
				Stage: pulumi.Any(exampleSnowflakeGitRepository.FullyQualifiedName),
				Path:  pulumi.String("branches/main/connectors/orders"),
			},
		})
		if err != nil {
			return err
		}
		// complete resource
		_, err = snowflake.NewOpenflowConnector(ctx, "complete", &snowflake.OpenflowConnectorArgs{
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			Name:     pulumi.String("my_connector_complete"),
			Runtime:  pulumi.Any(example.FullyQualifiedName),
			From: &snowflake.OpenflowConnectorFromArgs{
				Definition: pulumi.String("OPENFLOW_POSTGRES_CDC"),
			},
			DisplayName: pulumi.String("My connector"),
			Comment:     pulumi.String("Managed by Terraform."),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Snowflake = Pulumi.Snowflake;

return await Deployment.RunAsync(() => 
{
    // from a Snowflake-managed connector definition; the connector carries no configuration yet, so it cannot be
    // started until one is supplied
    var fromDefinition = new Snowflake.OpenflowConnector("from_definition", new()
    {
        Database = "my_database",
        Schema = "my_schema",
        Name = "my_connector",
        Runtime = example.FullyQualifiedName,
        From = new Snowflake.Inputs.OpenflowConnectorFromArgs
        {
            Definition = "OPENFLOW_POSTGRES_CDC",
        },
    });

    // from a connector bundle on a stage; the connector arrives already configured. A git repository is a stage,
    // so `stage` takes one of those too
    var fromStage = new Snowflake.OpenflowConnector("from_stage", new()
    {
        Database = "my_database",
        Schema = "my_schema",
        Name = "my_configured_connector",
        Runtime = example.FullyQualifiedName,
        From = new Snowflake.Inputs.OpenflowConnectorFromArgs
        {
            Stage = exampleSnowflakeStage.FullyQualifiedName,
            Path = "connectors/postgres",
        },
    });

    // uploading the bundle yourself, then creating the connector from it. Snowflake reads config.json from the
    // location and checks that the connector definition it names matches, so that file has to be there; the same
    // PUT pattern uploads anything else the bundle needs, such as a driver jar.
    //
    // PUT runs from the machine executing Terraform, so the local file has to exist there. That rules it out for
    // runners that do not have your bundle checked out, where a git repository stage is the better route.
    var bundles = new Snowflake.Stage("bundles", new()
    {
        Database = "my_database",
        Schema = "my_schema",
        Name = "my_connector_bundles",
    });

    var uploadConfig = new Snowflake.Execute("upload_config", new()
    {
        ExecuteSQL = Output.Tuple(bundles.Database, bundles.Schema, bundles.Name).Apply(values =>
        {
            var database = values.Item1;
            var schema = values.Item2;
            var name = values.Item3;
            return $"PUT file:///path/to/bundle/config.json @\"{database}\".\"{schema}\".\"{name}\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE";
        }),
        Revert = Output.Tuple(bundles.Database, bundles.Schema, bundles.Name).Apply(values =>
        {
            var database = values.Item1;
            var schema = values.Item2;
            var name = values.Item3;
            return $"REMOVE @\"{database}\".\"{schema}\".\"{name}\"/orders/config.json";
        }),
    });

    var uploadDriver = new Snowflake.Execute("upload_driver", new()
    {
        ExecuteSQL = Output.Tuple(bundles.Database, bundles.Schema, bundles.Name).Apply(values =>
        {
            var database = values.Item1;
            var schema = values.Item2;
            var name = values.Item3;
            return $"PUT file:///path/to/bundle/postgresql.jar @\"{database}\".\"{schema}\".\"{name}\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE";
        }),
        Revert = Output.Tuple(bundles.Database, bundles.Schema, bundles.Name).Apply(values =>
        {
            var database = values.Item1;
            var schema = values.Item2;
            var name = values.Item3;
            return $"REMOVE @\"{database}\".\"{schema}\".\"{name}\"/orders/postgresql.jar";
        }),
    });

    var fromUploadedBundle = new Snowflake.OpenflowConnector("from_uploaded_bundle", new()
    {
        Database = "my_database",
        Schema = "my_schema",
        Name = "my_uploaded_connector",
        Runtime = example.FullyQualifiedName,
        From = new Snowflake.Inputs.OpenflowConnectorFromArgs
        {
            Stage = bundles.FullyQualifiedName,
            Path = "orders",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            uploadConfig,
            uploadDriver,
        },
    });

    // from a git repository, which is a stage as far as Snowflake is concerned. Preferred when the bundle is
    // version controlled, since nothing has to be uploaded from the machine running Terraform.
    var fromGit = new Snowflake.OpenflowConnector("from_git", new()
    {
        Database = "my_database",
        Schema = "my_schema",
        Name = "my_git_connector",
        Runtime = example.FullyQualifiedName,
        From = new Snowflake.Inputs.OpenflowConnectorFromArgs
        {
            Stage = exampleSnowflakeGitRepository.FullyQualifiedName,
            Path = "branches/main/connectors/orders",
        },
    });

    // complete resource
    var complete = new Snowflake.OpenflowConnector("complete", new()
    {
        Database = "my_database",
        Schema = "my_schema",
        Name = "my_connector_complete",
        Runtime = example.FullyQualifiedName,
        From = new Snowflake.Inputs.OpenflowConnectorFromArgs
        {
            Definition = "OPENFLOW_POSTGRES_CDC",
        },
        DisplayName = "My connector",
        Comment = "Managed by Terraform.",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.OpenflowConnector;
import com.pulumi.snowflake.OpenflowConnectorArgs;
import com.pulumi.snowflake.inputs.OpenflowConnectorFromArgs;
import com.pulumi.snowflake.Stage;
import com.pulumi.snowflake.StageArgs;
import com.pulumi.snowflake.Execute;
import com.pulumi.snowflake.ExecuteArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // from a Snowflake-managed connector definition; the connector carries no configuration yet, so it cannot be
        // started until one is supplied
        var fromDefinition = new OpenflowConnector("fromDefinition", OpenflowConnectorArgs.builder()
            .database("my_database")
            .schema("my_schema")
            .name("my_connector")
            .runtime(example.fullyQualifiedName())
            .from(OpenflowConnectorFromArgs.builder()
                .definition("OPENFLOW_POSTGRES_CDC")
                .build())
            .build());

        // from a connector bundle on a stage; the connector arrives already configured. A git repository is a stage,
        // so `stage` takes one of those too
        var fromStage = new OpenflowConnector("fromStage", OpenflowConnectorArgs.builder()
            .database("my_database")
            .schema("my_schema")
            .name("my_configured_connector")
            .runtime(example.fullyQualifiedName())
            .from(OpenflowConnectorFromArgs.builder()
                .stage(exampleSnowflakeStage.fullyQualifiedName())
                .path("connectors/postgres")
                .build())
            .build());

        // uploading the bundle yourself, then creating the connector from it. Snowflake reads config.json from the
        // location and checks that the connector definition it names matches, so that file has to be there; the same
        // PUT pattern uploads anything else the bundle needs, such as a driver jar.
        //
        // PUT runs from the machine executing Terraform, so the local file has to exist there. That rules it out for
        // runners that do not have your bundle checked out, where a git repository stage is the better route.
        var bundles = new Stage("bundles", StageArgs.builder()
            .database("my_database")
            .schema("my_schema")
            .name("my_connector_bundles")
            .build());

        var uploadConfig = new Execute("uploadConfig", ExecuteArgs.builder()
            .execute(Output.tuple(bundles.database(), bundles.schema(), bundles.name()).applyValue(values -> {
                var database = values.t1;
                var schema = values.t2;
                var name = values.t3;
                return String.format("PUT file:///path/to/bundle/config.json @\"%s\".\"%s\".\"%s\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE", database,schema,name);
            }))
            .revert(Output.tuple(bundles.database(), bundles.schema(), bundles.name()).applyValue(values -> {
                var database = values.t1;
                var schema = values.t2;
                var name = values.t3;
                return String.format("REMOVE @\"%s\".\"%s\".\"%s\"/orders/config.json", database,schema,name);
            }))
            .build());

        var uploadDriver = new Execute("uploadDriver", ExecuteArgs.builder()
            .execute(Output.tuple(bundles.database(), bundles.schema(), bundles.name()).applyValue(values -> {
                var database = values.t1;
                var schema = values.t2;
                var name = values.t3;
                return String.format("PUT file:///path/to/bundle/postgresql.jar @\"%s\".\"%s\".\"%s\"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE", database,schema,name);
            }))
            .revert(Output.tuple(bundles.database(), bundles.schema(), bundles.name()).applyValue(values -> {
                var database = values.t1;
                var schema = values.t2;
                var name = values.t3;
                return String.format("REMOVE @\"%s\".\"%s\".\"%s\"/orders/postgresql.jar", database,schema,name);
            }))
            .build());

        var fromUploadedBundle = new OpenflowConnector("fromUploadedBundle", OpenflowConnectorArgs.builder()
            .database("my_database")
            .schema("my_schema")
            .name("my_uploaded_connector")
            .runtime(example.fullyQualifiedName())
            .from(OpenflowConnectorFromArgs.builder()
                .stage(bundles.fullyQualifiedName())
                .path("orders")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    uploadConfig,
                    uploadDriver)
                .build());

        // from a git repository, which is a stage as far as Snowflake is concerned. Preferred when the bundle is
        // version controlled, since nothing has to be uploaded from the machine running Terraform.
        var fromGit = new OpenflowConnector("fromGit", OpenflowConnectorArgs.builder()
            .database("my_database")
            .schema("my_schema")
            .name("my_git_connector")
            .runtime(example.fullyQualifiedName())
            .from(OpenflowConnectorFromArgs.builder()
                .stage(exampleSnowflakeGitRepository.fullyQualifiedName())
                .path("branches/main/connectors/orders")
                .build())
            .build());

        // complete resource
        var complete = new OpenflowConnector("complete", OpenflowConnectorArgs.builder()
            .database("my_database")
            .schema("my_schema")
            .name("my_connector_complete")
            .runtime(example.fullyQualifiedName())
            .from(OpenflowConnectorFromArgs.builder()
                .definition("OPENFLOW_POSTGRES_CDC")
                .build())
            .displayName("My connector")
            .comment("Managed by Terraform.")
            .build());

    }
}

resources:
  # from a Snowflake-managed connector definition; the connector carries no configuration yet, so it cannot be
  # started until one is supplied
  fromDefinition:
    type: snowflake:OpenflowConnector
    name: from_definition
    properties:
      database: my_database
      schema: my_schema
      name: my_connector
      runtime: ${example.fullyQualifiedName}
      from:
        definition: OPENFLOW_POSTGRES_CDC
  # from a connector bundle on a stage; the connector arrives already configured. A git repository is a stage,
  # so `stage` takes one of those too
  fromStage:
    type: snowflake:OpenflowConnector
    name: from_stage
    properties:
      database: my_database
      schema: my_schema
      name: my_configured_connector
      runtime: ${example.fullyQualifiedName}
      from:
        stage: ${exampleSnowflakeStage.fullyQualifiedName}
        path: connectors/postgres
  # uploading the bundle yourself, then creating the connector from it. Snowflake reads config.json from the
  # location and checks that the connector definition it names matches, so that file has to be there; the same
  # PUT pattern uploads anything else the bundle needs, such as a driver jar.
  #
  # PUT runs from the machine executing Terraform, so the local file has to exist there. That rules it out for
  # runners that do not have your bundle checked out, where a git repository stage is the better route.
  bundles:
    type: snowflake:Stage
    properties:
      database: my_database
      schema: my_schema
      name: my_connector_bundles
  uploadConfig:
    type: snowflake:Execute
    name: upload_config
    properties:
      execute: PUT file:///path/to/bundle/config.json @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE
      revert: REMOVE @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/config.json
  uploadDriver:
    type: snowflake:Execute
    name: upload_driver
    properties:
      execute: PUT file:///path/to/bundle/postgresql.jar @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE
      revert: REMOVE @"${bundles.database}"."${bundles.schema}"."${bundles.name}"/orders/postgresql.jar
  fromUploadedBundle:
    type: snowflake:OpenflowConnector
    name: from_uploaded_bundle
    properties:
      database: my_database
      schema: my_schema
      name: my_uploaded_connector
      runtime: ${example.fullyQualifiedName}
      from:
        stage: ${bundles.fullyQualifiedName}
        path: orders
    options:
      dependsOn:
        - ${uploadConfig}
        - ${uploadDriver}
  # from a git repository, which is a stage as far as Snowflake is concerned. Preferred when the bundle is
  # version controlled, since nothing has to be uploaded from the machine running Terraform.
  fromGit:
    type: snowflake:OpenflowConnector
    name: from_git
    properties:
      database: my_database
      schema: my_schema
      name: my_git_connector
      runtime: ${example.fullyQualifiedName}
      from:
        stage: ${exampleSnowflakeGitRepository.fullyQualifiedName}
        path: branches/main/connectors/orders
  # complete resource
  complete:
    type: snowflake:OpenflowConnector
    properties:
      database: my_database
      schema: my_schema
      name: my_connector_complete
      runtime: ${example.fullyQualifiedName}
      from:
        definition: OPENFLOW_POSTGRES_CDC
      displayName: My connector
      comment: Managed by Terraform.

pulumi {
  required_providers {
    snowflake = {
      source = "pulumi/snowflake"
    }
  }
}

# from a Snowflake-managed connector definition; the connector carries no configuration yet, so it cannot be
# started until one is supplied
resource "snowflake_openflowconnector" "from_definition" {
  database = "my_database"
  schema   = "my_schema"
  name     = "my_connector"
  runtime  = example.fullyQualifiedName
  from = {
    definition = "OPENFLOW_POSTGRES_CDC"
  }
}
# from a connector bundle on a stage; the connector arrives already configured. A git repository is a stage,
# so `stage` takes one of those too
resource "snowflake_openflowconnector" "from_stage" {
  database = "my_database"
  schema   = "my_schema"
  name     = "my_configured_connector"
  runtime  = example.fullyQualifiedName
  from = {
    stage = exampleSnowflakeStage.fullyQualifiedName
    path  = "connectors/postgres"
  }
}
# uploading the bundle yourself, then creating the connector from it. Snowflake reads config.json from the
# location and checks that the connector definition it names matches, so that file has to be there; the same
# PUT pattern uploads anything else the bundle needs, such as a driver jar.
#
# PUT runs from the machine executing Terraform, so the local file has to exist there. That rules it out for
# runners that do not have your bundle checked out, where a git repository stage is the better route.
resource "snowflake_stage" "bundles" {
  database = "my_database"
  schema   = "my_schema"
  name     = "my_connector_bundles"
}
resource "snowflake_execute" "upload_config" {
  execute ="PUT file:///path/to/bundle/config.json @"${snowflake_stage.bundles.database}"."${snowflake_stage.bundles.schema}"."${snowflake_stage.bundles.name}"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE"
  revert  ="REMOVE @"${snowflake_stage.bundles.database}"."${snowflake_stage.bundles.schema}"."${snowflake_stage.bundles.name}"/orders/config.json"
}
resource "snowflake_execute" "upload_driver" {
  execute ="PUT file:///path/to/bundle/postgresql.jar @"${snowflake_stage.bundles.database}"."${snowflake_stage.bundles.schema}"."${snowflake_stage.bundles.name}"/orders/ AUTO_COMPRESS = FALSE OVERWRITE = TRUE"
  revert  ="REMOVE @"${snowflake_stage.bundles.database}"."${snowflake_stage.bundles.schema}"."${snowflake_stage.bundles.name}"/orders/postgresql.jar"
}
resource "snowflake_openflowconnector" "from_uploaded_bundle" {
  depends_on = [snowflake_execute.upload_config, snowflake_execute.upload_driver]
  database   = "my_database"
  schema     = "my_schema"
  name       = "my_uploaded_connector"
  runtime    = example.fullyQualifiedName
  from = {
    stage = snowflake_stage.bundles.fully_qualified_name
    path  = "orders"
  }
}
# from a git repository, which is a stage as far as Snowflake is concerned. Preferred when the bundle is
# version controlled, since nothing has to be uploaded from the machine running Terraform.
resource "snowflake_openflowconnector" "from_git" {
  database = "my_database"
  schema   = "my_schema"
  name     = "my_git_connector"
  runtime  = example.fullyQualifiedName
  from = {
    stage = exampleSnowflakeGitRepository.fullyQualifiedName
    path  = "branches/main/connectors/orders"
  }
}
# complete resource
resource "snowflake_openflowconnector" "complete" {
  database = "my_database"
  schema   = "my_schema"
  name     = "my_connector_complete"
  runtime  = example.fullyQualifiedName
  from = {
    definition = "OPENFLOW_POSTGRES_CDC"
  }
  display_name = "My connector"
  comment      = "Managed by Terraform."
}

var openflowConnectorResource = new Snowflake.OpenflowConnector("openflowConnectorResource", new()
{
    Database = "string",
    From = new Snowflake.Inputs.OpenflowConnectorFromArgs
    {
        Definition = "string",
        Path = "string",
        Stage = "string",
    },
    Runtime = "string",
    Schema = "string",
    Comment = "string",
    DisplayName = "string",
    Name = "string",
});

example, err := snowflake.NewOpenflowConnector(ctx, "openflowConnectorResource", &snowflake.OpenflowConnectorArgs{
	Database: pulumi.String("string"),
	From: &snowflake.OpenflowConnectorFromArgs{
		Definition: pulumi.String("string"),
		Path:       pulumi.String("string"),
		Stage:      pulumi.String("string"),
	},
	Runtime:     pulumi.String("string"),
	Schema:      pulumi.String("string"),
	Comment:     pulumi.String("string"),
	DisplayName: pulumi.String("string"),
	Name:        pulumi.String("string"),
})

resource "snowflake_openflow_connector" "openflowConnectorResource" {
  lifecycle {
    create_before_destroy = true
  }
  database = "string"
  from = {
    definition = "string"
    path       = "string"
    stage      = "string"
  }
  runtime      = "string"
  schema       = "string"
  comment      = "string"
  display_name = "string"
  name         = "string"
}

var openflowConnectorResource = new OpenflowConnector("openflowConnectorResource", OpenflowConnectorArgs.builder()
    .database("string")
    .from(OpenflowConnectorFromArgs.builder()
        .definition("string")
        .path("string")
        .stage("string")
        .build())
    .runtime("string")
    .schema("string")
    .comment("string")
    .displayName("string")
    .name("string")
    .build());

openflow_connector_resource = snowflake.OpenflowConnector("openflowConnectorResource",
    database="string",
    from_={
        "definition": "string",
        "path": "string",
        "stage": "string",
    },
    runtime="string",
    schema="string",
    comment="string",
    display_name="string",
    name="string")

const openflowConnectorResource = new snowflake.OpenflowConnector("openflowConnectorResource", {
    database: "string",
    from: {
        definition: "string",
        path: "string",
        stage: "string",
    },
    runtime: "string",
    schema: "string",
    comment: "string",
    displayName: "string",
    name: "string",
});

type: snowflake:OpenflowConnector
properties:
    comment: string
    database: string
    displayName: string
    from:
        definition: string
        path: string
        stage: string
    name: string
    runtime: string
    schema: string