python-chi 1.0.8__tar.gz → 1.1.0__tar.gz

{python_chi-1.0.8 → python_chi-1.1.0}/.github/workflows/test.yml

@@ -1,8 +1,5 @@
 name: Unit tests
 
-env:
-  PYTHON_VERSION: 3.8
-
 on:
   push:
     branches:
@@ -13,18 +10,18 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
-
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        python:
+          - 3.8
     steps:
-      - uses: actions/checkout@v2
-
+      - uses: actions/checkout@v4
       - name: Set up Python 3.x
-        uses: actions/setup-python@v1
+        uses: actions/setup-python@v5
         with:
-          python-version: ${{ env.PYTHON_VERSION }}
-
+          python-version: ${{ matrix.python }}
       - name: Install tox
         run: pip install tox
-
       - name: Run tests
-        run: tox
+        run: tox -e "py${{ matrix.python }}"

python_chi-1.1.0/ChangeLog

@@ -0,0 +1,7 @@
+CHANGES
+=======
+
+v1.1
+----
+
+* Add configurable option for CHI@Edge hardware API

{python_chi-1.0.8 → python_chi-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: python-chi
-Version: 1.0.8
+Version: 1.1.0
 Summary: Helper library for Chameleon Infrastructure (CHI) testbed
 Home-page: https://www.chameleoncloud.org
 Author: University of Chicago
@@ -35,6 +35,7 @@ Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{python_chi-1.0.8 → python_chi-1.1.0}/chi/container.py

@@ -23,11 +23,14 @@ from IPython.display import HTML, display
 from packaging.version import Version
 from zunclient.exceptions import NotFound
 
-from chi import context
+from chi import context, util
 
-from .clients import zun
-from .exception import ResourceError
+from .clients import connection, zun
+from .context import session
+from .exception import ResourceError, ServiceError
 from .network import bind_floating_ip, get_free_floating_ip
+from chi import network as chi_network
+
 
 DEFAULT_IMAGE_DRIVER = "docker"
 DEFAULT_NETWORK = "containernet1"
@@ -46,6 +49,8 @@ class Container:
         start (bool, optional): Indicates whether to start the container. Defaults to True.
         start_timeout (int, optional): The timeout value for starting the container. Defaults to None.
         runtime (str, optional): The runtime environment for the container. Defaults to None.
+        command (List[str], optional): The command to run inside the container.
+        workdir (str, optional): The workdir to use in the container.
 
     Attributes:
         name (str): The name of the container.
@@ -69,6 +74,8 @@ class Container:
         start: bool = True,
         start_timeout: int = 0,
         runtime: str = None,
+        command: List[str] = None,
+        workdir: str = None,
     ):
         self.name = name
         self.image_ref = image_ref
@@ -80,6 +87,8 @@ class Container:
         self.id = None
         self.created_at = None
         self._status = None
+        self.command = command
+        self.workdir = workdir
 
     @classmethod
     def from_zun_container(cls, zun_container):
@@ -103,7 +112,7 @@ class Container:
     def submit(
         self,
         wait_for_active: bool = True,
-        wait_timeout: int = None,
+        wait_timeout: int = 5 * 60,
         show: str = "widget",
         idempotent: bool = False,
     ):
@@ -112,7 +121,7 @@ class Container:
 
         Args:
             wait_for_active (bool, optional): Whether to wait for the container to become active. Defaults to True.
-            wait_timeout (int, optional): The maximum time (in seconds) to wait for the container to become active. Defaults to None.
+            wait_timeout (int, optional): The maximum time (in seconds) to wait for the container to become active. Defaults to 5 minutes.
             show (str, optional): The type of output to display. Defaults to "widget".
             idempotent (bool, optional): Whether to update the existing container if it already exists. Defaults to False.
 
@@ -130,6 +139,11 @@ class Container:
                 if show:
                     existing.show(type=show, wait_for_active=wait_for_active)
                 return existing
+        kwargs = {}
+        if self.command:
+            kwargs["command"] = self.command
+        if self.workdir:
+            kwargs["workdir"] = self.workdir
 
         container = create_container(
             name=self.name,
@@ -139,6 +153,7 @@ class Container:
             start=self.start,
             start_timeout=self.start_timeout,
             runtime=self.runtime,
+            **kwargs,
         )
 
         if container:
