# -------------------------------------------------------------------------
# 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.
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 schematics.exceptions import DataError
-from requests import RequestException
-from optparse import OptionParser
+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 osdf.operation.exceptions import BusinessException
-from osdf.operation.error_handling import request_exception_to_json_body, internal_error_message
-from osdf.logging.osdf_logging import MH, audit_log, error_log, debug_log
-from osdf.models.api.placementRequest import PlacementAPI
-from osdf.models.api.pciOptimizationRequest import PCIOptimizationAPI
+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
-from osdf.optimizers.pciopt.pci_opt_processor import process_pci_optimation
from osdf.utils import api_data_utils
-
-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.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"])
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():
version_info=api_version_info, request_status="accepted", status_message="")
-@app.route("/api/oof/v1/route", methods=["POST"])
+@app.route("/api/oof/route/v1", methods=["POST"])
def do_route_calc():
"""
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.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
+
+
+@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="")
@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)
+
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
+ # 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="")
-@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
- return response
+@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="")
-def get_options(argv):
- program_version_string = '%%prog %s' % "v1.0"
- program_longdesc = ""
- program_license = ""
- 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/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="")
- if opts.debughost:
- debug_log.debug('pydevd.settrace({}, port={})'.format(opts.debughost, opts.debugport))
- pydevd.settrace(opts.debughost, port=opts.debugport)
- return opts
+
+@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)
if __name__ == "__main__":
-
- sys_conf = osdf_config['core']['osdf_system']
- ports = sys_conf['osdf_ports']
- internal_port, external_port = ports['internal'], ports['external']
-
- local_host = sys_conf['osdf_ip_default']
- common_app_opts = dict(host=local_host, threaded=True, use_reloader=False)
-
- ssl_opts = sys_conf.get('ssl_context')
- if ssl_opts:
- common_app_opts.update({'ssl_context': tuple(ssl_opts)})
-
- opts = get_options(sys.argv)
- # TODO(Dileep): Uncomment once Helm charts to preload secrets available
- # sms.load_secrets()
- 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)
+ run_app()
Code Review / optf / osdf.git / blobdiff