osm_nbi/nbi.py

   1 #!/usr/bin/python3
   2 # -*- coding: utf-8 -*-
   3
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #    http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  13 # implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 import cherrypy
  18 import time
  19 import json
  20 import yaml
  21 import osm_nbi.html_out as html
  22 import logging
  23 import logging.handlers
  24 import getopt
  25 import sys
  26
  27 from osm_nbi.authconn import AuthException, AuthconnException
  28 from osm_nbi.auth import Authenticator
  29 from osm_nbi.engine import Engine, EngineException
  30 from osm_nbi.subscriptions import SubscriptionThread
  31 from osm_nbi.validation import ValidationError
  32 from osm_common.dbbase import DbException
  33 from osm_common.fsbase import FsException
  34 from osm_common.msgbase import MsgException
  35 from http import HTTPStatus
  36 from codecs import getreader
  37 from os import environ, path
  38 from osm_nbi import version as nbi_version, version_date as nbi_version_date
  39
  40 __author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
  41
  42 __version__ = "0.1.3"  # file version, not NBI version
  43 version_date = "Aug 2019"
  44
  45 database_version = "1.2"
  46 auth_database_version = "1.0"
  47 nbi_server = None  # instance of Server class
  48 subscription_thread = None  # instance of SubscriptionThread class
  49
  50 """
  51 North Bound Interface  (O: OSM specific; 5,X: SOL005 not implemented yet; O5: SOL005 implemented)
  52 URL: /osm                                                       GET     POST    PUT     DELETE  PATCH
  53         /nsd/v1
  54             /ns_descriptors_content                             O       O
  55                 /<nsdInfoId>                                    O       O       O       O
  56             /ns_descriptors                                     O5      O5
  57                 /<nsdInfoId>                                    O5                      O5      5
  58                     /nsd_content                                O5              O5
  59                     /nsd                                        O
  60                     /artifacts[/<artifactPath>]                 O
  61             /pnf_descriptors                                    5       5
  62                 /<pnfdInfoId>                                   5                       5       5
  63                     /pnfd_content                               5               5
  64             /subscriptions                                      5       5
  65                 /<subscriptionId>                               5                       X
  66
  67         /vnfpkgm/v1
  68             /vnf_packages_content                               O       O
  69                 /<vnfPkgId>                                     O                       O
  70             /vnf_packages                                       O5      O5
  71                 /<vnfPkgId>                                     O5                      O5      5
  72                     /package_content                            O5               O5
  73                         /upload_from_uri                                X
  74                     /vnfd                                       O5
  75                     /artifacts[/<artifactPath>]                 O5
  76             /subscriptions                                      X       X
  77                 /<subscriptionId>                               X                       X
  78
  79         /nslcm/v1
  80             /ns_instances_content                               O       O
  81                 /<nsInstanceId>                                 O                       O
  82             /ns_instances                                       5       5
  83                 /<nsInstanceId>                                 O5                      O5
  84                     instantiate                                         O5
  85                     terminate                                           O5
  86                     action                                              O
  87                     scale                                               O5
  88                     heal                                                5
  89             /ns_lcm_op_occs                                     5       5
  90                 /<nsLcmOpOccId>                                 5                       5       5
  91                     TO BE COMPLETED                             5               5
  92             /vnf_instances  (also vnfrs for compatibility)      O
  93                 /<vnfInstanceId>                                O
  94             /subscriptions                                      5       5
  95                 /<subscriptionId>                               5                       X
  96
  97         /pdu/v1
  98             /pdu_descriptors                                    O       O
  99                 /<id>                                           O               O       O       O
 100
 101         /admin/v1
 102             /tokens                                             O       O
 103                 /<id>                                           O                       O
 104             /users                                              O       O
 105                 /<id>                                           O               O       O       O
 106             /projects                                           O       O
 107                 /<id>                                           O                       O
 108             /vim_accounts  (also vims for compatibility)        O       O
 109                 /<id>                                           O                       O       O
 110             /wim_accounts                                       O       O
 111                 /<id>                                           O                       O       O
 112             /sdns                                               O       O
 113                 /<id>                                           O                       O       O
 114             /k8sclusters                                        O       O
 115                 /<id>                                           O                       O       O
 116             /k8srepos                                           O       O
 117                 /<id>                                           O                               O
 118             /osmrepos                                           O       O
 119                 /<id>                                           O                               O
 120
 121         /nst/v1                                                 O       O
 122             /netslice_templates_content                         O       O
 123                 /<nstInfoId>                                    O       O       O       O
 124             /netslice_templates                                 O       O
 125                 /<nstInfoId>                                    O                       O       O
 126                     /nst_content                                O               O
 127                     /nst                                        O
 128                     /artifacts[/<artifactPath>]                 O
 129             /subscriptions                                      X       X
 130                 /<subscriptionId>                               X                       X
 131
 132         /nsilcm/v1
 133             /netslice_instances_content                         O       O
 134                 /<SliceInstanceId>                              O                       O
 135             /netslice_instances                                 O       O
 136                 /<SliceInstanceId>                              O                       O
 137                     instantiate                                         O
 138                     terminate                                           O
 139                     action                                              O
 140             /nsi_lcm_op_occs                                    O       O
 141                 /<nsiLcmOpOccId>                                O                       O       O
 142             /subscriptions                                      X       X
 143                 /<subscriptionId>                               X                       X
 144
 145 query string:
 146     Follows SOL005 section 4.3.2 It contains extra METHOD to override http method, FORCE to force.
 147         simpleFilterExpr := <attrName>["."<attrName>]*["."<op>]"="<value>[","<value>]*
 148         filterExpr := <simpleFilterExpr>["&"<simpleFilterExpr>]*
 149         op := "eq" | "neq" (or "ne") | "gt" | "lt" | "gte" | "lte" | "cont" | "ncont"
 150         attrName := string
 151     For filtering inside array, it must select the element of the array, or add ANYINDEX to apply the filtering over any
 152     item of the array, that is, pass if any item of the array pass the filter.
 153     It allows both ne and neq for not equal
 154     TODO: 4.3.3 Attribute selectors
 155         all_fields, fields=x,y,.., exclude_default, exclude_fields=x,y,...
 156         (none)  … same as “exclude_default”
 157         all_fields      … all attributes.
 158         fields=<list>   … all attributes except all complex attributes with minimum cardinality of zero that are not
 159         conditionally mandatory, and that are not provided in <list>.
 160         exclude_fields=<list>   … all attributes except those complex attributes with a minimum cardinality of zero that
 161         are not conditionally mandatory, and that are provided in <list>.
 162         exclude_default … all attributes except those complex attributes with a minimum cardinality of zero that are not
 163         conditionally mandatory, and that are part of the "default exclude set" defined in the present specification for
 164         the particular resource
 165         exclude_default and include=<list>      … all attributes except those complex attributes with a minimum cardinality
 166         of zero that are not conditionally mandatory and that are part of the "default exclude set" defined in the
 167         present specification for the particular resource, but that are not part of <list>
 168     Additionally it admits some administrator values:
 169         FORCE: To force operations skipping dependency checkings
 170         ADMIN: To act as an administrator or a different project
 171         PUBLIC: To get public descriptors or set a descriptor as public
 172         SET_PROJECT: To make a descriptor available for other project
 173
 174 Header field name       Reference       Example Descriptions
 175     Accept      IETF RFC 7231 [19]      application/json        Content-Types that are acceptable for the response.
 176     This header field shall be present if the response is expected to have a non-empty message body.
 177     Content-Type        IETF RFC 7231 [19]      application/json        The MIME type of the body of the request.
 178     This header field shall be present if the request has a non-empty message body.
 179     Authorization       IETF RFC 7235 [22]      Bearer mF_9.B5f-4.1JqM  The authorization token for the request.
 180     Details are specified in clause 4.5.3.
 181     Range       IETF RFC 7233 [21]      1000-2000       Requested range of bytes from a file
 182 Header field name       Reference       Example Descriptions
 183     Content-Type        IETF RFC 7231 [19]      application/json        The MIME type of the body of the response.
 184     This header field shall be present if the response has a non-empty message body.
 185     Location    IETF RFC 7231 [19]      http://www.example.com/vnflcm/v1/vnf_instances/123      Used in redirection, or when a
 186     new resource has been created.
 187     This header field shall be present if the response status code is 201 or 3xx.
 188     In the present document this header field is also used if the response status code is 202 and a new resource was
 189     created.
 190     WWW-Authenticate    IETF RFC 7235 [22]      Bearer realm="example"  Challenge if the corresponding HTTP request has not
 191     provided authorization, or error details if the corresponding HTTP request has provided an invalid authorization
 192     token.
 193     Accept-Ranges       IETF RFC 7233 [21]      bytes   Used by the Server to signal whether or not it supports ranges for
 194     certain resources.
 195     Content-Range       IETF RFC 7233 [21]      bytes 21010-47021/ 47022        Signals the byte range that is contained in the
 196     response, and the total length of the file.
 197     Retry-After IETF RFC 7231 [19]      Fri, 31 Dec 1999 23:59:59 GMT
 198 """
 199
 200 valid_query_string = ("ADMIN", "SET_PROJECT", "FORCE", "PUBLIC")
 201 # ^ Contains possible administrative query string words:
 202 #     ADMIN=True(by default)|Project|Project-list:  See all elements, or elements of a project
 203 #           (not owned by my session project).
 204 #     PUBLIC=True(by default)|False: See/hide public elements. Set/Unset a topic to be public
 205 #     FORCE=True(by default)|False: Force edition/deletion operations
 206 #     SET_PROJECT=Project|Project-list: Add/Delete the topic to the projects portfolio
 207
 208 valid_url_methods = {
 209     # contains allowed URL and methods, and the role_permission name
 210     "admin": {
 211         "v1": {
 212             "tokens": {
 213                 "METHODS": ("GET", "POST", "DELETE"),
 214                 "ROLE_PERMISSION": "tokens:",
 215                 "<ID>": {"METHODS": ("GET", "DELETE"), "ROLE_PERMISSION": "tokens:id:"},
 216             },
 217             "users": {
 218                 "METHODS": ("GET", "POST"),
 219                 "ROLE_PERMISSION": "users:",
 220                 "<ID>": {
 221                     "METHODS": ("GET", "DELETE", "PATCH"),
 222                     "ROLE_PERMISSION": "users:id:",
 223                 },
 224             },
 225             "projects": {
 226                 "METHODS": ("GET", "POST"),
 227                 "ROLE_PERMISSION": "projects:",
 228                 "<ID>": {
 229                     "METHODS": ("GET", "DELETE", "PATCH"),
 230                     "ROLE_PERMISSION": "projects:id:",
 231                 },
 232             },
 233             "roles": {
 234                 "METHODS": ("GET", "POST"),
 235                 "ROLE_PERMISSION": "roles:",
 236                 "<ID>": {
 237                     "METHODS": ("GET", "DELETE", "PATCH"),
 238                     "ROLE_PERMISSION": "roles:id:",
 239                 },
 240             },
 241             "vims": {
 242                 "METHODS": ("GET", "POST"),
 243                 "ROLE_PERMISSION": "vims:",
 244                 "<ID>": {
 245                     "METHODS": ("GET", "DELETE", "PATCH"),
 246                     "ROLE_PERMISSION": "vims:id:",
 247                 },
 248             },
 249             "vim_accounts": {
 250                 "METHODS": ("GET", "POST"),
 251                 "ROLE_PERMISSION": "vim_accounts:",
 252                 "<ID>": {
 253                     "METHODS": ("GET", "DELETE", "PATCH"),
 254                     "ROLE_PERMISSION": "vim_accounts:id:",
 255                 },
 256             },
 257             "wim_accounts": {
 258                 "METHODS": ("GET", "POST"),
 259                 "ROLE_PERMISSION": "wim_accounts:",
 260                 "<ID>": {
 261                     "METHODS": ("GET", "DELETE", "PATCH"),
 262                     "ROLE_PERMISSION": "wim_accounts:id:",
 263                 },
 264             },
 265             "sdns": {
 266                 "METHODS": ("GET", "POST"),
 267                 "ROLE_PERMISSION": "sdn_controllers:",
 268                 "<ID>": {
 269                     "METHODS": ("GET", "DELETE", "PATCH"),
 270                     "ROLE_PERMISSION": "sdn_controllers:id:",
 271                 },
 272             },
 273             "k8sclusters": {
 274                 "METHODS": ("GET", "POST"),
 275                 "ROLE_PERMISSION": "k8sclusters:",
 276                 "<ID>": {
 277                     "METHODS": ("GET", "DELETE", "PATCH"),
 278                     "ROLE_PERMISSION": "k8sclusters:id:",
 279                 },
 280             },
 281             "vca": {
 282                 "METHODS": ("GET", "POST"),
 283                 "ROLE_PERMISSION": "vca:",
 284                 "<ID>": {
 285                     "METHODS": ("GET", "DELETE", "PATCH"),
 286                     "ROLE_PERMISSION": "vca:id:",
 287                 },
 288             },
 289             "k8srepos": {
 290                 "METHODS": ("GET", "POST"),
 291                 "ROLE_PERMISSION": "k8srepos:",
 292                 "<ID>": {
 293                     "METHODS": ("GET", "DELETE"),
 294                     "ROLE_PERMISSION": "k8srepos:id:",
 295                 },
 296             },
 297             "osmrepos": {
 298                 "METHODS": ("GET", "POST"),
 299                 "ROLE_PERMISSION": "osmrepos:",
 300                 "<ID>": {
 301                     "METHODS": ("GET", "DELETE", "PATCH"),
 302                     "ROLE_PERMISSION": "osmrepos:id:",
 303                 },
 304             },
 305             "domains": {
 306                 "METHODS": ("GET",),
 307                 "ROLE_PERMISSION": "domains:",
 308             },
 309         }
 310     },
 311     "pdu": {
 312         "v1": {
 313             "pdu_descriptors": {
 314                 "METHODS": ("GET", "POST"),
 315                 "ROLE_PERMISSION": "pduds:",
 316                 "<ID>": {
 317                     "METHODS": ("GET", "POST", "DELETE", "PATCH", "PUT"),
 318                     "ROLE_PERMISSION": "pduds:id:",
 319                 },
 320             },
 321         }
 322     },
 323     "nsd": {
 324         "v1": {
 325             "ns_descriptors_content": {
 326                 "METHODS": ("GET", "POST"),
 327                 "ROLE_PERMISSION": "nsds:",
 328                 "<ID>": {
 329                     "METHODS": ("GET", "PUT", "DELETE"),
 330                     "ROLE_PERMISSION": "nsds:id:",
 331                 },
 332             },
 333             "ns_descriptors": {
 334                 "METHODS": ("GET", "POST"),
 335                 "ROLE_PERMISSION": "nsds:",
 336                 "<ID>": {
 337                     "METHODS": ("GET", "DELETE", "PATCH"),
 338                     "ROLE_PERMISSION": "nsds:id:",
 339                     "nsd_content": {
 340                         "METHODS": ("GET", "PUT"),
 341                         "ROLE_PERMISSION": "nsds:id:content:",
 342                     },
 343                     "nsd": {
 344                         "METHODS": ("GET",),  # descriptor inside package
 345                         "ROLE_PERMISSION": "nsds:id:content:",
 346                     },
 347                     "artifacts": {
 348                         "METHODS": ("GET",),
 349                         "ROLE_PERMISSION": "nsds:id:nsd_artifact:",
 350                         "*": None,
 351                     },
 352                 },
 353             },
 354             "pnf_descriptors": {
 355                 "TODO": ("GET", "POST"),
 356                 "<ID>": {
 357                     "TODO": ("GET", "DELETE", "PATCH"),
 358                     "pnfd_content": {"TODO": ("GET", "PUT")},
 359                 },
 360             },
 361             "subscriptions": {
 362                 "TODO": ("GET", "POST"),
 363                 "<ID>": {"TODO": ("GET", "DELETE")},
 364             },
 365         }
 366     },
 367     "vnfpkgm": {
 368         "v1": {
 369             "vnf_packages_content": {
 370                 "METHODS": ("GET", "POST"),
 371                 "ROLE_PERMISSION": "vnfds:",
 372                 "<ID>": {
 373                     "METHODS": ("GET", "PUT", "DELETE"),
 374                     "ROLE_PERMISSION": "vnfds:id:",
 375                 },
 376             },
 377             "vnf_packages": {
 378                 "METHODS": ("GET", "POST"),
 379                 "ROLE_PERMISSION": "vnfds:",
 380                 "<ID>": {
 381                     "METHODS": ("GET", "DELETE", "PATCH"),  # GET: vnfPkgInfo
 382                     "ROLE_PERMISSION": "vnfds:id:",
 383                     "package_content": {
 384                         "METHODS": ("GET", "PUT"),  # package
 385                         "ROLE_PERMISSION": "vnfds:id:",
 386                         "upload_from_uri": {
 387                             "METHODS": (),
 388                             "TODO": ("POST",),
 389                             "ROLE_PERMISSION": "vnfds:id:upload:",
 390                         },
 391                     },
 392                     "vnfd": {
 393                         "METHODS": ("GET",),  # descriptor inside package
 394                         "ROLE_PERMISSION": "vnfds:id:content:",
 395                     },
 396                     "artifacts": {
 397                         "METHODS": ("GET",),
 398                         "ROLE_PERMISSION": "vnfds:id:vnfd_artifact:",
 399                         "*": None,
 400                     },
 401                     "action": {
 402                         "METHODS": ("POST",),
 403                         "ROLE_PERMISSION": "vnfds:id:action:",
 404                     },
 405                 },
 406             },
 407             "subscriptions": {
 408                 "TODO": ("GET", "POST"),
 409                 "<ID>": {"TODO": ("GET", "DELETE")},
 410             },
 411             "vnfpkg_op_occs": {
 412                 "METHODS": ("GET",),
 413                 "ROLE_PERMISSION": "vnfds:vnfpkgops:",
 414                 "<ID>": {"METHODS": ("GET",), "ROLE_PERMISSION": "vnfds:vnfpkgops:id:"},
 415             },
 416         }
 417     },
 418     "nslcm": {
 419         "v1": {
 420             "ns_instances_content": {
 421                 "METHODS": ("GET", "POST"),
 422                 "ROLE_PERMISSION": "ns_instances:",
 423                 "<ID>": {
 424                     "METHODS": ("GET", "DELETE"),
 425                     "ROLE_PERMISSION": "ns_instances:id:",
 426                 },
 427             },
 428             "ns_instances": {
 429                 "METHODS": ("GET", "POST"),
 430                 "ROLE_PERMISSION": "ns_instances:",
 431                 "<ID>": {
 432                     "METHODS": ("GET", "DELETE"),
 433                     "ROLE_PERMISSION": "ns_instances:id:",
 434                     "scale": {
 435                         "METHODS": ("POST",),
 436                         "ROLE_PERMISSION": "ns_instances:id:scale:",
 437                     },
 438                     "terminate": {
 439                         "METHODS": ("POST",),
 440                         "ROLE_PERMISSION": "ns_instances:id:terminate:",
 441                     },
 442                     "instantiate": {
 443                         "METHODS": ("POST",),
 444                         "ROLE_PERMISSION": "ns_instances:id:instantiate:",
 445                     },
 446                     "action": {
 447                         "METHODS": ("POST",),
 448                         "ROLE_PERMISSION": "ns_instances:id:action:",
 449                     },
 450                 },
 451             },
 452             "ns_lcm_op_occs": {
 453                 "METHODS": ("GET",),
 454                 "ROLE_PERMISSION": "ns_instances:opps:",
 455                 "<ID>": {
 456                     "METHODS": ("GET",),
 457                     "ROLE_PERMISSION": "ns_instances:opps:id:",
 458                 },
 459             },
 460             "vnfrs": {
 461                 "METHODS": ("GET",),
 462                 "ROLE_PERMISSION": "vnf_instances:",
 463                 "<ID>": {"METHODS": ("GET",), "ROLE_PERMISSION": "vnf_instances:id:"},
 464             },
 465             "vnf_instances": {
 466                 "METHODS": ("GET",),
 467                 "ROLE_PERMISSION": "vnf_instances:",
 468                 "<ID>": {"METHODS": ("GET",), "ROLE_PERMISSION": "vnf_instances:id:"},
 469             },
 470             "subscriptions": {
 471                 "METHODS": ("GET", "POST"),
 472                 "ROLE_PERMISSION": "ns_subscriptions:",
 473                 "<ID>": {
 474                     "METHODS": ("GET", "DELETE"),
 475                     "ROLE_PERMISSION": "ns_subscriptions:id:",
 476                 },
 477             },
 478         }
 479     },
 480     "nst": {
 481         "v1": {
 482             "netslice_templates_content": {
 483                 "METHODS": ("GET", "POST"),
 484                 "ROLE_PERMISSION": "slice_templates:",
 485                 "<ID>": {
 486                     "METHODS": ("GET", "PUT", "DELETE"),
 487                     "ROLE_PERMISSION": "slice_templates:id:",
 488                 },
 489             },
 490             "netslice_templates": {
 491                 "METHODS": ("GET", "POST"),
 492                 "ROLE_PERMISSION": "slice_templates:",
 493                 "<ID>": {
 494                     "METHODS": ("GET", "DELETE"),
 495                     "TODO": ("PATCH",),
 496                     "ROLE_PERMISSION": "slice_templates:id:",
 497                     "nst_content": {
 498                         "METHODS": ("GET", "PUT"),
 499                         "ROLE_PERMISSION": "slice_templates:id:content:",
 500                     },
 501                     "nst": {
 502                         "METHODS": ("GET",),  # descriptor inside package
 503                         "ROLE_PERMISSION": "slice_templates:id:content:",
 504                     },
 505                     "artifacts": {
 506                         "METHODS": ("GET",),
 507                         "ROLE_PERMISSION": "slice_templates:id:content:",
 508                         "*": None,
 509                     },
 510                 },
 511             },
 512             "subscriptions": {
 513                 "TODO": ("GET", "POST"),
 514                 "<ID>": {"TODO": ("GET", "DELETE")},
 515             },
 516         }
 517     },
 518     "nsilcm": {
 519         "v1": {
 520             "netslice_instances_content": {
 521                 "METHODS": ("GET", "POST"),
 522                 "ROLE_PERMISSION": "slice_instances:",
 523                 "<ID>": {
 524                     "METHODS": ("GET", "DELETE"),
 525                     "ROLE_PERMISSION": "slice_instances:id:",
 526                 },
 527             },
 528             "netslice_instances": {
 529                 "METHODS": ("GET", "POST"),
 530                 "ROLE_PERMISSION": "slice_instances:",
 531                 "<ID>": {
 532                     "METHODS": ("GET", "DELETE"),
 533                     "ROLE_PERMISSION": "slice_instances:id:",
 534                     "terminate": {
 535                         "METHODS": ("POST",),
 536                         "ROLE_PERMISSION": "slice_instances:id:terminate:",
 537                     },
 538                     "instantiate": {
 539                         "METHODS": ("POST",),
 540                         "ROLE_PERMISSION": "slice_instances:id:instantiate:",
 541                     },
 542                     "action": {
 543                         "METHODS": ("POST",),
 544                         "ROLE_PERMISSION": "slice_instances:id:action:",
 545                     },
 546                 },
 547             },
 548             "nsi_lcm_op_occs": {
 549                 "METHODS": ("GET",),
 550                 "ROLE_PERMISSION": "slice_instances:opps:",
 551                 "<ID>": {
 552                     "METHODS": ("GET",),
 553                     "ROLE_PERMISSION": "slice_instances:opps:id:",
 554                 },
 555             },
 556         }
 557     },
 558     "nspm": {
 559         "v1": {
 560             "pm_jobs": {
 561                 "<ID>": {
 562                     "reports": {
 563                         "<ID>": {
 564                             "METHODS": ("GET",),
 565                             "ROLE_PERMISSION": "reports:id:",
 566                         }
 567                     }
 568                 },
 569             },
 570         },
 571     },
 572 }
 573
 574
 575 class NbiException(Exception):
 576     def __init__(self, message, http_code=HTTPStatus.METHOD_NOT_ALLOWED):
 577         Exception.__init__(self, message)
 578         self.http_code = http_code
 579
 580
 581 class Server(object):
 582     instance = 0
 583     # to decode bytes to str
 584     reader = getreader("utf-8")
 585
 586     def __init__(self):
 587         self.instance += 1
 588         self.authenticator = Authenticator(valid_url_methods, valid_query_string)
 589         self.engine = Engine(self.authenticator)
 590
 591     def _format_in(self, kwargs):
 592         try:
 593             indata = None
 594             if cherrypy.request.body.length:
 595                 error_text = "Invalid input format "
 596
 597                 if "Content-Type" in cherrypy.request.headers:
 598                     if "application/json" in cherrypy.request.headers["Content-Type"]:
 599                         error_text = "Invalid json format "
 600                         indata = json.load(self.reader(cherrypy.request.body))
 601                         cherrypy.request.headers.pop("Content-File-MD5", None)
 602                     elif "application/yaml" in cherrypy.request.headers["Content-Type"]:
 603                         error_text = "Invalid yaml format "
 604                         indata = yaml.load(
 605                             cherrypy.request.body, Loader=yaml.SafeLoader
 606                         )
 607                         cherrypy.request.headers.pop("Content-File-MD5", None)
 608                     elif (
 609                         "application/binary" in cherrypy.request.headers["Content-Type"]
 610                         or "application/gzip"
 611                         in cherrypy.request.headers["Content-Type"]
 612                         or "application/zip" in cherrypy.request.headers["Content-Type"]
 613                         or "text/plain" in cherrypy.request.headers["Content-Type"]
 614                     ):
 615                         indata = cherrypy.request.body  # .read()
 616                     elif (
 617                         "multipart/form-data"
 618                         in cherrypy.request.headers["Content-Type"]
 619                     ):
 620                         if "descriptor_file" in kwargs:
 621                             filecontent = kwargs.pop("descriptor_file")
 622                             if not filecontent.file:
 623                                 raise NbiException(
 624                                     "empty file or content", HTTPStatus.BAD_REQUEST
 625                                 )
 626                             indata = filecontent.file  # .read()
 627                             if filecontent.content_type.value:
 628                                 cherrypy.request.headers[
 629                                     "Content-Type"
 630                                 ] = filecontent.content_type.value
 631                     else:
 632                         # raise cherrypy.HTTPError(HTTPStatus.Not_Acceptable,
 633                         #                          "Only 'Content-Type' of type 'application/json' or
 634                         # 'application/yaml' for input format are available")
 635                         error_text = "Invalid yaml format "
 636                         indata = yaml.load(
 637                             cherrypy.request.body, Loader=yaml.SafeLoader
 638                         )
 639                         cherrypy.request.headers.pop("Content-File-MD5", None)
 640                 else:
 641                     error_text = "Invalid yaml format "
 642                     indata = yaml.load(cherrypy.request.body, Loader=yaml.SafeLoader)
 643                     cherrypy.request.headers.pop("Content-File-MD5", None)
 644             if not indata:
 645                 indata = {}
 646
 647             format_yaml = False
 648             if cherrypy.request.headers.get("Query-String-Format") == "yaml":
 649                 format_yaml = True
 650
 651             for k, v in kwargs.items():
 652                 if isinstance(v, str):
 653                     if v == "":
 654                         kwargs[k] = None
 655                     elif format_yaml:
 656                         try:
 657                             kwargs[k] = yaml.load(v, Loader=yaml.SafeLoader)
 658                         except Exception:
 659                             pass
 660                     elif (
 661                         k.endswith(".gt")
 662                         or k.endswith(".lt")
 663                         or k.endswith(".gte")
 664                         or k.endswith(".lte")
 665                     ):
 666                         try:
 667                             kwargs[k] = int(v)
 668                         except Exception:
 669                             try:
 670                                 kwargs[k] = float(v)
 671                             except Exception:
 672                                 pass
 673                     elif v.find(",") > 0:
 674                         kwargs[k] = v.split(",")
 675                 elif isinstance(v, (list, tuple)):
 676                     for index in range(0, len(v)):
 677                         if v[index] == "":
 678                             v[index] = None
 679                         elif format_yaml:
 680                             try:
 681                                 v[index] = yaml.load(v[index], Loader=yaml.SafeLoader)
 682                             except Exception:
 683                                 pass
 684
 685             return indata
 686         except (ValueError, yaml.YAMLError) as exc:
 687             raise NbiException(error_text + str(exc), HTTPStatus.BAD_REQUEST)
 688         except KeyError as exc:
 689             raise NbiException(
 690                 "Query string error: " + str(exc), HTTPStatus.BAD_REQUEST
 691             )
 692         except Exception as exc:
 693             raise NbiException(error_text + str(exc), HTTPStatus.BAD_REQUEST)
 694
 695     @staticmethod
 696     def _format_out(data, token_info=None, _format=None):
 697         """
 698         return string of dictionary data according to requested json, yaml, xml. By default json
 699         :param data: response to be sent. Can be a dict, text or file
 700         :param token_info: Contains among other username and project
 701         :param _format: The format to be set as Content-Type if data is a file
 702         :return: None
 703         """
 704         accept = cherrypy.request.headers.get("Accept")
 705         if data is None:
 706             if accept and "text/html" in accept:
 707                 return html.format(
 708                     data, cherrypy.request, cherrypy.response, token_info
 709                 )
 710             # cherrypy.response.status = HTTPStatus.NO_CONTENT.value
 711             return
 712         elif hasattr(data, "read"):  # file object
 713             if _format:
 714                 cherrypy.response.headers["Content-Type"] = _format
 715             elif "b" in data.mode:  # binariy asssumig zip
 716                 cherrypy.response.headers["Content-Type"] = "application/zip"
 717             else:
 718                 cherrypy.response.headers["Content-Type"] = "text/plain"
 719             # TODO check that cherrypy close file. If not implement pending things to close  per thread next
 720             return data
 721         if accept:
 722             if "text/html" in accept:
 723                 return html.format(
 724                     data, cherrypy.request, cherrypy.response, token_info
 725                 )
 726             elif "application/yaml" in accept or "*/*" in accept:
 727                 pass
 728             elif "application/json" in accept or (
 729                 cherrypy.response.status and cherrypy.response.status >= 300
 730             ):
 731                 cherrypy.response.headers[
 732                     "Content-Type"
 733                 ] = "application/json; charset=utf-8"
 734                 a = json.dumps(data, indent=4) + "\n"
 735                 return a.encode("utf8")
 736         cherrypy.response.headers["Content-Type"] = "application/yaml"
 737         return yaml.safe_dump(
 738             data,
 739             explicit_start=True,
 740             indent=4,
 741             default_flow_style=False,
 742             tags=False,
 743             encoding="utf-8",
 744             allow_unicode=True,
 745         )  # , canonical=True, default_style='"'
 746
 747     @cherrypy.expose
 748     def index(self, *args, **kwargs):
 749         token_info = None
 750         try:
 751             if cherrypy.request.method == "GET":
 752                 token_info = self.authenticator.authorize()
 753                 outdata = token_info  # Home page
 754             else:
 755                 raise cherrypy.HTTPError(
 756                     HTTPStatus.METHOD_NOT_ALLOWED.value,
 757                     "Method {} not allowed for tokens".format(cherrypy.request.method),
 758                 )
 759
 760             return self._format_out(outdata, token_info)
 761
 762         except (EngineException, AuthException) as e:
 763             # cherrypy.log("index Exception {}".format(e))
 764             cherrypy.response.status = e.http_code.value
 765             return self._format_out("Welcome to OSM!", token_info)
 766
 767     @cherrypy.expose
 768     def version(self, *args, **kwargs):
 769         # TODO consider to remove and provide version using the static version file
 770         try:
 771             if cherrypy.request.method != "GET":
 772                 raise NbiException(
 773                     "Only method GET is allowed", HTTPStatus.METHOD_NOT_ALLOWED
 774                 )
 775             elif args or kwargs:
 776                 raise NbiException(
 777                     "Invalid URL or query string for version",
 778                     HTTPStatus.METHOD_NOT_ALLOWED,
 779                 )
 780             # TODO include version of other modules, pick up from some kafka admin message
 781             osm_nbi_version = {"version": nbi_version, "date": nbi_version_date}
 782             return self._format_out(osm_nbi_version)
 783         except NbiException as e:
 784             cherrypy.response.status = e.http_code.value
 785             problem_details = {
 786                 "code": e.http_code.name,
 787                 "status": e.http_code.value,
 788                 "detail": str(e),
 789             }
 790             return self._format_out(problem_details, None)
 791
 792     def domain(self):
 793         try:
 794             domains = {
 795                 "user_domain_name": cherrypy.tree.apps["/osm"]
 796                 .config["authentication"]
 797                 .get("user_domain_name"),
 798                 "project_domain_name": cherrypy.tree.apps["/osm"]
 799                 .config["authentication"]
 800                 .get("project_domain_name"),
 801             }
 802             return self._format_out(domains)
 803         except NbiException as e:
 804             cherrypy.response.status = e.http_code.value
 805             problem_details = {
 806                 "code": e.http_code.name,
 807                 "status": e.http_code.value,
 808                 "detail": str(e),
 809             }
 810             return self._format_out(problem_details, None)
 811
 812     @staticmethod
 813     def _format_login(token_info):
 814         """
 815         Changes cherrypy.request.login to include username/project_name;session so that cherrypy access log will
 816         log this information
 817         :param token_info: Dictionary with token content
 818         :return: None
 819         """
 820         cherrypy.request.login = token_info.get("username", "-")
 821         if token_info.get("project_name"):
 822             cherrypy.request.login += "/" + token_info["project_name"]
 823         if token_info.get("id"):
 824             cherrypy.request.login += ";session=" + token_info["id"][0:12]
 825
 826     @cherrypy.expose
 827     def token(self, method, token_id=None, kwargs=None):
 828         token_info = None
 829         # self.engine.load_dbase(cherrypy.request.app.config)
 830         indata = self._format_in(kwargs)
 831         if not isinstance(indata, dict):
 832             raise NbiException(
 833                 "Expected application/yaml or application/json Content-Type",
 834                 HTTPStatus.BAD_REQUEST,
 835             )
 836
 837         if method == "GET":
 838             token_info = self.authenticator.authorize()
 839             # for logging
 840             self._format_login(token_info)
 841             if token_id:
 842                 outdata = self.authenticator.get_token(token_info, token_id)
 843             else:
 844                 outdata = self.authenticator.get_token_list(token_info)
 845         elif method == "POST":
 846             try:
 847                 token_info = self.authenticator.authorize()
 848             except Exception:
 849                 token_info = None
 850             if kwargs:
 851                 indata.update(kwargs)
 852             # This is needed to log the user when authentication fails
 853             cherrypy.request.login = "{}".format(indata.get("username", "-"))
 854             outdata = token_info = self.authenticator.new_token(
 855                 token_info, indata, cherrypy.request.remote
 856             )
 857             cherrypy.session["Authorization"] = outdata["_id"]
 858             self._set_location_header("admin", "v1", "tokens", outdata["_id"])
 859             # for logging
 860             self._format_login(token_info)
 861
 862             # cherrypy.response.cookie["Authorization"] = outdata["id"]
 863             # cherrypy.response.cookie["Authorization"]['expires'] = 3600
 864         elif method == "DELETE":
 865             if not token_id and "id" in kwargs:
 866                 token_id = kwargs["id"]
 867             elif not token_id:
 868                 token_info = self.authenticator.authorize()
 869                 # for logging
 870                 self._format_login(token_info)
 871                 token_id = token_info["_id"]
 872             outdata = self.authenticator.del_token(token_id)
 873             token_info = None
 874             cherrypy.session["Authorization"] = "logout"
 875             # cherrypy.response.cookie["Authorization"] = token_id
 876             # cherrypy.response.cookie["Authorization"]['expires'] = 0
 877         else:
 878             raise NbiException(
 879                 "Method {} not allowed for token".format(method),
 880                 HTTPStatus.METHOD_NOT_ALLOWED,
 881             )
 882         return self._format_out(outdata, token_info)
 883
 884     @cherrypy.expose
 885     def test(self, *args, **kwargs):
 886         if not cherrypy.config.get("server.enable_test") or (
 887             isinstance(cherrypy.config["server.enable_test"], str)
 888             and cherrypy.config["server.enable_test"].lower() == "false"
 889         ):
 890             cherrypy.response.status = HTTPStatus.METHOD_NOT_ALLOWED.value
 891             return "test URL is disabled"
 892         thread_info = None
 893         if args and args[0] == "help":
 894             return (
 895                 "<html><pre>\ninit\nfile/<name>  download file\ndb-clear/table\nfs-clear[/folder]\nlogin\nlogin2\n"
 896                 "sleep/<time>\nmessage/topic\n</pre></html>"
 897             )
 898
 899         elif args and args[0] == "init":
 900             try:
 901                 # self.engine.load_dbase(cherrypy.request.app.config)
 902                 self.engine.create_admin()
 903                 return "Done. User 'admin', password 'admin' created"
 904             except Exception:
 905                 cherrypy.response.status = HTTPStatus.FORBIDDEN.value
 906                 return self._format_out("Database already initialized")
 907         elif args and args[0] == "file":
 908             return cherrypy.lib.static.serve_file(
 909                 cherrypy.tree.apps["/osm"].config["storage"]["path"] + "/" + args[1],
 910                 "text/plain",
 911                 "attachment",
 912             )
 913         elif args and args[0] == "file2":
 914             f_path = (
 915                 cherrypy.tree.apps["/osm"].config["storage"]["path"] + "/" + args[1]
 916             )
 917             f = open(f_path, "r")
 918             cherrypy.response.headers["Content-type"] = "text/plain"
 919             return f
 920
 921         elif len(args) == 2 and args[0] == "db-clear":
 922             deleted_info = self.engine.db.del_list(args[1], kwargs)
 923             return "{} {} deleted\n".format(deleted_info["deleted"], args[1])
 924         elif len(args) and args[0] == "fs-clear":
 925             if len(args) >= 2:
 926                 folders = (args[1],)
 927             else:
 928                 folders = self.engine.fs.dir_ls(".")
 929             for folder in folders:
 930                 self.engine.fs.file_delete(folder)
 931             return ",".join(folders) + " folders deleted\n"
 932         elif args and args[0] == "login":
 933             if not cherrypy.request.headers.get("Authorization"):
 934                 cherrypy.response.headers[
 935                     "WWW-Authenticate"
 936                 ] = 'Basic realm="Access to OSM site", charset="UTF-8"'
 937                 cherrypy.response.status = HTTPStatus.UNAUTHORIZED.value
 938         elif args and args[0] == "login2":
 939             if not cherrypy.request.headers.get("Authorization"):
 940                 cherrypy.response.headers[
 941                     "WWW-Authenticate"
 942                 ] = 'Bearer realm="Access to OSM site"'
 943                 cherrypy.response.status = HTTPStatus.UNAUTHORIZED.value
 944         elif args and args[0] == "sleep":
 945             sleep_time = 5
 946             try:
 947                 sleep_time = int(args[1])
 948             except Exception:
 949                 cherrypy.response.status = HTTPStatus.FORBIDDEN.value
 950                 return self._format_out("Database already initialized")
 951             thread_info = cherrypy.thread_data
 952             print(thread_info)
 953             time.sleep(sleep_time)
 954             # thread_info
 955         elif len(args) >= 2 and args[0] == "message":
 956             main_topic = args[1]
 957             return_text = "<html><pre>{} ->\n".format(main_topic)
 958             try:
 959                 if cherrypy.request.method == "POST":
 960                     to_send = yaml.load(cherrypy.request.body, Loader=yaml.SafeLoader)
 961                     for k, v in to_send.items():
 962                         self.engine.msg.write(main_topic, k, v)
 963                         return_text += "  {}: {}\n".format(k, v)
 964                 elif cherrypy.request.method == "GET":
 965                     for k, v in kwargs.items():
 966                         v_dict = yaml.load(v, Loader=yaml.SafeLoader)
 967                         self.engine.msg.write(main_topic, k, v_dict)
 968                         return_text += "  {}: {}\n".format(k, v_dict)
 969             except Exception as e:
 970                 return_text += "Error: " + str(e)
 971             return_text += "</pre></html>\n"
 972             return return_text
 973
 974         return_text = (
 975             "<html><pre>\nheaders:\n  args: {}\n".format(args)
 976             + "  kwargs: {}\n".format(kwargs)
 977             + "  headers: {}\n".format(cherrypy.request.headers)
 978             + "  path_info: {}\n".format(cherrypy.request.path_info)
 979             + "  query_string: {}\n".format(cherrypy.request.query_string)
 980             + "  session: {}\n".format(cherrypy.session)
 981             + "  cookie: {}\n".format(cherrypy.request.cookie)
 982             + "  method: {}\n".format(cherrypy.request.method)
 983             + "  session: {}\n".format(cherrypy.session.get("fieldname"))
 984             + "  body:\n"
 985         )
 986         return_text += "    length: {}\n".format(cherrypy.request.body.length)
 987         if cherrypy.request.body.length:
 988             return_text += "    content: {}\n".format(
 989                 str(
 990                     cherrypy.request.body.read(
 991                         int(cherrypy.request.headers.get("Content-Length", 0))
 992                     )
 993                 )
 994             )
 995         if thread_info:
 996             return_text += "thread: {}\n".format(thread_info)
 997         return_text += "</pre></html>"
 998         return return_text
 999
