rwlaunchpad/test/launchpad.py

   1 #!/usr/bin/env python3
   2
   3 #
   4 #   Copyright 2016 RIFT.IO Inc
   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 implied.
  15 #   See the License for the specific language governing permissions and
  16 #   limitations under the License.
  17 #
  18
  19
  20 import logging
  21 import os
  22 import resource
  23 import socket
  24 import sys
  25 import subprocess
  26 import shlex
  27 import shutil
  28 import netifaces
  29
  30 from rift.rwlib.util import certs
  31 import rift.rwcal.cloudsim
  32 import rift.rwcal.cloudsim.net
  33 import rift.vcs
  34 import rift.vcs.core as core
  35 import rift.vcs.demo
  36 import rift.vcs.vms
  37
  38 import rift.rwcal.cloudsim
  39 import rift.rwcal.cloudsim.net
  40
  41 from rift.vcs.ext import ClassProperty
  42
  43
  44 logger = logging.getLogger(__name__)
  45
  46
  47 class NsmTasklet(rift.vcs.core.Tasklet):
  48     """
  49     This class represents a network services manager tasklet.
  50     """
  51
  52     def __init__(self, name='network-services-manager', uid=None,
  53                  config_ready=True,
  54                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
  55                  data_storetype=core.DataStore.NOSTORE.value,
  56                  ):
  57         """
  58         Creates a NsmTasklet object.
  59
  60         Arguments:
  61             name  - the name of the tasklet
  62             uid   - a unique identifier
  63         """
  64         super(NsmTasklet, self).__init__(name=name, uid=uid,
  65                                          config_ready=config_ready,
  66                                          recovery_action=recovery_action,
  67                                          data_storetype=data_storetype,
  68                                         )
  69
  70     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwnsmtasklet')
  71     plugin_name = ClassProperty('rwnsmtasklet')
  72
  73
  74 class VnsTasklet(rift.vcs.core.Tasklet):
  75     """
  76     This class represents a network services manager tasklet.
  77     """
  78
  79     def __init__(self, name='virtual-network-service', uid=None,
  80                  config_ready=True,
  81                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
  82                  data_storetype=core.DataStore.NOSTORE.value,
  83                  ):
  84         """
  85         Creates a VnsTasklet object.
  86
  87         Arguments:
  88             name  - the name of the tasklet
  89             uid   - a unique identifier
  90         """
  91         super(VnsTasklet, self).__init__(name=name, uid=uid,
  92                                          config_ready=config_ready,
  93                                          recovery_action=recovery_action,
  94                                          data_storetype=data_storetype,
  95                                         )
  96
  97     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwvnstasklet')
  98     plugin_name = ClassProperty('rwvnstasklet')
  99
 100
 101 class VnfmTasklet(rift.vcs.core.Tasklet):
 102     """
 103     This class represents a virtual network function manager tasklet.
 104     """
 105
 106     def __init__(self, name='virtual-network-function-manager', uid=None,
 107                  config_ready=True,
 108                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 109                  data_storetype=core.DataStore.NOSTORE.value,
 110                  ):
 111         """
 112         Creates a VnfmTasklet object.
 113
 114         Arguments:
 115             name  - the name of the tasklet
 116             uid   - a unique identifier
 117         """
 118         super(VnfmTasklet, self).__init__(name=name, uid=uid,
 119                                           config_ready=config_ready,
 120                                           recovery_action=recovery_action,
 121                                           data_storetype=data_storetype,
 122                                          )
 123
 124     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwvnfmtasklet')
 125     plugin_name = ClassProperty('rwvnfmtasklet')
 126
 127
 128 class ResMgrTasklet(rift.vcs.core.Tasklet):
 129     """
 130     This class represents a Resource Manager tasklet.
 131     """
 132
 133     def __init__(self, name='Resource-Manager', uid=None,
 134                  config_ready=True,
 135                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 136                  data_storetype=core.DataStore.NOSTORE.value,
 137                  ):
 138         """
 139         Creates a ResMgrTasklet object.
 140
 141         Arguments:
 142             name  - the name of the tasklet
 143             uid   - a unique identifier
 144         """
 145         super(ResMgrTasklet, self).__init__(name=name, uid=uid,
 146                                             config_ready=config_ready,
 147                                             recovery_action=recovery_action,
 148                                             data_storetype=data_storetype,
 149                                            )
 150
 151     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwresmgrtasklet')
 152     plugin_name = ClassProperty('rwresmgrtasklet')
 153
 154
 155 class ImageMgrTasklet(rift.vcs.core.Tasklet):
 156     """
 157     This class represents a Image Manager tasklet.
 158     """
 159
 160     def __init__(self, name='Image-Manager', uid=None,
 161                  config_ready=True,
 162                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 163                  data_storetype=core.DataStore.NOSTORE.value,
 164                  ):
 165         """
 166         Creates a Image Manager Tasklet object.
 167
 168         Arguments:
 169             name  - the name of the tasklet
 170             uid   - a unique identifier
 171         """
 172         super(ImageMgrTasklet, self).__init__(
 173                 name=name, uid=uid,
 174                 config_ready=config_ready,
 175                 recovery_action=recovery_action,
 176                 data_storetype=data_storetype,
 177                 )
 178
 179     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwimagemgrtasklet')
 180     plugin_name = ClassProperty('rwimagemgrtasklet')
 181
 182
 183 class MonitorTasklet(rift.vcs.core.Tasklet):
 184     """
 185     This class represents a tasklet that is used to monitor NFVI metrics.
 186     """
 187
 188     def __init__(self, name='nfvi-metrics-monitor', uid=None,
 189                  config_ready=True,
 190                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 191                  data_storetype=core.DataStore.NOSTORE.value,
 192                  ):
 193         """
 194         Creates a MonitorTasklet object.
 195
 196         Arguments:
 197             name  - the name of the tasklet
 198             uid   - a unique identifier
 199
 200         """
 201         super(MonitorTasklet, self).__init__(name=name, uid=uid,
 202                                              config_ready=config_ready,
 203                                              recovery_action=recovery_action,
 204                                              data_storetype=data_storetype,
 205                                             )
 206
 207     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwmonitor')
 208     plugin_name = ClassProperty('rwmonitor')
 209
 210 class RedisServer(rift.vcs.NativeProcess):
 211     def __init__(self, name="RW.Redis.Server",
 212                  config_ready=True,
 213                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 214                  data_storetype=core.DataStore.NOSTORE.value,
 215                  ):
 216         super(RedisServer, self).__init__(
 217                 name=name,
 218                 exe="/usr/bin/redis-server",
 219                 config_ready=config_ready,
 220                 recovery_action=recovery_action,
 221                 data_storetype=data_storetype,
 222                 )
 223
 224     @property
 225     def args(self):
 226         return "./usr/bin/active_redis.conf --port 9999"
 227
 228
 229 class MonitoringParameterTasklet(rift.vcs.core.Tasklet):
 230     """
 231     This class represents a tasklet that is used to generate monitoring
 232     parameters.
 233     """
 234
 235     def __init__(self, name='Monitoring-Parameter', uid=None,
 236                  config_ready=True,
 237                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 238                  data_storetype=core.DataStore.NOSTORE.value,
 239                  ):
 240         """
 241         Creates a MonitoringParameterTasklet object.
 242
 243         Arguments:
 244             name  - the name of the tasklet
 245             uid   - a unique identifier
 246
 247         """
 248         super(MonitoringParameterTasklet, self).__init__(name=name, uid=uid,
 249                                              config_ready=config_ready,
 250                                              recovery_action=recovery_action,
 251                                              data_storetype=data_storetype,
 252                                             )
 253
 254     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwmonparam')
 255     plugin_name = ClassProperty('rwmonparam')
 256
 257
 258 class AutoscalerTasklet(rift.vcs.core.Tasklet):
 259     """
 260     This class represents a tasklet that is used to generate monitoring
 261     parameters.
 262     """
 263
 264     def __init__(self, name='Autoscaler', uid=None,
 265                  config_ready=True,
 266                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 267                  data_storetype=core.DataStore.NOSTORE.value,
 268                  ):
 269         """
 270         Creates a MonitoringParameterTasklet object.
 271
 272         Arguments:
 273             name  - the name of the tasklet
 274             uid   - a unique identifier
 275
 276         """
 277         super(AutoscalerTasklet, self).__init__(name=name, uid=uid,
 278                                              config_ready=config_ready,
 279                                              recovery_action=recovery_action,
 280                                              data_storetype=data_storetype,
 281                                             )
 282
 283     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwautoscaler')
 284     plugin_name = ClassProperty('rwautoscaler')
 285
 286 class StagingManagerTasklet(rift.vcs.core.Tasklet):
 287     """
 288     A class that provide a simple staging area for all tasklets
 289     """
 290
 291     def __init__(self, name='StagingManager', uid=None,
 292                  config_ready=True,
 293                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 294                  data_storetype=core.DataStore.NOSTORE.value,
 295                  ):
 296         """
 297         Creates a StagingMangerTasklet object.
 298
 299         Arguments:
 300             name  - the name of the tasklet
 301             uid   - a unique identifier
 302
 303         """
 304         super(StagingManagerTasklet, self).__init__(name=name, uid=uid,
 305                                              config_ready=config_ready,
 306                                              recovery_action=recovery_action,
 307                                              data_storetype=data_storetype,
 308                                             )
 309
 310     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwstagingmgr')
 311     plugin_name = ClassProperty('rwstagingmgr')
 312
 313 def get_ui_ssl_args():
 314     """Returns the SSL parameter string for launchpad UI processes"""
 315
 316     try:
 317         use_ssl, certfile_path, keyfile_path = certs.get_bootstrap_cert_and_key()
 318     except certs.BootstrapSslMissingException:
 319         logger.error('No bootstrap certificates found.  Disabling UI SSL')
 320         use_ssl = False
 321
 322     # If we're not using SSL, no SSL arguments are necessary
 323     if not use_ssl:
 324         return ""
 325
 326     return "--enable-https --keyfile-path=%s --certfile-path=%s" % (keyfile_path, certfile_path)
 327
 328
 329 class UIServer(rift.vcs.NativeProcess):
 330     def __init__(self, name="RW.MC.UI",
 331                  config_ready=True,
 332                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 333                  data_storetype=core.DataStore.NOSTORE.value,
 334                  ):
 335         super(UIServer, self).__init__(
 336                 name=name,
 337                 exe="./usr/share/rw.ui/skyquake/scripts/launch_ui.sh",
 338                 config_ready=config_ready,
 339                 recovery_action=recovery_action,
 340                 data_storetype=data_storetype,
 341                 )
 342
 343     @property
 344     def args(self):
 345         return get_ui_ssl_args()
 346
 347 class ConfigManagerTasklet(rift.vcs.core.Tasklet):
 348     """
 349     This class represents a Resource Manager tasklet.
 350     """
 351
 352     def __init__(self, name='Configuration-Manager', uid=None,
 353                  config_ready=True,
 354                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 355                  data_storetype=core.DataStore.NOSTORE.value,
 356                  ):
 357         """
 358         Creates a ConfigManagerTasklet object.
 359
 360         Arguments:
 361             name  - the name of the tasklet
 362             uid   - a unique identifier
 363         """
 364         super(ConfigManagerTasklet, self).__init__(name=name, uid=uid,
 365                                                    config_ready=config_ready,
 366                                                    recovery_action=recovery_action,
 367                                                    data_storetype=data_storetype,
 368                                                   )
 369
 370     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwconmantasklet')
 371     plugin_name = ClassProperty('rwconmantasklet')
 372
 373 class PackageManagerTasklet(rift.vcs.core.Tasklet):
 374     """
 375     This class represents a Resource Manager tasklet.
 376     """
 377
 378     def __init__(self, name='Package-Manager', uid=None,
 379                  config_ready=True,
 380                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 381                  data_storetype=core.DataStore.NOSTORE.value,
 382                  ):
 383         """
 384         Creates a PackageManager object.
 385
 386         Arguments:
 387             name  - the name of the tasklet
 388             uid   - a unique identifier
 389         """
 390         super(PackageManagerTasklet, self).__init__(name=name, uid=uid,
 391                                                    config_ready=config_ready,
 392                                                    recovery_action=recovery_action,
 393                                                    data_storetype=data_storetype,
 394                                                   )
 395
 396     plugin_directory = ClassProperty('./usr/lib/rift/plugins/rwpkgmgr')
 397     plugin_name = ClassProperty('rwpkgmgr')
 398
 399 class GlanceServer(rift.vcs.NativeProcess):
 400     def __init__(self, name="glance-image-catalog",
 401                  config_ready=True,
 402                  recovery_action=core.RecoveryType.FAILCRITICAL.value,
 403                  data_storetype=core.DataStore.NOSTORE.value,
 404                  ):
 405         super(GlanceServer, self).__init__(
 406                 name=name,
 407                 exe="./usr/bin/glance_start_wrapper",
 408                 config_ready=config_ready,
 409                 recovery_action=recovery_action,
 410                 data_storetype=data_storetype,
 411                 )
 412
 413     @property
 414     def args(self):
 415         return "./etc/glance"
 416
 417
 418 class Demo(rift.vcs.demo.Demo):
 419     def __init__(self, no_ui=False, ha_mode=None, mgmt_ip_list=[], test_name=None):
 420         procs = [
 421             ConfigManagerTasklet(),
 422             GlanceServer(),
 423             rift.vcs.DtsRouterTasklet(),
 424             rift.vcs.MsgBrokerTasklet(),
 425             #rift.vcs.RestPortForwardTasklet(),
 426             rift.vcs.RestconfTasklet(),
 427             rift.vcs.RiftCli(),
 428             rift.vcs.uAgentTasklet(),
 429             rift.vcs.Launchpad(),
 430             ]
 431
 432         standby_procs = [
 433             RedisServer(),
 434             rift.vcs.DtsRouterTasklet(),
 435             rift.vcs.MsgBrokerTasklet(),
 436             ]
 437
 438         datastore = core.DataStore.BDB.value
 439         if ha_mode:
 440             procs.append(RedisServer())
 441             datastore = core.DataStore.REDIS.value
 442
 443         if not no_ui:
 444             procs.append(UIServer())
 445
 446         restart_procs = [
 447               VnfmTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 448               VnsTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 449               # MonitorTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 450               MonitoringParameterTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 451               NsmTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 452               ResMgrTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 453               ImageMgrTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 454               AutoscalerTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 455               PackageManagerTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 456               StagingManagerTasklet(recovery_action=core.RecoveryType.RESTART.value, data_storetype=datastore),
 457             ]
 458
 459         if not mgmt_ip_list or len(mgmt_ip_list) == 0:
 460             mgmt_ip_list.append("127.0.0.1")
 461
 462         colony = rift.vcs.core.Colony(name='top', uid=1)
 463
 464         lead_lp_vm = rift.vcs.VirtualMachine(
 465               name='vm-launchpad-1',
 466               ip=mgmt_ip_list[0],
 467               procs=procs,
 468               restart_procs=restart_procs,
 469             )
 470         lead_lp_vm.leader = True
 471         colony.append(lead_lp_vm)
 472
 473         if ha_mode:
 474             stby_lp_vm = rift.vcs.VirtualMachine(
 475                   name='launchpad-vm-2',
 476                   ip=mgmt_ip_list[1],
 477                   procs=standby_procs,
 478                   start=False,
 479                 )
 480             # WA to Agent mode_active flag reset
 481             stby_lp_vm.add_tasklet(rift.vcs.uAgentTasklet(), mode_active=False)
 482             colony.append(stby_lp_vm)
 483
 484         sysinfo = rift.vcs.SystemInfo(
 485                     mode='ethsim',
 486                     zookeeper=rift.vcs.manifest.RaZookeeper(master_ip=mgmt_ip_list[0]),
 487                     colonies=[colony],
 488                     multi_broker=True,
 489                     multi_dtsrouter=True,
 490                     mgmt_ip_list=mgmt_ip_list,
 491                     test_name=test_name,
 492                   )
 493
 494         super(Demo, self).__init__(
 495             # Construct the system. This system consists of 1 cluster in 1
 496             # colony. The master cluster houses CLI and management VMs
 497             sysinfo = sysinfo,
 498
 499             # Define the generic portmap.
 500             port_map = {},
 501
 502             # Define a mapping from the placeholder logical names to the real
 503             # port names for each of the different modes supported by this demo.
 504             port_names = {
 505                 'ethsim': {
 506                 },
 507                 'pci': {
 508                 }
 509             },
 510
 511             # Define the connectivity between logical port names.
 512             port_groups = {},
 513         )
 514
 515
 516 def main(argv=sys.argv[1:]):
 517     logging.basicConfig(format='%(asctime)-15s %(levelname)s %(message)s')
 518
 519     # Create a parser which includes all generic demo arguments
 520     parser = rift.vcs.demo.DemoArgParser()
 521     parser.add_argument("--no-ui", action='store_true')
 522     args = parser.parse_args(argv)
 523
 524     # Disable loading any kernel modules for the launchpad VM
 525     # since it doesn't need it and it will fail within containers
 526     os.environ["NO_KERNEL_MODS"] = "1"
 527
 528     cleanup_dir_name = None
 529     if os.environ["INSTALLDIR"] in ["/", "/home/rift", "/home/rift/.install",
 530         "/usr/rift/build/fc20_debug/install/usr/rift", "/usr/rift"]:
 531         cleanup_dir_name = os.environ["INSTALLDIR"] + "/var/rift/"
 532
 533     if args.test_name and not cleanup_dir_name:
 534         cleanup_dir_name = "find {rift_install}/var/rift -name '*{pattern}*' -type d".format( \
 535             rift_install=os.environ['RIFT_INSTALL'],
 536             pattern = args.test_name)
 537         try:
 538             cleanup_dir_name = subprocess.check_output(cleanup_dir_name, shell=True)
 539             cleanup_dir_name = cleanup_dir_name[:-1].decode("utf-8") + "/"
 540         except Exception as e:
 541             print ("Directory not found exception occurred. Probably running for first time")
 542             print ("Zookeper cleanup cmd = {}".format(cleanup_dir_name))
 543     else:
 544         if not cleanup_dir_name:
 545           cleanup_dir_name = os.environ["INSTALLDIR"] + "/"
 546
 547     # Remove the persistent Redis data
 548     try:
 549         for f in os.listdir(cleanup_dir_name):
 550             if f.endswith(".aof") or f.endswith(".rdb"):
 551                 os.remove(os.path.join(cleanup_dir_name, f))
 552
 553         # Remove the persistant DTS recovery files
 554         for f in os.listdir(cleanup_dir_name):
 555             if f.endswith(".db"):
 556                 os.remove(os.path.join(cleanup_dir_name, f))
 557
 558         shutil.rmtree(os.path.join(cleanup_dir_name, "zk/server-1"))
 559         shutil.rmtree(os.path.join(os.environ["INSTALLDIR"], "var/rift/tmp*"))
 560     except FileNotFoundError as e:
 561         pass
 562     except Exception as e:
 563         print ("Error while cleanup: {}".format(str(e)))
 564
 565     ha_mode = args.ha_mode
 566     mgmt_ip_list = [] if not args.mgmt_ip_list else args.mgmt_ip_list
 567
 568     #load demo info and create Demo object
 569     demo = Demo(args.no_ui, ha_mode, mgmt_ip_list, args.test_name)
 570
 571     # Create the prepared system from the demo
 572     system = rift.vcs.demo.prepared_system_from_demo_and_args(demo, args,
 573               northbound_listing=["cli_launchpad_schema_listing.txt"],
 574               netconf_trace_override=True)
 575
 576     # TODO: This need to be changed when launchpad starts running on multiple VMs
 577     # confd_ip = socket.gethostbyname(socket.gethostname())
 578     rift.vcs.logger.configure_sink(config_file=None, confd_ip="127.0.0.1")
 579
 580     # Start the prepared system
 581     system.start()
 582
 583
 584 if __name__ == "__main__":
 585     resource.setrlimit(resource.RLIMIT_CORE, (resource.RLIM_INFINITY, resource.RLIM_INFINITY) )
 586     try:
 587         main()
 588     except rift.vcs.demo.ReservationError:
 589         print("ERROR: unable to retrieve a list of IP addresses from the reservation system")
 590         sys.exit(1)
 591     except rift.vcs.demo.MissingModeError:
 592         print("ERROR: you need to provide a mode to run the script")
 593         sys.exit(1)
 594     finally:
 595         os.system("stty sane")