@@ -171,19 +186,38 @@ class Container:
             self.id = None
             self._status = None
 
-    def wait(self, status: str = "Running", timeout: int = None):
+    def wait(
+        self, status: str = "Running", show: str = "widget", timeout: int = 5 * 60
+    ):
         """
         Waits for the container to reach the specified status.
 
         Args:
             status (str, optional): The status to wait for. Defaults to "Running".
-            timeout (int, optional): The maximum time to wait in seconds. Defaults to None.
+            show (str, optional): The type of container information to display after creation. Defaults to "widget".
+            timeout (int, optional): The maximum time to wait in seconds. Defaults to 5 minutes.
 
         Returns:
             None
         """
-        wait_for_active(self.id, timeout=timeout)
-        self._status = status
+
+        pb = util.TimerProgressBar()
+        if show == "widget" and context._is_ipynb():
+            pb.display()
+
+        def _callback():
+            # self.status is a property that refreshes itself
+            # NOTE: zun statuses are title case
+            if self.status.upper() == status.upper() or self.status == "Error":
+                print(f"Container has moved to status {self.status}")
+                return True
+            return False
+
+        res = pb.wait(_callback, 2 * 60, timeout)
+        if not res:
+            raise ServiceError(
+                f"Timeout waiting for container to reach {status} status"
+            )
 
     def show(self, type: str = "text", wait_for_active: bool = False):
         """
@@ -292,6 +326,36 @@ class Container:
         """
         return associate_floating_ip(self.id, fip)
 
