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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inmanta-module-openstack
-Version: 5.1.0
+Version: 5.1.2
 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.2}/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.2
 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.2}/inmanta_module_openstack.egg-info/SOURCES.txt

@@ -16,7 +16,6 @@ inmanta_plugins/openstack/common/deps.py
 inmanta_plugins/openstack/compute/__init__.py
 inmanta_plugins/openstack/compute/flavor.py
 inmanta_plugins/openstack/compute/host_aggregate.py
-inmanta_plugins/openstack/compute/host_port.py
 inmanta_plugins/openstack/compute/virtual_machine.py
 inmanta_plugins/openstack/identity/__init__.py
 inmanta_plugins/openstack/identity/group.py
@@ -47,9 +46,10 @@ tests/test_dependency_handling.py
 tests/test_examples.py
 tests/test_flavor.py
 tests/test_host_aggregate.py
-tests/test_host_port_security_groups.py
 tests/test_image.py
 tests/test_keystone.py
+tests/test_network_port_fixed_ips.py
+tests/test_network_port_security_groups.py
 tests/test_neutron.py
 tests/test_nova.py
 tests/test_quota.py

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.2}/inmanta_plugins/openstack/common/deps.py

@@ -32,7 +32,7 @@ MANAGED_DEPENDENCIES = {
     "openstack::Router",
     "openstack::Subnet",
     "openstack::VirtualMachine",
-    "openstack::HostPort",
+    "openstack::NetworkPort",
     "openstack::FloatingIP",
     "openstack::SecurityGroup",
 }
@@ -66,15 +66,21 @@ def set_dependencies_on_purged_resources(collector: ResourceCollector) -> None:
     Set the dependencies between purged VMs/ports and the security groups they reference.
     """
     vms = collector.get("openstack::VirtualMachine", {})
-    ports = collector.get("openstack::HostPort", {})
+    ports = collector.get("openstack::NetworkPort", {})
     sgs = collector.get("openstack::SecurityGroup", {})
 
     # When the VM is purged, all its purged ports should be deployed first
     for vm in vms.values():
         for vm_port in vm.ports:
             if vm_port["name"] in ports:
-                port_id = ports[vm_port["name"]].id
-                vm.requires.add(port_id)
+                port = ports[vm_port["name"]]
+                if port.is_trunk_parent:
+                    # The vm boots on (and binds) its trunk parent port, so the vm must be
+                    # torn down before the port. This mirrors the create-time inversion and
+                    # avoids a cycle with the trunk (which is deleted before its parent).
+                    port.requires.add(vm.id)
+                else:
+                    vm.requires.add(port.id)
 
     # When a security group is purged, every port referencing it must be removed (or have the
     # reference dropped) before the group itself can be deleted.
@@ -90,7 +96,7 @@ def set_dependencies_on_non_purged_resources(collector: ResourceCollector) -> No
     routers = collector.get("openstack::Router", {})
     subnets = collector.get("openstack::Subnet", {})
     vms = collector.get("openstack::VirtualMachine", {})
-    ports = collector.get("openstack::HostPort", {})
+    ports = collector.get("openstack::NetworkPort", {})
     fips = collector.get("openstack::FloatingIP", {})
     sgs = collector.get("openstack::SecurityGroup", {})
     router_map = {}
@@ -143,7 +149,14 @@ def set_dependencies_on_non_purged_resources(collector: ResourceCollector) -> No
             port.requires.add(subnets[port.network].id)
 
         if port.host in vms:
-            port.requires.add(vms[port.host].id)
+            if port.is_trunk_parent:
+                # A trunk parent must exist (unbound) before its vm: the trunk is built
+                # on it and the vm then boots on the pre-created port. Ordering the port
+                # after the vm would both bind it too early (neutron rejects a trunk on a
+                # bound port) and cycle with the trunk (vm -> trunk -> parent port).
+                vms[port.host].requires.add(port.id)
+            else:
+                port.requires.add(vms[port.host].id)
 
         for sg_name in port.security_groups:
             if sg_name in sgs:

{inmanta_module_openstack-5.1.0 → inmanta_module_openstack-5.1.2}/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)
 
@@ -156,7 +183,9 @@ class VirtualMachineHandler(OpenStackHandler):
     @cache(timeout=10, cache_none=False)
     def _port_id(self, port_name):
         ports = self._connection.network.ports(name=port_name)
-        return self.require_single_item(ports)
+        port = self.require_single_item(ports)
+        # Nova expects the port id (a string) in the boot NIC, not the port object.
+        return port.id if port is not None else None
 
     @cache(timeout=10, cache_none=False)
     def _get_subnet_id(self, subnet_name):
@@ -176,8 +205,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 NetworkPort 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 +279,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 +394,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 +455,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 +485,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.2}/inmanta_plugins/openstack/model/_init.cf

@@ -345,42 +345,6 @@ implement RouterPort using providerRequire
 
 RouterPort.subnet [1] -- Subnet.routers [0:]
 
-entity HostPort extends Port:
-    """
-        A port attached to a VM
-
-        :param name: The name of the host port.
-        :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.
-        :param retries: A hostport can only be attached to a VM when it is in an active state. The handler will skip this port when the VM is not ready. To
-                        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
-    bool portsecurity=true
-    bool dhcp=true
-    int port_index=0
-    int retries=20
-    int wait=5
-end
-
-implementation noSecurityGroupsWhenPortSecurityDisabled for HostPort:
-    # Security groups can only be enforced on a port when port security is enabled.
-    std::assert(
-        std::count(self.security_groups) == 0,
-        "HostPort '{{name}}' cannot have security_groups assigned while portsecurity is disabled."
-    )
-end
-
-implement HostPort using providerRequire
-implement HostPort using noSecurityGroupsWhenPortSecurityDisabled when not self.portsecurity
-
-HostPort.subnet [1] -- Subnet.host_ports [0:]
-HostPort.vm [1] -- VirtualMachine.ports [0:]
-
-index HostPort(provider, vm, name)
-
 entity SubnetBase extends OpenStackResource:
     """
         A neutron subnet
@@ -502,25 +466,66 @@ implement QoSPolicy using providerRequire
 
 entity NetworkPort extends Port:
     """
