edge_cloud_management_api/controllers/edge_cloud_controller.py

@@ -6,12 +6,16 @@ from edge_cloud_management_api.managers.log_manager import logger
 from edge_cloud_management_api.services.edge_cloud_services import PiEdgeAPIClientFactory
 from edge_cloud_management_api.services.storage_service import insert_zones
 
+
+try:
     pi_edge_factory = PiEdgeAPIClientFactory()
     api_client = pi_edge_factory.create_pi_edge_api_client()
     zones = api_client.edge_cloud_zones()
     for zone in zones:
         zone['_id'] = zone.get('edgeCloudZoneId')
     insert_zones(zones)
+except Exception as e:
+    logger.error(e.args)
 
 class EdgeCloudZone(BaseModel):
     edgeCloudZoneId: str = Field(..., description="Unique identifier of the Edge Cloud Zone")
@@ -47,8 +51,6 @@ def get_local_zones() -> list[dict]:
         if isinstance(result, dict) and "error" in result:
             logger.error(f"SRM error: {result['error']}")
             return []
-
-
         return result
 
     except Exception as e:

edge_cloud_management_api/controllers/federation_manager_controller.py

@@ -17,28 +17,28 @@ def create_federation():
 
     body = request.get_json()
     token = __get_token()
-    response = federation_client.post_partner(body, token)
-    return jsonify(response)
+    response, code = federation_client.post_partner(body, token)
+    return response, code
 
 def get_federation(federationContextId):
     """GET /{federationContextId}/partner - Get federation info."""
 
     token = __get_token()
-    result = federation_client.get_partner(federationContextId, token)
-    return jsonify(result)
+    response, code = federation_client.get_partner(federationContextId, token)
+    return response, code
 
 def delete_federation(federationContextId):
     """DELETE /{federationContextId}/partner - Delete federation."""
 
     token = __get_token()
-    result = federation_client.delete_partner(federationContextId, token)
-    return jsonify(result)
+    response, code = federation_client.delete_partner(federationContextId, token)
+    return response, code
 
 def get_federation_context_ids():
     """GET /fed-context-id - Fetch federationContextId(s)."""
     token = __get_token()
-    response = federation_client.get_federation_context_ids(token)
-    return jsonify(response)
+    response, code = federation_client.get_federation_context_ids(token)
+    return response, code
   
 
 def onboard_application_to_partner(federationContextId):
@@ -64,6 +64,23 @@ def delete_onboarded_app(federationContextId, appId):
     result = federation_client.delete_onboarded_app(federationContextId, appId, token)
     return jsonify(result)
 
+'''---AVAILABILITY ZONE INFO SYNCHRONIZATION---'''
+
+def request_zone_synch(federationContextId):
+    token = __get_token()
+    body = request.get_json()
+    response = federation_client.request_zone_sync(federation_context_id=federationContextId, body=body, token=token)
+    return jsonify(response)
+
+def get_zone_resource_info(federationContextId, zoneId):
+    token = __get_token()
+    response = federation_client.get_zone_resource_info(federation_context_id=federationContextId, zone_id=zoneId, token=token)
+    return jsonify(response)
+
+def remove_zone_sync(federationContextId, zoneId):
+    token = __get_token()
+    response = federation_client.remove_zone_sync(federation_context_id=federationContextId, zone_id=zoneId, token=token)
+    return jsonify(response)
 
 def __get_token():
     bearer = connexion.request.headers['Authorization']

edge_cloud_management_api/services/federation_services.py

@@ -18,83 +18,86 @@ class FederationManagerClient:
         headers['Accept'] = 'application/json'
         return headers
 
+    '''---FEDERATION ESTABLISHMENT---'''
+
     def post_partner(self, data: dict, token: str):
         url = f"{self.base_url}/partner"
         try:
             response = requests.post(url, json=data, headers=self._get_headers(token), timeout=10)
             response.raise_for_status()