+    def detach_floating_ip(self, fip: str) -> None:
+        """
+        Detaches and deletes a floating IP from the container.
+
+        Args:
+            fip (str): The floating IP to detach.
+            delete (Optional[bool], optional): Whether to delete the floating IP after disassociation. Defaults to True.
+
+        Returns:
+            None
+        """
+        conn = connection(session=session())
+        floating_ip_obj = chi_network.get_floating_ip(fip)
+        conn.network.delete(floating_ip_obj["id"])
+
+    def logs(self, stdout: str = True, stderr: str = True) -> str:
+        """
+        Print all logs outputted by the container.
+
+        Args:
+            container_ref (str): The name or ID of the container.
+            stdout (bool): Whether to include stdout logs. Default True.
+            stderr (bool): Whether to include stderr logs. Default True.
+
+        Returns:
+            A string containing all log output. Log lines will be delimited by
+                newline characters.
+        """
+        return get_logs(self.id, stdout=stdout, stderr=stderr)
+
 
 def create_container(
     name: "str",
@@ -515,7 +579,7 @@ def download(container_ref: "str", source: "str", dest: "str"):
     res = zun().containers.get_archive(container_ref, source)
     fd = io.BytesIO(res["data"])
     with tarfile.open(fileobj=fd, mode="r") as tar:
-        tar.extraction_filter = (lambda member, path: member)
+        tar.extraction_filter = lambda member, path: member
         tar.extractall(dest)
 
 

{python_chi-1.0.8 → python_chi-1.1.0}/chi/context.py

@@ -26,6 +26,9 @@ DEFAULT_AUTH_TYPE = "v3token"
 DEFAULT_NETWORK = "sharednet1"
 CONF_GROUP = "chi"
 RESOURCE_API_URL = os.getenv("CHI_RESOURCE_API_URL", "https://api.chameleoncloud.org")
+EDGE_RESOURCE_API_URL = os.getenv(
+    "EDGE_RESOURCE_API_URL", "https://chameleoncloud.org/edge-hw-discovery/devices"
+)
 
 
 def default_key_name():

{python_chi-1.0.8 → python_chi-1.1.0}/chi/hardware.py

@@ -2,12 +2,13 @@ from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
-from typing import List, Optional, Tuple
+from typing import List, Optional, Set, Tuple
 
 from chi import exception
 
-from .clients import blazar
-from .context import get, RESOURCE_API_URL
+from .clients import blazar, connection
+from .context import get, RESOURCE_API_URL, EDGE_RESOURCE_API_URL, session
+
 
 import requests
 import logging
@@ -17,6 +18,31 @@ LOG = logging.getLogger(__name__)
 node_types = []
 
 
+def _get_next_free_timeslot(allocation, minimum_hours):
+    now = datetime.now(timezone.utc)
+
+    if not allocation:
+        return (now, None)
+
+    reservations = sorted(allocation["reservations"], key=lambda x: x["start_date"])
+
+    buffer = timedelta(hours=minimum_hours)
+    # Next time this interval could possibly start
+    possible_start = now
+    for i in range(len(reservations)):
+        # Check we have enough time between last known free period and this reservation
+        this_start = _parse_blazar_dt(reservations[i]["start_date"])
+        if possible_start + buffer < this_start:
+            # We found a gap
+            return (possible_start, this_start)
+
+        # Otherwise, no possible start until end of this reservation
+        this_end = _parse_blazar_dt(reservations[i]["end_date"])
+        possible_start = this_end
+    # If there was no gap, use the last reservation's end time
+    return (possible_start, None)
+
+
 @dataclass
 class Node:
     """
@@ -55,7 +81,10 @@ class Node:
 
         def get_host_id(items, target_uid):
             for item in items:
-                if item.get("uid") == target_uid or item.get("hypervisor_hostname") == target_uid:
+                if (
+                    item.get("uid") == target_uid
+                    or item.get("hypervisor_hostname") == target_uid
+                ):
                     return item["id"]
             return None
 
@@ -63,33 +92,12 @@ class Node:
 
         # Get allocation for this specific host
         host_id = get_host_id(blazarclient.host.list(), self.uid)
-
         if not host_id:
             raise exception.ServiceError(f"Host for {self.uid} not found in Blazar")
-        allocation = blazarclient.host.get_allocation(host_id)
 
-        now = datetime.now(timezone.utc)
-
-        if not allocation:
-            return (now, None)
-
-        reservations = sorted(allocation["reservations"], key=lambda x: x["start_date"])
-
-        buffer = timedelta(hours=minimum_hours)
-        # Next time this interval could possibly start
-        possible_start = now
-        for i in range(len(reservations)):
-            # Check we have enough time between last known free period and this reservation
-            this_start = _parse_blazar_dt(reservations[i]["start_date"])
-            if possible_start + buffer < this_start:
-                # We found a gap
-                return (possible_start, this_start)
-
-            # Otherwise, no possible start until end of this reservation
-            this_end = _parse_blazar_dt(reservations[i]["end_date"])
-            possible_start = this_end
-        # If there was no gap, use the last reservation's end time
-        return (possible_start, None)
+        return _get_next_free_timeslot(
+            blazarclient.host.get_allocation(host_id), minimum_hours
+        )
 
 
 def _call_api(endpoint):
@@ -115,7 +123,7 @@ def get_nodes(
         all_sites (bool, optional): Flag to indicate whether to retrieve nodes from all sites.
             Defaults to False.
         filter_reserved (bool, optional): Flag to indicate whether to filter out reserved nodes.
-            Defaults to False. (Not Currently implemented)
+            Defaults to False.
         gpu (bool, optional): Flag to indicate whether to filter nodes based on GPU availability.
             Defaults to None.
         min_number_cpu (int, optional): Minimum number of CPU logical cores per node.
@@ -137,9 +145,7 @@ def get_nodes(
     for site in sites:
         # Soufiane: Skipping CHI@EDGE since it is not enrolled in the hardware API,
         if site == "CHI@Edge":
-            print(
-                "Please visit the Hardware discovery page for information about CHI@Edge devices"
-            )
+            print("See `hardware.get_devices` for information about CHI@Edge devices")
             continue
 
         allocations = defaultdict(list)
@@ -174,7 +180,9 @@ def get_nodes(
                             reserved_now.add(blazar_host["hypervisor_hostname"])
 
         for node_data in data["items"]:
-            blazar_host = blazar_hosts_by_hypervisor_hostname.get(node_data.get("uid"), None)
+            blazar_host = blazar_hosts_by_hypervisor_hostname.get(
+                node_data.get("uid"), {}
+            )
             node = Node(
                 site=site,
                 name=node_data.get("node_name"),
@@ -199,7 +207,9 @@ def get_nodes(
                     node.gpu and gpu == bool(node.gpu[0].get("gpu"))
                 )
             else:
-                gpu_filter = gpu is None or (node.gpu and gpu == bool(node.gpu.get("gpu")))
+                gpu_filter = gpu is None or (
+                    node.gpu and gpu == bool(node.gpu.get("gpu"))
+                )
 
             cpu_filter = (
                 min_number_cpu is None
@@ -249,3 +259,153 @@ def get_node_types() -> List[str]:
     if len(node_types) < 1:
         get_nodes()
     return list(set(node_types))
+
+
+@dataclass
+class Device:
+    """
+    A dataclass for device information directly from the hardware browser.
+    """
+
+    device_name: str
+    device_type: str
+    supported_device_profiles: List[str]
+    authorized_projects: Set[str]
+    owning_project: str
+    uuid: str
+    reservable: bool
+
+    def next_free_timeslot(
+        self, minimum_hours: int = 1
+    ) -> Tuple[datetime, Optional[datetime]]:
+        """
+        Finds the next available timeslot for the device using the Blazar client.
+
+        Args:
+            minimum_hours (int, optional): The minimum number of hours for this timeslot.
+
+        Returns:
+            A tuple containing the start and end datetime of the next available timeslot.
+            If no timeslot is available, returns (end_datetime_of_last_allocation, None).
+        """
+
+        def get_device_id(items, target_uid):
+            for item in items:
+                if item.get("uid") == target_uid or item.get("uid") == target_uid:
+                    return item["id"]
+            return None
+
+        blazarclient = blazar()
+
+        # Get allocation for this specific device
+        device_id = get_device_id(blazarclient.device.list(), self.uuid)
+        if not device_id:
+            raise exception.ServiceError(f"Device for {self.uuid} not found in Blazar")
+
+        # Bug in Blazar API for devices means `get_alloction` doesn't work. We get around this with `list`
+        allocs = blazarclient.device.list_allocations()
+        this_alloc = None
+        for alloc in allocs:
+            if alloc["resource_id"] == device_id:
+                this_alloc = alloc
+        return _get_next_free_timeslot(this_alloc, minimum_hours)
+
+
+def get_devices(
+    device_type: Optional[str] = None,
+    filter_reserved: bool = False,
+    filter_unauthorized: bool = True,
+) -> List[Device]:
+    """
+    Retrieve a list of devices based on the specified criteria.
+
+    Args:
+        device_type (str, optional): The device type to filter by
+        filter_reserved (bool, optional): Flag to indicate whether to filter out reserved devices. Defaults to False.
+        filter_unauthorized (bool, optional): Filter devices that the current project is not authorized to use
+
+    Returns:
+        List[Device]: A list of Device objects that match the specified criteria.
+    """
+    # Query hardware API
+    res = requests.get(EDGE_RESOURCE_API_URL)
+    try:
+        res.raise_for_status()
+    except requests.exceptions.HTTPError:
+        raise exception.ServiceError(
+            f"Failed to get devices. Status code {res.status_code}"
+        )
+
+    blazarclient = blazar()
+    # Blazar uid matches doni's uuid, so we need to map blazar id to blazar uid for allocations,
+    # and uid to id for reservable status
+    blazar_devices_by_id = {}
+    blazar_devices_by_uid = {}
+    for device in blazarclient.device.list():
+        blazar_devices_by_id[device["id"]] = device
+        blazar_devices_by_uid[device["uid"]] = device
+
+    devices = []
+    for dev_json in res.json():
+        blazar_host = blazar_devices_by_uid.get(dev_json.get("uuid"), {})
+        devices.append(
+            Device(
+                device_name=dev_json["device_name"],
+                device_type=dev_json["device_type"],
+                supported_device_profiles=dev_json["supported_device_profiles"],
+                authorized_projects=set(dev_json["authorized_projects"]),
+                owning_project=dev_json["owning_project"],
+                uuid=dev_json["uuid"],
+                reservable=blazar_host.get(
+                    "reservable", False
+                ),  # not all devices will appear in blazar if registration failed
+            )
+        )
+
+    # Filter based on authorized projects
+    authorized_devices = [] if filter_unauthorized else devices
+    if filter_unauthorized:
+        conn = connection(session=session())
+        current_project_id = conn.current_project_id
+        for device in devices:
+            if (
+                "all" in device.authorized_projects
+                or current_project_id in device.authorized_projects
+            ):
+                authorized_devices.append(device)
+
+    # Filter based on device type
+    matching_type_devices = [] if device_type else authorized_devices
+    if device_type:
+        for device in authorized_devices:
+            if device.device_type == device_type:
+                matching_type_devices.append(device)
+
+    # Filter based on reserved status
+    unreserved_devices = [] if filter_reserved else matching_type_devices
+    if filter_reserved:
+        now = datetime.now(timezone.utc)
+
+        reserved_devices = set()
+        for resource in blazarclient.device.list_allocations():
+            blazar_device = blazar_devices_by_id.get(resource["resource_id"], None)
+            if blazar_device:
+                for allocation in resource["reservations"]:
+                    if _reserved_now(allocation, now):
+                        reserved_devices.add(blazar_device["uid"])
+        for device in matching_type_devices:
+            # Ensure the device is free and in `reservable` state
+            if device.uuid not in reserved_devices and device.reservable:
+                unreserved_devices.append(device)
+
+    return unreserved_devices
+
+
+def get_device_types() -> List[str]:
+    """
+    Retrieve a list of unique device types.
+
+    Returns:
+        List[str]: A list of unique device types.
+    """
+    return list(set(d.device_type for d in get_devices()))

{python_chi-1.0.8 → python_chi-1.1.0}/chi/lease.py

@@ -16,9 +16,9 @@ from chi import context, util
 from .clients import blazar
 from .context import _is_ipynb
 from .exception import CHIValueError, ResourceError, ServiceError
-from .hardware import Node
+from .hardware import Device, Node
 from .network import PUBLIC_NETWORK, get_network_id, list_floating_ips
-from .util import utcnow
+from .util import retry_create, utcnow
 
 if TYPE_CHECKING:
     from typing import Pattern
@@ -260,6 +260,7 @@ class Lease:
         machine_type: str = None,
         device_model: str = None,
         device_name: str = None,
+        devices: List[Device] = None,
     ):
         """
         Add a IoT device reservation to the list of device reservations.
@@ -269,14 +270,29 @@ class Lease:
             machine_type (str, optional): The type of machine to reserve. Defaults to None.
             device_model (str, optional): The model of the device to reserve. Defaults to None.
             device_name (str, optional): The name of the device to reserve. Defaults to None.
+            devices (List[Device]): A list of Device objects to reserve.
+
+        Raises:
+            CHIValueError: If devices are specified, no other arguments should be included.
         """
-        add_device_reservation(
-            reservation_list=self.device_reservations,
-            count=amount,
-            machine_name=machine_type,
-            device_model=device_model,
-            device_name=device_name,
-        )
+        if devices:
+            if any([amount, machine_type, device_model, device_name]):
+                raise CHIValueError(
+                    "When specifying nodes, no other arguments should be included"
+                )
+            for device in devices:
+                add_device_reservation(
+                    reservation_list=self.device_reservations,
+                    device_name=device.device_name,
+                )
+        else:
+            add_device_reservation(
+                reservation_list=self.device_reservations,
+                count=amount,
+                machine_name=machine_type,
+                device_model=device_model,
+                device_name=device_name,
+            )
 
     def add_node_reservation(
         self,
@@ -355,6 +371,7 @@ class Lease:
         wait_timeout: int = 300,
         show: Optional[str] = None,
         idempotent: bool = False,
+        retry_on_error: bool = False,
     ):
         """
         Submits the lease for creation.
@@ -364,6 +381,7 @@ class Lease:
             wait_timeout (int, optional): The maximum time to wait for the lease to become active, in seconds. Defaults to 300.
             show (Optional[str], optional): The types of lease information to display. Defaults to None, options are "widget", "text".
             idempotent (bool, optional): Whether to create the lease only if it doesn't already exist. Defaults to False.
+            retry_on_error (bool, optional): Whether to retry the server creation if creation fails. Defaults to False.
 
         Raises:
             ResourceError: If unable to create the lease.
@@ -389,23 +407,35 @@ class Lease:
             + self.network_reservations
         )
 
