Managers now use name instead of manager_name when appropriate

Author: ianmkenney

alchemiscale/compute/api.py

@@ -114,7 +114,7 @@ def register_computeservice(
     if compute_manager_id:
         manager_name = process_compute_manager_id_string(
             compute_manager_id
-        ).manager_name
+        ).name
     else:
         manager_name = None
 
@@ -126,7 +126,13 @@ def register_computeservice(
         manager_name=manager_name,
     )
 
-    compute_service_id_ = n4js.register_computeservice(csreg)
+    try:
+        compute_service_id_ = n4js.register_computeservice(csreg)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=http_status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(e),
+        )
 
     return compute_service_id_
 
@@ -412,15 +418,10 @@ def process_compute_manager_id_string(
     """Try creating a ComputeManagerID from a string representation. Raise HTTPException."""
     try:
         compute_manager_id = ComputeManagerID(compute_manager_id_string)
-    except ValueError as e:
-        raise HTTPException(
-            status_code=http_status.HTTP_422_UNPROCESSABLE_ENTITY,
-            details=str(e),
-        )
     except Exception as e:
         raise HTTPException(
-            status_code=http_status.HTTP_500_INTERNAL_SERVER_ERROR,
-            details=str(e),
+            status_code=http_status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(e),
         )
 
     return compute_manager_id
@@ -436,7 +437,7 @@ def register_computemanager(
 
     now = datetime.datetime.now(tz=datetime.UTC)
     cm_registration = ComputeManagerRegistration(
-        manager_name=compute_manager_id.manager_name,
+        name=compute_manager_id.name,
         uuid=compute_manager_id.uuid,
         registered=now,
         last_status_update=now,
@@ -445,7 +446,14 @@ def register_computemanager(
         saturation=0,
     )
 
-    compute_manager_id_ = n4js.register_computemanager(cm_registration)
+    try:
+        compute_manager_id_ = n4js.register_computemanager(cm_registration)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=http_status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(e),
+        )
+
     return compute_manager_id_
 
 
@@ -513,12 +521,12 @@ def update_status_computemanager(
     except ValueError as e:
         raise HTTPException(
             status_code=http_status.HTTP_400_BAD_REQUEST,
-            details=str(e),
+            detail=str(e),
         )
     except Exception as e:
         raise HTTPException(
             status_code=http_status.HTTP_500_INTERNAL_SERVER_ERROR,
-            details=str(e),
+            detail=str(e),
         )
 
     return compute_manager_id

alchemiscale/compute/manager.py

@@ -26,7 +26,7 @@ class ComputeManager:
 
     def __init__(self, settings: ComputeManagerSettings):
         self.settings = settings
-        self.compute_manager_id = ComputeManagerID.new_from_manager_name(
+        self.compute_manager_id = ComputeManagerID.new_from_name(
             self.settings.name
         )
         self.client = AlchemiscaleComputeManagerClient(
@@ -35,6 +35,8 @@ def __init__(self, settings: ComputeManagerSettings):
             key=self.settings.key,
         )
 
+        self._stop = False
+
         logger = logging.getLogger("AlchemiscaleComputeManager")
         logger.setLevel(self.settings.loglevel)
 
@@ -66,8 +68,7 @@ def start(self, max_cycles: int | None = None):
         self._stop = False
         try:
             count = 0
-            while not self._stop:
-                self.cycle()
+            while self.cycle():
                 count += 1
                 if max_cycles and count >= max_cycles:
                     break
@@ -90,7 +91,14 @@ def create_compute_services(self, data: dict) -> int:
         """
         raise NotImplementedError
 
-    def cycle(self):
+    def stop(self):
+        self._stop = True
+
+    def cycle(self) -> bool:
+
+        if self._stop:
+            return False
+
         instruction, data = self.client.get_instruction(self.compute_manager_id)
         match instruction:
             case ComputeManagerInstruction.OK:
@@ -107,17 +115,17 @@ def cycle(self):
                             f"Created {new_services} new compute service(s)"
                         )
                     else:
-                        self.logger.info(f"No new compute services created")
+                        self.logger.info("No new compute services created")
             case ComputeManagerInstruction.SKIP:
                 total_services = len(data["compute_service_ids"])
-                self.logger.info(f"Received skip instruction")
+                self.logger.info("Received skip instruction")
             case ComputeManagerInstruction.SHUTDOWN:
                 shutdown_message = data["message"]
                 self.logger.info(f'Received shutdown message: "{shutdown_message}"')
-                self._stop = True
-                return
+                return False
         self.client.update_status(
             self.compute_manager_id,
             ComputeManagerStatus.OK,
             saturation=total_services / self.settings.max_compute_services,
         )
+        return True

alchemiscale/storage/models.py

@@ -79,13 +79,13 @@ def __init__(self, _value):
         if len(parts) != 6:
             # this currently only supports field-separated hex uuid4s
             raise ValueError(
-                "ComputeManagerID must have the form `{manager_name}-{uuid}` with a field-separated hex"
+                "ComputeManagerID must have the form `{name}-{uuid}` with a field-separated hex"
             )
 
-        self._manager_name = parts[0]
+        self._name = parts[0]
         self._uuid = "-".join(parts[1:])
 
-        if not self.manager_name.isalnum():
+        if not self.name.isalnum():
             raise ValueError("ComputeManagerID only allows alpha-numeric names")
 
         try:
@@ -94,21 +94,21 @@ def __init__(self, _value):
             raise ValueError("Could not interpret the provided UUID.")
 
     @classmethod
-    def new_from_manager_name(cls, manager_name: str):
-        return cls(f"{manager_name}-{uuid4()}")
+    def new_from_name(cls, name: str):
+        return cls(f"{name}-{uuid4()}")
 
     def to_dict(self):
-        return {"manager_name": self.manager_name, "uuid": self.uuid}
+        return {"name": self.name, "uuid": self.uuid}
 
     @classmethod
     def from_dict(cls, dct):
-        manager_name = dct["manager_name"]
+        name = dct["name"]
         uuid = dct["uuid"]
-        return cls(manager_name + "-" + uuid)
+        return cls(name + "-" + uuid)
 
     @property
-    def manager_name(self) -> str:
-        return self._manager_name
+    def name(self) -> str:
+        return self._name
 
     @property
     def uuid(self) -> str:
@@ -117,18 +117,19 @@ def uuid(self) -> str:
 
 class ComputeManagerRegistration(BaseModel):
 
-    manager_name: str
+    name: str
     uuid: str
     last_status_update: datetime.datetime
     status: str
     detail: str
     saturation: float
+    registered: datetime.datetime
 
     def __repr__(self):  # pragma: no cover
         return f"<ComputeManagerRegistration('{str(self)}')>"
 
     def __str__(self):
-        return "-".join([self.manager_name, self.uuid])
+        return "-".join([self.name, self.uuid])
 
     def to_dict(self):
         return self.model_dump()
@@ -138,7 +139,7 @@ def from_dict(cls, dct):
         return cls(**dct)
 
     def to_compute_manager_id(self):
-        return ComputeManagerID("-".join([self.manager_name, self.uuid]))
+        return ComputeManagerID("-".join([self.name, self.uuid]))
 
 
 class TaskProvenance(BaseModel):