inmanta-module-openstack 5.1.0__tar.gz → 5.1.1__tar.gz

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inmanta-module-openstack
-Version: 5.1.0
+Version: 5.1.1
 License: Apache 2.0
 Requires-Dist: inmanta-module-ssh
 Requires-Dist: inmanta-module-std

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/inmanta_module_openstack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inmanta-module-openstack
-Version: 5.1.0
+Version: 5.1.1
 License: Apache 2.0
 Requires-Dist: inmanta-module-ssh
 Requires-Dist: inmanta-module-std

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/inmanta_module_openstack.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ tests/test_dependency_handling.py
 tests/test_examples.py
 tests/test_flavor.py
 tests/test_host_aggregate.py
+tests/test_host_port_fixed_ips.py
 tests/test_host_port_security_groups.py
 tests/test_image.py
 tests/test_keystone.py

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/inmanta_plugins/openstack/compute/host_port.py

@@ -16,6 +16,8 @@ limitations under the License.
 Contact: code@inmanta.com
 """
 
+import ipaddress
+import json
 import time
 from typing import Optional
 
@@ -35,7 +37,7 @@ from inmanta_plugins.openstack.common.base import (
 @resource("openstack::HostPort", agent="provider.name", id_attribute="name")
 class HostPort(Port):
     """
-    A port in a router
+    A port attached to a VM.
     """
 
     fields = (
@@ -48,6 +50,7 @@ class HostPort(Port):
         "allowed_address_pairs",
         "wait_for_vm",
         "security_groups",
+        "address_v6",
     )
     host: str
     portsecurity: bool
@@ -58,6 +61,21 @@ class HostPort(Port):
     allowed_address_pairs: dict[str, Optional[str]]
     wait_for_vm: bool
     security_groups: list[str]
+    address_v6: Optional[str]
+
+    @staticmethod
+    def get_address(_, port):
+        try:
+            return port.address
+        except ast.OptionalValueException:
+            return None
+
+    @staticmethod
+    def get_address_v6(_, port):
+        try:
+            return port.address_v6
+        except ast.OptionalValueException:
+            return None
 
     @staticmethod
     def get_host(_, port):
@@ -86,6 +104,11 @@ class HostPort(Port):
 
 @provider("openstack::HostPort", name="openstack")
 class HostPortHandler(OpenStackHandler):
+    """
+    Manage a neutron port on a VM. Its ``subnet`` relation may be an IPv4 or an
+    IPv6 (``SubnetBase``) subnet, so a port can live on an IPv6-only network.
+    """
+
     def _get_port(self, ctx, network_id, device_id):
         """
         Retrieve a port attached to a given device (VM) on a specific network.
@@ -119,10 +142,13 @@ class HostPortHandler(OpenStackHandler):
                 if vm_state == "active":
                     return vm
                 else:
-                    ctx.info(
-                        "VM for port is not in active state, but %(state)s. Waiting and retrying in 5 seconds.",
-                        state=vm_state,
-                    )
+                    if resource.wait_for_vm:
+                        ctx.info(
+                            "VM for port is not in active state, but %(state)s. Waiting and retrying in 5 seconds.",
+                            state=vm_state,
+                        )
+                    else:
+                        raise ResourcePurged()
             else:
                 if not resource.wait_for_vm:
                     # Vm doesn't exist, so we can assume this port doesn't exist either
@@ -165,21 +191,17 @@ class HostPortHandler(OpenStackHandler):
             raise ResourcePurged()
 
         resource.purged = False