1000     @staticmethod
1001     def _check_valid_url_method(method, *args):
1002         if len(args) < 3:
1003             raise NbiException(
1004                 "URL must contain at least 'main_topic/version/topic'",
1005                 HTTPStatus.METHOD_NOT_ALLOWED,
1006             )
1007
1008         reference = valid_url_methods
1009         for arg in args:
1010             if arg is None:
1011                 break
1012             if not isinstance(reference, dict):
1013                 raise NbiException(
1014                     "URL contains unexpected extra items '{}'".format(arg),
1015                     HTTPStatus.METHOD_NOT_ALLOWED,
1016                 )
1017
1018             if arg in reference:
1019                 reference = reference[arg]
1020             elif "<ID>" in reference:
1021                 reference = reference["<ID>"]
1022             elif "*" in reference:
1023                 # if there is content
1024                 if reference["*"]:
1025                     reference = reference["*"]
1026                 break
1027             else:
1028                 raise NbiException(
1029                     "Unexpected URL item {}".format(arg), HTTPStatus.METHOD_NOT_ALLOWED
1030                 )
1031         if "TODO" in reference and method in reference["TODO"]:
1032             raise NbiException(
1033                 "Method {} not supported yet for this URL".format(method),
1034                 HTTPStatus.NOT_IMPLEMENTED,
1035             )
1036         elif "METHODS" in reference and method not in reference["METHODS"]:
1037             raise NbiException(
1038                 "Method {} not supported for this URL".format(method),
1039                 HTTPStatus.METHOD_NOT_ALLOWED,
1040             )
1041         return reference["ROLE_PERMISSION"] + method.lower()
1042
1043     @staticmethod
1044     def _set_location_header(main_topic, version, topic, id):
1045         """
1046         Insert response header Location with the URL of created item base on URL params
1047         :param main_topic:
1048         :param version:
1049         :param topic:
1050         :param id:
1051         :return: None
1052         """
1053         # Use cherrypy.request.base for absoluted path and make use of request.header HOST just in case behind aNAT
1054         cherrypy.response.headers["Location"] = "/osm/{}/{}/{}/{}".format(
1055             main_topic, version, topic, id
1056         )
1057         return
1058
1059     @staticmethod
1060     def _extract_query_string_operations(kwargs, method):
1061         """
1062
1063         :param kwargs:
1064         :return:
1065         """
1066         query_string_operations = []
1067         if kwargs:
1068             for qs in ("FORCE", "PUBLIC", "ADMIN", "SET_PROJECT"):
1069                 if qs in kwargs and kwargs[qs].lower() != "false":
1070                     query_string_operations.append(qs.lower() + ":" + method.lower())
1071         return query_string_operations
1072
1073     @staticmethod
1074     def _manage_admin_query(token_info, kwargs, method, _id):
1075         """
1076         Processes the administrator query inputs (if any) of FORCE, ADMIN, PUBLIC, SET_PROJECT
1077         Check that users has rights to use them and returs the admin_query
1078         :param token_info: token_info rights obtained by token
1079         :param kwargs: query string input.
1080         :param method: http method: GET, POSST, PUT, ...
1081         :param _id:
1082         :return: admin_query dictionary with keys:
1083             public: True, False or None
1084             force: True or False
1085             project_id: tuple with projects used for accessing an element
1086             set_project: tuple with projects that a created element will belong to
1087             method: show, list, delete, write
1088         """
1089         admin_query = {
1090             "force": False,
1091             "project_id": (token_info["project_id"],),
1092             "username": token_info["username"],
1093             "admin": token_info["admin"],
1094             "public": None,
1095             "allow_show_user_project_role": token_info["allow_show_user_project_role"],
1096         }
1097         if kwargs:
1098             # FORCE
1099             if "FORCE" in kwargs:
1100                 if (
1101                     kwargs["FORCE"].lower() != "false"
1102                 ):  # if None or True set force to True
1103                     admin_query["force"] = True
1104                 del kwargs["FORCE"]
1105             # PUBLIC
1106             if "PUBLIC" in kwargs:
1107                 if (
1108                     kwargs["PUBLIC"].lower() != "false"
1109                 ):  # if None or True set public to True
1110                     admin_query["public"] = True
1111                 else:
1112                     admin_query["public"] = False
1113                 del kwargs["PUBLIC"]
1114             # ADMIN
1115             if "ADMIN" in kwargs:
1116                 behave_as = kwargs.pop("ADMIN")
1117                 if behave_as.lower() != "false":
1118                     if not token_info["admin"]:
1119                         raise NbiException(
1120                             "Only admin projects can use 'ADMIN' query string",
1121                             HTTPStatus.UNAUTHORIZED,
1122                         )
1123                     if (
1124                         not behave_as or behave_as.lower() == "true"
1125                     ):  # convert True, None to empty list
1126                         admin_query["project_id"] = ()
1127                     elif isinstance(behave_as, (list, tuple)):
1128                         admin_query["project_id"] = behave_as
1129                     else:  # isinstance(behave_as, str)
1130                         admin_query["project_id"] = (behave_as,)
1131             if "SET_PROJECT" in kwargs:
1132                 set_project = kwargs.pop("SET_PROJECT")
1133                 if not set_project:
1134                     admin_query["set_project"] = list(admin_query["project_id"])
1135                 else:
1136                     if isinstance(set_project, str):
1137                         set_project = (set_project,)
1138                     if admin_query["project_id"]:
1139                         for p in set_project:
1140                             if p not in admin_query["project_id"]:
1141                                 raise NbiException(
1142                                     "Unauthorized for 'SET_PROJECT={p}'. Try with 'ADMIN=True' or "
1143                                     "'ADMIN='{p}'".format(p=p),
1144                                     HTTPStatus.UNAUTHORIZED,
1145                                 )
1146                     admin_query["set_project"] = set_project
1147
1148             # PROJECT_READ
1149             # if "PROJECT_READ" in kwargs:
1150             #     admin_query["project"] = kwargs.pop("project")
1151             #     if admin_query["project"] == token_info["project_id"]:
1152         if method == "GET":
1153             if _id:
1154                 admin_query["method"] = "show"
1155             else:
1156                 admin_query["method"] = "list"
1157         elif method == "DELETE":
1158             admin_query["method"] = "delete"
1159         else:
1160             admin_query["method"] = "write"
1161         return admin_query
1162
1163     @cherrypy.expose
1164     def default(
1165         self,
1166         main_topic=None,
1167         version=None,
1168         topic=None,
1169         _id=None,
1170         item=None,
1171         *args,
1172         **kwargs
1173     ):
1174         token_info = None
1175         outdata = None
1176         _format = None
1177         method = "DONE"
1178         engine_topic = None
1179         rollback = []
1180         engine_session = None
1181         try:
1182             if not main_topic or not version or not topic:
1183                 raise NbiException(
1184                     "URL must contain at least 'main_topic/version/topic'",
1185                     HTTPStatus.METHOD_NOT_ALLOWED,
1186                 )
1187             if main_topic not in (
1188                 "admin",
1189                 "vnfpkgm",
1190                 "nsd",
1191                 "nslcm",
1192                 "pdu",
1193                 "nst",
1194                 "nsilcm",
1195                 "nspm",
1196             ):
1197                 raise NbiException(
1198                     "URL main_topic '{}' not supported".format(main_topic),
1199                     HTTPStatus.METHOD_NOT_ALLOWED,
1200                 )
1201             if version != "v1":
1202                 raise NbiException(
1203                     "URL version '{}' not supported".format(version),
1204                     HTTPStatus.METHOD_NOT_ALLOWED,
1205                 )
1206
1207             if (
1208                 kwargs
1209                 and "METHOD" in kwargs
1210                 and kwargs["METHOD"] in ("PUT", "POST", "DELETE", "GET", "PATCH")
1211             ):
1212                 method = kwargs.pop("METHOD")
1213             else:
1214                 method = cherrypy.request.method
1215
1216             role_permission = self._check_valid_url_method(
1217                 method, main_topic, version, topic, _id, item, *args
1218             )
1219             query_string_operations = self._extract_query_string_operations(
1220                 kwargs, method
1221             )
1222             if main_topic == "admin" and topic == "tokens":
1223                 return self.token(method, _id, kwargs)
1224             token_info = self.authenticator.authorize(
1225                 role_permission, query_string_operations, _id
1226             )
1227             if main_topic == "admin" and topic == "domains":
1228                 return self.domain()
1229             engine_session = self._manage_admin_query(token_info, kwargs, method, _id)
1230             indata = self._format_in(kwargs)
1231             engine_topic = topic
1232
1233             if item and topic != "pm_jobs":
1234                 engine_topic = item
1235
1236             if main_topic == "nsd":
1237                 engine_topic = "nsds"
1238             elif main_topic == "vnfpkgm":
1239                 engine_topic = "vnfds"
1240                 if topic == "vnfpkg_op_occs":
1241                     engine_topic = "vnfpkgops"
1242                 if topic == "vnf_packages" and item == "action":
1243                     engine_topic = "vnfpkgops"
1244             elif main_topic == "nslcm":
1245                 engine_topic = "nsrs"
1246                 if topic == "ns_lcm_op_occs":
1247                     engine_topic = "nslcmops"
1248                 if topic == "vnfrs" or topic == "vnf_instances":
1249                     engine_topic = "vnfrs"
1250             elif main_topic == "nst":
1251                 engine_topic = "nsts"
1252             elif main_topic == "nsilcm":
1253                 engine_topic = "nsis"
1254                 if topic == "nsi_lcm_op_occs":
1255                     engine_topic = "nsilcmops"
1256             elif main_topic == "pdu":
1257                 engine_topic = "pdus"
1258             if (
1259                 engine_topic == "vims"
1260             ):  # TODO this is for backward compatibility, it will be removed in the future
1261                 engine_topic = "vim_accounts"
1262
1263             if topic == "subscriptions":
1264                 engine_topic = main_topic + "_" + topic
1265
1266             if method == "GET":
1267                 if item in (
1268                     "nsd_content",
1269                     "package_content",
1270                     "artifacts",
1271                     "vnfd",
1272                     "nsd",
1273                     "nst",
1274                     "nst_content",
1275                 ):
1276                     if item in ("vnfd", "nsd", "nst"):
1277                         path = "$DESCRIPTOR"
1278                     elif args:
1279                         path = args
1280                     elif item == "artifacts":
1281                         path = ()
1282                     else:
1283                         path = None
1284                     file, _format = self.engine.get_file(
1285                         engine_session,
1286                         engine_topic,
1287                         _id,
1288                         path,
1289                         cherrypy.request.headers.get("Accept"),
1290                     )
1291                     outdata = file
1292                 elif not _id:
1293                     outdata = self.engine.get_item_list(
1294                         engine_session, engine_topic, kwargs, api_req=True
1295                     )
1296                 else:
1297                     if item == "reports":
1298                         # TODO check that project_id (_id in this context) has permissions
1299                         _id = args[0]
1300                     filter_q = None
1301                     if "vcaStatusRefresh" in kwargs:
1302                         filter_q = {"vcaStatusRefresh": kwargs["vcaStatusRefresh"]}
1303                     outdata = self.engine.get_item(engine_session, engine_topic, _id, filter_q, True)
1304
1305             elif method == "POST":
1306                 cherrypy.response.status = HTTPStatus.CREATED.value
1307                 if topic in (
1308                     "ns_descriptors_content",
1309                     "vnf_packages_content",
1310                     "netslice_templates_content",
1311                 ):
1312                     _id = cherrypy.request.headers.get("Transaction-Id")
1313                     if not _id:
1314                         _id, _ = self.engine.new_item(
1315                             rollback,
1316                             engine_session,
1317                             engine_topic,
1318                             {},
1319                             None,
1320                             cherrypy.request.headers,
1321                         )
1322                     completed = self.engine.upload_content(
1323                         engine_session,
1324                         engine_topic,
1325                         _id,
1326                         indata,
1327                         kwargs,
1328                         cherrypy.request.headers,
1329                     )
1330                     if completed:
1331                         self._set_location_header(main_topic, version, topic, _id)
1332                     else:
1333                         cherrypy.response.headers["Transaction-Id"] = _id
1334                     outdata = {"id": _id}
1335                 elif topic == "ns_instances_content":
1336                     # creates NSR
1337                     _id, _ = self.engine.new_item(
1338                         rollback, engine_session, engine_topic, indata, kwargs
1339                     )
1340                     # creates nslcmop
1341                     indata["lcmOperationType"] = "instantiate"
1342                     indata["nsInstanceId"] = _id
1343                     nslcmop_id, _ = self.engine.new_item(
1344                         rollback, engine_session, "nslcmops", indata, None
1345                     )
1346                     self._set_location_header(main_topic, version, topic, _id)
1347                     outdata = {"id": _id, "nslcmop_id": nslcmop_id}
1348                 elif topic == "ns_instances" and item:
1349                     indata["lcmOperationType"] = item
1350                     indata["nsInstanceId"] = _id
1351                     _id, _ = self.engine.new_item(
1352                         rollback, engine_session, "nslcmops", indata, kwargs
1353                     )
1354                     self._set_location_header(
1355                         main_topic, version, "ns_lcm_op_occs", _id
1356                     )
1357                     outdata = {"id": _id}
1358                     cherrypy.response.status = HTTPStatus.ACCEPTED.value
1359                 elif topic == "netslice_instances_content":
1360                     # creates NetSlice_Instance_record (NSIR)
1361                     _id, _ = self.engine.new_item(
1362                         rollback, engine_session, engine_topic, indata, kwargs
1363                     )
1364                     self._set_location_header(main_topic, version, topic, _id)
1365                     indata["lcmOperationType"] = "instantiate"
1366                     indata["netsliceInstanceId"] = _id
1367                     nsilcmop_id, _ = self.engine.new_item(
1368                         rollback, engine_session, "nsilcmops", indata, kwargs
1369                     )
1370                     outdata = {"id": _id, "nsilcmop_id": nsilcmop_id}
1371                 elif topic == "netslice_instances" and item:
1372                     indata["lcmOperationType"] = item
1373                     indata["netsliceInstanceId"] = _id
1374                     _id, _ = self.engine.new_item(
1375                         rollback, engine_session, "nsilcmops", indata, kwargs
1376                     )
1377                     self._set_location_header(
1378                         main_topic, version, "nsi_lcm_op_occs", _id
1379                     )
1380                     outdata = {"id": _id}
1381                     cherrypy.response.status = HTTPStatus.ACCEPTED.value
1382                 elif topic == "vnf_packages" and item == "action":
1383                     indata["lcmOperationType"] = item
1384                     indata["vnfPkgId"] = _id
1385                     _id, _ = self.engine.new_item(
1386                         rollback, engine_session, "vnfpkgops", indata, kwargs
1387                     )
1388                     self._set_location_header(
1389                         main_topic, version, "vnfpkg_op_occs", _id
1390                     )
1391                     outdata = {"id": _id}
1392                     cherrypy.response.status = HTTPStatus.ACCEPTED.value
1393                 elif topic == "subscriptions":
1394                     _id, _ = self.engine.new_item(
1395                         rollback, engine_session, engine_topic, indata, kwargs
1396                     )
1397                     self._set_location_header(main_topic, version, topic, _id)
1398                     link = {}
1399                     link["self"] = cherrypy.response.headers["Location"]
1400                     outdata = {
1401                         "id": _id,
1402                         "filter": indata["filter"],
1403                         "callbackUri": indata["CallbackUri"],
1404                         "_links": link,
1405                     }
1406                     cherrypy.response.status = HTTPStatus.CREATED.value
1407                 else:
1408                     _id, op_id = self.engine.new_item(
1409                         rollback,
1410                         engine_session,
1411                         engine_topic,
1412                         indata,
1413                         kwargs,
1414                         cherrypy.request.headers,
1415                     )
1416                     self._set_location_header(main_topic, version, topic, _id)
1417                     outdata = {"id": _id}
1418                     if op_id:
1419                         outdata["op_id"] = op_id
1420                         cherrypy.response.status = HTTPStatus.ACCEPTED.value
1421                     # TODO form NsdInfo when topic in ("ns_descriptors", "vnf_packages")
1422
1423             elif method == "DELETE":
1424                 if not _id:
1425                     outdata = self.engine.del_item_list(
1426                         engine_session, engine_topic, kwargs
1427                     )
1428                     cherrypy.response.status = HTTPStatus.OK.value
1429                 else:  # len(args) > 1
1430                     # for NS NSI generate an operation
1431                     op_id = None
1432                     if topic == "ns_instances_content" and not engine_session["force"]:
1433                         nslcmop_desc = {
1434                             "lcmOperationType": "terminate",
1435                             "nsInstanceId": _id,
1436                             "autoremove": True,
1437                         }
1438                         op_id, _ = self.engine.new_item(
1439                             rollback, engine_session, "nslcmops", nslcmop_desc, kwargs
1440                         )
1441                         if op_id:
1442                             outdata = {"_id": op_id}
1443                     elif (
1444                         topic == "netslice_instances_content"
1445                         and not engine_session["force"]
1446                     ):
1447                         nsilcmop_desc = {
1448                             "lcmOperationType": "terminate",
1449                             "netsliceInstanceId": _id,
1450                             "autoremove": True,
1451                         }
1452                         op_id, _ = self.engine.new_item(
1453                             rollback, engine_session, "nsilcmops", nsilcmop_desc, None
1454                         )
1455                         if op_id:
1456                             outdata = {"_id": op_id}
1457                     # if there is not any deletion in process, delete
1458                     if not op_id:
1459                         op_id = self.engine.del_item(engine_session, engine_topic, _id)
1460                         if op_id:
1461                             outdata = {"op_id": op_id}
1462                     cherrypy.response.status = (
1463                         HTTPStatus.ACCEPTED.value
1464                         if op_id
1465                         else HTTPStatus.NO_CONTENT.value
1466                     )
1467
1468             elif method in ("PUT", "PATCH"):
1469                 op_id = None
1470                 if not indata and not kwargs and not engine_session.get("set_project"):
1471                     raise NbiException(
1472                         "Nothing to update. Provide payload and/or query string",
1473                         HTTPStatus.BAD_REQUEST,
1474                     )
1475                 if (
1476                     item in ("nsd_content", "package_content", "nst_content")
1477                     and method == "PUT"
1478                 ):
1479                     completed = self.engine.upload_content(
1480                         engine_session,
1481                         engine_topic,
1482                         _id,
1483                         indata,
1484                         kwargs,
1485                         cherrypy.request.headers,
1486                     )
1487                     if not completed:
1488                         cherrypy.response.headers["Transaction-Id"] = id
1489                 else:
1490                     op_id = self.engine.edit_item(
1491                         engine_session, engine_topic, _id, indata, kwargs
1492                     )
1493
1494                 if op_id:
1495                     cherrypy.response.status = HTTPStatus.ACCEPTED.value
1496                     outdata = {"op_id": op_id}
1497                 else:
1498                     cherrypy.response.status = HTTPStatus.NO_CONTENT.value
1499                     outdata = None
1500             else:
1501                 raise NbiException(
1502                     "Method {} not allowed".format(method),
1503                     HTTPStatus.METHOD_NOT_ALLOWED,
1504                 )
1505
1506             # if Role information changes, it is needed to reload the information of roles
1507             if topic == "roles" and method != "GET":
1508                 self.authenticator.load_operation_to_allowed_roles()
1509
1510             if (
1511                 topic == "projects"
1512                 and method == "DELETE"
1513                 or topic in ["users", "roles"]
1514                 and method in ["PUT", "PATCH", "DELETE"]
1515             ):
1516                 self.authenticator.remove_token_from_cache()
1517
1518             return self._format_out(outdata, token_info, _format)
1519         except Exception as e:
1520             if isinstance(
1521                 e,
1522                 (
1523                     NbiException,
1524                     EngineException,
1525                     DbException,
1526                     FsException,
1527                     MsgException,
1528                     AuthException,
1529                     ValidationError,
1530                     AuthconnException,
1531                 ),
1532             ):
1533                 http_code_value = cherrypy.response.status = e.http_code.value
1534                 http_code_name = e.http_code.name
1535                 cherrypy.log("Exception {}".format(e))
1536             else:
1537                 http_code_value = (
1538                     cherrypy.response.status
1539                 ) = HTTPStatus.BAD_REQUEST.value  # INTERNAL_SERVER_ERROR
1540                 cherrypy.log("CRITICAL: Exception {}".format(e), traceback=True)
1541                 http_code_name = HTTPStatus.BAD_REQUEST.name
1542             if hasattr(outdata, "close"):  # is an open file
1543                 outdata.close()
1544             error_text = str(e)
1545             rollback.reverse()
1546             for rollback_item in rollback:
1547                 try:
1548                     if rollback_item.get("operation") == "set":
1549                         self.engine.db.set_one(
1550                             rollback_item["topic"],
1551                             {"_id": rollback_item["_id"]},
1552                             rollback_item["content"],
1553                             fail_on_empty=False,
1554                         )
1555                     elif rollback_item.get("operation") == "del_list":
1556                         self.engine.db.del_list(
1557                             rollback_item["topic"],
1558                             rollback_item["filter"],
1559                             fail_on_empty=False,
1560                         )
1561                     else:
1562                         self.engine.db.del_one(
1563                             rollback_item["topic"],
1564                             {"_id": rollback_item["_id"]},
1565                             fail_on_empty=False,
1566                         )
1567                 except Exception as e2:
1568                     rollback_error_text = "Rollback Exception {}: {}".format(
1569                         rollback_item, e2
1570                     )
1571                     cherrypy.log(rollback_error_text)
1572                     error_text += ". " + rollback_error_text
1573             # if isinstance(e, MsgException):
1574             #     error_text = "{} has been '{}' but other modules cannot be informed because an error on bus".format(
1575             #         engine_topic[:-1], method, error_text)
1576             problem_details = {
1577                 "code": http_code_name,
1578                 "status": http_code_value,
1579                 "detail": error_text,
1580             }
1581             return self._format_out(problem_details, token_info)
1582             # raise cherrypy.HTTPError(e.http_code.value, str(e))
1583         finally:
1584             if token_info:
1585                 self._format_login(token_info)
1586                 if method in ("PUT", "PATCH", "POST") and isinstance(outdata, dict):
1587                     for logging_id in ("id", "op_id", "nsilcmop_id", "nslcmop_id"):
1588                         if outdata.get(logging_id):
1589                             cherrypy.request.login += ";{}={}".format(
1590                                 logging_id, outdata[logging_id][:36]
1591                             )
1592
1593
1594 def _start_service():
1595     """
1596     Callback function called when cherrypy.engine starts
1597     Override configuration with env variables
1598     Set database, storage, message configuration
1599     Init database with admin/admin user password
1600     """
1601     global nbi_server
1602     global subscription_thread
1603     cherrypy.log.error("Starting osm_nbi")
1604     # update general cherrypy configuration
1605     update_dict = {}
1606
1607     engine_config = cherrypy.tree.apps["/osm"].config
1608     for k, v in environ.items():
1609         if not k.startswith("OSMNBI_"):
1610             continue
1611         k1, _, k2 = k[7:].lower().partition("_")
1612         if not k2:
1613             continue
1614         try:
1615             # update static configuration
1616             if k == "OSMNBI_STATIC_DIR":
1617                 engine_config["/static"]["tools.staticdir.dir"] = v
1618                 engine_config["/static"]["tools.staticdir.on"] = True
1619             elif k == "OSMNBI_SOCKET_PORT" or k == "OSMNBI_SERVER_PORT":
1620                 update_dict["server.socket_port"] = int(v)
1621             elif k == "OSMNBI_SOCKET_HOST" or k == "OSMNBI_SERVER_HOST":
1622                 update_dict["server.socket_host"] = v
1623             elif k1 in ("server", "test", "auth", "log"):
1624                 update_dict[k1 + "." + k2] = v
1625             elif k1 in ("message", "database", "storage", "authentication"):
1626                 # k2 = k2.replace('_', '.')
1627                 if k2 in ("port", "db_port"):
1628                     engine_config[k1][k2] = int(v)
1629                 else:
1630                     engine_config[k1][k2] = v
1631
1632         except ValueError as e:
1633             cherrypy.log.error("Ignoring environ '{}': " + str(e))
1634         except Exception as e:
1635             cherrypy.log.warn("skipping environ '{}' on exception '{}'".format(k, e))
1636
1637     if update_dict:
1638         cherrypy.config.update(update_dict)
1639         engine_config["global"].update(update_dict)
1640
1641     # logging cherrypy
1642     log_format_simple = (
1643         "%(asctime)s %(levelname)s %(name)s %(filename)s:%(lineno)s %(message)s"
1644     )
1645     log_formatter_simple = logging.Formatter(
1646         log_format_simple, datefmt="%Y-%m-%dT%H:%M:%S"
1647     )
1648     logger_server = logging.getLogger("cherrypy.error")
1649     logger_access = logging.getLogger("cherrypy.access")
1650     logger_cherry = logging.getLogger("cherrypy")
1651     logger_nbi = logging.getLogger("nbi")
1652
1653     if "log.file" in engine_config["global"]:
1654         file_handler = logging.handlers.RotatingFileHandler(
1655             engine_config["global"]["log.file"], maxBytes=100e6, backupCount=9, delay=0
1656         )
1657         file_handler.setFormatter(log_formatter_simple)
1658         logger_cherry.addHandler(file_handler)
1659         logger_nbi.addHandler(file_handler)
1660     # log always to standard output
1661     for format_, logger in {
1662         "nbi.server %(filename)s:%(lineno)s": logger_server,
1663         "nbi.access %(filename)s:%(lineno)s": logger_access,
1664         "%(name)s %(filename)s:%(lineno)s": logger_nbi,
1665     }.items():
1666         log_format_cherry = "%(asctime)s %(levelname)s {} %(message)s".format(format_)
1667         log_formatter_cherry = logging.Formatter(
1668             log_format_cherry, datefmt="%Y-%m-%dT%H:%M:%S"
1669         )
1670         str_handler = logging.StreamHandler()
1671         str_handler.setFormatter(log_formatter_cherry)
1672         logger.addHandler(str_handler)
1673
1674     if engine_config["global"].get("log.level"):
1675         logger_cherry.setLevel(engine_config["global"]["log.level"])
1676         logger_nbi.setLevel(engine_config["global"]["log.level"])
1677
1678     # logging other modules
1679     for k1, logname in {
1680         "message": "nbi.msg",
1681         "database": "nbi.db",
1682         "storage": "nbi.fs",
1683     }.items():
1684         engine_config[k1]["logger_name"] = logname
1685         logger_module = logging.getLogger(logname)
1686         if "logfile" in engine_config[k1]:
1687             file_handler = logging.handlers.RotatingFileHandler(
1688                 engine_config[k1]["logfile"], maxBytes=100e6, backupCount=9, delay=0
1689             )
1690             file_handler.setFormatter(log_formatter_simple)
1691             logger_module.addHandler(file_handler)
1692         if "loglevel" in engine_config[k1]:
1693             logger_module.setLevel(engine_config[k1]["loglevel"])
1694     # TODO add more entries, e.g.: storage
1695     cherrypy.tree.apps["/osm"].root.engine.start(engine_config)
1696     cherrypy.tree.apps["/osm"].root.authenticator.start(engine_config)
1697     cherrypy.tree.apps["/osm"].root.engine.init_db(target_version=database_version)
1698     cherrypy.tree.apps["/osm"].root.authenticator.init_db(
1699         target_version=auth_database_version
1700     )
1701
1702     # start subscriptions thread:
1703     subscription_thread = SubscriptionThread(
1704         config=engine_config, engine=nbi_server.engine
1705     )
1706     subscription_thread.start()
1707     # Do not capture except SubscriptionException
1708
1709     backend = engine_config["authentication"]["backend"]
1710     cherrypy.log.error(
1711         "Starting OSM NBI Version '{} {}' with '{}' authentication backend".format(
1712             nbi_version, nbi_version_date, backend
1713         )
1714     )
1715
1716
1717 def _stop_service():
1718     """
1719     Callback function called when cherrypy.engine stops
1720     TODO: Ending database connections.
1721     """
1722     global subscription_thread
1723     if subscription_thread:
1724         subscription_thread.terminate()
1725     subscription_thread = None
1726     cherrypy.tree.apps["/osm"].root.engine.stop()
1727     cherrypy.log.error("Stopping osm_nbi")
1728
1729
1730 def nbi(config_file):
1731     global nbi_server
1732     # conf = {
1733     #     '/': {
1734     #         #'request.dispatch': cherrypy.dispatch.MethodDispatcher(),
1735     #         'tools.sessions.on': True,
1736     #         'tools.response_headers.on': True,
1737     #         # 'tools.response_headers.headers': [('Content-Type', 'text/plain')],
1738     #     }
1739     # }
1740     # cherrypy.Server.ssl_module = 'builtin'
1741     # cherrypy.Server.ssl_certificate = "http/cert.pem"
1742     # cherrypy.Server.ssl_private_key = "http/privkey.pem"
1743     # cherrypy.Server.thread_pool = 10
1744     # cherrypy.config.update({'Server.socket_port': config["port"], 'Server.socket_host': config["host"]})
1745
1746     # cherrypy.config.update({'tools.auth_basic.on': True,
1747     #    'tools.auth_basic.realm': 'localhost',
1748     #    'tools.auth_basic.checkpassword': validate_password})
1749     nbi_server = Server()
1750     cherrypy.engine.subscribe("start", _start_service)
1751     cherrypy.engine.subscribe("stop", _stop_service)
1752     cherrypy.quickstart(nbi_server, "/osm", config_file)
1753
1754
1755 def usage():
1756     print(
1757         """Usage: {} [options]
1758         -c|--config [configuration_file]: loads the configuration file (default: ./nbi.cfg)
1759         -h|--help: shows this help
1760         """.format(
1761             sys.argv[0]
1762         )
1763     )
1764     # --log-socket-host HOST: send logs to this host")
1765     # --log-socket-port PORT: send logs using this port (default: 9022)")
1766
1767
1768 if __name__ == "__main__":
1769     try:
1770         # load parameters and configuration
1771         opts, args = getopt.getopt(sys.argv[1:], "hvc:", ["config=", "help"])
1772         # TODO add  "log-socket-host=", "log-socket-port=", "log-file="
1773         config_file = None
1774         for o, a in opts:
1775             if o in ("-h", "--help"):
1776                 usage()
1777                 sys.exit()
1778             elif o in ("-c", "--config"):
1779                 config_file = a
1780             # elif o == "--log-socket-port":
1781             #     log_socket_port = a
1782             # elif o == "--log-socket-host":
1783             #     log_socket_host = a
1784             # elif o == "--log-file":
1785             #     log_file = a
1786             else:
1787                 assert False, "Unhandled option"
1788         if config_file:
1789             if not path.isfile(config_file):
1790                 print(
1791                     "configuration file '{}' that not exist".format(config_file),
1792                     file=sys.stderr,
1793                 )
1794                 exit(1)
1795         else:
1796             for config_file in (
1797                 __file__[: __file__.rfind(".")] + ".cfg",
1798                 "./nbi.cfg",
1799                 "/etc/osm/nbi.cfg",
1800             ):
1801                 if path.isfile(config_file):
1802                     break
1803             else:
1804                 print(
1805                     "No configuration file 'nbi.cfg' found neither at local folder nor at /etc/osm/",
1806                     file=sys.stderr,
1807                 )
1808                 exit(1)
1809         nbi(config_file)
1810     except getopt.GetoptError as e:
1811         print(str(e), file=sys.stderr)
1812         # usage()
1813         exit(1)