Commit b5c88bb1 authored by Dimitrios Laskaratos's avatar Dimitrios Laskaratos
Browse files

Merge branch 'dev-dimitris' into 'main' 

Fixed federation api error codes

See merge request !5
parents 62d4b26d f2ede60a

edge_cloud_management_api/controllers/edge_cloud_controller.py

+10 −8
Original line number Diff line number Diff line
@@ -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

+26 −9
Original line number Diff line number Diff line
@@ -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

+86 −22
Original line number Diff line number Diff line
@@ -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:

edge_cloud_management_api/specification/openapi.yaml

+248 −250

File changed.

Preview size limit exceeded, changes collapsed.