-            return response.json()
+            return response.json(), 200
         except Timeout:
             logger.error("POST /partner timed out")
             return {"error": "Request timed out"}, 408
         except ConnectionError:
             logger.error("POST /partner connection error")
-            return {"error": "Connection error"}
+            return {"error": "Connection error"}, 504
         except requests.exceptions.HTTPError as http_err:
             logger.error(f"POST /partner HTTP error: {http_err}")
-            return {"error": str(http_err), "status_code": response.status_code}
+            return {'Error': http_err.response.json().get('detail')}, response.status_code
         except Exception as e:
             logger.error(f"POST /partner unexpected error: {e}")
-            return {"error": str(e)}
+            return {"error": str(e)}, 500
 
     def get_partner(self, federation_context_id: str, token: str):
         url = f"{self.base_url}/{federation_context_id}/partner"
         try:
             response = requests.get(url, headers=self._get_headers(token), timeout=10)
             response.raise_for_status()
-            return response.json()
+            return response.json(), 200
         except Timeout:
             logger.error("GET /{id}/partner timed out")
-            return {"error": "Request timed out"}
+            return {"error": "Request timed out"}, 408
         except ConnectionError:
             logger.error("GET /{id}/partner connection error")
-            return {"error": "Connection error"}
+            return {"error": "Connection error"}, 504
         except requests.exceptions.HTTPError as http_err:
             logger.error(f"GET /{id}/partner HTTP error: {http_err}")
-            return {"error": str(http_err), "status_code": response.status_code}
+            return {'Error': http_err.response.json().get('detail')}, response.status_code
         except Exception as e:
             logger.error(f"GET /{id}/partner unexpected error: {e}")
-            return {"error": str(e)}
+            return {"error": str(e)}, 500
 
     def delete_partner(self, federation_context_id: str, token: str):
         url = f"{self.base_url}/{federation_context_id}/partner"
         try:
             response = requests.delete(url, headers=self._get_headers(token), timeout=10)
             if response.content:
-                return response.json()
+                return response.json(), 200
             return {"status": response.status_code}
         except Timeout:
             logger.error("DELETE /{id}/partner timed out")
-            return {"error": "Request timed out"}
+            return {"error": "Request timed out"}, 408
         except ConnectionError:
             logger.error("DELETE /{id}/partner connection error")
-            return {"error": "Connection error"}
+            return {"error": "Connection error"}, 504
         except requests.exceptions.HTTPError as http_err:
             logger.error(f"DELETE /{id}/partner HTTP error: {http_err}")
-            return {"error": str(http_err), "status_code": response.status_code}
+            return {'Error': http_err.response.json().get('detail')}, response.status_code
         except Exception as e:
             logger.error(f"DELETE /{id}/partner unexpected error: {e}")
-            return {"error": str(e)}
+            return {"error": str(e)}, 500
 
     def get_federation_context_ids(self, token: str):
         url = f"{self.base_url}/fed-context-id"
         try:
             response = requests.get(url, headers=self._get_headers(token), timeout=10)
             response.raise_for_status()
-            return response.json()
+            return response.json(), 200
         except Timeout:
             logger.error("GET /fed-context-id timed out")
-            return {"error": "Request timed out"}
+            return {"error": "Request timed out"}, 408
         except ConnectionError:
             logger.error("GET /fed-context-id connection error")
-            return {"error": "Connection error"}
+            return {"error": "Connection error"}, 504
         except requests.exceptions.HTTPError as http_err:
             logger.error(f"GET /fed-context-id HTTP error: {http_err}")
-            if response.status_code==404:
-                return {'erorr': http_err}, 404
+            return {'Error': http_err.response.json().get('detail')}, response.status_code
         except Exception as e:
             logger.error(f"GET /fed-context-id unexpected error: {e}")
-            return {"error": str(e)}
+            return {"error": str(e)}, 500
+        
+    '''---PARTNER APP ONBOARDING---'''    
 
     def onboard_application(self, federation_context_id: str, body: dict, token: str):
         url = f"{self.base_url}/{federation_context_id}/application/onboarding"