-        A standalone neutron port, managed directly on a network and not bound
-        to a router or a virtual machine. This mirrors the
-        ``openstack port create --network <network> <name>`` command and is
-        suitable as the parent port of a :py:class:`TrunkNetwork`.
-
+        A neutron port. By default it is a standalone port, managed directly on a
+        network and not bound to a virtual machine -- this mirrors the
+        ``openstack port create --network <network> <name>`` command and is suitable
+        as the parent port of a :py:class:`TrunkNetwork`. Setting the ``vm`` relation
+        instead attaches the port to that virtual machine.
+
+        The port lives on an explicit ``network`` or, when only a ``subnet`` is given,
+        on that subnet's network.
+
+        :attr address: An optional fixed IPv4 to request. When omitted neutron assigns one; leave
+                       unset for an IPv6-only port. Ignored on a vm-attached port when dhcp is true
+                       (a standalone port always takes the address it is given).
+        :attr 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.
+        :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.
         :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 dhcp: Enable dhcp for this port or not. Only relevant when the port is attached to a vm.
+        :attr port_index: The index of the port. This determines the order of the interfaces on the
+                          virtual machine. 0 means no specific order. Only relevant when the port is
+                          attached to a vm.
+        :attr retries: A port attached to a vm can only be attached when the vm is in an active state.
+                       The handler will skip this port when the vm is not ready. To speed up
+                       deployments, the handler can retry this number of times before skipping.
+        :attr wait: The number of seconds to wait between retries.
+    """
+    std::ipv4_address? address = null
+    std::ipv6_address? address_v6 = null
+    string? mac_address = null
     bool portsecurity=true
-    std::ipv4_address? address=null
+    bool dhcp=true
+    int port_index=0
+    int retries=20
+    int wait=5
 end
 
-index NetworkPort(project, name)
-
-NetworkPort.network [1] -- Network.network_ports [0:]
-NetworkPort.subnet [0:1] -- Subnet.network_ports [0:]
+implementation noSecurityGroupsWhenPortSecurityDisabled for NetworkPort:
+    # Security groups can only be enforced on a port when port security is enabled.
+    std::assert(
+        std::count(self.security_groups) == 0,
+        "NetworkPort '{{name}}' cannot have security_groups assigned while portsecurity is disabled."
+    )
+end
 
 implement NetworkPort using providerRequire
+implement NetworkPort using noSecurityGroupsWhenPortSecurityDisabled when not self.portsecurity
+
+index NetworkPort(project, name)
+
+# The port lives on an explicit network, or derives it from its subnet when only the
+# subnet is given.
+NetworkPort.network [0:1] -- Network.network_ports [0:]
+NetworkPort.subnet [0:1] -- SubnetBase.network_ports [0:]
+# When set, the port is attached to this virtual machine. Left unset, the port is a
+# standalone port (e.g. the parent port of a trunk).
+NetworkPort.vm [0:1] -- VirtualMachine.ports [0:]
 
 
 entity TrunkNetwork extends OpenStackResource:
@@ -529,9 +534,11 @@ entity TrunkNetwork extends OpenStackResource:
         subports (see :py:class:`TrunkPort`) so that a single VM interface can
         carry traffic for multiple networks using VLAN tagging.
 
-        The trunk is built on top of an existing parent port. That port can be a
-        standalone :py:class:`NetworkPort` or a :py:class:`HostPort` attached to
-        a virtual machine. The parent port is managed separately.
+        The trunk is built on top of an existing parent port (a
+        :py:class:`NetworkPort`). Neutron only accepts a parent port that is not yet
+        bound to a virtual machine, so when the trunk parent is attached to a vm the
+        port must be created (and the trunk built on it) before the vm boots on it.
+        The parent port is managed separately.
 
         :attr name: The name of the trunk. Must be unique per project.
         :attr description: An optional human-readable description.
@@ -553,8 +560,8 @@ implement TrunkNetwork using providerRequire
 
 entity TrunkPort extends OpenStackResource:
     """
