X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=osdfapp.py;h=8b672f4a9e109bcd05fabb46b74972f01a26bd2f;hb=HEAD;hp=bd5efa718efff1be51966a5b6df66c31c08007a9;hpb=eb744cef4d81f9f88709d3ba8cdf81015b27106b;p=optf%2Fosdf.git diff --git a/osdfapp.py b/osdfapp.py index bd5efa7..8b672f4 100755 --- a/osdfapp.py +++ b/osdfapp.py @@ -1,5 +1,6 @@ # ------------------------------------------------------------------------- # Copyright (c) 2015-2017 AT&T Intellectual Property +# Copyright (C) 2020 Wipro Limited. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -20,79 +21,36 @@ OSDF Manager Main Flask Application """ -import sys -from threading import Thread # for scaling up, may need celery with RabbitMQ or redis +import json -from flask import Flask, request, Response, g +from threading import Thread # for scaling up, may need celery with RabbitMQ or redis -import osdf -import pydevd -import json -import osdf.adapters.policy.interface -import osdf.config.credentials -import osdf.config.loader -import osdf.operation.error_handling -import osdf.operation.responses -import traceback +from flask import request, g + +from osdf.apps.baseapp import app, run_app +from apps.nst.models.api.nstSelectionRequest import NSTSelectionAPI +from apps.nsst.models.api.nsstSelectionRequest import NSSTSelectionAPI +from apps.pci.models.api.pciOptimizationRequest import PCIOptimizationAPI +from apps.nst.optimizers.nst_select_processor import NstSelection +from apps.nsst.optimizers.nsst_select_processor import NsstSelection +from apps.pci.optimizers.pci_opt_processor import process_pci_optimation +from apps.placement.models.api.placementRequest import PlacementAPI +from apps.placement.optimizers.conductor.remote_opt_processor import process_placement_opt +from apps.route.optimizers.inter_domain_route_opt import InterDomainRouteOpt +from apps.route.optimizers.simple_route_opt import RouteOpt +from apps.slice_selection.models.api.nsi_selection_request import NSISelectionAPI +from apps.slice_selection.models.api.nssi_selection_request import NSSISelectionAPI +from apps.slice_selection.optimizers.conductor.remote_opt_processor import SliceSelectionOptimizer from osdf.adapters.policy.interface import get_policies +from osdf.adapters.policy.interface import upload_policy_models from osdf.config.base import osdf_config -from osdf.optimizers.placementopt.conductor.remote_opt_processor import process_placement_opt -from osdf.webapp.appcontroller import auth_basic -from optparse import OptionParser -from osdf.operation.exceptions import BusinessException -from osdf.operation.error_handling import request_exception_to_json_body, internal_error_message -from requests import RequestException -from schematics.exceptions import DataError -from osdf.logging.osdf_logging import MH, audit_log, error_log, debug_log -from osdf.models.api.placementRequest import PlacementAPI +from osdf.config.base import slice_config +from osdf.logging.osdf_logging import MH, audit_log from osdf.operation.responses import osdf_response_for_request_accept as req_accept -from osdf.optimizers.routeopt.simple_route_opt import RouteOpt - -ERROR_TEMPLATE = osdf.ERROR_TEMPLATE - -app = Flask(__name__) - -BAD_CLIENT_REQUEST_MESSAGE = 'Client sent an invalid request' - - -@app.errorhandler(BusinessException) -def handle_business_exception(e): - """An exception explicitly raised due to some business rule""" - error_log.error("Synchronous error for request id {} {}".format(g.request_id, traceback.format_exc())) - err_msg = ERROR_TEMPLATE.render(description=str(e)) - response = Response(err_msg, content_type='application/json; charset=utf-8') - response.status_code = 400 - return response - - -@app.errorhandler(RequestException) -def handle_request_exception(e): - """Returns a detailed synchronous message to the calling client - when osdf fails due to a remote call to another system""" - error_log.error("Synchronous error for request id {} {}".format(g.request_id, traceback.format_exc())) - err_msg = request_exception_to_json_body(e) - response = Response(err_msg, content_type='application/json; charset=utf-8') - response.status_code = 400 - return response - - -@app.errorhandler(DataError) -def handle_data_error(e): - """Returns a detailed message to the calling client when the initial synchronous message is invalid""" - error_log.error("Synchronous error for request id {} {}".format(g.request_id, traceback.format_exc())) - - body_dictionary = { - "serviceException": { - "text": BAD_CLIENT_REQUEST_MESSAGE, - "exceptionMessage": str(e.errors), - "errorType": "InvalidClientRequest" - } - } - - body_as_json = json.dumps(body_dictionary) - response = Response(body_as_json, content_type='application/json; charset=utf-8') - response.status_code = 400 - return response +from osdf.utils import api_data_utils +from osdf.webapp.appcontroller import auth_basic +from apps.nxi_termination.optimizers.remote_opt_processor import process_nxi_termination_opt +from apps.nxi_termination.models.api.nxi_termination_request import NxiTerminationApi @app.route("/api/oof/v1/healthcheck", methods=["GET"]) @@ -102,9 +60,28 @@ def do_osdf_health_check(): return "OK" +@app.route("/api/oof/loadmodels/v1", methods=["GET"]) +def do_osdf_load_policies(): + audit_log.info("Uploading policy models") + """Upload policy models""" + response = upload_policy_models() + audit_log.info(response) + return "OK" + + @app.route("/api/oof/v1/placement", methods=["POST"]) @auth_basic.login_required def do_placement_opt(): + return placement_rest_api() + + +@app.route("/api/oof/placement/v1", methods=["POST"]) +@auth_basic.login_required +def do_placement_opt_common_versioning(): + return placement_rest_api() + + +def placement_rest_api(): """Perform placement optimization after validating the request and fetching policies Make a call to the call-back URL with the output of the placement request. Note: Call to Conductor for placement optimization may have redirects, so account for them @@ -113,6 +90,7 @@ def do_placement_opt(): req_id = request_json['requestInfo']['requestId'] g.request_id = req_id audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) + api_version_info = api_data_utils.retrieve_version_info(request, req_id) PlacementAPI(request_json).validate() policies = get_policies(request_json, "placement") audit_log.info(MH.new_worker_thread(req_id, "[for placement]")) @@ -121,64 +99,124 @@ def do_placement_opt(): audit_log.info(MH.accepted_valid_request(req_id, request)) return req_accept(request_id=req_id, transaction_id=request_json['requestInfo']['transactionId'], - request_status="accepted", status_message="") + version_info=api_version_info, request_status="accepted", status_message="") -@app.route("/api/oof/v1/route", methods=["POST"]) -@auth_basic.login_required +@app.route("/api/oof/route/v1", methods=["POST"]) def do_route_calc(): - """Perform the basic route calculations and returnn the vpn-bindings - TODO:Need to add the new class for the route in the API and model to provide this function + """ + Perform the basic route calculations and returnn the vpn-bindings """ request_json = request.get_json() audit_log.info("Calculate Route request received!") - return RouteOpt.getRoute(request_json) + response = RouteOpt().get_route(request_json, osdf_config) + return response -@app.errorhandler(500) -def internal_failure(error): - """Returned when unexpected coding errors occur during initial synchronous processing""" - error_log.error("Synchronous error for request id {} {}".format(g.request_id, traceback.format_exc())) - response = Response(internal_error_message, content_type='application/json; charset=utf-8') - response.status_code = 500 +@app.route("/api/oof/mdons/route/v1", methods=["POST"]) +def do_mdons_route_calc(): + """ + Perform the inter domain route calculation + """ + request_json = request.get_json() + audit_log.info("Inter Domain Calculation Route request received!") + response = InterDomainRouteOpt().get_route(request_json, osdf_config) return response -def get_options(argv): - program_version_string = '%%prog %s' % "v1.0" - program_longdesc = "" - program_license = "" +@app.route("/api/oof/v1/selection/nst", methods=["POST"]) +def do_nst_selection(): + request_json = request.get_json() + req_id = request_json['requestInfo']['requestId'] + audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) + NSTSelectionAPI(request_json).validate() + audit_log.info(MH.new_worker_thread(req_id, "[for NST selection]")) + nst_selection = NstSelection(osdf_config, request_json) + nst_selection.start() + return req_accept(request_id=req_id, + transaction_id=request_json['requestInfo']['transactionId'], + request_status="accepted", status_message="") + + +@app.route("/api/oof/v1/selection/nsst", methods=["POST"]) +def do_nsst_selection(): + request_json = request.get_json() + req_id = request_json['requestInfo']['requestId'] + audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) + NSSTSelectionAPI(request_json).validate() + audit_log.info(MH.new_worker_thread(req_id, "[for NSST selection]")) + nsst_selection = NsstSelection(osdf_config, request_json) + nsst_selection.start() + return req_accept(request_id=req_id, + transaction_id=request_json['requestInfo']['transactionId'], + request_status="accepted", status_message="") - parser = OptionParser(version=program_version_string, epilog=program_longdesc, description=program_license) - parser.add_option("-l", "--local", dest="local", help="run locally", action="store_true", default=False) - parser.add_option("-t", "--devtest", dest="devtest", help="run in dev/test environment", action="store_true", - default=False) - parser.add_option("-d", "--debughost", dest="debughost", help="IP Address of host running debug server", default='') - parser.add_option("-p", "--debugport", dest="debugport", help="Port number of debug server", type=int, default=5678) - opts, args = parser.parse_args(argv) +@app.route("/api/oof/v1/pci", methods=["POST"]) +@app.route("/api/oof/pci/v1", methods=["POST"]) +@auth_basic.login_required +def do_pci_optimization(): + request_json = request.get_json() + audit_log.info('request json obtained==>') + audit_log.info(request_json) - if opts.debughost: - debug_log.debug('pydevd.settrace({}, port={})'.format(opts.debughost, opts.debugport)) - pydevd.settrace(opts.debughost, port=opts.debugport) - return opts + req_id = request_json['requestInfo']['requestId'] + audit_log.info('requestID obtained==>') + audit_log.info(req_id) + g.request_id = req_id + audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) + PCIOptimizationAPI(request_json).validate() + # disable policy retrieval + # policies = get_policies(request_json, "pciopt") + audit_log.info(MH.new_worker_thread(req_id, "[for pciopt]")) + t = Thread(target=process_pci_optimation, args=(request_json, osdf_config, None)) + t.start() + audit_log.info(MH.accepted_valid_request(req_id, request)) + audit_log.info('reached upto return') + return req_accept(request_id=req_id, + transaction_id=request_json['requestInfo']['transactionId'], + request_status="accepted", status_message="") -if __name__ == "__main__": - sys_conf = osdf_config['core']['osdf_system'] - ports = sys_conf['osdf_ports'] - internal_port, external_port = ports['internal'], ports['external'] +@app.route("/api/oof/selection/nsi/v1", methods=["POST"]) +def do_nsi_selection(): + request_json = request.get_json() + req_id = request_json['requestInfo']['requestId'] + g.request_id = req_id + audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) + NSISelectionAPI(request_json).validate() + audit_log.info(MH.new_worker_thread(req_id, "[for NSI selection]")) + slice_opt = SliceSelectionOptimizer(osdf_config, slice_config, request_json, 'NSI') + slice_opt.start() + return req_accept(request_id=req_id, + transaction_id=request_json['requestInfo']['transactionId'], + request_status="accepted", status_message="") + + +@app.route("/api/oof/selection/nssi/v1", methods=["POST"]) +def do_nssi_selection(): + request_json = request.get_json() + req_id = request_json['requestInfo']['requestId'] + g.request_id = req_id + audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) + NSSISelectionAPI(request_json).validate() + audit_log.info(MH.new_worker_thread(req_id, "[for NSSI selection]")) + slice_opt = SliceSelectionOptimizer(osdf_config, slice_config, request_json, 'NSSI') + slice_opt.start() + return req_accept(request_id=req_id, + transaction_id=request_json['requestInfo']['transactionId'], + request_status="accepted", status_message="") + - local_host = sys_conf['osdf_ip_default'] - common_app_opts = dict(host=local_host, threaded=True, use_reloader=False) +@app.route("/api/oof/terminate/nxi/v1",methods=["POST"]) +def do_nxi_terminaton(): + request_json = request.get_json() + req_id = request_json['requestInfo']['requestId'] + g.request_id = req_id + audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) + NxiTerminationApi(request_json).validate() + return process_nxi_termination_opt(request_json,osdf_config) - ssl_opts = sys_conf.get('ssl_context') - if ssl_opts: - common_app_opts.update({'ssl_context': tuple(ssl_opts)}) - opts = get_options(sys.argv) - if not opts.local and not opts.devtest: # normal deployment - app.run(port=internal_port, debug=False, **common_app_opts) - else: - port = internal_port if opts.local else external_port - app.run(port=port, debug=True, **common_app_opts) +if __name__ == "__main__": + run_app()