-        response = create_lease(
-            lease_name=self.name,
-            reservations=reservations,
-            start_date=self.start_date,
-            end_date=self.end_date,
-        )
+        def _lease_create_func():
+            response = create_lease(
+                lease_name=self.name,
+                reservations=reservations,
+                start_date=self.start_date,
+                end_date=self.end_date,
+            )
 
-        if response:
-            self._populate_from_json(response)
-        else:
-            raise ResourceError("Unable to make lease")
+            if response:
+                self._populate_from_json(response)
+            else:
+                raise ResourceError("Unable to make lease")
 
-        if wait_for_active:
-            self.wait(status="active", timeout=wait_timeout)
+            if wait_for_active:
+                self.wait(status="active", timeout=wait_timeout)
 
-        if show:
-            self.show(type=show, wait_for_active=wait_for_active)
+            if show:
+                self.show(type=show, wait_for_active=wait_for_active)
+
+        def _lease_cleanup_func():
+            try:
+                self.delete()
+            except Exception:
+                # Ignore any cleanup errors
+                pass
+
+        retry_create(
+            3 if retry_on_error else 1, _lease_create_func, _lease_cleanup_func
+        )
 
     def wait(self, status="active", show: str = "widget", timeout: int = 500):
         """
@@ -423,7 +453,7 @@ class Lease:
             None
         """
 
