| # Copyright 2017-present Open Networking Foundation |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| from protos import dynamicload_pb2 |
| from protos import dynamicload_pb2_grpc |
| |
| from dynamicbuild import DynamicBuilder |
| from apistats import REQUEST_COUNT, track_request_time |
| from authhelper import XOSAuthHelperMixin |
| from decorators import translate_exceptions, require_authentication |
| import grpc |
| import semver |
| from xosconfig import Config |
| from multistructlog import create_logger |
| |
| log = create_logger(Config().get("logging")) |
| |
| |
| class DynamicLoadService(dynamicload_pb2_grpc.dynamicloadServicer, XOSAuthHelperMixin): |
| def __init__(self, thread_pool, server): |
| self.thread_pool = thread_pool |
| self.server = server |
| self.django_apps = None |
| self.django_apps_by_name = {} |
| XOSAuthHelperMixin.__init__(self) |
| |
| def stop(self): |
| pass |
| |
| def set_django_apps(self, django_apps): |
| """ Allows the creator of DynamicLoadService to pass in a pointer to django's app list once django has been |
| installed. This is optional. We don't import django.apps directly, as DynamicLoadService must be able |
| to run even if django is broken due to modeling issues. |
| """ |
| self.django_apps = django_apps |
| |
| # Build up some dictionaries used by the API handlers. We can build these once at initialization time because |
| # when apps are onboarded, the core is always restarted. |
| |
| self.django_apps_by_name = {} |
| self.django_app_models = {} |
| if self.django_apps: |
| for app in self.django_apps.get_app_configs(): |
| self.django_apps_by_name[app.name] = app |
| |
| # Build up a dictionary of all non-decl models. |
| django_models = {} |
| for (k, v) in app.models.items(): |
| if not k.endswith("_decl"): |
| django_models[k] = v |
| self.django_app_models[app.name] = django_models |
| |
| def get_core_version(self): |
| try: |
| core_version = open("/opt/xos/VERSION").readline().strip() |
| except Exception: |
| core_version = "unknown" |
| |
| return core_version |
| |
| @track_request_time("DynamicLoad", "LoadModels") |
| @translate_exceptions("DynamicLoad", "LoadModels") |
| @require_authentication |
| def LoadModels(self, request, context): |
| try: |
| core_version = self.get_core_version() |
| requested_core_version = request.core_version |
| log.info("Loading service models", |
| service=request.name, |
| service_version=request.version, |
| requested_core_version=requested_core_version |
| ) |
| |
| if not requested_core_version: |
| requested_core_version = ">=2.2.1" |
| |
| if "~" in requested_core_version: |
| [min_requested, max_requested] = requested_core_version.split("~") |
| |
| match_min_version = semver.match(core_version, min_requested.strip()) |
| match_max_version = semver.match(core_version, max_requested.strip()) |
| |
| if not match_min_version or not match_max_version: |
| log.error("Not loading service because of mismatching versions", |
| service=request.name, |
| core_version=core_version, |
| requested_min_core_version=min_requested, |
| requested_max_core_version=max_requested |
| ) |
| context.set_code(grpc.StatusCode.INVALID_ARGUMENT) |
| msg = "Service %s is requesting core version between %s and %s but actual version is %s" % ( |
| request.name, |
| min_requested, |
| max_requested, |
| core_version |
| ) |
| context.set_details(msg) |
| raise Exception(msg) |
| |
| else: |
| match_version = semver.match(core_version, requested_core_version.strip()) |
| if not match_version: |
| log.error("Not loading service because of mismatching versions", service=request.name, |
| core_version=core_version, requested_core_version=requested_core_version) |
| context.set_code(grpc.StatusCode.INVALID_ARGUMENT) |
| msg = "Service %s is requesting core version %s but actual version is %s" % ( |
| request.name, requested_core_version, core_version) |
| context.set_details(msg) |
| raise Exception(msg) |
| |
| builder = DynamicBuilder() |
| result = builder.handle_loadmodels_request(request) |
| |
| if result == builder.SUCCESS: |
| self.server.delayed_shutdown(5) |
| |
| response = dynamicload_pb2.LoadModelsReply() |
| response.status = result |
| REQUEST_COUNT.labels( |
| "xos-core", "DynamicLoad", "LoadModels", grpc.StatusCode.OK |
| ).inc() |
| return response |
| except Exception as e: |
| import traceback |
| |
| traceback.print_exc() |
| REQUEST_COUNT.labels( |
| "xos-core", "DynamicLoad", "LoadModels", grpc.StatusCode.INTERNAL |
| ).inc() |
| raise e |
| |
| def map_error_code(self, status, context): |
| """ Map the DynamicLoad status into an appropriate gRPC status code |
| and include an error description if appropriate. |
| |
| Chameleon supports limited mapping to http status codes. |
| Picked a best-fit: |
| OK = 200 |
| INVALID_ARGUMENT = 400 |
| ALREADY_EXISTS = 409 |
| """ |
| |
| code_names = { |
| DynamicBuilder.SUCCESS: "SUCCESS", |
| DynamicBuilder.SUCCESS_NOTHING_CHANGED: "SUCCESS_NOTHING_CHANGED", |
| DynamicBuilder.ERROR: "ERROR", |
| DynamicBuilder.ERROR_LIVE_MODELS: "ERROR_LIVE_MODELS", |
| DynamicBuilder.ERROR_DELETION_IN_PROGRESS: "ERROR_DELETION_IN_PROGRESS", |
| DynamicBuilder.TRYAGAIN: "TRYAGAIN"} |
| |
| code_map = { |
| DynamicBuilder.SUCCESS: grpc.StatusCode.OK, |
| DynamicBuilder.SUCCESS_NOTHING_CHANGED: grpc.StatusCode.OK, |
| DynamicBuilder.ERROR: grpc.StatusCode.INVALID_ARGUMENT, |
| DynamicBuilder.ERROR_LIVE_MODELS: grpc.StatusCode.ALREADY_EXISTS, |
| DynamicBuilder.ERROR_DELETION_IN_PROGRESS: grpc.StatusCode.ALREADY_EXISTS, |
| DynamicBuilder.TRYAGAIN: grpc.StatusCode.OK} |
| |
| code = code_map.get(status, DynamicBuilder.ERROR) |
| |
| context.set_code(code) |
| if code != grpc.StatusCode.OK: |
| # In case of error, send helpful text back to the caller |
| context.set_details(code_names.get(status, "UNKNOWN")) |
| |
| @track_request_time("DynamicLoad", "UnloadModels") |
| @translate_exceptions("DynamicLoad", "UnloadModels") |
| @require_authentication |
| def UnloadModels(self, request, context): |
| try: |
| builder = DynamicBuilder() |
| result = builder.handle_unloadmodels_request(request, |
| self.django_app_models.get("services." + request.name, {})) |
| |
| if result == builder.SUCCESS: |
| self.server.delayed_shutdown(5) |
| |
| self.map_error_code(result, context) |
| |
| response = dynamicload_pb2.LoadModelsReply() |
| response.status = result |
| REQUEST_COUNT.labels( |
| "xos-core", "DynamicLoad", "UnloadModels", grpc.StatusCode.OK |
| ).inc() |
| return response |
| except Exception as e: |
| import traceback |
| |
| traceback.print_exc() |
| REQUEST_COUNT.labels( |
| "xos-core", "DynamicLoad", "UnloadModels", grpc.StatusCode.INTERNAL |
| ).inc() |
| raise e |
| |
| @track_request_time("DynamicLoad", "GetLoadStatus") |
| @translate_exceptions("DynamicLoad", "GetLoadStatus") |
| @require_authentication |
| def GetLoadStatus(self, request, context): |
| try: |
| builder = DynamicBuilder() |
| manifests = builder.get_manifests() |
| |
| response = dynamicload_pb2.LoadStatusReply() |
| response.model_status = self.server.model_status |
| response.model_output = self.server.model_output |
| for manifest in manifests: |
| item = response.services.add() |
| item.name = manifest["name"] |
| item.version = manifest["version"] |
| item.state = manifest.get("state", "unspecified") |
| |
| if item.state == "load": |
| django_app = self.django_apps_by_name.get("services." + item.name) |
| if django_app: |
| item.state = "present" |
| # TODO: Might be useful to return a list of models as well |
| |
| # the core is always onboarded, so doesn't have an explicit manifest |
| item = response.services.add() |
| item.name = "core" |
| item.version = self.get_core_version() |
| if "core" in self.django_apps_by_name: |
| item.state = "present" |
| else: |
| item.state = "load" |
| REQUEST_COUNT.labels( |
| "xos-core", "DynamicLoad", "GetLoadStatus", grpc.StatusCode.OK |
| ).inc() |
| return response |
| except Exception as e: |
| import traceback |
| |
| traceback.print_exc() |
| REQUEST_COUNT.labels( |
| "xos-core", "DynamicLoad", "GetLoadStatus", grpc.StatusCode.INTERNAL |
| ).inc() |
| raise e |
| |
| @track_request_time("DynamicLoad", "GetConvenienceMethods") |
| @translate_exceptions("DynamicLoad", "GetConvenienceMethods") |
| @require_authentication |
| def GetConvenienceMethods(self, request, context): |
| # self.authenticate(context, required=True) |
| try: |
| builder = DynamicBuilder() |
| manifests = builder.get_manifests() |
| |
| response = dynamicload_pb2.ListConvenienceMethodsReply() |
| |
| for manifest in manifests: |
| for cm in manifest["convenience_methods"]: |
| item = response.convenience_methods.add() |
| item.filename = cm["filename"] |
| item.contents = open(cm["path"]).read() |
| REQUEST_COUNT.labels( |
| "xos-core", "DynamicLoad", "GetConvenienceMethods", grpc.StatusCode.OK |
| ).inc() |
| return response |
| |
| except Exception as e: |
| import traceback |
| |
| traceback.print_exc() |
| REQUEST_COUNT.labels( |
| "xos-core", |
| "DynamicLoad", |
| "GetConvenienceMethods", |
| grpc.StatusCode.INTERNAL, |
| ).inc() |
| raise e |