pulumi-tailscale 1.0.0a1770157009__tar.gz → 1.0.0a1770273225__tar.gz

{pulumi_tailscale-1.0.0a1770157009 → pulumi_tailscale-1.0.0a1770273225}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_tailscale
-Version: 1.0.0a1770157009
+Version: 1.0.0a1770273225
 Summary: A Pulumi package for creating and managing Tailscale cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_tailscale-1.0.0a1770157009 → pulumi_tailscale-1.0.0a1770273225}/pulumi_tailscale/acl.py

@@ -163,9 +163,9 @@ class Acl(pulumi.CustomResource):
             \\"grants\\": [
               {
                 // Allow all users access to all ports.
-                \\"src\\" = [\\"*\\"],
-                \\"dst\\" = [\\"*\\"],
-                \\"ip\\"  = [\\"*\\"],
+                \\"src\\": [\\"*\\"],
+                \\"dst\\": [\\"*\\"],
+                \\"ip\\": [\\"*\\"],
               },
             ],
           }
@@ -218,9 +218,9 @@ class Acl(pulumi.CustomResource):
             \\"grants\\": [
               {
                 // Allow all users access to all ports.
-                \\"src\\" = [\\"*\\"],
-                \\"dst\\" = [\\"*\\"],
-                \\"ip\\"  = [\\"*\\"],
+                \\"src\\": [\\"*\\"],
+                \\"dst\\": [\\"*\\"],
+                \\"ip\\": [\\"*\\"],
               },
             ],
           }

pulumi_tailscale-1.0.0a1770273225/pulumi_tailscale/get_device.py

