osdfapp.py

   1 # -------------------------------------------------------------------------
   2 #   Copyright (c) 2015-2017 AT&T Intellectual Property
   3 #   Copyright (C) 2020 Wipro Limited.
   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 #
  19
  20 """
  21 OSDF Manager Main Flask Application
  22 """
  23
  24 import json
  25
  26 from threading import Thread  # for scaling up, may need celery with RabbitMQ or redis
  27
  28 from flask import request, g
  29
  30 from osdf.apps.baseapp import app, run_app
  31 from apps.nst.models.api.nstSelectionRequest import NSTSelectionAPI
  32 from apps.nsst.models.api.nsstSelectionRequest import NSSTSelectionAPI
  33 from apps.pci.models.api.pciOptimizationRequest import PCIOptimizationAPI
  34 from apps.nst.optimizers.nst_select_processor import NstSelection
  35 from apps.nsst.optimizers.nsst_select_processor import NsstSelection
  36 from apps.pci.optimizers.pci_opt_processor import process_pci_optimation
  37 from apps.placement.models.api.placementRequest import PlacementAPI
  38 from apps.placement.optimizers.conductor.remote_opt_processor import process_placement_opt
  39 from apps.route.optimizers.inter_domain_route_opt import InterDomainRouteOpt
  40 from apps.route.optimizers.simple_route_opt import RouteOpt
  41 from apps.slice_selection.models.api.nsi_selection_request import NSISelectionAPI
  42 from apps.slice_selection.models.api.nssi_selection_request import NSSISelectionAPI
  43 from apps.slice_selection.optimizers.conductor.remote_opt_processor import SliceSelectionOptimizer
  44 from osdf.adapters.policy.interface import get_policies
  45 from osdf.adapters.policy.interface import upload_policy_models
  46 from osdf.config.base import osdf_config
  47 from osdf.config.base import slice_config
  48 from osdf.logging.osdf_logging import MH, audit_log
  49 from osdf.operation.responses import osdf_response_for_request_accept as req_accept
  50 from osdf.utils import api_data_utils
  51 from osdf.webapp.appcontroller import auth_basic
  52 from apps.nxi_termination.optimizers.remote_opt_processor import process_nxi_termination_opt
  53 from apps.nxi_termination.models.api.nxi_termination_request import NxiTerminationApi
  54
  55
  56 @app.route("/api/oof/v1/healthcheck", methods=["GET"])
  57 def do_osdf_health_check():
  58     """Simple health check"""
  59     audit_log.info("A health check request is processed!")
  60     return "OK"
  61
  62
  63 @app.route("/api/oof/loadmodels/v1", methods=["GET"])
  64 def do_osdf_load_policies():
  65     audit_log.info("Uploading policy models")
  66     """Upload policy models"""
  67     response = upload_policy_models()
  68     audit_log.info(response)
  69     return "OK"
  70
  71
  72 @app.route("/api/oof/v1/placement", methods=["POST"])
  73 @auth_basic.login_required
  74 def do_placement_opt():
  75     return placement_rest_api()
  76
  77
  78 @app.route("/api/oof/placement/v1", methods=["POST"])
  79 @auth_basic.login_required
  80 def do_placement_opt_common_versioning():
  81     return placement_rest_api()
  82
  83
  84 def placement_rest_api():
  85     """Perform placement optimization after validating the request and fetching policies
  86     Make a call to the call-back URL with the output of the placement request.
  87     Note: Call to Conductor for placement optimization may have redirects, so account for them
  88     """
  89     request_json = request.get_json()
  90     req_id = request_json['requestInfo']['requestId']
  91     g.request_id = req_id
  92     audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json)))
  93     api_version_info = api_data_utils.retrieve_version_info(request, req_id)
  94     PlacementAPI(request_json).validate()
  95     policies = get_policies(request_json, "placement")
  96     audit_log.info(MH.new_worker_thread(req_id, "[for placement]"))
  97     t = Thread(target=process_placement_opt, args=(request_json, policies, osdf_config))
  98     t.start()
  99     audit_log.info(MH.accepted_valid_request(req_id, request))
 100     return req_accept(request_id=req_id,
 101                       transaction_id=request_json['requestInfo']['transactionId'],
 102                       version_info=api_version_info, request_status="accepted", status_message="")
 103
 104
 105 @app.route("/api/oof/route/v1", methods=["POST"])
 106 def do_route_calc():
 107     """
 108     Perform the basic route calculations and returnn the vpn-bindings
 109     """
 110     request_json = request.get_json()
 111     audit_log.info("Calculate Route request received!")
 112     response = RouteOpt().get_route(request_json, osdf_config)
 113     return response
 114
 115
 116 @app.route("/api/oof/mdons/route/v1", methods=["POST"])
 117 def do_mdons_route_calc():
 118     """
 119     Perform the inter domain route calculation
 120     """
 121     request_json = request.get_json()
 122     audit_log.info("Inter Domain Calculation  Route request received!")
 123     response = InterDomainRouteOpt().get_route(request_json, osdf_config)
 124     return response
 125
 126
 127 @app.route("/api/oof/v1/selection/nst", methods=["POST"])
 128 def do_nst_selection():
 129     request_json = request.get_json()
 130     req_id = request_json['requestInfo']['requestId']
 131     audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json)))
 132     NSTSelectionAPI(request_json).validate()
 133     audit_log.info(MH.new_worker_thread(req_id, "[for NST selection]"))
 134     nst_selection = NstSelection(osdf_config, request_json)
 135     nst_selection.start()
 136     return req_accept(request_id=req_id,
 137                       transaction_id=request_json['requestInfo']['transactionId'],
 138                       request_status="accepted", status_message="")
 139
 140
 141 @app.route("/api/oof/v1/selection/nsst", methods=["POST"])
 142 def do_nsst_selection():
 143     request_json = request.get_json()
 144     req_id = request_json['requestInfo']['requestId']
 145     audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json)))
 146     NSSTSelectionAPI(request_json).validate()
 147     audit_log.info(MH.new_worker_thread(req_id, "[for NSST selection]"))
 148     nsst_selection = NsstSelection(osdf_config, request_json)
 149     nsst_selection.start()
 150     return req_accept(request_id=req_id,
 151                       transaction_id=request_json['requestInfo']['transactionId'],
 152                       request_status="accepted", status_message="")
 153
 154 @app.route("/api/oof/v1/pci", methods=["POST"])
 155 @app.route("/api/oof/pci/v1", methods=["POST"])
 156 @auth_basic.login_required
 157 def do_pci_optimization():
 158     request_json = request.get_json()
 159     audit_log.info('request json obtained==>')
 160     audit_log.info(request_json)
 161
 162     req_id = request_json['requestInfo']['requestId']
 163     audit_log.info('requestID obtained==>')
 164     audit_log.info(req_id)
 165
 166     g.request_id = req_id
 167     audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json)))
 168     PCIOptimizationAPI(request_json).validate()
 169     # disable policy retrieval
 170     # policies = get_policies(request_json, "pciopt")
 171     audit_log.info(MH.new_worker_thread(req_id, "[for pciopt]"))
 172     t = Thread(target=process_pci_optimation, args=(request_json, osdf_config, None))
 173     t.start()
 174     audit_log.info(MH.accepted_valid_request(req_id, request))
 175     audit_log.info('reached upto return')
 176     return req_accept(request_id=req_id,
 177                       transaction_id=request_json['requestInfo']['transactionId'],
 178                       request_status="accepted", status_message="")
 179
 180
 181 @app.route("/api/oof/selection/nsi/v1", methods=["POST"])
 182 def do_nsi_selection():
 183     request_json = request.get_json()
 184     req_id = request_json['requestInfo']['requestId']
 185     g.request_id = req_id
 186     audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json)))
 187     NSISelectionAPI(request_json).validate()
 188     audit_log.info(MH.new_worker_thread(req_id, "[for NSI selection]"))
 189     slice_opt = SliceSelectionOptimizer(osdf_config, slice_config, request_json, 'NSI')
 190     slice_opt.start()
 191     return req_accept(request_id=req_id,
 192                       transaction_id=request_json['requestInfo']['transactionId'],
 193                       request_status="accepted", status_message="")
 194
 195
 196 @app.route("/api/oof/selection/nssi/v1", methods=["POST"])
 197 def do_nssi_selection():
 198     request_json = request.get_json()
 199     req_id = request_json['requestInfo']['requestId']
 200     g.request_id = req_id
 201     audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json)))
 202     NSSISelectionAPI(request_json).validate()
 203     audit_log.info(MH.new_worker_thread(req_id, "[for NSSI selection]"))
 204     slice_opt = SliceSelectionOptimizer(osdf_config, slice_config, request_json, 'NSSI')
 205     slice_opt.start()
 206     return req_accept(request_id=req_id,
 207                       transaction_id=request_json['requestInfo']['transactionId'],
 208                       request_status="accepted", status_message="")
 209
 210
 211 @app.route("/api/oof/terminate/nxi/v1",methods=["POST"])
 212 def do_nxi_terminaton():
 213     request_json = request.get_json()
 214     req_id = request_json['requestInfo']['requestId']
 215     g.request_id = req_id
 216     audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json)))
 217     NxiTerminationApi(request_json).validate()
 218     return process_nxi_termination_opt(request_json,osdf_config)
 219
 220
 221 if __name__ == "__main__":
 222     run_app()