-        print("Waiting for lease to start... This can take up to 60 seconds")
+        print("Waiting for lease to start...")
 
         pb = util.TimerProgressBar()
         if show == "widget" and _is_ipynb():

{python_chi-1.0.8 → python_chi-1.1.0}/chi/server.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Optional, Union
 
 from fabric import Connection
 from IPython.display import HTML, display
-from novaclient.exceptions import Conflict, NotFound
+from novaclient.exceptions import NotFound
 from novaclient.v2.flavor_access import FlavorAccess as NovaFlavor
 from novaclient.v2.keypairs import Keypair as NovaKeypair
 from novaclient.v2.servers import Server as NovaServer
@@ -25,7 +25,7 @@ from .exception import CHIValueError, ResourceError, ServiceError
 from .image import Image, get_image_id, get_image_name
 from .keypair import Keypair
 from chi import network as chi_network
-from .util import random_base32, sshkey_fingerprint
+from .util import random_base32, retry_create, sshkey_fingerprint
 from chi import exception
 
 DEFAULT_IMAGE = DEFAULT_IMAGE_NAME
@@ -157,6 +157,8 @@ class Server:
         wait_for_active: bool = True,
         show: str = "widget",
         idempotent: bool = False,
+        retry_on_error: bool = False,
+        wait_timeout: int = 20 * 60,
         **kwargs,
     ) -> "Server":
         """
@@ -166,6 +168,8 @@ class Server:
             wait_for_active (bool, optional): Whether to wait for the server to become active before returning. Defaults to True.
             show (str, optional): The type of server information to display after creation. Defaults to "widget".
             idempotent (bool, optional): Whether to create the server only if it doesn't already exist. Defaults to False.
+            retry_on_error (bool, optional): Whether to retry the server creation if creation fails. Defaults to False.
+            wait_timeout (int): How long to wait for server to start in seconds. Default 20 minutes.
 
         Raises:
             Conflict: If the server creation fails due to a conflict and idempotent mode is not enabled.
@@ -192,18 +196,25 @@ class Server:
             net_ids=[chi_network.get_network_id(DEFAULT_NETWORK)],
             **kwargs,
         )
-        try:
-            nova_server = self.conn.compute.create_server(**server_args)
-        except Conflict as e:
-            raise ResourceError(e.message)  # Re-raise the exception if not handled
 
-        # TODO use nova_server to update self
+        def _server_create_func():
+            self.conn.compute.create_server(**server_args)
+            if wait_for_active:
+                self.wait(timeout=wait_timeout)
+            if show:
+                self.show(type=show)
 
-        if wait_for_active:
-            self.wait()
+        def _server_cleanup_func():
+            try:
+                self.delete(idempotent=True, delete_ips=False)
+                time.sleep(10)
+            except Exception:
+                # Ignore any cleanup errors
+                pass
 
-        if show:
-            self.show(type=show)
+        retry_create(
+            3 if retry_on_error else 1, _server_create_func, _server_cleanup_func
+        )
 
     @classmethod
     def _from_nova_server(cls, nova_server):
@@ -237,7 +248,9 @@ class Server:
             flavor_name=get_flavor(flavor_id).name,
             key_name=nova_server.key_name,
             network_name=(
-                chi_network.get_network(network_id)["name"] if network_id is not None else None
+                chi_network.get_network(network_id)["name"]
+                if network_id is not None
+                else None
             ),
         )
 
@@ -277,10 +290,24 @@ class Server:
 
         return server
 
-    def delete(self) -> None:
-        """Deletes the server.
+    def delete(self, idempotent: bool = False, delete_ips: bool = True) -> None:
+        """
+        Deletes the server.
+
+        Args:
+            idempotent (bool, optional): Whether to create the server only if it doesn't already exist. Defaults to False.
+            delete_ips (bool, optional): Whether to delete the server IPs from this project. Defauls to False
         """