@@ -0,0 +1,410 @@
+# 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__ = [
+    'GetDeviceResult',
+    'AwaitableGetDeviceResult',
+    'get_device',
+    'get_device_output',
+]
+
+@pulumi.output_type
+class GetDeviceResult:
+    """
+    A collection of values returned by getDevice.
+    """
+    def __init__(__self__, addresses=None, authorized=None, blocks_incoming_connections=None, client_version=None, created=None, expires=None, hostname=None, id=None, is_external=None, key_expiry_disabled=None, last_seen=None, machine_key=None, name=None, node_id=None, node_key=None, os=None, tags=None, tailnet_lock_error=None, tailnet_lock_key=None, update_available=None, user=None, wait_for=None):
+        if addresses and not isinstance(addresses, list):
+            raise TypeError("Expected argument 'addresses' to be a list")
+        pulumi.set(__self__, "addresses", addresses)
+        if authorized and not isinstance(authorized, bool):
+            raise TypeError("Expected argument 'authorized' to be a bool")
+        pulumi.set(__self__, "authorized", authorized)
+        if blocks_incoming_connections and not isinstance(blocks_incoming_connections, bool):
+            raise TypeError("Expected argument 'blocks_incoming_connections' to be a bool")
+        pulumi.set(__self__, "blocks_incoming_connections", blocks_incoming_connections)
+        if client_version and not isinstance(client_version, str):
+            raise TypeError("Expected argument 'client_version' to be a str")
+        pulumi.set(__self__, "client_version", client_version)
+        if created and not isinstance(created, str):
+            raise TypeError("Expected argument 'created' to be a str")
+        pulumi.set(__self__, "created", created)
+        if expires and not isinstance(expires, str):
+            raise TypeError("Expected argument 'expires' to be a str")
+        pulumi.set(__self__, "expires", expires)
+        if hostname and not isinstance(hostname, str):
+            raise TypeError("Expected argument 'hostname' to be a str")
+        pulumi.set(__self__, "hostname", hostname)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if is_external and not isinstance(is_external, bool):
+            raise TypeError("Expected argument 'is_external' to be a bool")
+        pulumi.set(__self__, "is_external", is_external)
+        if key_expiry_disabled and not isinstance(key_expiry_disabled, bool):
+            raise TypeError("Expected argument 'key_expiry_disabled' to be a bool")
+        pulumi.set(__self__, "key_expiry_disabled", key_expiry_disabled)
+        if last_seen and not isinstance(last_seen, str):
+            raise TypeError("Expected argument 'last_seen' to be a str")
+        pulumi.set(__self__, "last_seen", last_seen)
+        if machine_key and not isinstance(machine_key, str):
+            raise TypeError("Expected argument 'machine_key' to be a str")
+        pulumi.set(__self__, "machine_key", machine_key)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if node_id and not isinstance(node_id, str):
+            raise TypeError("Expected argument 'node_id' to be a str")
+        pulumi.set(__self__, "node_id", node_id)
+        if node_key and not isinstance(node_key, str):
+            raise TypeError("Expected argument 'node_key' to be a str")
+        pulumi.set(__self__, "node_key", node_key)
+        if os and not isinstance(os, str):
+            raise TypeError("Expected argument 'os' to be a str")
+        pulumi.set(__self__, "os", os)
+        if tags and not isinstance(tags, list):
+            raise TypeError("Expected argument 'tags' to be a list")
+        pulumi.set(__self__, "tags", tags)
+        if tailnet_lock_error and not isinstance(tailnet_lock_error, str):
+            raise TypeError("Expected argument 'tailnet_lock_error' to be a str")
+        pulumi.set(__self__, "tailnet_lock_error", tailnet_lock_error)
+        if tailnet_lock_key and not isinstance(tailnet_lock_key, str):
+            raise TypeError("Expected argument 'tailnet_lock_key' to be a str")
+        pulumi.set(__self__, "tailnet_lock_key", tailnet_lock_key)
+        if update_available and not isinstance(update_available, bool):
+            raise TypeError("Expected argument 'update_available' to be a bool")
+        pulumi.set(__self__, "update_available", update_available)
+        if user and not isinstance(user, str):
+            raise TypeError("Expected argument 'user' to be a str")
+        pulumi.set(__self__, "user", user)
+        if wait_for and not isinstance(wait_for, str):
+            raise TypeError("Expected argument 'wait_for' to be a str")
+        pulumi.set(__self__, "wait_for", wait_for)
+
+    @_builtins.property
+    @pulumi.getter
+    def addresses(self) -> Sequence[_builtins.str]:
+        """
+        The list of device's IPs
+        """
+        return pulumi.get(self, "addresses")
+
+    @_builtins.property
+    @pulumi.getter
+    def authorized(self) -> _builtins.bool:
+        """
+        Whether the device is authorized to access the tailnet
+        """
+        return pulumi.get(self, "authorized")
+
+    @_builtins.property
+    @pulumi.getter(name="blocksIncomingConnections")
+    def blocks_incoming_connections(self) -> _builtins.bool:
+        """
+        Whether the device blocks incoming connections
+        """
+        return pulumi.get(self, "blocks_incoming_connections")
+
+    @_builtins.property
+    @pulumi.getter(name="clientVersion")
+    def client_version(self) -> _builtins.str:
+        """
+        The Tailscale client version running on the device
+        """
+        return pulumi.get(self, "client_version")
+
+    @_builtins.property
+    @pulumi.getter
+    def created(self) -> _builtins.str:
+        """
+        The creation time of the device
+        """
+        return pulumi.get(self, "created")
+
+    @_builtins.property
+    @pulumi.getter
+    def expires(self) -> _builtins.str:
+        """
+        The expiry time of the device's key
+        """
+        return pulumi.get(self, "expires")
+
+    @_builtins.property
+    @pulumi.getter
+    def hostname(self) -> Optional[_builtins.str]:
+        """
+        The short hostname of the device
+        """
+        return pulumi.get(self, "hostname")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="isExternal")
+    def is_external(self) -> _builtins.bool:
+        """
+        Whether the device is marked as external
+        """
+        return pulumi.get(self, "is_external")
+
+    @_builtins.property
+    @pulumi.getter(name="keyExpiryDisabled")
+    def key_expiry_disabled(self) -> _builtins.bool:
+        """
+        Whether the device's key expiry is disabled
+        """
+        return pulumi.get(self, "key_expiry_disabled")
+
+    @_builtins.property
+    @pulumi.getter(name="lastSeen")
+    def last_seen(self) -> _builtins.str:
+        """
+        The last seen time of the device
+        """
+        return pulumi.get(self, "last_seen")
+
+    @_builtins.property
+    @pulumi.getter(name="machineKey")
+    def machine_key(self) -> _builtins.str:
+        """
+        The machine key of the device
+        """
+        return pulumi.get(self, "machine_key")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        The full name of the device (e.g. `hostname.domain.ts.net`)
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeId")
+    def node_id(self) -> _builtins.str:
+        """
+        The preferred indentifier for a device.
+        """
+        return pulumi.get(self, "node_id")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeKey")
+    def node_key(self) -> _builtins.str:
+        """
+        The node key of the device
+        """
+        return pulumi.get(self, "node_key")
+
+    @_builtins.property
+    @pulumi.getter
+    def os(self) -> _builtins.str:
+        """
+        The operating system of the device
+        """
+        return pulumi.get(self, "os")
+
+    @_builtins.property
+    @pulumi.getter
+    def tags(self) -> Sequence[_builtins.str]:
+        """
+        The tags applied to the device
+        """
+        return pulumi.get(self, "tags")
+
+    @_builtins.property
+    @pulumi.getter(name="tailnetLockError")
+    def tailnet_lock_error(self) -> _builtins.str:
+        """
+        The tailnet lock error for the device, if any
+        """
+        return pulumi.get(self, "tailnet_lock_error")
+
+    @_builtins.property
+    @pulumi.getter(name="tailnetLockKey")
+    def tailnet_lock_key(self) -> _builtins.str:
+        """
+        The tailnet lock key for the device, if any
+        """
+        return pulumi.get(self, "tailnet_lock_key")
+
+    @_builtins.property
+    @pulumi.getter(name="updateAvailable")
+    def update_available(self) -> _builtins.bool:
+        """
+        Whether an update is available for the device
+        """
+        return pulumi.get(self, "update_available")
+
+    @_builtins.property
+    @pulumi.getter
+    def user(self) -> _builtins.str:
+        """
+        The user associated with the device
+        """
+        return pulumi.get(self, "user")
+
+    @_builtins.property
+    @pulumi.getter(name="waitFor")
+    def wait_for(self) -> Optional[_builtins.str]:
+        """
+        If specified, the provider will make multiple attempts to obtain the data source until the wait_for duration is reached. Retries are made every second so this value should be greater than 1s
+        """
+        return pulumi.get(self, "wait_for")
+
+
+class AwaitableGetDeviceResult(GetDeviceResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetDeviceResult(
+            addresses=self.addresses,
+            authorized=self.authorized,
+            blocks_incoming_connections=self.blocks_incoming_connections,
+            client_version=self.client_version,
+            created=self.created,
+            expires=self.expires,
+            hostname=self.hostname,
+            id=self.id,
+            is_external=self.is_external,
+            key_expiry_disabled=self.key_expiry_disabled,
+            last_seen=self.last_seen,
+            machine_key=self.machine_key,
+            name=self.name,
+            node_id=self.node_id,
+            node_key=self.node_key,
+            os=self.os,
+            tags=self.tags,
+            tailnet_lock_error=self.tailnet_lock_error,
+            tailnet_lock_key=self.tailnet_lock_key,
+            update_available=self.update_available,
+            user=self.user,
+            wait_for=self.wait_for)
+
+
+def get_device(hostname: Optional[_builtins.str] = None,
+               name: Optional[_builtins.str] = None,
+               wait_for: Optional[_builtins.str] = None,
+               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDeviceResult:
+    """
+    The device data source describes a single device in a tailnet
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_tailscale as tailscale
+
+    sample_device = tailscale.get_device(name="device1.example.ts.net",
+        wait_for="60s")
+    sample_device2 = tailscale.get_device(hostname="device2",
+        wait_for="60s")
+    ```
+
+
+    :param _builtins.str hostname: The short hostname of the device
+    :param _builtins.str name: The full name of the device (e.g. `hostname.domain.ts.net`)
+    :param _builtins.str wait_for: If specified, the provider will make multiple attempts to obtain the data source until the wait_for duration is reached. Retries are made every second so this value should be greater than 1s
+    """
+    __args__ = dict()
+    __args__['hostname'] = hostname
+    __args__['name'] = name
+    __args__['waitFor'] = wait_for
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('tailscale:index/getDevice:getDevice', __args__, opts=opts, typ=GetDeviceResult).value
+
+    return AwaitableGetDeviceResult(
+        addresses=pulumi.get(__ret__, 'addresses'),
+        authorized=pulumi.get(__ret__, 'authorized'),
+        blocks_incoming_connections=pulumi.get(__ret__, 'blocks_incoming_connections'),
+        client_version=pulumi.get(__ret__, 'client_version'),
+        created=pulumi.get(__ret__, 'created'),
+        expires=pulumi.get(__ret__, 'expires'),
+        hostname=pulumi.get(__ret__, 'hostname'),
+        id=pulumi.get(__ret__, 'id'),
+        is_external=pulumi.get(__ret__, 'is_external'),
+        key_expiry_disabled=pulumi.get(__ret__, 'key_expiry_disabled'),
+        last_seen=pulumi.get(__ret__, 'last_seen'),
+        machine_key=pulumi.get(__ret__, 'machine_key'),
+        name=pulumi.get(__ret__, 'name'),
+        node_id=pulumi.get(__ret__, 'node_id'),
+        node_key=pulumi.get(__ret__, 'node_key'),
+        os=pulumi.get(__ret__, 'os'),
+        tags=pulumi.get(__ret__, 'tags'),
+        tailnet_lock_error=pulumi.get(__ret__, 'tailnet_lock_error'),
+        tailnet_lock_key=pulumi.get(__ret__, 'tailnet_lock_key'),
+        update_available=pulumi.get(__ret__, 'update_available'),
+        user=pulumi.get(__ret__, 'user'),
+        wait_for=pulumi.get(__ret__, 'wait_for'))
+def get_device_output(hostname: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                      name: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                      wait_for: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDeviceResult]:
+    """
+    The device data source describes a single device in a tailnet
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_tailscale as tailscale
+
+    sample_device = tailscale.get_device(name="device1.example.ts.net",
+        wait_for="60s")
+    sample_device2 = tailscale.get_device(hostname="device2",
+        wait_for="60s")
+    ```
+
+
+    :param _builtins.str hostname: The short hostname of the device
+    :param _builtins.str name: The full name of the device (e.g. `hostname.domain.ts.net`)
+    :param _builtins.str wait_for: If specified, the provider will make multiple attempts to obtain the data source until the wait_for duration is reached. Retries are made every second so this value should be greater than 1s
+    """
+    __args__ = dict()
+    __args__['hostname'] = hostname
+    __args__['name'] = name
+    __args__['waitFor'] = wait_for
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('tailscale:index/getDevice:getDevice', __args__, opts=opts, typ=GetDeviceResult)
+    return __ret__.apply(lambda __response__: GetDeviceResult(
+        addresses=pulumi.get(__response__, 'addresses'),
+        authorized=pulumi.get(__response__, 'authorized'),
+        blocks_incoming_connections=pulumi.get(__response__, 'blocks_incoming_connections'),
+        client_version=pulumi.get(__response__, 'client_version'),
+        created=pulumi.get(__response__, 'created'),
+        expires=pulumi.get(__response__, 'expires'),
+        hostname=pulumi.get(__response__, 'hostname'),
+        id=pulumi.get(__response__, 'id'),
+        is_external=pulumi.get(__response__, 'is_external'),
+        key_expiry_disabled=pulumi.get(__response__, 'key_expiry_disabled'),
+        last_seen=pulumi.get(__response__, 'last_seen'),
+        machine_key=pulumi.get(__response__, 'machine_key'),
+        name=pulumi.get(__response__, 'name'),
+        node_id=pulumi.get(__response__, 'node_id'),
+        node_key=pulumi.get(__response__, 'node_key'),
+        os=pulumi.get(__response__, 'os'),
+        tags=pulumi.get(__response__, 'tags'),
+        tailnet_lock_error=pulumi.get(__response__, 'tailnet_lock_error'),
+        tailnet_lock_key=pulumi.get(__response__, 'tailnet_lock_key'),
+        update_available=pulumi.get(__response__, 'update_available'),
+        user=pulumi.get(__response__, 'user'),
+        wait_for=pulumi.get(__response__, 'wait_for')))

{pulumi_tailscale-1.0.0a1770157009 → pulumi_tailscale-1.0.0a1770273225}/pulumi_tailscale/get_users.py

@@ -53,7 +53,7 @@ class GetUsersResult:
     @pulumi.getter
     def role(self) -> Optional[_builtins.str]:
         """
-        Filters the users list to elements whose role is the provided value.
+        Filter the results to only include users with a specific role. Valid values are `owner`, `member`, `admin`, `it-admin`, `network-admin`, `billing-admin`, and `auditor`.
         """
         return pulumi.get(self, "role")
 
@@ -61,7 +61,7 @@ class GetUsersResult:
     @pulumi.getter
     def type(self) -> Optional[_builtins.str]:
         """
-        Filters the users list to elements whose type is the provided value.
+        Filter the results to only include users of a specific type. Valid values are `member` or `shared`.
         """
         return pulumi.get(self, "type")
 
@@ -102,8 +102,8 @@ def get_users(role: Optional[_builtins.str] = None,
     ```
 
 
-    :param _builtins.str role: Filters the users list to elements whose role is the provided value.
-    :param _builtins.str type: Filters the users list to elements whose type is the provided value.
+    :param _builtins.str role: Filter the results to only include users with a specific role. Valid values are `owner`, `member`, `admin`, `it-admin`, `network-admin`, `billing-admin`, and `auditor`.
+    :param _builtins.str type: Filter the results to only include users of a specific type. Valid values are `member` or `shared`.
     """
     __args__ = dict()
     __args__['role'] = role
@@ -132,8 +132,8 @@ def get_users_output(role: Optional[pulumi.Input[Optional[_builtins.str]]] = Non
     ```
 
 
-    :param _builtins.str role: Filters the users list to elements whose role is the provided value.
-    :param _builtins.str type: Filters the users list to elements whose type is the provided value.
+    :param _builtins.str role: Filter the results to only include users with a specific role. Valid values are `owner`, `member`, `admin`, `it-admin`, `network-admin`, `billing-admin`, and `auditor`.
+    :param _builtins.str type: Filter the results to only include users of a specific type. Valid values are `member` or `shared`.
     """
     __args__ = dict()
     __args__['role'] = role