| 1 |
|
#!/usr/bin/python3 |
| 2 |
|
# -*- coding: utf-8 -*- |
| 3 |
|
|
| 4 |
|
# Copyright 2020 ArctosLabs Scandinavia AB |
| 5 |
|
# |
| 6 |
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
| 7 |
|
# you may not use this file except in compliance with the License. |
| 8 |
|
# You may obtain a copy of the License at |
| 9 |
|
# |
| 10 |
|
# http://www.apache.org/licenses/LICENSE-2.0 |
| 11 |
|
# |
| 12 |
|
# Unless required by applicable law or agreed to in writing, software |
| 13 |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
| 14 |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| 15 |
|
# implied. |
| 16 |
|
# See the License for the specific language governing permissions and |
| 17 |
|
# limitations under the License. |
| 18 |
|
|
| 19 |
1 |
import asyncio |
| 20 |
1 |
import logging |
| 21 |
1 |
import itertools |
| 22 |
1 |
from pathlib import Path |
| 23 |
|
|
| 24 |
1 |
import yaml |
| 25 |
1 |
from osm_common import dbmemory, dbmongo, msglocal, msgkafka |
| 26 |
|
|
| 27 |
1 |
from osm_pla.config.config import Config |
| 28 |
1 |
from osm_pla.placement.mznplacement import MznPlacementConductor |
| 29 |
1 |
from osm_pla.placement.mznplacement import NsPlacementDataFactory |
| 30 |
|
|
| 31 |
|
|
| 32 |
1 |
class Server: |
| 33 |
1 |
pil_price_list_file = Path("/placement/pil_price_list.yaml") |
| 34 |
1 |
vnf_price_list_file = Path("/placement/vnf_price_list.yaml") |
| 35 |
|
|
| 36 |
1 |
def __init__(self, config: Config): |
| 37 |
1 |
self.log = logging.getLogger("pla.server") |
| 38 |
1 |
self.db = None |
| 39 |
1 |
self.msgBus = None |
| 40 |
1 |
self.config = config |
| 41 |
|
|
| 42 |
1 |
try: |
| 43 |
1 |
if config.get("database", "driver") == "mongo": |
| 44 |
0 |
self.db = dbmongo.DbMongo() |
| 45 |
0 |
self.db.db_connect(config.get("database")) |
| 46 |
1 |
elif config.get("database", "driver") == "memory": |
| 47 |
1 |
self.db = dbmemory.DbMemory() |
| 48 |
1 |
self.db.db_connect(config.get("database")) |
| 49 |
|
else: |
| 50 |
0 |
raise Exception( |
| 51 |
|
"Invalid configuration param '{}' at '[database]':'driver'".format( |
| 52 |
|
config.get("database", "driver") |
| 53 |
|
) |
| 54 |
|
) |
| 55 |
|
|
| 56 |
1 |
if config.get("message", "driver") == "local": |
| 57 |
1 |
self.msgBus = msglocal.MsgLocal() |
| 58 |
0 |
elif config.get("message", "driver") == "kafka": |
| 59 |
0 |
self.msgBus = msgkafka.MsgKafka() |
| 60 |
|
else: |
| 61 |
0 |
raise Exception( |
| 62 |
|
"Invalid message bus driver {}".format( |
| 63 |
|
config.get("message", "driver") |
| 64 |
|
) |
| 65 |
|
) |
| 66 |
1 |
self.msgBus.connect(config.get("message")) |
| 67 |
|
|
| 68 |
0 |
except Exception as e: |
| 69 |
0 |
self.log.exception("kafka setup error. Exception: {}".format(e)) |
| 70 |
|
|
| 71 |
1 |
def _get_nslcmop(self, nsdlcmop_id): |
| 72 |
|
""" |
| 73 |
|
:param nsdlcmop_id: |
| 74 |
|
:return: nslcmop from database corresponding to nslcmop_id |
| 75 |
|
""" |
| 76 |
1 |
db_filter = {"_id": nsdlcmop_id} |
| 77 |
1 |
nslcmop = self.db.get_one("nslcmops", db_filter) |
| 78 |
1 |
return nslcmop |
| 79 |
|
|
| 80 |
1 |
def _get_projects(self): |
| 81 |
|
""" |
| 82 |
|
:return: project name to project id mapping |
| 83 |
|
""" |
| 84 |
0 |
projects = self.db.get_list("projects") |
| 85 |
0 |
return {project["_id"]: project["name"] for project in projects} |
| 86 |
|
|
| 87 |
1 |
def _get_nsd(self, nsd_id): |
| 88 |
|
""" |
| 89 |
|
:param nsd_id: |
| 90 |
|
:return: nsd from database corresponding to nsd_id |
| 91 |
|
""" |
| 92 |
1 |
db_filter = {"_id": nsd_id} |
| 93 |
1 |
return self.db.get_one("nsds", db_filter) |
| 94 |
|
|
| 95 |
1 |
def _get_vim_accounts(self, vim_account_ids): |
| 96 |
|
""" |
| 97 |
|
:param vim_account_ids: list of VIM account ids |
| 98 |
|
:return: list of vim account entries from database corresponding to list in vim_accounts_id |
| 99 |
|
""" |
| 100 |
1 |
db_filter = {"_id": vim_account_ids} |
| 101 |
1 |
return self.db.get_list("vim_accounts", db_filter) |
| 102 |
|
|
| 103 |
1 |
def _read_vnf_price_list(self, price_list_file_path): |
| 104 |
|
""" |
| 105 |
|
read vnf price list configuration file |
| 106 |
|
:param price_list_file_path: |
| 107 |
|
:return: |
| 108 |
|
""" |
| 109 |
1 |
with open(str(price_list_file_path)) as pl_fd: |
| 110 |
1 |
price_list = yaml.safe_load_all(pl_fd) |
| 111 |
1 |
return next(price_list) |
| 112 |
|
|
| 113 |
1 |
def _price_list_with_project(self, price_list): |
| 114 |
|
""" |
| 115 |
|
Figure out if this price list is with project or not. |
| 116 |
|
Note: to handle the unlikely event that a project is called 'prices' we do not simply check if 'prices' |
| 117 |
|
is in the dict keys for a price list sequence but rather go down one step in the nesting |
| 118 |
|
in which we either have |
| 119 |
|
1) 'prices:{vim_url:...}' if prices are also per project, or |
| 120 |
|
2) '{vim_url:...}' if prices are only per vim |
| 121 |
|
|
| 122 |
|
:param price_list: |
| 123 |
|
:return: True if project part of price list, else False |
| 124 |
|
""" |
| 125 |
1 |
price_list_entry_keys = set(price_list[0].keys()) |
| 126 |
1 |
price_list_entry_keys.remove("vnfd") |
| 127 |
1 |
pl_key = price_list_entry_keys.pop() |
| 128 |
1 |
entry_to_check = price_list[0][pl_key][0].keys() |
| 129 |
1 |
return True if "prices" in entry_to_check else False |
| 130 |
|
|
| 131 |
1 |
def _get_vnf_price_list(self, price_list_file_path, project_name=None): |
| 132 |
|
""" |
| 133 |
|
read vnf price list configuration file, determine its type and reformat content accordingly |
| 134 |
|
|
| 135 |
|
:param price_list_file_path: |
| 136 |
|
:param project_name: |
| 137 |
|
:return: dictionary formatted as {'<vnfd>': {'<vim-url>':'<price>'}} |
| 138 |
|
""" |
| 139 |
1 |
price_list_data = self._read_vnf_price_list(price_list_file_path) |
| 140 |
1 |
if self._price_list_with_project(price_list_data): |
| 141 |
1 |
res = {} |
| 142 |
1 |
for i in price_list_data: |
| 143 |
1 |
price_data = ( |
| 144 |
|
i[project_name] |
| 145 |
|
if type(i[project_name]) is dict |
| 146 |
|
else i[project_name][0] |
| 147 |
|
) |
| 148 |
1 |
res_component = { |
| 149 |
|
i["vim_name"]: i["price"] for i in price_data["prices"] |
| 150 |
|
} |
| 151 |
1 |
res.update({i["vnfd"]: res_component}) |
| 152 |
1 |
return res |
| 153 |
|
else: |
| 154 |
1 |
return { |
| 155 |
|
i["vnfd"]: {i1["vim_name"]: i1["price"] for i1 in i["prices"]} |
| 156 |
|
for i in price_list_data |
| 157 |
|
} |
| 158 |
|
|
| 159 |
1 |
def _get_pil_info(self, pil_info_file_path): |
| 160 |
|
""" |
| 161 |
|
read and return pil information from file |
| 162 |
|
:param pil_info_file_path: Path to pil_info file |
| 163 |
|
:return pil configuration file content as Python object |
| 164 |
|
""" |
| 165 |
1 |
with open(str(pil_info_file_path)) as pil_fd: |
| 166 |
1 |
data = yaml.safe_load_all(pil_fd) |
| 167 |
1 |
return next(data) |
| 168 |
|
|
| 169 |
1 |
def _create_vnf_id_maps(self, nsd): |
| 170 |
|
""" |
| 171 |
|
map identifier for 'member-vnf-index' in nsd to syntax that is safe for mzn |
| 172 |
|
|
| 173 |
|
return tuples with mappings {<adjusted id>: <original id>} and {<original id>: <adjusted id>} |
| 174 |
|
""" |
| 175 |
|
# TODO: Change for multiple DF support |
| 176 |
1 |
ns_df = nsd.get("df", [{}])[0] |
| 177 |
1 |
next_idx = itertools.count() |
| 178 |
1 |
member_vnf_index2mzn = { |
| 179 |
|
e["id"]: "VNF" + str(next(next_idx)) for e in ns_df.get("vnf-profile", []) |
| 180 |
|
} |
| 181 |
|
|
| 182 |
|
# reverse the name map dictionary, used when the placement result is remapped |
| 183 |
1 |
mzn_name2member_vnf_index = {v: k for k, v in member_vnf_index2mzn.items()} |
| 184 |
|
|
| 185 |
1 |
return member_vnf_index2mzn, mzn_name2member_vnf_index |
| 186 |
|
|
| 187 |
1 |
async def get_placement(self, nslcmop_id): |
| 188 |
|
""" |
| 189 |
|
- Collects and prepares placement information. |
| 190 |
|
- Request placement computation. |
| 191 |
|
- Formats and distribute placement result |
| 192 |
|
|
| 193 |
|
Note: exceptions result in empty response message |
| 194 |
|
|
| 195 |
|
:param nslcmop_id: |
| 196 |
|
:return: |
| 197 |
|
""" |
| 198 |
1 |
try: |
| 199 |
1 |
nslcmop = self._get_nslcmop(nslcmop_id) |
| 200 |
1 |
nsd = self._get_nsd(nslcmop["operationParams"]["nsdId"]) |
| 201 |
1 |
member_vnf_index2mzn, mzn2member_vnf_index = self._create_vnf_id_maps(nsd) |
| 202 |
|
# adjust vnf identifiers |
| 203 |
|
# TODO: Change for multiple DF support |
| 204 |
1 |
ns_df = nsd.get("df", [{}])[0] |
| 205 |
1 |
for vnf_profile in ns_df.get("vnf-profile", []): |
| 206 |
1 |
vnf_profile["id"] = member_vnf_index2mzn[vnf_profile["id"]] |
| 207 |
1 |
for vlc in vnf_profile.get("virtual-link-connectivity", []): |
| 208 |
1 |
for ccpd in vlc.get("constituent-cpd-id", []): |
| 209 |
1 |
ccpd["constituent-base-element-id"] = member_vnf_index2mzn[ |
| 210 |
|
ccpd["constituent-base-element-id"] |
| 211 |
|
] |
| 212 |
1 |
self.log.info("adjusted nsd: {}".format(nsd)) |
| 213 |
1 |
projects = self._get_projects() |
| 214 |
1 |
self.log.info("projects: {}".format(projects)) |
| 215 |
1 |
nslcmop_project = nslcmop["_admin"]["projects_read"][0] |
| 216 |
1 |
self.log.info("nslcmop_project: {}".format(nslcmop_project)) |
| 217 |
1 |
valid_vim_accounts = nslcmop["operationParams"]["validVimAccounts"] |
| 218 |
1 |
vim_accounts_data = self._get_vim_accounts(valid_vim_accounts) |
| 219 |
1 |
vims_information = {_["name"]: _["_id"] for _ in vim_accounts_data} |
| 220 |
1 |
price_list = self._get_vnf_price_list( |
| 221 |
|
Server.vnf_price_list_file, projects[nslcmop_project] |
| 222 |
|
) |
| 223 |
1 |
pil_info = self._get_pil_info(Server.pil_price_list_file) |
| 224 |
1 |
pinnings = nslcmop["operationParams"].get("vnf", []) |
| 225 |
|
# remap member-vnf-index values according to id map |
| 226 |
1 |
for pinning in pinnings: |
| 227 |
0 |
pinning["member-vnf-index"] = member_vnf_index2mzn[ |
| 228 |
|
pinning["member-vnf-index"] |
| 229 |
|
] |
| 230 |
1 |
self.log.info("pinnings: {}".format(pinnings)) |
| 231 |
1 |
order_constraints = nslcmop["operationParams"].get("placement-constraints") |
| 232 |
1 |
self.log.info("order constraints: {}".format(order_constraints)) |
| 233 |
|
|
| 234 |
1 |
nspd = NsPlacementDataFactory( |
| 235 |
|
vims_information, price_list, nsd, pil_info, pinnings, order_constraints |
| 236 |
|
).create_ns_placement_data() |
| 237 |
|
|
| 238 |
1 |
vnf_placement = MznPlacementConductor(self.log).do_placement_computation( |
| 239 |
|
nspd |
| 240 |
|
) |
| 241 |
|
|
| 242 |
1 |
except Exception as e: |
| 243 |
|
# Note: there is no cure for failure so we have a catch-all clause here |
| 244 |
1 |
self.log.exception("PLA fault. Exception: {}".format(e)) |
| 245 |
1 |
vnf_placement = [] |
| 246 |
|
finally: |
| 247 |
|
# remap names in vnf_placement |
| 248 |
1 |
for e in vnf_placement: |
| 249 |
1 |
e["member-vnf-index"] = mzn2member_vnf_index[e["member-vnf-index"]] |
| 250 |
1 |
await self.msgBus.aiowrite( |
| 251 |
|
"pla", |
| 252 |
|
"placement", |
| 253 |
|
{"placement": {"vnf": vnf_placement, "nslcmopId": nslcmop_id}}, |
| 254 |
|
) |
| 255 |
|
|
| 256 |
1 |
def handle_kafka_command(self, topic, command, params): |
| 257 |
0 |
self.log.info("Kafka msg arrived: {} {} {}".format(topic, command, params)) |
| 258 |
0 |
if topic == "pla" and command == "get_placement": |
| 259 |
0 |
nslcmop_id = params.get("nslcmopId") |
| 260 |
0 |
asyncio.create_task(self.get_placement(nslcmop_id)) |
| 261 |
|
|
| 262 |
1 |
async def kafka_read(self): |
| 263 |
0 |
self.log.info("Task kafka_read start") |
| 264 |
0 |
while True: |
| 265 |
0 |
try: |
| 266 |
0 |
topics = "pla" |
| 267 |
0 |
await self.msgBus.aioread(topics, self.handle_kafka_command) |
| 268 |
0 |
except Exception as e: |
| 269 |
0 |
self.log.error("kafka read error. Exception: {}".format(e)) |
| 270 |
0 |
await asyncio.sleep(5) |
| 271 |
|
|
| 272 |
1 |
def run(self): |
| 273 |
0 |
asyncio.run(self.kafka_read()) |
| 274 |
0 |
if self.msgBus: |
| 275 |
0 |
self.msgBus.disconnect() |
![[Jenkins]](/jenkins/static/c06f6c43/images/jenkins-header-logo-v2.svg){kind=logo}