-        if resource.address and self.port.fixed_ips:
-            resource.address = self.port.fixed_ips[0]["ip_address"]
-
-        if self.port.fixed_ips:
-            subnet_id = self.port.fixed_ips[0]["subnet_id"]
-            subnet = self.get_subnet(None, subnet_id=subnet_id)
-            if subnet is None:
-                ctx.warning(
-                    f"Unable to find the name of the subnet with id {subnet_id} "
-                    f"for port {self.port.id} with ip {self.port.fixed_ips[0]['ip_address']}"
-                )
-            else:
-                resource.subnet = subnet.name
-        else:
-            resource.subnet = ""
+
+        # A fixed ip is pinned at creation and exposed through the fixed_ips fact; it is
+        # not reflected back into the resource, as reflecting it would surface a spurious
+        # diff on an address the handler does not reconcile. The one exception is a
+        # statically requested IPv6: a dual-stack port boots with only its IPv4 (a boot
+        # NIC holds a single fixed_ip), so drive an update when the requested address is
+        # not already assigned. Test for that exact address (a port may carry several
+        # IPv6, e.g. an extra subnet or a SLAAC address) and leave the attribute alone
+        # when no IPv6 was requested, so an auto-assigned address is not seen as a change.
+        if resource.address_v6 and not self._has_fixed_ip(resource.address_v6):
+            resource.address_v6 = None
 
         resource.portsecurity = self.port.is_port_security_enabled
 
@@ -216,10 +238,17 @@ class HostPortHandler(OpenStackHandler):
             "project_id": self.project_id,
         }
 
-        if resource.address and not resource.dhcp:
-            port_attrs["fixed_ips"] = [
-                {"subnet_id": subnet.id, "ip_address": resource.address}
-            ]
+        if not resource.dhcp:
+            fixed_ips = []
+            if resource.address:
+                fixed_ips.append(
+                    {"subnet_id": subnet.id, "ip_address": resource.address}
+                )
+            if resource.address_v6:
+                # No subnet_id: neutron allocates from the matching IPv6 subnet
+                fixed_ips.append({"ip_address": resource.address_v6})
+            if fixed_ips:
+                port_attrs["fixed_ips"] = fixed_ips
 
         port_attrs["port_security_enabled"] = resource.portsecurity
         if resource.security_groups:
@@ -268,7 +297,13 @@ class HostPortHandler(OpenStackHandler):
     ) -> None:
         self.validate_allowed_fields(
             changes,
-            {"portsecurity", "name", "allowed_address_pairs", "security_groups"},
+            {
+                "portsecurity",
+                "name",
+                "allowed_address_pairs",
+                "security_groups",
+                "address_v6",
+            },
         )
 
         disabling_portsecurity = (
@@ -299,18 +334,41 @@ class HostPortHandler(OpenStackHandler):
             ]
             self.port.allowed_address_pairs = allowed_address_pairs
 
+        if "address_v6" in changes:
+            # The requested IPv6 is not on the port (a dual-stack port boots with only
+            # its IPv4). Add it, keeping the existing v4 and any other assigned ips;
+            # neutron picks the matching subnet. Updating fixed_ips does not move the
+            # port's interface, so its boot-time ordering is preserved.
+            self.port.fixed_ips = list(self.port.fixed_ips) + [
+                {"ip_address": resource.address_v6}
+            ]
+
         try:
             self.port = self._connection.network.update_port(self.port)
         except openstack.exceptions.ConflictException as e:
             raise SkipResource(f"Port is not ready: {e}")
+
+        # The fixed ips may have changed; re-report the fixed_ips fact for this deploy.
+        self._set_facts(ctx)
         ctx.set_updated()
 
-    def _set_facts(self, ctx):
-        for i, ip in enumerate(self.port.fixed_ips):
-            if i > 1:
-                # report only additional ip addresses not present in model
-                ctx.set_fact(f"ip_address_{i}", ip["ip_address"], expires=True)
+    def _has_fixed_ip(self, address: str) -> bool:
+        """Whether the neutron port already has ``address`` as a fixed ip.
+
+        Compares normalised addresses so equivalent textual forms of the same IPv6
+        (e.g. ``2001:db8::1`` and ``2001:0db8::0001``) are treated as equal.
+        """
+        target = ipaddress.ip_address(address)
+        return any(
+            ipaddress.ip_address(ip["ip_address"]) == target
+            for ip in self.port.fixed_ips
+        )
 
+    def _set_facts(self, ctx):
+        # Report every assigned ip as a plain list of addresses. This is the only channel
+        # exposing IPv6 and pool-assigned addresses, which the model cannot hold.
+        fixed_ips = [ip["ip_address"] for ip in self.port.fixed_ips]
+        ctx.set_fact("fixed_ips", json.dumps(fixed_ips), expires=True)
         ctx.set_fact("mac_address", self.port.mac_address, expires=True)
         ctx.set_fact("port_id", self.port.id, expires=False)
 

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/inmanta_plugins/openstack/compute/virtual_machine.py

