pulumi-openstack 5.4.0a1760596695__tar.gz → 5.5.0a1769713126__tar.gz

{pulumi_openstack-5.4.0a1760596695 → pulumi_openstack-5.5.0a1769713126}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_openstack
-Version: 5.4.0a1760596695
+Version: 5.5.0a1769713126
 Summary: A Pulumi package for creating and managing OpenStack cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_openstack-5.4.0a1760596695 → pulumi_openstack-5.5.0a1769713126}/pulumi_openstack/__init__.py

@@ -16,6 +16,7 @@ from .get_fw_rule_v2 import *
 from .lb_flavorprofile_v2 import *
 from .lb_loadbalancer_v2 import *
 from .provider import *
+from .taas_tap_mirror_v2 import *
 from .workflow_workflow_v2 import *
 from ._inputs import *
 from . import outputs
@@ -542,6 +543,14 @@ _utilities.register(
    "openstack:index/lbLoadbalancerV2:LbLoadbalancerV2": "LbLoadbalancerV2"
   }
  },
+ {
+  "pkg": "openstack",
+  "mod": "index/taasTapMirrorV2",
+  "fqn": "pulumi_openstack",
+  "classes": {
+   "openstack:index/taasTapMirrorV2:TaasTapMirrorV2": "TaasTapMirrorV2"
+  }
+ },
  {
   "pkg": "openstack",
   "mod": "keymanager/containerV1",

{pulumi_openstack-5.4.0a1760596695 → pulumi_openstack-5.5.0a1769713126}/pulumi_openstack/_inputs.py

@@ -17,6 +17,8 @@ from . import _utilities
 __all__ = [
     'BgpvpnPortAssociateV2RouteArgs',
     'BgpvpnPortAssociateV2RouteArgsDict',
+    'TaasTapMirrorV2DirectionsArgs',
+    'TaasTapMirrorV2DirectionsArgsDict',
 ]
 
 MYPY = False
@@ -127,3 +129,67 @@ class BgpvpnPortAssociateV2RouteArgs:
         pulumi.set(self, "prefix", value)
 
 
+if not MYPY:
+    class TaasTapMirrorV2DirectionsArgsDict(TypedDict):
+        in_: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Declares ingress traffic to the port will be mirrored. The value
+        is the identifier of the ERSPAN or GRE session between the source and destination,
+        this must be unique within the project.
+        """
+        out: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Declares egress traffic will be mirrored. The value is the
+        identifier of the ERSPAN or GRE session between the source and destination,
+        this must be unique within the project.
+        """
+elif False:
+    TaasTapMirrorV2DirectionsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TaasTapMirrorV2DirectionsArgs:
+    def __init__(__self__, *,
+                 in_: Optional[pulumi.Input[_builtins.int]] = None,
+                 out: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] in_: Declares ingress traffic to the port will be mirrored. The value
+               is the identifier of the ERSPAN or GRE session between the source and destination,
+               this must be unique within the project.
+        :param pulumi.Input[_builtins.int] out: Declares egress traffic will be mirrored. The value is the
+               identifier of the ERSPAN or GRE session between the source and destination,
+               this must be unique within the project.
+        """
+        if in_ is not None:
+            pulumi.set(__self__, "in_", in_)
+        if out is not None:
+            pulumi.set(__self__, "out", out)
+
+    @_builtins.property
+    @pulumi.getter(name="in")
+    def in_(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Declares ingress traffic to the port will be mirrored. The value
+        is the identifier of the ERSPAN or GRE session between the source and destination,
+        this must be unique within the project.
+        """
+        return pulumi.get(self, "in_")
+
+    @in_.setter
+    def in_(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "in_", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def out(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Declares egress traffic will be mirrored. The value is the
+        identifier of the ERSPAN or GRE session between the source and destination,
+        this must be unique within the project.
+        """
+        return pulumi.get(self, "out")
+
+    @out.setter
+    def out(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "out", value)
+
+

{pulumi_openstack-5.4.0a1760596695 → pulumi_openstack-5.5.0a1769713126}/pulumi_openstack/compute/interface_attach.py

@@ -285,6 +285,66 @@ class InterfaceAttach(pulumi.CustomResource):
             port_id=port1.id)
         ```
 
+        ### Attaching Multiple Interfaces
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        network1 = openstack.networking.Network("network_1",
+            name="network_1",
+            admin_state_up=True)
+        ports = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            ports.append(openstack.networking.Port(f"ports-{range['value']}",
+                name=std.format(input="port-%02d",
+                    args=[range["value"] + 1]).result,
+                network_id=network1.id,
+                admin_state_up=True))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        attachments = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            attachments.append(openstack.compute.InterfaceAttach(f"attachments-{range['value']}",
+                port_id=ports[range["value"]].id,
+                instance_id=instance1.id))
+        ```
+
+        Note that the above example will not guarantee that the ports are attached in
+        a deterministic manner. The ports will be attached in a seemingly random
+        order.
+
+        If you want to ensure that the ports are attached in a given order, create
+        explicit dependencies between the ports, such as:
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        network1 = openstack.networking.Network("network_1",
+            name="network_1",
+            admin_state_up=True)
+        ports = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            ports.append(openstack.networking.Port(f"ports-{range['value']}",
+                name=std.format(input="port-%02d",
+                    args=[range["value"] + 1]).result,
+                network_id=network1.id,
+                admin_state_up=True))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        ai1 = openstack.compute.InterfaceAttach("ai_1",
+            instance_id=instance1.id,
+            port_id=ports[0].id)
+        ai2 = openstack.compute.InterfaceAttach("ai_2",
+            instance_id=instance1.id,
+            port_id=ports[1].id)
+        ```
+
         ## Import
 
         Interface Attachments can be imported using the Instance ID and Port ID
@@ -375,6 +435,66 @@ class InterfaceAttach(pulumi.CustomResource):
             port_id=port1.id)
         ```
 
+        ### Attaching Multiple Interfaces
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        network1 = openstack.networking.Network("network_1",
+            name="network_1",
+            admin_state_up=True)
+        ports = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            ports.append(openstack.networking.Port(f"ports-{range['value']}",
+                name=std.format(input="port-%02d",
+                    args=[range["value"] + 1]).result,
+                network_id=network1.id,
+                admin_state_up=True))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        attachments = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            attachments.append(openstack.compute.InterfaceAttach(f"attachments-{range['value']}",
+                port_id=ports[range["value"]].id,
+                instance_id=instance1.id))
+        ```
+
+        Note that the above example will not guarantee that the ports are attached in
+        a deterministic manner. The ports will be attached in a seemingly random
+        order.
+
+        If you want to ensure that the ports are attached in a given order, create
+        explicit dependencies between the ports, such as:
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        network1 = openstack.networking.Network("network_1",
+            name="network_1",
+            admin_state_up=True)
+        ports = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            ports.append(openstack.networking.Port(f"ports-{range['value']}",
+                name=std.format(input="port-%02d",
+                    args=[range["value"] + 1]).result,
+                network_id=network1.id,
+                admin_state_up=True))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        ai1 = openstack.compute.InterfaceAttach("ai_1",
+            instance_id=instance1.id,
+            port_id=ports[0].id)
+        ai2 = openstack.compute.InterfaceAttach("ai_2",
+            instance_id=instance1.id,
+            port_id=ports[1].id)
+        ```
+
         ## Import
 
         Interface Attachments can be imported using the Instance ID and Port ID

{pulumi_openstack-5.4.0a1760596695 → pulumi_openstack-5.5.0a1769713126}/pulumi_openstack/compute/volume_attach.py

@@ -309,6 +309,61 @@ class VolumeAttach(pulumi.CustomResource):
             volume_id=volume1.id)
         ```
 
+        ### Attaching multiple volumes to a single instance
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        volumes = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            volumes.append(openstack.blockstorage.Volume(f"volumes-{range['value']}",
+                name=std.format(input="vol-%02d",
+                    args=[range["value"] + 1]).result,
+                size=1))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        attachments = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            attachments.append(openstack.compute.VolumeAttach(f"attachments-{range['value']}",
+                instance_id=instance1.id,
+                volume_id=volumes[range["value"]].id))
+        pulumi.export("volumeDevices", [__item.device for __item in attachments])
+        ```
+
+        Note that the above example will not guarantee that the volumes are attached in
+        a deterministic manner. The volumes will be attached in a seemingly random
+        order.
+
+        If you want to ensure that the volumes are attached in a given order, create
+        explicit dependencies between the volumes, such as:
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        volumes = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            volumes.append(openstack.blockstorage.Volume(f"volumes-{range['value']}",
+                name=std.format(input="vol-%02d",
+                    args=[range["value"] + 1]).result,
+                size=1))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        attach1 = openstack.compute.VolumeAttach("attach_1",
+            instance_id=instance1.id,
+            volume_id=volumes[0].id)
+        attach2 = openstack.compute.VolumeAttach("attach_2",
+            instance_id=instance1.id,
+            volume_id=volumes[1].id,
+            opts = pulumi.ResourceOptions(depends_on=[attach1]))
+        pulumi.export("volumeDevices", [__item["device"] for __item in attachments])
+        ```
+
         ### Using Multiattach-enabled volumes
 
         Multiattach Volumes are dependent upon your OpenStack cloud and not all
@@ -395,6 +450,61 @@ class VolumeAttach(pulumi.CustomResource):
             volume_id=volume1.id)
         ```
 
+        ### Attaching multiple volumes to a single instance
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        volumes = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            volumes.append(openstack.blockstorage.Volume(f"volumes-{range['value']}",
+                name=std.format(input="vol-%02d",
+                    args=[range["value"] + 1]).result,
+                size=1))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        attachments = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            attachments.append(openstack.compute.VolumeAttach(f"attachments-{range['value']}",
+                instance_id=instance1.id,
+                volume_id=volumes[range["value"]].id))
+        pulumi.export("volumeDevices", [__item.device for __item in attachments])
+        ```
+
+        Note that the above example will not guarantee that the volumes are attached in
+        a deterministic manner. The volumes will be attached in a seemingly random
+        order.
+
+        If you want to ensure that the volumes are attached in a given order, create
+        explicit dependencies between the volumes, such as:
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        volumes = []
+        for range in [{"value": i} for i in range(0, 2)]:
+            volumes.append(openstack.blockstorage.Volume(f"volumes-{range['value']}",
+                name=std.format(input="vol-%02d",
+                    args=[range["value"] + 1]).result,
+                size=1))
+        instance1 = openstack.compute.Instance("instance_1",
+            name="instance_1",
+            security_groups=["default"])
+        attach1 = openstack.compute.VolumeAttach("attach_1",
+            instance_id=instance1.id,
+            volume_id=volumes[0].id)
+        attach2 = openstack.compute.VolumeAttach("attach_2",
+            instance_id=instance1.id,
+            volume_id=volumes[1].id,
+            opts = pulumi.ResourceOptions(depends_on=[attach1]))
+        pulumi.export("volumeDevices", [__item["device"] for __item in attachments])
+        ```
+
         ### Using Multiattach-enabled volumes
 
         Multiattach Volumes are dependent upon your OpenStack cloud and not all

{pulumi_openstack-5.4.0a1760596695 → pulumi_openstack-5.5.0a1769713126}/pulumi_openstack/keymanager/secret_v1.py

@@ -618,6 +618,23 @@ class SecretV1(pulumi.CustomResource):
             payload_content_encoding="base64")
         ```
 
+        ### Secret with the expiration date
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        secret1 = openstack.keymanager.SecretV1("secret_1",
+            name="certificate",
+            payload=std.file(input="certificate.pem").result,
+            secret_type="certificate",
+            payload_content_type="text/plain",
+            expiration=std.timeadd(duration=std.timestamp().result,
+                timestamp=std.format(input="%dh",
+                    args=[8760]).result).result)
+        ```
+
         ### Secret with the ACL
 
         > **Note** Only read ACLs are supported
@@ -721,6 +738,23 @@ class SecretV1(pulumi.CustomResource):
             payload_content_encoding="base64")
         ```
 
+        ### Secret with the expiration date
+
+        ```python
+        import pulumi
+        import pulumi_openstack as openstack
+        import pulumi_std as std
+
+        secret1 = openstack.keymanager.SecretV1("secret_1",
+            name="certificate",
+            payload=std.file(input="certificate.pem").result,
+            secret_type="certificate",
+            payload_content_type="text/plain",
+            expiration=std.timeadd(duration=std.timestamp().result,
+                timestamp=std.format(input="%dh",
+                    args=[8760]).result).result)
+        ```
+
         ### Secret with the ACL
 
         > **Note** Only read ACLs are supported

{pulumi_openstack-5.4.0a1760596695 → pulumi_openstack-5.5.0a1769713126}/pulumi_openstack/loadbalancer/__init__.py

@@ -11,6 +11,9 @@ from .flavorprofile_v2 import *
 from .get_flavor_v2 import *
 from .get_flavorprofile_v2 import *
 from .get_lb_flavor_deprecated import *
+from .get_listener_v2 import *
+from .get_loadbalancer_v2 import *
+from .get_pool_v2 import *
 from .l7_policy_v2 import *
 from .l7_rule_v2 import *
 from .listener import *