Skip listing sessions over paused dbs during delete lookup

Author: FlorentinD

graphdatascience/session/dedicated_sessions.py

@@ -51,7 +51,6 @@ def get_or_create(
         # hashing the password to avoid storing the actual db password in Aura
         password = hashlib.sha256(db_connection.password.encode()).hexdigest()
 
-        # TODO configure session size (and check existing_session has same size)
         if existing_session:
             self._check_expiry_date(existing_session)
             self._check_memory_configuration(existing_session, memory.value)
@@ -106,7 +105,13 @@ def list(self) -> List[SessionInfo]:
         return [SessionInfo.from_session_details(i) for i in sessions]
 
     def _find_existing_session(self, session_name: str, dbid: str) -> Optional[SessionDetails]:
-        matched_sessions = [s for s in self._aura_api.list_sessions(dbid) if s.name == session_name]
+        matched_sessions: List[SessionDetails] = []
+        try:
+            matched_sessions = [s for s in self._aura_api.list_sessions(dbid) if s.name == session_name]
+        except HTTPError as e:
+            # ignore 404 errors when listing sessions as it could mean paused sessions or deleted sessions
+            if e.response.status_code != 404:
+                raise e
 
         if len(matched_sessions) == 0:
             return None

graphdatascience/tests/unit/test_dedicated_sessions.py

@@ -69,6 +69,15 @@ def add_session(self, session: SessionDetails) -> None:
 
         self._sessions[session.id] = session
 
+    # aura behaviour of paused instances not being in an orchestra
+    def _mimic_paused_db_behaviour(self, dbid: str) -> None:
+        db = self.list_instance(dbid)
+        if db and db.status == "paused":
+            response = Response()
+            response.status_code = 404
+            response._content = b"database not found"
+            raise HTTPError(request=None, response=response)
+
     def create_instance(
         self, name: str, memory: SessionMemoryValue, cloud_provider: str, region: str
     ) -> InstanceCreateDetails:
@@ -104,20 +113,16 @@ def delete_instance(self, instance_id: str) -> InstanceSpecificDetails:
         return self._instances.pop(instance_id)
 
     def list_sessions(self, dbid: str) -> List[SessionDetails]:
-        # mimic aura behaviour of paused instances not being in an orchestra
-        db = self.list_instance(dbid)
-        if db and db.status == "paused":
-            response = Response()
-            response.status_code = 404
-            response._content = b"database not found"
-            raise HTTPError(request=None, response=response)
+        self._mimic_paused_db_behaviour(dbid)
 
         return [v for _, v in self._sessions.items() if v.instance_id == dbid]
 
     def list_instances(self) -> List[InstanceDetails]:
         return [v for _, v in self._instances.items()]
 
     def list_session(self, session_id: str, dbid: str) -> Optional[SessionDetails]:
+        self._mimic_paused_db_behaviour(dbid)
+
         matched_instance = self._sessions.get(session_id, None)
 
         if matched_instance:
@@ -399,6 +404,35 @@ def test_delete_nonunique_session(aura_api: AuraApi) -> None:
     assert len(sessions.list()) == 2
 
 
+def test_delete_session_paused_instance(aura_api: AuraApi) -> None:
+    fake_aura_api = cast(FakeAuraApi, aura_api)
+
+    fake_aura_api.id_counter += 1
+    paused_db = InstanceSpecificDetails(
+        id="4242",
+        status="paused",
+        connection_url="foo.bar",
+        memory=SessionMemory.m_16GB.value,
+        type="",
+        region="dresden",
+        name="paused-db",
+        tenant_id=fake_aura_api._tenant_id,
+        cloud_provider="aws",
+    )
+    fake_aura_api._instances[paused_db.id] = paused_db
+
+    session = aura_api.create_session(
+        name="gds-session-my-session-name",
+        dbid=paused_db.id,
+        pwd="some_pwd",
+        memory=SessionMemory.m_8GB.value,
+    )
+    sessions = DedicatedSessions(aura_api)
+
+    # cannot delete session running against a paused instance
+    assert not sessions.delete(session.name)
+
+
 def test_create_waiting_forever() -> None:
     aura_api = FakeAuraApi(status_after_creating="updating")
     _setup_db_instance(aura_api)