@@ -138,12 +141,12 @@ class FederationManagerClient:
     def delete_onboarded_app(self, federation_context_id: str, app_id: str, token: str):
         url = f"{self.base_url}/{federation_context_id}/application/onboarding/app/{app_id}"
         try:
-            response = requests.delete(url, headers=self._get_headers(), timeout=10)
+            response = requests.delete(url, headers=self._get_headers(token), timeout=10)
             response.raise_for_status()
             return {"message": "Deleted successfully", "status_code": response.status_code}
         except Timeout:
             logger.error("DELETE onboarding app timed out")
-            return {"error": "Request timed out", "status_code": 504}
+            return {"error": "Request timed out", "status_code": 408}
         except ConnectionError:
             logger.error("DELETE onboarding app connection error")
             return {"error": "Connection error", "status_code": 503}
@@ -154,6 +157,67 @@ class FederationManagerClient:
             logger.error(f"DELETE onboarding app unexpected error: {e}")
             return {"error": str(e), "status_code": 500}
 
+    '''---PARTNER APP DEPLOYMENT---'''
+
+
+    '''---AVAILABILITY ZONE INFO SYNCHRONIZATION---'''
+
+    def request_zone_sync(self, federation_context_id: str, body: dict, token: str):
+
+        url = f"{self.base_url}/{federation_context_id}/zones"
+        try:
+            response = requests.post(url, headers=self._get_headers(token), json=body, timeout=10)
+            return response.json()
+        except Timeout:
+            logger.error("Zone synchronization timed out")
+            return {"error": "Request timed out", "status_code": 408}
+        except ConnectionError:
+            logger.error("Zone synchronization connection error")
+            return {"error": "Connection error", "status_code": 503}
+        except requests.exceptions.HTTPError as http_err:
+            logger.error(f"Zone synchronization HTTP error: {http_err}")
+            return {"error": str(http_err), "status_code": response.status_code}
+        except Exception as e:
+            logger.error(f"Zone synchronization unexpected error: {e}")
+            return {"error": str(e), "status_code": 500}
+
+    def get_zone_resource_info(self, federation_context_id: str, zone_id: str, token: str):
+
+        url = f"{self.base_url}/{federation_context_id}/zones/{zone_id}"
+        try:
+            response = requests.get(url, headers=self._get_headers(token), timeout=10)
+            return response.json()
+        except Timeout:
+            logger.error("Zone resource info timed out")
+            return {"error": "Request timed out", "status_code": 408}
+        except ConnectionError:
+            logger.error("Zone resource info connection error")
+            return {"error": "Connection error", "status_code": 503}
+        except requests.exceptions.HTTPError as http_err:
+            logger.error(f"Zone resource info HTTP error: {http_err}")
+            return {"error": str(http_err), "status_code": response.status_code}
+        except Exception as e:
+            logger.error(f"Zone resource info unexpected error: {e}")
+            return {"error": str(e), "status_code": 500}
+        
+    def remove_zone_sync(self, federation_context_id: str, zone_id: str, token: str):
+
+        url = f"{self.base_url}/{federation_context_id}/zones/{zone_id}"
+        try:
+            response = requests.delete(url, headers=self._get_headers(token), timeout=10)
+            return response.json()
+        except Timeout:
+            logger.error("Remove Zone sync timed out")
+            return {"error": "Request timed out", "status_code": 408}
+        except ConnectionError:
+            logger.error("Remove Zone sync connection error")
+            return {"error": "Connection error", "status_code": 503}
+        except requests.exceptions.HTTPError as http_err:
+            logger.error(f"Remove Zone sync HTTP error: {http_err}")
+            return {"error": str(http_err), "status_code": response.status_code}
+        except Exception as e:
+            logger.error(f"Remove Zone sync unexpected error: {e}")
+            return {"error": str(e), "status_code": 500}    
 
 
 class FederationManagerClientFactory: