from account.jira_util import SignatureMethod_RSA_SHA1
from account.models import UserProfile
from booking.models import Booking
-from resource_inventory.models import GenericResourceBundle, ConfigBundle, Image
+from resource_inventory.models import ResourceTemplate, Image
@method_decorator(login_required, name='dispatch')
if not request.user.is_authenticated:
return render(request, "dashboard/login.html", {'title': 'Authentication Required'})
template = "account/resource_list.html"
- resources = GenericResourceBundle.objects.filter(
+ resources = ResourceTemplate.objects.filter(
owner=request.user).prefetch_related("configbundle_set")
mapping = {}
resource_list = []
if not request.user.is_authenticated:
return render(request, "dashboard/login.html", {'title': 'Authentication Required'})
template = "account/configuration_list.html"
- configs = list(ConfigBundle.objects.filter(owner=request.user))
+ configs = list(ResourceTemplate.objects.filter(owner=request.user))
context = {"title": "Configuration List", "configurations": configs}
return render(request, template, context=context)
def resource_delete_view(request, resource_id=None):
if not request.user.is_authenticated:
return HttpResponse('no') # 403?
- grb = get_object_or_404(GenericResourceBundle, pk=resource_id)
+ grb = get_object_or_404(ResourceTemplate, pk=resource_id)
if not request.user.id == grb.owner.id:
return HttpResponse('no') # 403?
if Booking.objects.filter(resource__template=grb, end__gt=timezone.now()).exists():
def configuration_delete_view(request, config_id=None):
if not request.user.is_authenticated:
return HttpResponse('no') # 403?
- config = get_object_or_404(ConfigBundle, pk=config_id)
+ config = get_object_or_404(ResourceTemplate, pk=config_id)
if not request.user.id == config.owner.id:
return HttpResponse('no') # 403?
if Booking.objects.filter(config_bundle=config, end__gt=timezone.now()).exists():
from rest_framework import serializers
from resource_inventory.models import (
- HostConfiguration,
+ ResourceConfiguration,
CpuProfile,
DiskProfile,
InterfaceProfile,
host_configs = {} # mapping hostname -> config
networks = {} # mapping vlan id -> network_hosts
for host in booking.resource.hosts.all():
- host_configs[host.name] = HostConfiguration.objects.get(host=host.template)
+ host_configs[host.name] = ResourceConfiguration.objects.get(host=host.template)
if "jumphost" not in ser and host_configs[host.name].opnfvRole.name.lower() == "jumphost":
ser['jumphost'] = host.name
# host is a Host model
from django.db.models import Q
from datetime import timedelta
from django.utils import timezone
-from django.form import ValidationException
+from django.core.exceptions import ValidationError
from account.models import Lab
from resource_inventory.models import (
Image,
OPNFVRole,
OPNFVConfig,
- HostOPNFVConfig,
+ ResourceOPNFVConfig,
)
from resource_inventory.resource_manager import ResourceManager
from resource_inventory.pdf_templater import PDFTemplater
template = ResourceTemplate.objects.get(pk=resource_info['id'])
if lab is None:
- raise ValidationException("No lab was selected")
+ raise ValidationError("No lab was selected")
if template is None:
- raise ValidationException("No Host was selected")
+ raise ValidationError("No Host was selected")
return lab, template
name="Jumphost",
description="Single server jumphost role"
)
- return HostOPNFVConfig.objects.create(
+ return ResourceOPNFVConfig.objects.create(
role=role,
host_config=hostconfig,
opnfv_config=opnfvconfig
if installer in image.os.sup_installers.all():
# if installer not here, we can omit that and not check for scenario
if not scenario:
- raise ValidationException("An OPNFV Installer needs a scenario to be chosen to work properly")
+ raise ValidationError("An OPNFV Installer needs a scenario to be chosen to work properly")
if scenario not in installer.sup_scenarios.all():
- raise ValidationException("The chosen installer does not support the chosen scenario")
+ raise ValidationError("The chosen installer does not support the chosen scenario")
if image.from_lab != lab:
- raise ValidationException("The chosen image is not available at the chosen hosting lab")
+ raise ValidationError("The chosen image is not available at the chosen hosting lab")
if image.host_type != host_profile:
- raise ValidationException("The chosen image is not available for the chosen host type")
+ raise ValidationError("The chosen image is not available for the chosen host type")
if not image.public and image.owner != request.user:
- raise ValidationException("You are not the owner of the chosen private image")
+ raise ValidationError("You are not the owner of the chosen private image")
if length < 1 or length > 21:
raise BookingLengthException("Booking must be between 1 and 21 days long")
from django.db.models import Q
from django.urls import reverse
-from resource_inventory.models import ResourceBundle, HostProfile, Image, Host
+from resource_inventory.models import ResourceBundle, ResourceProfile, Image, ResourceQuery
from resource_inventory.resource_manager import ResourceManager
from account.models import Lab, Downtime
from booking.models import Booking
def build_image_mapping(lab, user):
mapping = {}
- for profile in HostProfile.objects.filter(labs=lab):
+ for profile in ResourceProfile.objects.filter(labs=lab):
images = Image.objects.filter(
from_lab=lab,
host_type=profile
if timezone.now() > booking.end:
return HttpResponse("unauthorized")
new_image = Image.objects.get(id=form.cleaned_data['image_id'])
- host = Host.objects.get(id=form.cleaned_data['host_id'])
+ host = ResourceQuery.get(labid=form.cleaned_data['host_id'])
host.config.image = new_image
host.config.save()
JobFactory.reimageHost(new_image, booking, host)
+##############################################################################
+# Copyright (c) 2020 Parker Berberian and others.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+from django.core.exceptions import ObjectDoesNotExist
+
class AbstractModelQuery():
"""
result = []
for model in cls.model_list:
result += list(model.objects.filter(*args, **kwargs))
+
+ @classmethod
+ def get(cls, *args, **kwargs):
+ try:
+ return cls.filter(*args, **kwargs)[0]
+ except IndexError:
+ raise ObjectDoesNotExist()
from account.models import Lab
-from resource_inventory.models import Image, HostProfile
+from resource_inventory.models import Image, ResourceProfile
from workflow.workflow_manager import ManagerTracker
hosts = []
- for host_profile in HostProfile.objects.all():
+ for host_profile in ResourceProfile.objects.all():
name = host_profile.name
description = host_profile.description
in_labs = host_profile.labs
DiskProfile,
CpuProfile,
RamProfile,
- GenericResourceBundle,
- GenericResource,
- GenericHost,
- GenericInterface,
- Host,
+ ResourceTemplate,
+ ResourceConfiguration,
+ InterfaceConfiguration,
+ Server,
Interface,
Network,
Vlan,
Scenario,
Installer,
Opsys,
- ConfigBundle,
OPNFVConfig,
OPNFVRole,
Image,
- ResourceConfiguration,
RemoteInfo
)
-profiles = [HostProfile, InterfaceProfile, DiskProfile, CpuProfile, RamProfile]
-
-admin.site.register(profiles)
-
-generics = [GenericResourceBundle, GenericResource, GenericHost, GenericInterface]
-
-admin.site.register(generics)
-
-physical = [Host, Interface, Network, Vlan, ResourceBundle]
-
-admin.site.register(physical)
-
-config = [Scenario, Installer, Opsys, ConfigBundle, OPNFVConfig, OPNFVRole, Image, HostConfiguration, RemoteInfo]
-
-admin.site.register(config)
+admin.site.register([
+ ResourceProfile,
+ InterfaceProfile,
+ DiskProfile,
+ CpuProfile,
+ RamProfile,
+ ResourceTemplate,
+ ResourceConfiguration,
+ InterfaceConfiguration,
+ Server,
+ Interface,
+ Network,
+ Vlan,
+ ResourceBundle,
+ Scenario,
+ Installer,
+ Opsys,
+ OPNFVConfig,
+ OPNFVRole,
+ Image,
+ RemoteInfo])
image = models.ForeignKey("Image", on_delete=models.PROTECT)
template = models.ForeignKey(ResourceTemplate, related_name="resourceConfigurations", null=True, on_delete=models.CASCADE)
is_head_node = models.BooleanField(default=False)
+ # name?
def __str__(self):
return "config with " + str(self.template) + " and image " + str(self.image)
from django.shortcuts import get_object_or_404
from django.shortcuts import render
-from resource_inventory.models import HostProfile, Host
+from resource_inventory.models import ResourceProfile, ResourceQuery
class HostView(TemplateView):
def get_context_data(self, **kwargs):
context = super(HostView, self).get_context_data(**kwargs)
- hosts = Host.objects.filter(working=True)
+ hosts = ResourceQuery.filter(working=True)
context.update({'hosts': hosts, 'title': "Hardware Resources"})
return context
def hostprofile_detail_view(request, hostprofile_id):
- hostprofile = get_object_or_404(HostProfile, id=hostprofile_id)
+ hostprofile = get_object_or_404(ResourceProfile, id=hostprofile_id)
return render(
request,
from booking.models import Booking
from workflow.models import WorkflowStep, AbstractSelectOrCreate
from workflow.forms import ResourceSelectorForm, SWConfigSelectorForm, BookingMetaForm, OPNFVSelectForm
-from resource_inventory.models import GenericResourceBundle, ConfigBundle, OPNFVConfig
+from resource_inventory.models import OPNFVConfig, ResourceTemplate
from django.db.models import Q
def get_form_queryset(self):
user = self.repo_get(self.repo.SESSION_USER)
- qs = GenericResourceBundle.objects.filter(Q(hidden=False) & (Q(owner=user) | Q(public=True)))
- return qs
+ return ResourceTemplate.objects.filter(Q(hidden=False) & (Q(owner=user) | Q(public=True)))
def get_page_context(self):
return {
def get_form_queryset(self):
user = self.repo_get(self.repo.SESSION_USER)
grb = self.repo_get(self.repo.SELECTED_GRESOURCE_BUNDLE)
- qs = ConfigBundle.objects.filter(Q(hidden=False) & (Q(owner=user) | Q(public=True))).filter(bundle=grb)
+ qs = ResourceTemplate.objects.filter(Q(hidden=False) & (Q(owner=user) | Q(public=True))).filter(bundle=grb)
return qs
def put_confirm_info(self, bundle):
from workflow.forms import ConfirmationForm
from api.models import JobFactory
from dashboard.exceptions import ResourceAvailabilityException, ModelValidationException
-from resource_inventory.models import Image, InterfaceProfile, OPNFVConfig, ResourceOPNFVConfig, NetworkRole
+from resource_inventory.models import Image, InterfaceConfiguration, OPNFVConfig, ResourceOPNFVConfig, NetworkRole
from resource_inventory.resource_manager import ResourceManager
from resource_inventory.pdf_templater import PDFTemplater
from notifier.manager import NotificationHandler
config = config_bundle.hostConfigurations.get(
host__resource__name=host_role['host_name']
)
- HostOPNFVConfig.objects.create(
+ ResourceOPNFVConfig.objects.create(
role=host_role['role'],
host_config=config,
opnfv_config=opnfv_config
from django.forms import formset_factory
from workflow.models import WorkflowStep, AbstractSelectOrCreate
-from resource_inventory.models import ConfigBundle, OPNFV_SETTINGS
+from resource_inventory.models import ResourceTemplate, OPNFV_SETTINGS
from workflow.forms import OPNFVSelectionForm, OPNFVNetworkRoleForm, OPNFVHostRoleForm, SWConfigSelectorForm, BasicMetaForm
def get_form_queryset(self):
user = self.repo_get(self.repo.SESSION_USER)
- qs = ConfigBundle.objects.filter(owner=user)
+ qs = ResourceTemplate.objects.filter(owner=user)
return qs
def put_confirm_info(self, bundle):
ResourceMetaForm,
)
from resource_inventory.models import (
- GenericResourceBundle,
- GenericInterface,
- GenericHost,
- GenericResource,
- HostProfile,
+ ResourceProfile,
+ ResourceTemplate,
+ ResourceConfiguration,
+ InterfaceConfiguration,
Network,
NetworkConnection
)
models['hosts'] = [] # This will always clear existing data when this step changes
models['interfaces'] = {}
if "bundle" not in models:
- models['bundle'] = GenericResourceBundle(owner=self.repo_get(self.repo.SESSION_USER))
+ models['bundle'] = ResourceTemplate(owner=self.repo_get(self.repo.SESSION_USER))
host_data = data['host']
names = {}
for host_profile_dict in host_data.values():
id = host_profile_dict['id']
- profile = HostProfile.objects.get(id=id)
+ profile = ResourceProfile.objects.get(id=id)
# instantiate genericHost and store in repo
for name in host_profile_dict['values'].values():
if not re.match(r"(?=^.{1,253}$)(^([A-Za-z0-9-_]{1,62}\.)*[A-Za-z0-9-_]{1,63})", name):
if name in names:
raise NonUniqueHostnameException("All hosts must have unique names")
names[name] = True
- genericResource = GenericResource(bundle=models['bundle'], name=name)
- genericHost = GenericHost(profile=profile, resource=genericResource)
- models['hosts'].append(genericHost)
+ resourceConfig = ResourceConfiguration(profile=profile, template=models['bundle'])
+ models['hosts'].append(resourceConfig)
for interface_profile in profile.interfaceprofile.all():
- genericInterface = GenericInterface(profile=interface_profile, host=genericHost)
- if genericHost.resource.name not in models['interfaces']:
- models['interfaces'][genericHost.resource.name] = []
- models['interfaces'][genericHost.resource.name].append(genericInterface)
+ genericInterface = InterfaceConfiguration(profile=interface_profile, resource_config=resourceConfig)
+ if resourceConfig.name not in models['interfaces']:
+ models['interfaces'][resourceConfig.name] = []
+ models['interfaces'][resourceConfig.name].append(genericInterface)
# add selected lab to models
for lab_dict in data['lab'].values():
for host in existing_host_list:
existing_hosts[host.resource.name] = host
- bundle = models.get("bundle", GenericResourceBundle(owner=self.repo_get(self.repo.SESSION_USER)))
+ bundle = models.get("bundle", ResourceTemplate(owner=self.repo_get(self.repo.SESSION_USER)))
for net_id, net in networks.items():
network = Network()
models = self.repo_get(self.repo.GRESOURCE_BUNDLE_MODELS, {})
name = form.cleaned_data['bundle_name']
desc = form.cleaned_data['bundle_description']
- bundle = models.get("bundle", GenericResourceBundle(owner=self.repo_get(self.repo.SESSION_USER)))
+ bundle = models.get("bundle", ResourceTemplate(owner=self.repo_get(self.repo.SESSION_USER)))
bundle.name = name
bundle.description = desc
models['bundle'] = bundle
import json
from booking.models import Booking
-from resource_inventory.models import Host, Image
+from resource_inventory.models import ResourceQuery, Image
from workflow.models import WorkflowStep
from workflow.forms import BasicMetaForm, SnapshotHostSelectForm
name = host['name']
booking_id = host['booking']
booking = Booking.objects.get(pk=booking_id)
- host = Host.objects.get(bundle=booking.resource, template__resource__name=name)
+ host = ResourceQuery.get(bundle=booking.resource, template__resource__name=name)
models = self.repo_get(self.repo.SNAPSHOT_MODELS, {})
if "host" not in models:
models['host'] = host
from workflow.models import WorkflowStep
from workflow.forms import BasicMetaForm, HostSoftwareDefinitionForm
from workflow.booking_workflow import Abstract_Resource_Select
-from resource_inventory.models import Image, GenericHost, ConfigBundle, HostConfiguration
+from resource_inventory.models import Image, ResourceConfiguration, ResourceTemplate
class SWConf_Resource_Select(Abstract_Resource_Select):
user = self.repo_get(self.repo.SESSION_USER)
lab = self.repo_get(self.repo.SELECTED_GRESOURCE_BUNDLE).lab
for i, host_data in enumerate(hosts_data):
- host = GenericHost.objects.get(pk=host_data['host_id'])
+ host = ResourceConfiguration.objects.get(pk=host_data['host_id'])
wrong_owner = Image.objects.exclude(owner=user).exclude(public=True)
wrong_host = Image.objects.exclude(host_type=host.profile)
wrong_lab = Image.objects.exclude(from_lab=lab)
if not grb:
return []
if grb.id:
- return GenericHost.objects.filter(resource__bundle=grb)
+ return ResourceConfiguration.objects.filter(resource__bundle=grb)
generic_hosts = self.repo_get(self.repo.GRESOURCE_BUNDLE_MODELS, {}).get("hosts", [])
return generic_hosts
def post(self, post_data, user):
models = self.repo_get(self.repo.CONFIG_MODELS, {})
if "bundle" not in models:
- models['bundle'] = ConfigBundle(owner=self.repo_get(self.repo.SESSION_USER))
+ models['bundle'] = ResourceTemplate(owner=self.repo_get(self.repo.SESSION_USER))
confirm = self.repo_get(self.repo.CONFIRMATION, {})
if headnode:
has_headnode = True
bundle = models['bundle']
- hostConfig = HostConfiguration(
+ hostConfig = ResourceConfiguration(
host=host,
image=image,
bundle=bundle,
def post(self, post_data, user):
models = self.repo_get(self.repo.CONFIG_MODELS, {})
if "bundle" not in models:
- models['bundle'] = ConfigBundle(owner=self.repo_get(self.repo.SESSION_USER))
+ models['bundle'] = ResourceTemplate(owner=self.repo_get(self.repo.SESSION_USER))
confirm = self.repo_get(self.repo.CONFIRMATION, {})
if "configuration" not in confirm:
from workflow.workflow_factory import WorkflowFactory
from workflow.models import Repository
from resource_inventory.models import (
- GenericResourceBundle,
- ConfigBundle,
- HostConfiguration,
+ ResourceTemplate,
+ ResourceConfiguration,
OPNFVConfig
)
from workflow.forms import ManagerForm
edit_object = Booking.objects.get(pk=target_id)
self.prefill_booking(edit_object)
elif workflow_type == 1:
- edit_object = GenericResourceBundle.objects.get(pk=target_id)
+ edit_object = ResourceTemplate.objects.get(pk=target_id)
self.prefill_resource(edit_object)
elif workflow_type == 2:
- edit_object = ConfigBundle.objects.get(pk=target_id)
+ edit_object = ResourceTemplate.objects.get(pk=target_id)
self.prefill_config(edit_object)
def prefill_booking(self, booking):
models = self.active_workflow().repository.el.get(self.active_workflow().repository.CONFIG_MODELS, {})
models['bundle'] = config
models['host_configs'] = []
- for host_conf in HostConfiguration.objects.filter(bundle=config):
+ for host_conf in ResourceConfiguration.objects.filter(bundle=config):
models['host_configs'].append(host_conf)
models['opnfv'] = OPNFVConfig.objects.filter(bundle=config).last()
return models
opnfv = OPNFVConfig.objects.filter(bundle=config).last()
confirm['configuration']['installer'] = opnfv.installer.name
confirm['configuration']['scenario'] = opnfv.scenario.name
- for host_conf in HostConfiguration.objects.filter(bundle=config):
+ for host_conf in ResourceConfiguration.objects.filter(bundle=config):
h = {"name": host_conf.host.resource.name, "image": host_conf.image.name, "role": host_conf.opnfvRole.name}
confirm['configuration']['hosts'].append(h)
return confirm
Code Review / laas.git / commitdiff