max-voitcov
73386ba0ff
Six new resources from terraform-provider-dokploy v0.2.0 -- Network, DnsProvider, VaultProvider, Schedule, VolumeBackup and Libsql -- plus the new properties on Domain (`enabled`), Compose (`serviceNetworks`, `createEnvFile`, `icon`) and Application. Verified with `pulumi up` against a live v0.30.2 instance: create, preview-clean, and destroy. The upstream provider also now refuses a volume Mount with no `volumeName`, which Dokploy would otherwise turn into an anonymous Docker volume recreated on every deploy. That surfaces here at preview time, before anything exists. Two things made that fix nearly invisible to Pulumi users, so this commit fixes the second one: the bridge resolves the upstream `docs/` through the Go module cache, where a locally `replace`d dependency never lands, so tfgen was emitting every resource with no description at all. UpstreamRepoPath now points at the checkout and all 445 inputs carry documentation -- with names rendered per language, so Python readers see `volume_name` where TypeScript readers see `volumeName`.
348 lines
15 KiB
Python
Generated
348 lines
15 KiB
Python
Generated
# coding=utf-8
|
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
|
|
import builtins as _builtins
|
|
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__ = ['PortArgs', 'Port']
|
|
|
|
@pulumi.input_type
|
|
class PortArgs:
|
|
def __init__(__self__, *,
|
|
application_id: pulumi.Input[_builtins.str],
|
|
protocol: pulumi.Input[_builtins.str],
|
|
published_port: pulumi.Input[_builtins.int],
|
|
target_port: pulumi.Input[_builtins.int],
|
|
publish_mode: pulumi.Input[Optional[_builtins.str]] = None):
|
|
"""
|
|
The set of arguments for constructing a Port resource.
|
|
|
|
:param pulumi.Input[_builtins.str] application_id: Application this port belongs to.
|
|
:param pulumi.Input[_builtins.str] protocol: Transport protocol. Valid values: `tcp`, `udp`.
|
|
:param pulumi.Input[_builtins.int] published_port: Port exposed on the host.
|
|
:param pulumi.Input[_builtins.int] target_port: Port the container listens on.
|
|
:param pulumi.Input[_builtins.str] publish_mode: Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
|
|
"""
|
|
pulumi.set(__self__, "application_id", application_id)
|
|
pulumi.set(__self__, "protocol", protocol)
|
|
pulumi.set(__self__, "published_port", published_port)
|
|
pulumi.set(__self__, "target_port", target_port)
|
|
if publish_mode is not None:
|
|
pulumi.set(__self__, "publish_mode", publish_mode)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="applicationId")
|
|
def application_id(self) -> pulumi.Input[_builtins.str]:
|
|
"""
|
|
Application this port belongs to.
|
|
"""
|
|
return pulumi.get(self, "application_id")
|
|
|
|
@application_id.setter
|
|
def application_id(self, value: pulumi.Input[_builtins.str]):
|
|
pulumi.set(self, "application_id", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter
|
|
def protocol(self) -> pulumi.Input[_builtins.str]:
|
|
"""
|
|
Transport protocol. Valid values: `tcp`, `udp`.
|
|
"""
|
|
return pulumi.get(self, "protocol")
|
|
|
|
@protocol.setter
|
|
def protocol(self, value: pulumi.Input[_builtins.str]):
|
|
pulumi.set(self, "protocol", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="publishedPort")
|
|
def published_port(self) -> pulumi.Input[_builtins.int]:
|
|
"""
|
|
Port exposed on the host.
|
|
"""
|
|
return pulumi.get(self, "published_port")
|
|
|
|
@published_port.setter
|
|
def published_port(self, value: pulumi.Input[_builtins.int]):
|
|
pulumi.set(self, "published_port", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="targetPort")
|
|
def target_port(self) -> pulumi.Input[_builtins.int]:
|
|
"""
|
|
Port the container listens on.
|
|
"""
|
|
return pulumi.get(self, "target_port")
|
|
|
|
@target_port.setter
|
|
def target_port(self, value: pulumi.Input[_builtins.int]):
|
|
pulumi.set(self, "target_port", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="publishMode")
|
|
def publish_mode(self) -> pulumi.Input[Optional[_builtins.str]]:
|
|
"""
|
|
Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
|
|
"""
|
|
return pulumi.get(self, "publish_mode")
|
|
|
|
@publish_mode.setter
|
|
def publish_mode(self, value: pulumi.Input[Optional[_builtins.str]]):
|
|
pulumi.set(self, "publish_mode", value)
|
|
|
|
|
|
@pulumi.input_type
|
|
class _PortState:
|
|
def __init__(__self__, *,
|
|
application_id: pulumi.Input[Optional[_builtins.str]] = None,
|
|
protocol: pulumi.Input[Optional[_builtins.str]] = None,
|
|
publish_mode: pulumi.Input[Optional[_builtins.str]] = None,
|
|
published_port: pulumi.Input[Optional[_builtins.int]] = None,
|
|
target_port: pulumi.Input[Optional[_builtins.int]] = None):
|
|
"""
|
|
Input properties used for looking up and filtering Port resources.
|
|
|
|
:param pulumi.Input[_builtins.str] application_id: Application this port belongs to.
|
|
:param pulumi.Input[_builtins.str] protocol: Transport protocol. Valid values: `tcp`, `udp`.
|
|
:param pulumi.Input[_builtins.str] publish_mode: Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
|
|
:param pulumi.Input[_builtins.int] published_port: Port exposed on the host.
|
|
:param pulumi.Input[_builtins.int] target_port: Port the container listens on.
|
|
"""
|
|
if application_id is not None:
|
|
pulumi.set(__self__, "application_id", application_id)
|
|
if protocol is not None:
|
|
pulumi.set(__self__, "protocol", protocol)
|
|
if publish_mode is not None:
|
|
pulumi.set(__self__, "publish_mode", publish_mode)
|
|
if published_port is not None:
|
|
pulumi.set(__self__, "published_port", published_port)
|
|
if target_port is not None:
|
|
pulumi.set(__self__, "target_port", target_port)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="applicationId")
|
|
def application_id(self) -> pulumi.Input[Optional[_builtins.str]]:
|
|
"""
|
|
Application this port belongs to.
|
|
"""
|
|
return pulumi.get(self, "application_id")
|
|
|
|
@application_id.setter
|
|
def application_id(self, value: pulumi.Input[Optional[_builtins.str]]):
|
|
pulumi.set(self, "application_id", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter
|
|
def protocol(self) -> pulumi.Input[Optional[_builtins.str]]:
|
|
"""
|
|
Transport protocol. Valid values: `tcp`, `udp`.
|
|
"""
|
|
return pulumi.get(self, "protocol")
|
|
|
|
@protocol.setter
|
|
def protocol(self, value: pulumi.Input[Optional[_builtins.str]]):
|
|
pulumi.set(self, "protocol", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="publishMode")
|
|
def publish_mode(self) -> pulumi.Input[Optional[_builtins.str]]:
|
|
"""
|
|
Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
|
|
"""
|
|
return pulumi.get(self, "publish_mode")
|
|
|
|
@publish_mode.setter
|
|
def publish_mode(self, value: pulumi.Input[Optional[_builtins.str]]):
|
|
pulumi.set(self, "publish_mode", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="publishedPort")
|
|
def published_port(self) -> pulumi.Input[Optional[_builtins.int]]:
|
|
"""
|
|
Port exposed on the host.
|
|
"""
|
|
return pulumi.get(self, "published_port")
|
|
|
|
@published_port.setter
|
|
def published_port(self, value: pulumi.Input[Optional[_builtins.int]]):
|
|
pulumi.set(self, "published_port", value)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="targetPort")
|
|
def target_port(self) -> pulumi.Input[Optional[_builtins.int]]:
|
|
"""
|
|
Port the container listens on.
|
|
"""
|
|
return pulumi.get(self, "target_port")
|
|
|
|
@target_port.setter
|
|
def target_port(self, value: pulumi.Input[Optional[_builtins.int]]):
|
|
pulumi.set(self, "target_port", value)
|
|
|
|
|
|
@pulumi.type_token("dokploy:index/port:Port")
|
|
class Port(pulumi.CustomResource):
|
|
@overload
|
|
def __init__(__self__,
|
|
resource_name: str,
|
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
application_id: pulumi.Input[Optional[_builtins.str]] = None,
|
|
protocol: pulumi.Input[Optional[_builtins.str]] = None,
|
|
publish_mode: pulumi.Input[Optional[_builtins.str]] = None,
|
|
published_port: pulumi.Input[Optional[_builtins.int]] = None,
|
|
target_port: pulumi.Input[Optional[_builtins.int]] = None,
|
|
__props__=None):
|
|
"""
|
|
A published port that exposes an application directly on the host, bypassing Traefik.
|
|
|
|
|
|
:param str resource_name: The name of the resource.
|
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
:param pulumi.Input[_builtins.str] application_id: Application this port belongs to.
|
|
:param pulumi.Input[_builtins.str] protocol: Transport protocol. Valid values: `tcp`, `udp`.
|
|
:param pulumi.Input[_builtins.str] publish_mode: Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
|
|
:param pulumi.Input[_builtins.int] published_port: Port exposed on the host.
|
|
:param pulumi.Input[_builtins.int] target_port: Port the container listens on.
|
|
"""
|
|
...
|
|
@overload
|
|
def __init__(__self__,
|
|
resource_name: str,
|
|
args: PortArgs,
|
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
"""
|
|
A published port that exposes an application directly on the host, bypassing Traefik.
|
|
|
|
|
|
:param str resource_name: The name of the resource.
|
|
:param PortArgs args: The arguments to use to populate this resource's properties.
|
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
"""
|
|
...
|
|
def __init__(__self__, resource_name: str, *args, **kwargs):
|
|
resource_args, opts = _utilities.get_resource_args_opts(PortArgs, pulumi.ResourceOptions, *args, **kwargs)
|
|
if resource_args is not None:
|
|
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
|
|
else:
|
|
__self__._internal_init(resource_name, *args, **kwargs)
|
|
|
|
def _internal_init(__self__,
|
|
resource_name: str,
|
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
application_id: pulumi.Input[Optional[_builtins.str]] = None,
|
|
protocol: pulumi.Input[Optional[_builtins.str]] = None,
|
|
publish_mode: pulumi.Input[Optional[_builtins.str]] = None,
|
|
published_port: pulumi.Input[Optional[_builtins.int]] = None,
|
|
target_port: pulumi.Input[Optional[_builtins.int]] = None,
|
|
__props__=None):
|
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
raise TypeError('Expected resource options to be a ResourceOptions instance')
|
|
if opts.id is None:
|
|
if __props__ is not None:
|
|
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
__props__ = PortArgs.__new__(PortArgs)
|
|
|
|
if application_id is None and not opts.urn:
|
|
raise TypeError("Missing required property 'application_id'")
|
|
__props__.__dict__["application_id"] = application_id
|
|
if protocol is None and not opts.urn:
|
|
raise TypeError("Missing required property 'protocol'")
|
|
__props__.__dict__["protocol"] = protocol
|
|
__props__.__dict__["publish_mode"] = publish_mode
|
|
if published_port is None and not opts.urn:
|
|
raise TypeError("Missing required property 'published_port'")
|
|
__props__.__dict__["published_port"] = published_port
|
|
if target_port is None and not opts.urn:
|
|
raise TypeError("Missing required property 'target_port'")
|
|
__props__.__dict__["target_port"] = target_port
|
|
super(Port, __self__).__init__(
|
|
'dokploy:index/port:Port',
|
|
resource_name,
|
|
__props__,
|
|
opts)
|
|
|
|
@staticmethod
|
|
def get(resource_name: str,
|
|
id: pulumi.Input[str],
|
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
application_id: pulumi.Input[Optional[_builtins.str]] = None,
|
|
protocol: pulumi.Input[Optional[_builtins.str]] = None,
|
|
publish_mode: pulumi.Input[Optional[_builtins.str]] = None,
|
|
published_port: pulumi.Input[Optional[_builtins.int]] = None,
|
|
target_port: pulumi.Input[Optional[_builtins.int]] = None) -> 'Port':
|
|
"""
|
|
Get an existing Port resource's state with the given name, id, and optional extra
|
|
properties used to qualify the lookup.
|
|
|
|
:param str resource_name: The unique name of the resulting resource.
|
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
:param pulumi.Input[_builtins.str] application_id: Application this port belongs to.
|
|
:param pulumi.Input[_builtins.str] protocol: Transport protocol. Valid values: `tcp`, `udp`.
|
|
:param pulumi.Input[_builtins.str] publish_mode: Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
|
|
:param pulumi.Input[_builtins.int] published_port: Port exposed on the host.
|
|
:param pulumi.Input[_builtins.int] target_port: Port the container listens on.
|
|
"""
|
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
|
|
__props__ = _PortState.__new__(_PortState)
|
|
|
|
__props__.__dict__["application_id"] = application_id
|
|
__props__.__dict__["protocol"] = protocol
|
|
__props__.__dict__["publish_mode"] = publish_mode
|
|
__props__.__dict__["published_port"] = published_port
|
|
__props__.__dict__["target_port"] = target_port
|
|
return Port(resource_name, opts=opts, __props__=__props__)
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="applicationId")
|
|
def application_id(self) -> pulumi.Output[_builtins.str]:
|
|
"""
|
|
Application this port belongs to.
|
|
"""
|
|
return pulumi.get(self, "application_id")
|
|
|
|
@_builtins.property
|
|
@pulumi.getter
|
|
def protocol(self) -> pulumi.Output[_builtins.str]:
|
|
"""
|
|
Transport protocol. Valid values: `tcp`, `udp`.
|
|
"""
|
|
return pulumi.get(self, "protocol")
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="publishMode")
|
|
def publish_mode(self) -> pulumi.Output[_builtins.str]:
|
|
"""
|
|
Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
|
|
"""
|
|
return pulumi.get(self, "publish_mode")
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="publishedPort")
|
|
def published_port(self) -> pulumi.Output[_builtins.int]:
|
|
"""
|
|
Port exposed on the host.
|
|
"""
|
|
return pulumi.get(self, "published_port")
|
|
|
|
@_builtins.property
|
|
@pulumi.getter(name="targetPort")
|
|
def target_port(self) -> pulumi.Output[_builtins.int]:
|
|
"""
|
|
Port the container listens on.
|
|
"""
|
|
return pulumi.get(self, "target_port")
|
|
|