-        A subport of a :py:class:`TrunkNetwork`. It attaches an existing port
-        (a :py:class:`NetworkPort` or :py:class:`HostPort`) to the trunk with the
+        A subport of a :py:class:`TrunkNetwork`. It attaches an existing
+        :py:class:`NetworkPort` to the trunk with the
         configured segmentation type and id (typically a VLAN). The referenced
         port is managed separately; this resource only manages the trunk
         subport attachment, not the port itself.
@@ -627,7 +634,7 @@ end
 SecurityGroup.provider [1] -- Provider.security_groups [0:]
 SecurityGroup.project [1] -- Project.security_groups [0:]
 SecurityGroup.virtual_machines [0:] -- VirtualMachine.security_groups [0:]
-HostPort.security_groups [0:] -- SecurityGroup
+NetworkPort.security_groups [0:] -- SecurityGroup
 """
 :rel security_groups: The security groups to enforce on this port. When left empty (the default), the
     port's security groups are left unmanaged for backward compatibility: existing groups (including the
@@ -686,7 +693,7 @@ implement FloatingIP using fipAddr when not force_ip
 FloatingIP.project [1] -- Project.floating_ips [0:]
 FloatingIP.provider [1] -- Provider.floating_ips [0:]
 FloatingIP.external_network [1] -- Network.floating_ips [0:]
-FloatingIP.port [1] -- HostPort.floating_ips [0:]
+FloatingIP.port [1] -- NetworkPort.floating_ips [0:]
 
 entity VMAttributes:
     """
@@ -713,14 +720,25 @@ entity VirtualMachine extends OpenStackResource, VMAttributes:
     string name
 end
 
-implement VirtualMachine using providerRequire
-
 index VirtualMachine(provider, name)
 
-VirtualMachine.eth0_port [1] -- HostPort
+VirtualMachine.eth0_port [1] -- NetworkPort
 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:
     """
@@ -739,7 +757,7 @@ Host.provider [1] -- Provider
 Host.security_groups [0:] -- SecurityGroup
 
 implementation eth0Port for Host:
-    port = HostPort(provider=provider, vm=self.vm, subnet=subnet, name="{{name}}_eth0", address=std::getfact(self.vm, "ip_address"),
+    port = NetworkPort(provider=provider, vm=self.vm, subnet=subnet, name="{{name}}_eth0", address=std::getfact(self.vm, "ip_address"),
                     project=project, port_index=1, purged=purged, purge_on_delete=self.purge_on_delete)
     self.vm.eth0_port = port
 end