a1/controller.py

   1 # ==================================================================================
   2 #       Copyright (c) 2019-2020 Nokia
   3 #       Copyright (c) 2018-2020 AT&T Intellectual Property.
   4 #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");
   6 #   you may not use this file except in compliance with the License.
   7 #   You may obtain a copy of the License at
   8 #
   9 #          http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 #   Unless required by applicable law or agreed to in writing, software
  12 #   distributed under the License is distributed on an "AS IS" BASIS,
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 #   See the License for the specific language governing permissions and
  15 #   limitations under the License.
  16 # ==================================================================================
  17 """
  18 Main a1 controller
  19 """
  20 from jsonschema import validate
  21 from jsonschema.exceptions import ValidationError
  22 import connexion
  23 from prometheus_client import Counter
  24 from mdclogpy import Logger
  25 from ricsdl.exceptions import RejectedByBackend, NotConnected, BackendError
  26 from a1 import a1rmr, exceptions, data
  27
  28
  29 mdc_logger = Logger(name=__name__)
  30 request_counter = Counter('policy_requests', 'Policy type and instance requests', ['action', 'target'])
  31
  32
  33 def _log_build_http_resp(exception, http_resp_code):
  34     """
  35     helper method that logs the exception and returns a tuple of (str, int) as a http response
  36     """
  37     msg = repr(exception)
  38     mdc_logger.warning("Request failed, returning {0}: {1}".format(http_resp_code, msg))
  39     return msg, http_resp_code
  40
  41
  42 def _try_func_return(func):
  43     """
  44     helper method that runs the function and returns a detailed http response if an exception is raised.
  45     """
  46     try:
  47         return func()
  48     except (ValidationError, exceptions.PolicyTypeAlreadyExists, exceptions.PolicyTypeIdMismatch, exceptions.CantDeleteNonEmptyType) as exc:
  49         return _log_build_http_resp(exc, 400)
  50     except (exceptions.PolicyTypeNotFound, exceptions.PolicyInstanceNotFound) as exc:
  51         return _log_build_http_resp(exc, 404)
  52     except (RejectedByBackend, NotConnected, BackendError) as exc:
  53         """
  54         These are SDL errors. At the time of development here, we do not have a good understanding
  55         which of these errors are "try again later it may work" and which are "never going to work".
  56         There is some discussion that RejectedByBackend is in the latter category, suggesting it
  57         should map to 400, but until we understand the root cause of these errors, it's confusing
  58         to clients to give them a 400 (a "your fault" code) because they won't know how to fix.
  59         For now, we log, and 503, and investigate the logs later to improve the handling/reporting.
  60         """
  61         # mdc_logger.exception(exc)  # waiting for https://jira.o-ran-sc.org/browse/RIC-39
  62         return _log_build_http_resp(exc, 503)
  63     # let other types of unexpected exceptions blow up and log
  64
  65
  66 # Healthcheck
  67
  68
  69 def get_healthcheck():
  70     """
  71     Handles healthcheck GET
  72     Currently, this checks:
  73     1. whether the a1 webserver is up (if it isn't, this won't even be called, so even entering this function confirms it is)
  74     2. checks whether the rmr thread is running and has completed a loop recently
  75     3. checks that our SDL connection is healthy
  76     """
  77     if not a1rmr.healthcheck_rmr_thread():
  78         mdc_logger.debug("A1 is not healthy due to the rmr thread")
  79         return "rmr thread is unhealthy", 500
  80     if not data.SDL.healthcheck():
  81         mdc_logger.debug("A1 is not healthy because it does not have a connection to SDL")
  82         return "sdl connection is unhealthy", 500
  83     return "", 200
  84
  85
  86 # Policy types
  87
  88
  89 def get_all_policy_types():
  90     """
  91     Handles GET /a1-p/policytypes
  92     """
  93     return _try_func_return(data.get_type_list)
  94
  95
  96 def create_policy_type(policy_type_id):
  97     """
  98     Handles PUT /a1-p/policytypes/policy_type_id
  99     """
 100     request_counter.labels(action='create', target='policy_type').inc()
 101
 102     def put_type_handler():
 103         data.store_policy_type(policy_type_id, body)
 104         mdc_logger.debug("Policy type {} created.".format(policy_type_id))
 105         return "", 201
 106
 107     body = connexion.request.json
 108     return _try_func_return(put_type_handler)
 109
 110
 111 def get_policy_type(policy_type_id):
 112     """
 113     Handles GET /a1-p/policytypes/policy_type_id
 114     """
 115     return _try_func_return(lambda: data.get_policy_type(policy_type_id))
 116
 117
 118 def delete_policy_type(policy_type_id):
 119     """
 120     Handles DELETE /a1-p/policytypes/policy_type_id
 121     """
 122     request_counter.labels(action='delete', target='policy_type').inc()
 123
 124     def delete_policy_type_handler():
 125         data.delete_policy_type(policy_type_id)
 126         mdc_logger.debug("Policy type {} deleted.".format(policy_type_id))
 127         return "", 204
 128
 129     return _try_func_return(delete_policy_type_handler)
 130
 131
 132 # Policy instances
 133
 134
 135 def get_all_instances_for_type(policy_type_id):
 136     """
 137     Handles GET /a1-p/policytypes/policy_type_id/policies
 138     """
 139     return _try_func_return(lambda: data.get_instance_list(policy_type_id))
 140
 141
 142 def get_policy_instance(policy_type_id, policy_instance_id):
 143     """
 144     Handles GET /a1-p/policytypes/polidyid/policies/policy_instance_id
 145     """
 146     return _try_func_return(lambda: data.get_policy_instance(policy_type_id, policy_instance_id))
 147
 148
 149 def get_policy_instance_status(policy_type_id, policy_instance_id):
 150     """
 151     Handles GET /a1-p/policytypes/polidyid/policies/policy_instance_id/status
 152
 153     Return the aggregated status. The order of rules is as follows:
 154         1. If a1 has received at least one status, and *all* received statuses are "DELETED", we blow away the instance and return a 404
 155         2. if a1 has received at least one status and at least one is OK, we return "IN EFFECT"
 156         3. "NOT IN EFFECT" otherwise (no statuses, or none are OK but not all are deleted)
 157     """
 158     return _try_func_return(lambda: data.get_policy_instance_status(policy_type_id, policy_instance_id))
 159
 160
 161 def create_or_replace_policy_instance(policy_type_id, policy_instance_id):
 162     """
 163     Handles PUT /a1-p/policytypes/polidyid/policies/policy_instance_id
 164     """
 165     request_counter.labels(action='create', target='policy_inst').inc()
 166     instance = connexion.request.json
 167
 168     def put_instance_handler():
 169         """
 170         Handles policy instance put
 171
 172         For now, policy_type_id is used as the message type
 173         """
 174         #  validate the PUT against the schema
 175         schema = data.get_policy_type(policy_type_id)["create_schema"]
 176         validate(instance=instance, schema=schema)
 177
 178         # store the instance
 179         operation = data.store_policy_instance(policy_type_id, policy_instance_id, instance)
 180
 181         # queue rmr send (best effort)
 182         a1rmr.queue_instance_send((operation, policy_type_id, policy_instance_id, instance))
 183
 184         return "", 202
 185
 186     return _try_func_return(put_instance_handler)
 187
 188
 189 def delete_policy_instance(policy_type_id, policy_instance_id):
 190     """
 191     Handles DELETE /a1-p/policytypes/polidyid/policies/policy_instance_id
 192     """
 193     request_counter.labels(action='delete', target='policy_inst').inc()
 194
 195     def delete_instance_handler():
 196         data.delete_policy_instance(policy_type_id, policy_instance_id)
 197
 198         # queue rmr send (best effort)
 199         a1rmr.queue_instance_send(("DELETE", policy_type_id, policy_instance_id, ""))
 200
 201         return "", 202
 202
 203     return _try_func_return(delete_instance_handler)
 204
 205
 206 # data delivery
 207
 208
 209 def data_delivery():
 210     """
 211     Handle data delivery /data-delivery
 212     """
 213
 214     def data_delivery_handler():
 215         mdc_logger.debug("data: {}".format(connexion.request.json))
 216         ei_job_result_json = connexion.request.json
 217         mdc_logger.debug("jobid: {}".format(ei_job_result_json.get("job")))
 218         a1rmr.queue_ei_job_result((ei_job_result_json.get("job"), ei_job_result_json))
 219         return "", 200
 220
 221     return _try_func_return(data_delivery_handler)