@@ -20,6 +20,7 @@ import time
 import traceback
 from typing import Any
 
+from inmanta import ast
 from inmanta.agent.handler import (
     HandlerContext,
     ResourcePurged,
@@ -29,7 +30,7 @@ from inmanta.agent.handler import (
 )
 from inmanta.execute import proxy
 from inmanta.resources import resource
-from openstack.exceptions import ResourceFailure, ResourceTimeout
+from openstack.exceptions import NotFoundException, ResourceFailure, ResourceTimeout
 
 from inmanta_plugins.openstack.common.base import (
     NotUniqueException,
@@ -47,6 +48,7 @@ class VirtualMachine(OpenstackResource):
     fields = (
         "name",
         "flavor",
+        "flavor_spec",
         "image",
         "key_name",
         "user_data",
@@ -61,6 +63,7 @@ class VirtualMachine(OpenstackResource):
     )
     name: str
     flavor: str
+    flavor_spec: dict[str, int] | None
     image: str
     key_name: str
     user_data: str
@@ -73,6 +76,25 @@ class VirtualMachine(OpenstackResource):
     availability_zone: str | None
     block_devices: list[dict]
 
+    @staticmethod
+    def get_flavor_spec(_, vm):
+        """Resources of the linked flavor, used to detect a redefined flavor.
+
+        Returns None when no flavor relation is set; in that case the handler
+        only compares flavor names and does not resize on a content change.
+        """
+        try:
+            flavor = vm.flavor_rel
+        except ast.OptionalValueException:
+            return None
+        return {
+            "ram": flavor.ram,
+            "vcpus": flavor.vcpus,
+            "disk": flavor.disk,
+            "ephemeral": flavor.ephemeral,
+            "swap": flavor.swap,
+        }
+
     @staticmethod
     def get_key_name(exporter, vm):
         return vm.key_pair.name
@@ -100,13 +122,18 @@ class VirtualMachine(OpenstackResource):
             port = {
                 "name": p.name,
                 "address": None,
+                "address_v6": None,
                 "network": p.subnet.name,
                 "dhcp": p.dhcp,
                 "index": p.port_index,
             }
             try:
                 port["address"] = p.address
-            except proxy.UnknownException:
+            except (proxy.UnknownException, ast.OptionalValueException):
+                pass
+            try:
+                port["address_v6"] = p.address_v6
+            except (proxy.UnknownException, ast.OptionalValueException):
                 pass
             ports.append(port)
 
@@ -176,8 +203,13 @@ class VirtualMachineHandler(OpenStackHandler):
             if network is None:
                 raise SkipResource(f"Network {port['network']} not found")
             nic = {"uuid": network}
+            # A boot NIC carries a single fixed_ip. A dual-stack port boots with its
+            # IPv4 here (preserving its port_index slot); the HostPort handler adds the
+            # IPv6 to the same port afterwards via update_port, which keeps the slot.
             if port["address"] is not None:
                 nic["fixed_ip"] = port["address"]
+            elif port["address_v6"] is not None:
+                nic["fixed_ip"] = port["address_v6"]
         else:
             nic["port"] = port_id
 
@@ -245,29 +277,111 @@ class VirtualMachineHandler(OpenStackHandler):
             f"Server {self.server.id} ({self.server.name}) is in ERROR state: {msg}"
         ) from None
 
-    def _wait_for_active(self, ctx: HandlerContext, timeout: int = 600) -> None:
-        """Wait for self.server to reach ACTIVE, raise on ERROR or timeout."""
+    def _wait_for_status(
+        self,
+        ctx: HandlerContext,
+        status: str,
+        operation: str,
+        timeout: int = 600,
+    ) -> None:
+        """Wait for self.server to reach `status`, raise on ERROR or timeout.
+
+        `operation` describes the action in progress (e.g. "build" or "resize")
+        and is only used to build the error messages.
+
+        Nova may briefly return a 404 for the instance while a resize is being
+        applied; such transient NotFoundException errors are tolerated and polling
+        resumes until the status is reached or the timeout elapses.
+        """
+        deadline = time.monotonic() + timeout
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                self._raise_status_timeout(ctx, status, timeout)
+            try:
+                self.server = self._connection.compute.wait_for_server(
+                    self.server, status=status, wait=max(1, int(remaining))
+                )
+                return
+            except ResourceFailure:
+                self._raise_server_error(
+                    ctx, f"VM entered ERROR state during {operation}"
+                )
+            except ResourceTimeout:
+                self._raise_status_timeout(ctx, status, timeout)
+            except NotFoundException:
+                # The instance is temporarily not retrievable (e.g. mid-resize);
+                # give it a moment and keep polling until the deadline.
+                time.sleep(2)
+
+    def _raise_status_timeout(
+        self, ctx: HandlerContext, status: str, timeout: int
+    ) -> None:
         try:
-            self.server = self._connection.compute.wait_for_server(
-                self.server, wait=timeout
-            )
-        except ResourceFailure:
-            self._raise_server_error(ctx, "VM entered ERROR state during build")
-        except ResourceTimeout:
             server = self._connection.compute.get_server(self.server.id)
-            status = getattr(server, "status", "unknown")
+            current_status = getattr(server, "status", "unknown")
             task_state = getattr(server, "task_state", "unknown")
-            ctx.error(
-                "Timed out waiting for VM to become ACTIVE",
-                timeout_seconds=timeout,
-                current_status=status,
-                current_task_state=task_state,
-                server_id=self.server.id,
-            )
-            raise Exception(
-                f"Server {self.server.id} did not reach ACTIVE within {timeout}s "
-                f"(status={status}, task_state={task_state})"
-            ) from None
+        except NotFoundException:
+            current_status = "not_found"
+            task_state = "unknown"
+        ctx.error(
+            f"Timed out waiting for VM to reach {status}",
+            timeout_seconds=timeout,
+            current_status=current_status,
+            current_task_state=task_state,
+            server_id=self.server.id,
+        )
+        raise Exception(
+            f"Server {self.server.id} did not reach {status} within {timeout}s "
+            f"(status={current_status}, task_state={task_state})"
+        ) from None
+
+    def _get_server_flavor_name(self, server) -> str:
+        """Return the flavor name of `server`.
+
+        Depending on the negotiated Nova microversion the flavor embedded in a
+        server may only carry its id, so fall back to resolving the flavor by id.
+        """
+        flavor = server.flavor
+        if flavor.original_name:
+            return flavor.original_name
+        return self._connection.compute.get_flavor(flavor.id).name
+
+    def _get_server_flavor_spec(self, server) -> dict[str, int]:
+        """Return the resources `server` is actually running with.
+
+        Mirrors _get_server_flavor_name: recent Nova microversions embed the full
+        flavor spec in the server, older ones only its id, so resolve by id then.
+        The keys match those exported by VirtualMachine.get_flavor_spec.
+        """
+        flavor = server.flavor
+        if not flavor.original_name:
+            flavor = self._connection.compute.get_flavor(flavor.id)
+        return {
+            "ram": flavor.ram,
+            "vcpus": flavor.vcpus,
+            "disk": flavor.disk,
+            "ephemeral": getattr(flavor, "ephemeral", 0) or 0,
+            "swap": getattr(flavor, "swap", 0) or 0,
+        }
+
+    def _resize_server(
+        self, ctx: HandlerContext, resource: VirtualMachine, flavor_name: str
+    ) -> None:
+        """Resize self.server to the flavor named `flavor_name` and confirm it."""
+        flavor = self._connection.compute.find_flavor(flavor_name, ignore_missing=False)
+        # Confirming a resize returns the server to the status it had before,
+        # so remember it to know what to wait for afterwards.
+        original_status = self.server.status
+        ctx.info(
+            f"Resizing server {resource.name} to flavor {flavor_name}",
+            flavor_id=flavor.id,
+        )
+        self._connection.compute.resize_server(self.server, flavor.id)
+        # A resize must be explicitly confirmed once the server reports VERIFY_RESIZE.
+        self._wait_for_status(ctx, "VERIFY_RESIZE", "resize")
+        self._connection.compute.confirm_server_resize(self.server)
+        self._wait_for_status(ctx, original_status, "resize")
 
     def read_resource(self, ctx: HandlerContext, resource: VirtualMachine) -> None:
         """
@@ -278,12 +392,16 @@ class VirtualMachineHandler(OpenStackHandler):
         if self.server is None:
             raise ResourcePurged()
 
-        if self.server.status == "ERROR":
-            self._raise_server_error(
-                ctx, "Server is in ERROR state; delete it to allow redeployment"
-            )
-
         resource.purged = False
+        # Reflect the live flavor so a flavor change in the model is detected as
+        # drift and handled by update_resource through a resize.
+        resource.flavor = self._get_server_flavor_name(self.server)
+        # When the VM is linked to a managed flavor, also reflect the resources it
+        # is currently running with. This makes a flavor that was redefined under
+        # the same name (e.g. deleted and recreated with more RAM) show up as drift
+        # even though its name is unchanged.
+        if resource.flavor_spec is not None:
+            resource.flavor_spec = self._get_server_flavor_spec(self.server)
         if resource.security_groups:
             # An empty relation leaves the server-level security groups unmanaged, so port
             # security groups (managed through neutron) can be used for fine-grained control
@@ -335,7 +453,7 @@ class VirtualMachineHandler(OpenStackHandler):
         )
 
         self.server = self._connection.compute.create_server(**args)
-        self._wait_for_active(ctx)
+        self._wait_for_status(ctx, "ACTIVE", "build")
 
         self._set_facts(ctx)
         # Note: attach/detach of interfaces handled by Neutron or by passing ports at creation time
@@ -365,9 +483,23 @@ class VirtualMachineHandler(OpenStackHandler):
     def update_resource(
         self, ctx: HandlerContext, changes: dict, resource: VirtualMachine
     ) -> None:
-        self.validate_allowed_fields(changes, {"security_groups", "key_name"})
+
+        if self.server.status == "ERROR":
+            self._raise_server_error(
+                ctx, "Server is in ERROR state; delete it to allow redeployment"
+            )
+
+        self.validate_allowed_fields(
+            changes, {"security_groups", "key_name", "flavor", "flavor_spec"}
+        )
 
         self._ensure_key(ctx, resource)
+
+        # A change to either the flavor name or, for a flavor-linked VM, the flavor
+        # resources both translate to an in-place resize to the desired flavor.
+        if "flavor" in changes or "flavor_spec" in changes:
+            self._resize_server(ctx, resource, resource.flavor)
+
         if "security_groups" in changes:
             current = set(changes["security_groups"]["current"])
             desired = set(changes["security_groups"]["desired"])

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/inmanta_plugins/openstack/model/_init.cf

@@ -350,6 +350,10 @@ entity HostPort extends Port:
         A port attached to a VM
 
         :param name: The name of the host port.
+        :param address: An optional fixed IPv4 to request. When omitted neutron assigns one; leave unset
+                        for an IPv6-only port. Ignored when dhcp is true.
+        :param address_v6: An optional fixed IPv6 to request from an IPv6 subnet on the port's network.
+                           When omitted no IPv6 is requested. Ignored when dhcp is true.
         :param portsecurity: Enable or disable port security (security groups and spoofing filters)
         :param dhcp: Enable dhcp for this port or not for this port
         :param port_index: The index of the port. This determines the order of the interfaces on the virtual machine. 0 means no specific order.
@@ -357,7 +361,8 @@ entity HostPort extends Port:
                         speed up deployments, the handler can retry this number of times before skipping the resource.
         :param wait: The number of seconds to wait between retries.
     """
-    std::ipv4_address address
+    std::ipv4_address? address = null
+    std::ipv6_address? address_v6 = null
     bool portsecurity=true
     bool dhcp=true
     int port_index=0
@@ -376,7 +381,7 @@ end
 implement HostPort using providerRequire
 implement HostPort using noSecurityGroupsWhenPortSecurityDisabled when not self.portsecurity
 
-HostPort.subnet [1] -- Subnet.host_ports [0:]
+HostPort.subnet [1] -- SubnetBase.host_ports [0:]
 HostPort.vm [1] -- VirtualMachine.ports [0:]
 
 index HostPort(provider, vm, name)
@@ -510,9 +515,16 @@ entity NetworkPort extends Port:
         :attr portsecurity: Enable or disable port security (security groups and spoofing filters).
         :attr address: An optional fixed ip address for the port. When omitted, neutron
                        assigns one from the network. When set, a subnet must be provided.
+        :attr mac_address: An optional MAC address for the port. When omitted, neutron
+                       assigns one. It is typed as a plain string (not the ``mac_addr``
+                       typedef) so it can hold a fact reference resolved at deploy time,
+                       e.g. ``future::std::create_fact_reference(parent_port, "mac_address")``
+                       to make a trunk sub-port share its parent port's MAC. Set only at
+                       creation; neutron does not allow changing it afterwards.
     """
     bool portsecurity=true
     std::ipv4_address? address=null
+    string? mac_address=null
 end
 
 index NetworkPort(project, name)
@@ -713,14 +725,25 @@ entity VirtualMachine extends OpenStackResource, VMAttributes:
     string name
 end
 
-implement VirtualMachine using providerRequire
-
 index VirtualMachine(provider, name)
 
 VirtualMachine.eth0_port [1] -- HostPort
 VirtualMachine.key_pair [1] -- ssh::Key
 VirtualMachine.project [1] -- Project
 VirtualMachine.provider [1] -- Provider.virtual_machines [0:]
+# Optional link to the managed Flavor backing this VM. When set, the flavor name
+# is derived from it and the handler compares the flavor's resources against what
+# the VM is actually running, so a flavor recreated with different resources under
+# the same name is detected as drift and applied as an in-place resize.
+VirtualMachine.flavor_rel [0:1] -- Flavor
+
+implementation flavorFromRelation for VirtualMachine:
+    self.flavor = self.flavor_rel.name
+    self.requires += self.flavor_rel
+end
+
+implement VirtualMachine using providerRequire
+implement VirtualMachine using flavorFromRelation when flavor_rel is defined
 
 entity Host extends std::Host, VMAttributes:
     """

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/inmanta_plugins/openstack/network/network_port.py

@@ -35,12 +35,13 @@ class NetworkPort(OpenstackResource):
     A standalone neutron port, not bound to a router or a virtual machine
     """
 
-    fields = ("name", "portsecurity", "address", "network", "subnet")
+    fields = ("name", "portsecurity", "address", "network", "subnet", "mac_address")
     name: str
     portsecurity: bool
     address: Optional[str]
     network: str
     subnet: Optional[str]
+    mac_address: Optional[str]
 
     @staticmethod
     def get_network(_, port):
@@ -96,6 +97,14 @@ class NetworkPortHandler(OpenStackHandler):
             resource.address = None
             resource.subnet = None
 
+        if resource.mac_address:
+            # A MAC was requested (set only at creation, see create_resource);
+            # reflect what neutron has so an already-correct port shows no diff.
+            resource.mac_address = self.port.mac_address
+        else:
+            # No MAC is managed; leave neutron's auto-assigned MAC untouched.
+            resource.mac_address = None
+
         self._set_facts(ctx)
 
     def create_resource(
@@ -123,6 +132,11 @@ class NetworkPortHandler(OpenStackHandler):
                 {"subnet_id": subnet.id, "ip_address": resource.address}
             ]
 
+        if resource.mac_address:
+            # Pin the port MAC (e.g. to a trunk parent port's MAC) so a sub-port
+            # sharing the parent MAC is not dropped by port security as spoofed.
+            port_attrs["mac_address"] = resource.mac_address
+
         self.port = self._connection.network.create_port(**port_attrs)
         if self.port is None:
             raise Exception("Unable to create port.")

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/inmanta_plugins/openstack/setup.cfg

@@ -22,7 +22,7 @@ target-version = 'py36', 'py37', 'py38'
 name = inmanta-module-openstack
 freeze_recursive = False
 freeze_operator = ~=
-version = 5.1.0
+version = 5.1.1
 license = Apache 2.0
 
 [egg_info]

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.1}/setup.cfg

@@ -22,7 +22,7 @@ target-version = 'py36', 'py37', 'py38'
 name = inmanta-module-openstack
 freeze_recursive = False
 freeze_operator = ~=
-version = 5.1.0
+version = 5.1.1
 license = Apache 2.0
 
 [egg_info]