-        delete_server(self.id)
+        if delete_ips:
+            conn = connection(session=session())
+            for addr in self.get_all_floating_ips():
+                floating_ip_obj = chi_network.get_floating_ip(addr)
+                conn.network.delete(floating_ip_obj["id"])
+        try:
+            delete_server(self.id)
+        except NotFound:
+            if not idempotent:
+                raise ResourceError(f"Server {self.name} not found")
 
     def refresh(self):
         """
@@ -304,13 +331,16 @@ class Server:
         except Exception as e:
             raise ResourceError(f"Could not refresh server: {e}")
 
-    def wait(self, status: str = "ACTIVE", show: str = "widget") -> None:
+    def wait(
+        self, status: str = "ACTIVE", show: str = "widget", timeout: int = 20 * 60
+    ) -> None:
         """
         Waits for the server's status to reach the specified status.
 
         Args:
             status (str): The status to wait for. Defaults to "ACTIVE".
             show (str, optional): The type of server information to display after creation. Defaults to "widget".
+            timeout (int): How long to wait for server to start in seconds. Default 20 minutes.
 
         Raises:
             ServiceError: If the server does not reach the specified status within the timeout period.
@@ -333,7 +363,7 @@ class Server:
                 return True
             return False
 
-        res = pb.wait(_callback, 10 * 60, 20 * 60)
+        res = pb.wait(_callback, 10 * 60, timeout)
         if not res:
             raise ServiceError(f"Timeout waiting for server to reach {status} status")
 
