dashboard/src/api/models.py

   1 ##############################################################################
   2 # Copyright (c) 2018 Sawyer Bergeron, Parker Berberian, and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10
  11 from django.contrib.auth.models import User
  12 from django.db import models
  13 from django.core.exceptions import PermissionDenied
  14
  15 import json
  16 import uuid
  17
  18 from booking.models import Booking
  19 from resource_inventory.models import (
  20     Lab,
  21     HostProfile,
  22     Host,
  23     Image,
  24     Interface
  25 )
  26
  27
  28 class JobStatus(object):
  29     NEW = 0
  30     CURRENT = 100
  31     DONE = 200
  32     ERROR = 300
  33
  34
  35 class LabManagerTracker(object):
  36
  37     @classmethod
  38     def get(cls, lab_name, token):
  39         """
  40         Takes in a lab name (from a url path)
  41         returns a lab manager instance for that lab, if it exists
  42         """
  43         try:
  44             lab = Lab.objects.get(name=lab_name)
  45         except:
  46             raise PermissionDenied("Lab not found")
  47         if lab.api_token == token:
  48             return LabManager(lab)
  49         raise PermissionDenied("Lab not authorized")
  50
  51
  52 class LabManager(object):
  53     """
  54     This is the class that will ultimately handle all REST calls to
  55     lab endpoints.
  56     handles jobs, inventory, status, etc
  57     may need to create helper classes
  58     """
  59
  60     def __init__(self, lab):
  61         self.lab = lab
  62
  63     def get_profile(self):
  64         prof = {}
  65         prof['name'] = self.lab.name
  66         prof['contact'] = {
  67             "phone": self.lab.contact_phone,
  68             "email": self.lab.contact_email
  69         }
  70         prof['host_count'] = []
  71         for host in HostProfile.objects.filter(labs=self.lab):
  72             count = Host.objects.filter(profile=host, lab=self.lab).count()
  73             prof['host_count'].append(
  74                 {
  75                     "type": host.name,
  76                     "count": count
  77                 }
  78             )
  79         return prof
  80
  81     def get_inventory(self):
  82         inventory = {}
  83         hosts = Host.objects.filter(lab=self.lab)
  84         images = Image.objects.filter(from_lab=self.lab)
  85         profiles = HostProfile.objects.filter(labs=self.lab)
  86         inventory['hosts'] = self.serialize_hosts(hosts)
  87         inventory['images'] = self.serialize_images(images)
  88         inventory['host_types'] = self.serialize_host_profiles(profiles)
  89         return inventory
  90
  91     def get_status(self):
  92         return {"status": self.lab.status}
  93
  94     def set_status(self, payload):
  95         {}
  96
  97     def get_current_jobs(self):
  98         jobs = Job.objects.filter(booking__lab=self.lab)
  99
 100         return self.serialize_jobs(jobs, status=JobStatus.CURRENT)
 101
 102     def get_new_jobs(self):
 103         jobs = Job.objects.filter(booking__lab=self.lab)
 104
 105         return self.serialize_jobs(jobs, status=JobStatus.NEW)
 106
 107     def get_done_jobs(self):
 108         jobs = Job.objects.filter(booking__lab=self.lab)
 109
 110         return self.serialize_jobs(jobs, status=JobStatus.DONE)
 111
 112     def get_job(self, jobid):
 113         return Job.objects.get(pk=jobid).to_dict()
 114
 115     def update_job(self, jobid, data):
 116         {}
 117
 118     def serialize_jobs(self, jobs, status=JobStatus.NEW):
 119         job_ser = []
 120         for job in jobs:
 121             jsonized_job = job.get_delta(status)
 122             if len(jsonized_job['payload']) < 1:
 123                 continue
 124             job_ser.append(jsonized_job)
 125
 126         return job_ser
 127
 128     def serialize_hosts(self, hosts):
 129         host_ser = []
 130         for host in hosts:
 131             h = {}
 132             h['interfaces'] = []
 133             h['hostname'] = host.name
 134             h['host_type'] = host.profile.name
 135             for iface in host.interfaces.all():
 136                 eth = {}
 137                 eth['mac'] = iface.mac_address
 138                 eth['busaddr'] = iface.bus_address
 139                 eth['name'] = iface.name
 140                 eth['switchport'] = {"switch_name": iface.switch_name, "port_name": iface.port_name}
 141                 h['interfaces'].append(eth)
 142         return host_ser
 143
 144     def serialize_images(self, images):
 145         images_ser = []
 146         for image in images:
 147             images_ser.append(
 148                 {
 149                     "name": image.name,
 150                     "lab_id": image.lab_id,
 151                     "dashboard_id": image.id
 152                 }
 153             )
 154         return images_ser
 155
 156     def serialize_host_profiles(self, profiles):
 157         profile_ser = []
 158         for profile in profiles:
 159             p = {}
 160             p['cpu'] = {
 161                 "cores": profile.cpuprofile.first().cores,
 162                 "arch": profile.cpuprofile.first().architecture,
 163                 "cpus": profile.cpuprofile.first().cpus,
 164             }
 165             p['disks'] = []
 166             for disk in profile.storageprofile.all():
 167                 d = {
 168                     "size": disk.size,
 169                     "type": disk.media_type,
 170                     "name": disk.name
 171                 }
 172                 p['disks'].append(d)
 173             p['description'] = profile.description
 174             p['interfaces'] = []
 175             for iface in profile.interfaceprofile.all():
 176                 p['interfaces'].append(
 177                     {
 178                         "speed": iface.speed,
 179                         "name": iface.name
 180                     }
 181                 )
 182
 183             p['ram'] = {"amount": profile.ramprofile.first().amount}
 184             p['name'] = profile.name
 185             profile_ser.append(p)
 186         return profile_ser
 187
 188
 189 class Job(models.Model):
 190     """
 191     This is the class that is serialized and put into the api
 192     """
 193     booking = models.OneToOneField(Booking, on_delete=models.CASCADE, null=True)
 194     status = models.IntegerField(default=JobStatus.NEW)
 195     complete = models.BooleanField(default=False)
 196
 197     def to_dict(self):
 198         d = {}
 199         j = {}
 200         j['id'] = self.id
 201         for relation in AccessRelation.objects.filter(job=self):
 202             if 'access' not in d:
 203                 d['access'] = {}
 204             d['access'][relation.task_id] = relation.config.to_dict()
 205         for relation in SoftwareRelation.objects.filter(job=self):
 206             if 'software' not in d:
 207                 d['software'] = {}
 208             d['software'][relation.task_id] = relation.config.to_dict()
 209         for relation in HostHardwareRelation.objects.filter(job=self):
 210             if 'hardware' not in d:
 211                 d['hardware'] = {}
 212             d['hardware'][relation.task_id] = relation.config.to_dict()
 213         for relation in HostNetworkRelation.objects.filter(job=self):
 214             if 'network' not in d:
 215                 d['network'] = {}
 216             d['network'][relation.task_id] = relation.config.to_dict()
 217
 218         j['payload'] = d
 219
 220         return j
 221
 222     def get_tasklist(self, status="all"):
 223         tasklist = []
 224         clist = [HostHardwareRelation, AccessRelation, HostNetworkRelation, SoftwareRelation]
 225         if status == "all":
 226             for cls in clist:
 227                 tasklist += list(cls.objects.filter(job=self))
 228         else:
 229             for cls in clist:
 230                 tasklist += list(cls.objects.filter(job=self).filter(status=status))
 231         return tasklist
 232
 233     def is_fulfilled(self):
 234         """
 235         This method should return true if all of the job's tasks are done,
 236         and false otherwise
 237         """
 238         my_tasks = self.get_tasklist()
 239         for task in my_tasks:
 240             if task.status != JobStatus.DONE:
 241                 return False
 242         return True
 243
 244     def get_delta(self, status):
 245         d = {}
 246         j = {}
 247         j['id'] = self.id
 248         for relation in AccessRelation.objects.filter(job=self).filter(status=status):
 249             if 'access' not in d:
 250                 d['access'] = {}
 251             d['access'][relation.task_id] = relation.config.get_delta()
 252         for relation in SoftwareRelation.objects.filter(job=self).filter(status=status):
 253             if 'software' not in d:
 254                 d['software'] = {}
 255             d['software'][relation.task_id] = relation.config.get_delta()
 256         for relation in HostHardwareRelation.objects.filter(job=self).filter(status=status):
 257             if 'hardware' not in d:
 258                 d['hardware'] = {}
 259             d['hardware'][relation.task_id] = relation.config.get_delta()
 260         for relation in HostNetworkRelation.objects.filter(job=self).filter(status=status):
 261             if 'network' not in d:
 262                 d['network'] = {}
 263             d['network'][relation.task_id] = relation.config.get_delta()
 264
 265         j['payload'] = d
 266         return j
 267
 268     def to_json(self):
 269         return json.dumps(self.to_dict())
 270
 271
 272 class TaskConfig(models.Model):
 273     def to_dict(self):
 274         pass
 275
 276     def get_delta(self):
 277         pass
 278
 279     def to_json(self):
 280         return json.dumps(self.to_dict())
 281
 282     def clear_delta(self):
 283         self.delta = '{}'
 284
 285
 286 class OpnfvApiConfig(models.Model):
 287
 288     installer = models.CharField(max_length=100)
 289     scenario = models.CharField(max_length=100)
 290     roles = models.ManyToManyField(Host)
 291     delta = models.TextField()
 292
 293     def to_dict(self):
 294         d = {}
 295         if self.installer:
 296             d['installer'] = self.installer
 297         if self.scenario:
 298             d['scenario'] = self.scenario
 299
 300         hosts = self.roles.all()
 301         if hosts.exists():
 302             d['roles'] = []
 303         for host in self.roles.all():
 304             d['roles'].append({host.labid: host.config.opnfvRole.name})
 305
 306         return d
 307
 308     def to_json(self):
 309         return json.dumps(self.to_dict())
 310
 311     def set_installer(self, installer):
 312         self.installer = installer
 313         d = json.loads(self.delta)
 314         d['installer'] = installer
 315         self.delta = json.dumps(d)
 316
 317     def set_scenario(self, scenario):
 318         self.scenario = scenario
 319         d = json.loads(self.delta)
 320         d['scenario'] = scenario
 321         self.delta = json.dumps(d)
 322
 323     def add_role(self, host):
 324         self.roles.add(host)
 325         d = json.loads(self.delta)
 326         if 'role' not in d:
 327             d['role'] = []
 328         d['roles'].append({host.labid: host.config.opnfvRole.name})
 329         self.delta = json.dumps(d)
 330
 331     def clear_delta(self):
 332         self.delta = '{}'
 333
 334     def get_delta(self):
 335         if not self.delta:
 336             self.delta = self.to_json()
 337             self.save()
 338         return json.loads(self.delta)
 339
 340
 341 class AccessConfig(TaskConfig):
 342     access_type = models.CharField(max_length=50)
 343     user = models.ForeignKey(User, on_delete=models.CASCADE)
 344     revoke = models.BooleanField(default=False)
 345     context = models.TextField(default="")
 346     delta = models.TextField()
 347
 348     def to_dict(self):
 349         d = {}
 350         d['access_type'] = self.access_type
 351         d['user'] = self.user.id
 352         d['revoke'] = self.revoke
 353         d['context'] = json.loads(self.context)
 354         return d
 355
 356     def get_delta(self):
 357         if not self.delta:
 358             self.delta = self.to_json()
 359             self.save()
 360         d = json.loads(self.delta)
 361         d["lab_token"] = self.accessrelation.lab_token
 362
 363         return d
 364
 365     def to_json(self):
 366         return json.dumps(self.to_dict())
 367
 368     def clear_delta(self):
 369         d = {}
 370         d["lab_token"] = self.accessrelation.lab_token
 371         self.delta = json.dumps(d)
 372
 373     def set_access_type(self, access_type):
 374         self.access_type = access_type
 375         d = json.loads(self.delta)
 376         d['access_type'] = access_type
 377         self.delta = json.dumps(d)
 378
 379     def set_user(self, user):
 380         self.user = user
 381         d = json.loads(self.delta)
 382         d['user'] = self.user.id
 383         self.delta = json.dumps(d)
 384
 385     def set_revoke(self, revoke):
 386         self.revoke = revoke
 387         d = json.loads(self.delta)
 388         d['revoke'] = revoke
 389         self.delta = json.dumps(d)
 390
 391     def set_context(self, context):
 392         self.context = json.dumps(context)
 393         d = json.loads(self.delta)
 394         d['context'] = context
 395         self.delta = json.dumps(d)
 396
 397
 398 class SoftwareConfig(TaskConfig):
 399     """
 400     handled opnfv installations, etc
 401     """
 402     opnfv = models.ForeignKey(OpnfvApiConfig, on_delete=models.CASCADE)
 403
 404     def to_dict(self):
 405         d = {}
 406         if self.opnfv:
 407             d['opnfv'] = self.opnfv.to_dict()
 408
 409         d["lab_token"] = self.softwarerelation.lab_token
 410         self.delta = json.dumps(d)
 411
 412         return d
 413
 414     def get_delta(self):
 415         d = {}
 416         d['opnfv'] = self.opnfv.get_delta()
 417         d['lab_token'] = self.softwarerelation.lab_token
 418
 419         return d
 420
 421     def clear_delta(self):
 422         self.opnfv.clear_delta()
 423
 424     def to_json(self):
 425         return json.dumps(self.to_dict())
 426
 427
 428 class HardwareConfig(TaskConfig):
 429     """
 430     handles imaging, user accounts, etc
 431     """
 432     image = models.CharField(max_length=100, default="defimage")
 433     power = models.CharField(max_length=100, default="off")
 434     hostname = models.CharField(max_length=100, default="hostname")
 435     ipmi_create = models.BooleanField(default=False)
 436     delta = models.TextField()
 437
 438     def to_dict(self):
 439         d = {}
 440         d['image'] = self.image
 441         d['power'] = self.power
 442         d['hostname'] = self.hostname
 443         d['ipmi_create'] = str(self.ipmi_create)
 444         d['id'] = self.hosthardwarerelation.host.labid
 445         return d
 446
 447     def to_json(self):
 448         return json.dumps(self.to_dict())
 449
 450     def get_delta(self):
 451         if not self.delta:
 452             self.delta = self.to_json()
 453             self.save()
 454         d = json.loads(self.delta)
 455         d['lab_token'] = self.hosthardwarerelation.lab_token
 456         return d
 457
 458     def clear_delta(self):
 459         d = {}
 460         d["id"] = self.hosthardwarerelation.host.labid
 461         d["lab_token"] = self.hosthardwarerelation.lab_token
 462         self.delta = json.dumps(d)
 463
 464     def set_image(self, image):
 465         self.image = image
 466         d = json.loads(self.delta)
 467         d['image'] = self.image
 468         self.delta = json.dumps(d)
 469
 470     def set_power(self, power):
 471         self.power = power
 472         d = json.loads(self.delta)
 473         d['power'] = power
 474         self.delta = json.dumps(d)
 475
 476     def set_hostname(self, hostname):
 477         self.hostname = hostname
 478         d = json.loads(self.delta)
 479         d['hostname'] = hostname
 480         self.delta = json.dumps(d)
 481
 482     def set_ipmi_create(self, ipmi_create):
 483         self.ipmi_create = ipmi_create
 484         d = json.loads(self.delta)
 485         d['ipmi_create'] = ipmi_create
 486         self.delta = json.dumps(d)
 487
 488
 489 class NetworkConfig(TaskConfig):
 490     """
 491     handles network configuration
 492     """
 493     interfaces = models.ManyToManyField(Interface)
 494     delta = models.TextField()
 495
 496     def to_dict(self):
 497         d = {}
 498         hid = self.hostnetworkrelation.host.labid
 499         d[hid] = {}
 500         for interface in self.interfaces.all():
 501             d[hid][interface.mac_address] = []
 502             for vlan in interface.config.all():
 503                 d[hid][interface.mac_address].append({"vlan_id": vlan.vlan_id, "tagged": vlan.tagged})
 504
 505         return d
 506
 507     def to_json(self):
 508         return json.dumps(self.to_dict())
 509
 510     def get_delta(self):
 511         if not self.delta:
 512             self.delta = self.to_json()
 513             self.save()
 514         d = json.loads(self.delta)
 515         d['lab_token'] = self.hostnetworkrelation.lab_token
 516         return d
 517
 518     def clear_delta(self):
 519         self.delta = json.dumps(self.to_dict())
 520         self.save()
 521
 522     def add_interface(self, interface):
 523         self.interfaces.add(interface)
 524         d = json.loads(self.delta)
 525         hid = self.hostnetworkrelation.host.labid
 526         if hid not in d:
 527             d[hid] = {}
 528         d[hid][interface.mac_address] = []
 529         for vlan in interface.config.all():
 530             d[hid][interface.mac_address].append({"vlan_id": vlan.vlan_id, "tagged": vlan.tagged})
 531         self.delta = json.dumps(d)
 532
 533
 534 def get_task(task_id):
 535     for taskclass in [AccessRelation, SoftwareRelation, HostHardwareRelation, HostNetworkRelation]:
 536         try:
 537             ret = taskclass.objects.get(task_id=task_id)
 538             return ret
 539         except taskclass.DoesNotExist:
 540             pass
 541     from django.core.exceptions import ObjectDoesNotExist
 542     raise ObjectDoesNotExist("Could not find matching TaskRelation instance")
 543
 544
 545 def get_task_uuid():
 546     return str(uuid.uuid4())
 547
 548
 549 class TaskRelation(models.Model):
 550     status = models.IntegerField(default=JobStatus.NEW)
 551     job = models.ForeignKey(Job, on_delete=models.CASCADE)
 552     config = models.OneToOneField(TaskConfig, on_delete=models.CASCADE)
 553     task_id = models.CharField(default=get_task_uuid, max_length=37)
 554     lab_token = models.CharField(default="null", max_length=50)
 555     message = models.TextField(default="")
 556
 557     def delete(self, *args, **kwargs):
 558         self.config.delete()
 559         return super(self.__class__, self).delete(*args, **kwargs)
 560
 561     def type_str(self):
 562         return "Generic Task"
 563
 564     class Meta:
 565         abstract = True
 566
 567
 568 class AccessRelation(TaskRelation):
 569     config = models.OneToOneField(AccessConfig, on_delete=models.CASCADE)
 570
 571     def type_str(self):
 572         return "Access Task"
 573
 574     def delete(self, *args, **kwargs):
 575         self.config.delete()
 576         return super(self.__class__, self).delete(*args, **kwargs)
 577
 578
 579 class SoftwareRelation(TaskRelation):
 580     config = models.OneToOneField(SoftwareConfig, on_delete=models.CASCADE)
 581
 582     def type_str(self):
 583         return "Software Configuration Task"
 584
 585     def delete(self, *args, **kwargs):
 586         self.config.delete()
 587         return super(self.__class__, self).delete(*args, **kwargs)
 588
 589
 590 class HostHardwareRelation(TaskRelation):
 591     host = models.ForeignKey(Host, on_delete=models.CASCADE)
 592     config = models.OneToOneField(HardwareConfig, on_delete=models.CASCADE)
 593
 594     def type_str(self):
 595         return "Hardware Configuration Task"
 596
 597     def get_delta(self):
 598         return self.config.to_dict()
 599
 600     def delete(self, *args, **kwargs):
 601         self.config.delete()
 602         return super(self.__class__, self).delete(*args, **kwargs)
 603
 604
 605 class HostNetworkRelation(TaskRelation):
 606     host = models.ForeignKey(Host, on_delete=models.CASCADE)
 607     config = models.OneToOneField(NetworkConfig, on_delete=models.CASCADE)
 608
 609     def type_str(self):
 610         return "Network Configuration Task"
 611
 612     def delete(self, *args, **kwargs):
 613         self.config.delete()
 614         return super(self.__class__, self).delete(*args, **kwargs)
 615
 616
 617 class JobFactory(object):
 618
 619     @classmethod
 620     def makeCompleteJob(cls, booking):
 621         hosts = Host.objects.filter(bundle=booking.resource)
 622         job = None
 623         try:
 624             job = Job.objects.get(booking=booking)
 625         except:
 626             job = Job.objects.create(status=JobStatus.NEW, booking=booking)
 627         cls.makeHardwareConfigs(
 628             hosts=hosts,
 629             job=job
 630         )
 631         cls.makeNetworkConfigs(
 632             hosts=hosts,
 633             job=job
 634         )
 635         cls.makeSoftware(
 636             hosts=hosts,
 637             job=job
 638         )
 639         all_users = list(booking.collaborators.all())
 640         all_users.append(booking.owner)
 641         cls.makeAccessConfig(
 642             users=all_users,
 643             access_type="vpn",
 644             revoke=False,
 645             job=job
 646         )
 647         for user in all_users:
 648             try:
 649                 cls.makeAccessConfig(
 650                     users=[user],
 651                     access_type="ssh",
 652                     revoke=False,
 653                     job=job,
 654                     context={
 655                         "key": user.userprofile.ssh_public_key.open().read().decode(encoding="UTF-8"),
 656                         "hosts": [host.labid for host in hosts]
 657                     }
 658                 )
 659             except Exception:
 660                 continue
 661
 662     @classmethod
 663     def makeHardwareConfigs(cls, hosts=[], job=Job()):
 664         for host in hosts:
 665             hardware_config = None
 666             try:
 667                 hardware_config = HardwareConfig.objects.get(relation__host=host)
 668             except:
 669                 hardware_config = HardwareConfig()
 670
 671             relation = HostHardwareRelation()
 672             relation.host = host
 673             relation.job = job
 674             relation.config = hardware_config
 675             relation.config.save()
 676             relation.config = relation.config
 677             relation.save()
 678
 679             hardware_config.clear_delta()
 680             hardware_config.set_image(host.config.image.lab_id)
 681             hardware_config.set_hostname(host.template.resource.name)
 682             hardware_config.set_power("on")
 683             hardware_config.set_ipmi_create(True)
 684             hardware_config.save()
 685
 686     @classmethod
 687     def makeAccessConfig(cls, users, access_type, revoke=False, job=Job(), context=False):
 688         for user in users:
 689             relation = AccessRelation()
 690             relation.job = job
 691             config = AccessConfig()
 692             config.access_type = access_type
 693             config.user = user
 694             if context:
 695                 config.set_context(context)
 696             config.save()
 697             relation.config = config
 698             relation.save()
 699             config.clear_delta()
 700             config.set_access_type(access_type)
 701             config.set_revoke(revoke)
 702             config.set_user(user)
 703             config.save()
 704
 705     @classmethod
 706     def makeNetworkConfigs(cls, hosts=[], job=Job()):
 707         for host in hosts:
 708             network_config = None
 709             try:
 710                 network_config = NetworkConfig.objects.get(relation__host=host)
 711             except:
 712                 network_config = NetworkConfig.objects.create()
 713
 714             relation = HostNetworkRelation()
 715             relation.host = host
 716             relation.job = job
 717             network_config.save()
 718             relation.config = network_config
 719             relation.save()
 720             network_config.clear_delta()
 721
 722             for interface in host.interfaces.all():
 723                 network_config.add_interface(interface)
 724             network_config.save()
 725
 726     @classmethod
 727     def makeSoftware(cls, hosts=[], job=Job()):
 728         def init_config(host):
 729             opnfv_config = OpnfvApiConfig()
 730             if host is not None:
 731                 opnfv = host.config.bundle.opnfv_config.first()
 732                 opnfv_config.installer = opnfv.installer.name
 733                 opnfv_config.scenario = opnfv.scenario.name
 734             opnfv_config.save()
 735             return opnfv_config
 736
 737         try:
 738             host = None
 739             if len(hosts) > 0:
 740                 host = hosts[0]
 741             opnfv_config = init_config(host)
 742
 743             for host in hosts:
 744                 opnfv_config.roles.add(host)
 745             software_config = SoftwareConfig.objects.create(opnfv=opnfv_config)
 746             software_config.save()
 747             software_relation = SoftwareRelation.objects.create(job=job, config=software_config)
 748             software_relation.save()
 749             return software_relation
 750         except:
 751             return None