@@ -426,7 +456,9 @@ class Server:
                 )
         return formatted
 
-    def associate_floating_ip(self, fip: Optional[str] = None, port_id: Optional[str] = None) -> None:
+    def associate_floating_ip(
+        self, fip: Optional[str] = None, port_id: Optional[str] = None
+    ) -> None:
         """
         Associates a floating IP with the server.
 
@@ -441,17 +473,22 @@ class Server:
         associate_floating_ip(self.id, fip, port_id)
         self.refresh()
 
-    def detach_floating_ip(self, fip: str) -> None:
+    def detach_floating_ip(self, fip: str, delete: Optional[bool] = True) -> None:
         """
         Detaches a floating IP from the server.
 
         Args:
             fip (str): The floating IP to detach.
+            delete (Optional[bool], optional): Whether to delete the floating IP after disassociation. Defaults to True.
 
         Returns:
             None
         """
         detach_floating_ip(self.id, fip)
+        if delete:
+            conn = connection(session=session())
+            floating_ip_obj = chi_network.get_floating_ip(fip)
+            conn.network.delete(floating_ip_obj["id"])
         self.refresh()
 
     def _can_connect_to_port(self, host, port, timeout):
@@ -467,11 +504,23 @@ class Server:
         Returns:
             str: Floating IP address of server
         """
+        fips = self.get_all_floating_ips()
+        if fips:
+            return fips[0]
+        return None
+
+    def get_all_floating_ips(self):
+        """Get a list of attached floating ips of this server
+
+        Returns:
+            List[str[]: Floating IP addresses of server
+        """
+        fips = []
         for net, addresses in self.addresses.items():
             for address in addresses:
                 if address.get("OS-EXT-IPS:type") == "floating":
-                    return address["addr"]
-        return None
+                    fips.append(address["addr"])
+        return fips
 
     def check_connectivity(
         self,
@@ -576,6 +625,7 @@ class Server:
     def set_metadata_item(self, key, value):
         return nova().servers.set_meta_item(self.id, key, value)
 
+
 ##########
 # Flavors
 ##########
@@ -611,7 +661,9 @@ def list_flavors() -> List[Flavor]:
     if Version(context.version) >= Version("1.0"):
         nova_client = nova()
         flavors = nova_client.flavors.list()
-        return [Flavor(name=f.name, disk=f.disk, ram=f.ram, vcpus=f.vcpus) for f in flavors]
+        return [
+            Flavor(name=f.name, disk=f.disk, ram=f.ram, vcpus=f.vcpus) for f in flavors
+        ]
     return nova().flavors.list()
 
 
@@ -816,11 +868,13 @@ def associate_floating_ip(server_id, floating_ip_address=None, port_id=None):
     if port_id:
         port_obj = next(port for port in ports if port["id"] == port_id)
         if not port_obj:
-            raise exception.ResourceError(f"Port {port_id} not found on server {server_id}")
+            raise exception.ResourceError(
+                f"Port {port_id} not found on server {server_id}"
+            )
         ports = [port_obj]
     else:
         for port in ports:
-            floating_ip_args = {'port_id': port['id']}
+            floating_ip_args = {"port_id": port["id"]}
             try:
                 return conn.network.update_ip(
                     floating_ip_obj["id"], **floating_ip_args
@@ -829,7 +883,9 @@ def associate_floating_ip(server_id, floating_ip_address=None, port_id=None):
                 # Ignore errors and try the next port
                 pass
     floating_ip_address = floating_ip_obj["floating_ip_address"]
-    raise exception.ResourceError(f"None of the ports can route to floating ip {floating_ip_address} on server {server_id}")
+    raise exception.ResourceError(
+        f"None of the ports can route to floating ip {floating_ip_address} on server {server_id}"
+    )
 
 
 def detach_floating_ip(server_id, floating_ip_address):

{python_chi-1.0.8 → python_chi-1.1.0}/chi/util.py

@@ -4,6 +4,7 @@ import time
 from dateutil import tz
 from hashlib import md5
 import os
+from chi.exception import ResourceError
 import ipywidgets as widgets
 from IPython.display import display
 
@@ -61,17 +62,18 @@ class TimerProgressBar:
     def display(self):
         display(widgets.HBox([self.label, self.progress]))
 
-    def wait(self, callback, expected_timeout, timeout):
+    def wait(self, callback, expected_timeout, timeout, interval=5):
         """Wait and update the progress bar.
 
         Args:
             callback (function): bool function for whether to break
             expected_timeout (int): how long the progress bar should expect to wait for in seconds. Will display 90% when reached
             timeout (int): The time to reach 100% of the progress bar
-
+            interval (int): The time to wait between checking the callback)
         Returns:
             Whether callback returned true before timeout
         """
+        expected_proportion = 0.9
         start_time = time.time()
         while time.time() - start_time < timeout:
             if callback():
@@ -81,12 +83,32 @@ class TimerProgressBar:
             self.label.value = f"{str(elapased).split('.')[0]} elapsed."
 
             if elapased.total_seconds() < expected_timeout:
-                self.progress.value = 100 * elapased.total_seconds() / expected_timeout
-            else:
                 self.progress.value = (
-                    10
+                    100
+                    * expected_proportion
+                    * elapased.total_seconds()
+                    / expected_timeout
+                )
+            else:
+                self.progress.value = 100 * (
+                    expected_proportion
+                    + (1 - expected_proportion)
                     * (elapased.total_seconds() - expected_timeout)
                     / (timeout - expected_timeout)
                 )
-            time.sleep(5)
+            time.sleep(interval)
         return False
+
+
+def retry_create(max_attempts, create_func, cleanup_func):
+    attempt = 0
+    while attempt < 3:
+        try:
+            create_func()
+            break
+        except Exception as e:
+            attempt += 1
+            if attempt == max_attempts:
+                raise ResourceError(e)
+            print(f"Error creating resource on attempt {attempt}/{max_attempts}.")
+            cleanup_func()

{python_chi-1.0.8 → python_chi-1.1.0}/python_chi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: python-chi
-Version: 1.0.8
+Version: 1.1.0
 Summary: Helper library for Chameleon Infrastructure (CHI) testbed
 Home-page: https://www.chameleoncloud.org
 Author: University of Chicago
@@ -35,6 +35,7 @@ Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

python_chi-1.1.0/python_chi.egg-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "7011a87", "is_release": false}

{python_chi-1.0.8 → python_chi-1.1.0}/setup.py

@@ -5,5 +5,5 @@ from setuptools import setup
 setup(
     setup_requires=["pbr"],
     pbr=True,
-    version='v1.0.8'
+    version='v1.1'
 )

python_chi-1.0.8/ChangeLog

@@ -1,7 +0,0 @@
-CHANGES
-=======
-
-v1.0.8
-------
-
-* Add Node.reservable field

python_chi-1.0.8/python_chi.egg-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "857913c", "is_release": false}