# http://www.apache.org/licenses/LICENSE-2.0
##############################################################################
-
-from datetime import timedelta
-from django.utils import timezone
-
-from booking.models import Booking
from api.models import (
Job,
JobStatus,
JobFactory,
- AccessRelation,
HostNetworkRelation,
HostHardwareRelation,
SoftwareRelation,
+ AccessConfig,
)
from resource_inventory.models import (
from django.test import TestCase, Client
from dashboard.testing_utils import (
- instantiate_host,
- instantiate_user,
- instantiate_userprofile,
- instantiate_lab,
- instantiate_installer,
- instantiate_image,
- instantiate_scenario,
- instantiate_os,
- make_hostprofile_set,
- instantiate_opnfvrole,
- instantiate_publicnet,
- instantiate_booking,
+ make_host,
+ make_user,
+ make_user_profile,
+ make_lab,
+ make_installer,
+ make_image,
+ make_scenario,
+ make_os,
+ make_complete_host_profile,
+ make_booking,
)
class ValidBookingCreatesValidJob(TestCase):
@classmethod
def setUpTestData(cls):
- cls.loginuser = instantiate_user(False, username="newtestuser", password="testpassword")
- cls.userprofile = instantiate_userprofile(cls.loginuser)
+ cls.user = make_user(False, username="newtestuser", password="testpassword")
+ cls.userprofile = make_user_profile(cls.user)
+ cls.lab = make_lab()
+
+ cls.host_profile = make_complete_host_profile(cls.lab)
+ cls.scenario = make_scenario()
+ cls.installer = make_installer([cls.scenario])
+ os = make_os([cls.installer])
+ cls.image = make_image(cls.lab, 1, cls.user, os, cls.host_profile)
+ for i in range(30):
+ make_host(cls.host_profile, cls.lab, name="host" + str(i), labid="host" + str(i))
+ cls.client = Client()
- lab_user = instantiate_user(True)
- cls.lab = instantiate_lab(lab_user)
+ def setUp(self):
+ self.booking, self.compute_hostnames, self.jump_hostname = self.create_multinode_generic_booking()
- cls.host_profile = make_hostprofile_set(cls.lab)
- cls.scenario = instantiate_scenario()
- cls.installer = instantiate_installer([cls.scenario])
- os = instantiate_os([cls.installer])
- cls.image = instantiate_image(cls.lab, 1, cls.loginuser, os, cls.host_profile)
- for i in range(30):
- instantiate_host(cls.host_profile, cls.lab, name="host" + str(i), labid="host" + str(i))
- cls.role = instantiate_opnfvrole("Jumphost")
- cls.computerole = instantiate_opnfvrole("Compute")
- instantiate_publicnet(10, cls.lab)
- instantiate_publicnet(12, cls.lab)
- instantiate_publicnet(14, cls.lab)
+ def create_multinode_generic_booking(self):
+ topology = {}
- cls.lab_selected = 'lab_' + str(cls.lab.lab_user.id) + '_selected'
- cls.host_selected = 'host_' + str(cls.host_profile.id) + '_selected'
+ compute_hostnames = ["cmp01", "cmp02", "cmp03"]
- cls.post_data = cls.build_post_data()
+ host_type = HostProfile.objects.first()
- cls.client = Client()
+ universal_networks = [
+ {"name": "public", "tagged": False, "public": True},
+ {"name": "admin", "tagged": True, "public": False}]
+ compute_networks = [{"name": "private", "tagged": True, "public": False}]
+ jumphost_networks = [{"name": "external", "tagged": True, "public": True}]
- def setUp(self):
- self.client.login(
- username=self.loginuser.username, password="testpassword")
- self.booking, self.compute_hostnames, self.jump_hostname = self.create_multinode_generic_booking()
+ # generate a bunch of extra networks
+ for i in range(10):
+ net = {"tagged": False, "public": False}
+ net["name"] = "net" + str(i)
+ universal_networks.append(net)
- @classmethod
- def build_post_data(cls):
- post_data = {}
- post_data['filter_field'] = '{"hosts":[{"host_' + str(cls.host_profile.id) + '":"true"}], "labs": [{"lab_' + str(cls.lab.lab_user.id) + '":"true"}]}'
- post_data['purpose'] = 'purposefieldcontentstring'
- post_data['project'] = 'projectfieldcontentstring'
- post_data['length'] = '3'
- post_data['ignore_this'] = 1
- post_data['users'] = ''
- post_data['hostname'] = 'hostnamefieldcontentstring'
- post_data['image'] = str(cls.image.id)
- post_data['installer'] = str(cls.installer.id)
- post_data['scenario'] = str(cls.scenario.id)
- return post_data
-
- def post(self, changed_fields={}):
- payload = self.post_data.copy()
- payload.update(changed_fields)
- response = self.client.post('/booking/quick/', payload)
- return response
-
- def generate_booking(self):
- self.post()
- return Booking.objects.first()
+ jumphost_info = {
+ "type": host_type,
+ "role": OPNFVRole.objects.get_or_create(name="Jumphost")[0],
+ "nets": self.make_networks(host_type, jumphost_networks + universal_networks),
+ "image": self.image
+ }
+ topology["jump"] = jumphost_info
+
+ for hostname in compute_hostnames:
+ host_info = {
+ "type": host_type,
+ "role": OPNFVRole.objects.get_or_create(name="Compute")[0],
+ "nets": self.make_networks(host_type, compute_networks + universal_networks),
+ "image": self.image
+ }
+ topology[hostname] = host_info
+
+ booking = make_booking(
+ owner=self.user,
+ lab=self.lab,
+ topology=topology,
+ installer=self.installer,
+ scenario=self.scenario
+ )
+
+ if not booking.resource:
+ raise Exception("Booking does not have a resource when trying to pass to makeCompleteJob")
+ JobFactory.makeCompleteJob(booking)
+
+ return booking, compute_hostnames, "jump"
+
+ def make_networks(self, hostprofile, nets):
+ """
+ distributes nets accross hostprofile's interfaces
+ returns a 2D array
+ """
+ network_struct = []
+ count = hostprofile.interfaceprofile.all().count()
+ for i in range(count):
+ network_struct.append([])
+ while(nets):
+ index = len(nets) % count
+ network_struct[index].append(nets.pop())
+
+ return network_struct
+
+ # begin tests
def test_valid_access_configs(self):
job = Job.objects.get(booking=self.booking)
self.assertIsNotNone(job)
- access_configs = [r.config for r in AccessRelation.objects.filter(job=job).all()]
+ access_configs = AccessConfig.objects.filter(accessrelation__job=job)
- vpnconfigs = []
- sshconfigs = []
+ vpn_configs = access_configs.filter(access_type="vpn")
+ ssh_configs = access_configs.filter(access_type="ssh")
- for config in access_configs:
- if config.access_type == "vpn":
- vpnconfigs.append(config)
- elif config.access_type == "ssh":
- sshconfigs.append(config)
- else:
- self.fail(msg="Undefined accessconfig: " + config.access_type + " found")
+ self.assertFalse(AccessConfig.objects.exclude(access_type__in=["vpn", "ssh"]).exists())
- user_set = []
- user_set.append(self.booking.owner)
- user_set += self.booking.collaborators.all()
+ all_users = list(self.booking.collaborators.all())
+ all_users.append(self.booking.owner)
- for configs in [vpnconfigs, sshconfigs]:
- for user in user_set:
- configusers = [c.user for c in configs]
- self.assertTrue(user in configusers)
+ for user in all_users:
+ self.assertTrue(vpn_configs.filter(user=user).exists())
+ self.assertTrue(ssh_configs.filter(user=user).exists())
def test_valid_network_configs(self):
job = Job.objects.get(booking=self.booking)
booking_hosts = self.booking.resource.hosts.all()
- netrelation_set = HostNetworkRelation.objects.filter(job=job)
- netconfig_set = [r.config for r in netrelation_set]
+ netrelations = HostNetworkRelation.objects.filter(job=job)
+ netconfigs = [r.config for r in netrelations]
- netrelation_hosts = [r.host for r in netrelation_set]
+ netrelation_hosts = [r.host for r in netrelations]
- for config in netconfig_set:
+ for config in netconfigs:
for interface in config.interfaces.all():
self.assertTrue(interface.host in booking_hosts)
job = Job.objects.get(booking=self.booking)
self.assertIsNotNone(job)
- hrelations = HostHardwareRelation.objects.filter(job=job).all()
+ hardware_relations = HostHardwareRelation.objects.filter(job=job)
- job_hosts = [r.host for r in hrelations]
+ job_hosts = [r.host for r in hardware_relations]
booking_hosts = self.booking.resource.hosts.all()
self.assertEqual(len(booking_hosts), len(job_hosts))
- for relation in hrelations:
+ for relation in hardware_relations:
self.assertTrue(relation.host in booking_hosts)
self.assertEqual(relation.status, JobStatus.NEW)
config = relation.config
self.assertTrue(host.template.resource.name in self.compute_hostnames)
else:
self.fail(msg="Host with non-configured role name related to job: " + str(role_name))
-
- def create_multinode_generic_booking(self):
- topology = {}
-
- compute_hostnames = ["cmp01", "cmp02", "cmp03"]
-
- host_type = HostProfile.objects.first()
-
- universal_networks = [
- {"name": "public", "tagged": False, "public": True},
- {"name": "admin", "tagged": True, "public": False}]
- just_compute_networks = [{"name": "private", "tagged": True, "public": False}]
- just_jumphost_networks = [{"name": "external", "tagged": True, "public": True}]
-
- # generate a bunch of extra networks
- for i in range(10):
- net = {"tagged": False, "public": False}
- net["name"] = "u_net" + str(i)
- universal_networks.append(net)
-
- jhost_info = {}
- jhost_info["type"] = host_type
- jhost_info["role"] = OPNFVRole.objects.get(name="Jumphost")
- jhost_info["nets"] = self.make_networks(host_type, list(just_jumphost_networks + universal_networks))
- jhost_info["image"] = self.image
- topology["jump"] = jhost_info
-
- for hostname in compute_hostnames:
- host_info = {}
- host_info["type"] = host_type
- host_info["role"] = OPNFVRole.objects.get(name="Compute")
- host_info["nets"] = self.make_networks(host_type, list(just_compute_networks + universal_networks))
- host_info["image"] = self.image
- topology[hostname] = host_info
-
- booking = instantiate_booking(self.loginuser,
- timezone.now(),
- timezone.now() + timedelta(days=1),
- "demobooking",
- self.lab,
- topology=topology,
- installer=self.installer,
- scenario=self.scenario)
-
- if not booking.resource:
- raise Exception("Booking does not have a resource when trying to pass to makeCompleteJob")
- JobFactory.makeCompleteJob(booking)
-
- return booking, compute_hostnames, "jump"
-
- """
- evenly distributes networks given across a given profile's interfaces
- """
- def make_networks(self, hostprofile, nets):
- network_struct = []
- count = hostprofile.interfaceprofile.all().count()
- for i in range(count):
- network_struct.append([])
- while(nets):
- index = len(nets) % count
- network_struct[index].append(nets.pop())
-
- return network_struct
from booking.models import Booking
from dashboard.testing_utils import (
- instantiate_host,
- instantiate_user,
- instantiate_userprofile,
- instantiate_lab,
- instantiate_installer,
- instantiate_image,
- instantiate_scenario,
- instantiate_os,
- make_hostprofile_set,
- instantiate_opnfvrole,
- instantiate_publicnet,
+ make_host,
+ make_user,
+ make_user_profile,
+ make_lab,
+ make_installer,
+ make_image,
+ make_scenario,
+ make_os,
+ make_complete_host_profile,
+ make_opnfv_role,
+ make_public_net,
)
-# from dashboard import test_utils
class QuickBookingValidFormTestCase(TestCase):
@classmethod
def setUpTestData(cls):
- cls.loginuser = instantiate_user(False, username="newtestuser", password="testpassword")
- instantiate_userprofile(cls.loginuser, True)
+ cls.user = make_user(False, username="newtestuser", password="testpassword")
+ make_user_profile(cls.user, True)
- lab_user = instantiate_user(True)
- cls.lab = instantiate_lab(lab_user)
+ lab_user = make_user(True)
+ cls.lab = make_lab(lab_user)
- cls.host_profile = make_hostprofile_set(cls.lab)
- cls.scenario = instantiate_scenario()
- cls.installer = instantiate_installer([cls.scenario])
- os = instantiate_os([cls.installer])
- cls.image = instantiate_image(cls.lab, 1, cls.loginuser, os, cls.host_profile)
- cls.host = instantiate_host(cls.host_profile, cls.lab)
- cls.role = instantiate_opnfvrole()
- cls.pubnet = instantiate_publicnet(10, cls.lab)
-
- cls.lab_selected = 'lab_' + str(cls.lab.lab_user.id) + '_selected'
- cls.host_selected = 'host_' + str(cls.host_profile.id) + '_selected'
+ cls.host_profile = make_complete_host_profile(cls.lab)
+ cls.scenario = make_scenario()
+ cls.installer = make_installer([cls.scenario])
+ os = make_os([cls.installer])
+ cls.image = make_image(cls.lab, 1, cls.user, os, cls.host_profile)
+ cls.host = make_host(cls.host_profile, cls.lab)
+ cls.role = make_opnfv_role()
+ cls.pubnet = make_public_net(10, cls.lab)
cls.post_data = cls.build_post_data()
-
cls.client = Client()
@classmethod
def build_post_data(cls):
- post_data = {}
- post_data['filter_field'] = '{"hosts":[{"host_' + str(cls.host_profile.id) + '":"true"}], "labs": [{"lab_' + str(cls.lab.lab_user.id) + '":"true"}]}'
- post_data['purpose'] = 'purposefieldcontentstring'
- post_data['project'] = 'projectfieldcontentstring'
- post_data['length'] = '3'
- post_data['ignore_this'] = 1
- post_data['users'] = ''
- post_data['hostname'] = 'hostnamefieldcontentstring'
- post_data['image'] = str(cls.image.id)
- post_data['installer'] = str(cls.installer.id)
- post_data['scenario'] = str(cls.scenario.id)
- return post_data
+ return {
+ 'filter_field': '{"hosts":[{"host_' + str(cls.host_profile.id) + '":"true"}], "labs": [{"lab_' + str(cls.lab.lab_user.id) + '":"true"}]}',
+ 'purpose': 'my_purpose',
+ 'project': 'my_project',
+ 'length': '3',
+ 'ignore_this': 1,
+ 'users': '',
+ 'hostname': 'my_host',
+ 'image': str(cls.image.id),
+ 'installer': str(cls.installer.id),
+ 'scenario': str(cls.scenario.id)
+ }
def post(self, changed_fields={}):
payload = self.post_data.copy()
return response
def setUp(self):
- self.client.login(
- username=self.loginuser.username, password="testpassword")
+ self.client.login(username=self.user.username, password="testpassword")
- def is_valid_booking(self, booking):
- self.assertEqual(booking.owner, self.loginuser)
- self.assertEqual(booking.purpose, 'purposefieldcontentstring')
- self.assertEqual(booking.project, 'projectfieldcontentstring')
+ def assertValidBooking(self, booking):
+ self.assertEqual(booking.owner, self.user)
+ self.assertEqual(booking.purpose, 'my_purpose')
+ self.assertEqual(booking.project, 'my_project')
delta = booking.end - booking.start
delta -= datetime.timedelta(days=3)
self.assertLess(delta, datetime.timedelta(minutes=1))
- resourcebundle = booking.resource
- configbundle = booking.config_bundle
+ resource_bundle = booking.resource
+ config_bundle = booking.config_bundle
- self.assertEqual(self.installer, configbundle.opnfv_config.first().installer)
- self.assertEqual(self.scenario, configbundle.opnfv_config.first().scenario)
- self.assertEqual(resourcebundle.template.getHosts()[0].profile, self.host_profile)
- self.assertEqual(resourcebundle.template.getHosts()[0].resource.name, 'hostnamefieldcontentstring')
+ opnfv_config = config_bundle.opnfv_config.first()
+ self.assertEqual(self.installer, opnfv_config.installer)
+ self.assertEqual(self.scenario, opnfv_config.scenario)
- return True
+ host = resource_bundle.hosts.first()
+ self.assertEqual(host.profile, self.host_profile)
+ self.assertEqual(host.template.resource.name, 'my_host')
def test_with_too_long_length(self):
response = self.post({'length': '22'})
self.assertEqual(response.status_code, 200)
booking = Booking.objects.first()
self.assertIsNotNone(booking)
- self.assertTrue(self.is_valid_booking(booking))
+ self.assertValidBooking(booking)
def test_with_valid_form(self):
response = self.post()
self.assertEqual(response.status_code, 200)
booking = Booking.objects.first()
self.assertIsNotNone(booking)
- self.assertTrue(self.is_valid_booking(booking))
+ self.assertValidBooking(booking)
from django.contrib.auth.models import User
from django.core.files.base import ContentFile
+from django.utils import timezone
import json
import re
+from datetime import timedelta
-from dashboard.exceptions import (
- InvalidHostnameException
-)
+from dashboard.exceptions import InvalidHostnameException
from booking.models import Booking
from account.models import UserProfile, Lab, LabStatus, VlanManager, PublicNetwork
from resource_inventory.models import (
OPNFVRole,
RamProfile,
Network,
- Vlan,
GenericResourceBundle,
GenericResource,
GenericHost,
GenericInterface,
HostConfiguration,
OPNFVConfig,
+ NetworkConnection,
+ HostOPNFVConfig
)
from resource_inventory.resource_manager import ResourceManager
-
-class BookingContextData(object):
- def prepopulate(self, *args, **kwargs):
- self.loginuser = instantiate_user(False, username=kwargs.get("login_username", "newtestuser"), password="testpassword")
- instantiate_userprofile(self.loginuser)
-
- lab_user = kwargs.get("lab_user", instantiate_user(True))
- self.lab = instantiate_lab(lab_user)
-
- self.host_profile = make_hostprofile_set(self.lab)
- self.scenario = instantiate_scenario()
- self.installer = instantiate_installer([self.scenario])
- os = instantiate_os([self.installer])
- self.image = instantiate_image(self.lab, 1, self.loginuser, os, self.host_profile)
- self.host = instantiate_host(self.host_profile, self.lab)
- self.role = instantiate_opnfvrole()
- self.pubnet = instantiate_publicnet(10, self.lab)
-
-
"""
-Info for instantiate_booking() function:
+Info for make_booking() function:
[topology] argument structure:
the [topology] argument should describe the structure of the pod
the top level should be a dictionary, with each key being a hostname
"""
-def instantiate_booking(owner,
- start,
- end,
- booking_identifier,
- lab=Lab.objects.first(),
- purpose="purposetext",
- project="projecttext",
- collaborators=[],
- topology={},
- installer=None,
- scenario=None):
- (grb, host_set) = instantiate_grb(topology, owner, lab, booking_identifier)
- cb = instantiate_cb(grb, owner, booking_identifier, topology, host_set, installer, scenario)
-
- resource = ResourceManager.getInstance().convertResourceBundle(grb, lab, cb)
+def make_booking(owner=None, start=timezone.now(),
+ end=timezone.now() + timedelta(days=1),
+ lab=None, purpose="my_purpose",
+ project="my_project", collaborators=[],
+ topology={}, installer=None, scenario=None):
- booking = Booking()
-
- booking.resource = resource
+ grb, host_set = make_grb(topology, owner, lab)
+ config_bundle = make_config_bundle(grb, owner, topology, host_set, installer, scenario)
+ resource = ResourceManager.getInstance().convertResourceBundle(grb, config=config_bundle)
if not resource:
raise Exception("Resource not created")
- booking.config_bundle = cb
- booking.start = start
- booking.end = end
- booking.owner = owner
- booking.purpose = purpose
- booking.project = project
- booking.lab = lab
- booking.save()
-
- return booking
-
-
-def instantiate_cb(grb,
- owner,
- booking_identifier,
- topology={},
- host_set={},
- installer=None,
- scenario=None):
- cb = ConfigBundle()
- cb.owner = owner
- cb.name = str(booking_identifier) + "_cb"
- cb.description = "cb generated by instantiate_cb() method"
- cb.save()
-
- opnfvconfig = OPNFVConfig()
- opnfvconfig.installer = installer
- opnfvconfig.scenario = scenario
- opnfvconfig.bundle = cb
- opnfvconfig.save()
+
+ return Booking.objects.create(
+ resource=resource,
+ config_bundle=config_bundle,
+ start=start,
+ end=end,
+ owner=owner,
+ purpose=purpose,
+ project=project,
+ lab=lab
+ )
+
+
+def make_config_bundle(grb, owner, topology={}, host_set={},
+ installer=None, scenario=None):
+ cb = ConfigBundle.objects.create(
+ owner=owner,
+ name="config bundle " + str(ConfigBundle.objects.count()),
+ description="cb generated by make_config_bundle() method"
+ )
+
+ opnfv_config = OPNFVConfig.objects.create(
+ installer=installer,
+ scenario=scenario,
+ bundle=cb
+ )
# generate host configurations based on topology and host set
for hostname, host_info in topology.items():
- hconf = HostConfiguration()
- hconf.bundle = cb
- hconf.host = host_set[hostname]
- hconf.image = host_info["image"]
- hconf.opnfvRole = host_info["role"]
- hconf.save()
+ host_config = HostConfiguration.objects.create(
+ host=host_set[hostname],
+ image=host_info["image"],
+ bundle=cb,
+ is_head_node=host_info['role'].name.lower() == "jumphost"
+ )
+ HostOPNFVConfig.objects.create(
+ role=host_info["role"],
+ host_config=host_config,
+ opnfv_config=opnfv_config
+ )
return cb
-def instantiate_grb(topology,
- owner,
- lab,
- booking_identifier):
+def make_network(name, lab, grb, public):
+ network = Network(name=name, bundle=grb, is_public=public)
+ if public:
+ public_net = lab.vlan_manager.get_public_vlan()
+ if not public_net:
+ raise Exception("No more public networks available")
+ lab.vlan_manager.reserve_public_vlan(public_net.vlan)
+ network.vlan_id = public_net.vlan
+ else:
+ private_net = lab.vlan_manager.get_vlan()
+ if not private_net:
+ raise Exception("No more generic vlans are available")
+ lab.vlan_manager.reserve_vlans([private_net])
+ network.vlan_id = private_net
+
+ network.save()
+ return network
+
- grb = GenericResourceBundle(owner=owner, lab=lab)
- grb.name = str(booking_identifier) + "_grb"
- grb.description = "grb generated by instantiate_grb() method"
- grb.save()
+def make_grb(topology, owner, lab):
+
+ grb = GenericResourceBundle.objects.create(
+ owner=owner,
+ lab=lab,
+ name="Generic ResourceBundle " + str(GenericResourceBundle.objects.count()),
+ description="grb generated by make_grb() method"
+ )
networks = {}
host_set = {}
- for hostname in topology.keys():
- info = topology[hostname]
+ for hostname, info in topology.items():
host_profile = info["type"]
# need to construct host from hostname and type
- ghost = instantiate_ghost(grb, host_profile, hostname)
- host_set[hostname] = ghost
-
- ghost.save()
+ generic_host = make_generic_host(grb, host_profile, hostname)
+ host_set[hostname] = generic_host
# set up networks
nets = info["nets"]
for interface_index, interface_profile in enumerate(host_profile.interfaceprofile.all()):
- generic_interface = GenericInterface()
- generic_interface.host = ghost
- generic_interface.profile = interface_profile
- generic_interface.save()
-
+ generic_interface = GenericInterface.objects.create(host=generic_host, profile=interface_profile)
netconfig = nets[interface_index]
- for network_index, network_info in enumerate(netconfig):
+ for network_info in netconfig:
network_name = network_info["name"]
- network = None
- if network_name in networks:
- network = networks[network_name]
- else:
- network = Network()
- network.name = network_name
- network.vlan_id = lab.vlan_manager.get_vlan()
- network.save()
- networks[network_name] = network
- if network_info["public"]:
- public_net = lab.vlan_manager.get_public_vlan()
- if not public_net:
- raise Exception("No more public networks available")
- lab.vlan_manager.reserve_public_vlan(public_net.vlan)
- network.vlan_id = public_net.vlan
- else:
- private_net = lab.vlan_manager.get_vlan()
- if not private_net:
- raise Exception("No more generic vlans are available")
- lab.vlan_manager.reserve_vlans([private_net])
- network.vlan_id = private_net
-
- vlan = Vlan()
- vlan.vlan_id = network.vlan_id
- vlan.public = network_info["public"]
- vlan.tagged = network_info["tagged"]
- vlan.save()
- generic_interface.vlans.add(vlan)
-
- return (grb, host_set)
-
-
-def instantiate_ghost(grb, host_profile, hostname):
- if not re.match(r"(?=^.{1,253}$)(^([A-Za-z0-9-_]{1,62}\.)*[A-Za-z0-9-_]{1,63})$", hostname):
- raise InvalidHostnameException("Hostname must comply to RFC 952 and all extensions to it until this point")
- gresource = GenericResource(bundle=grb, name=hostname)
- gresource.save()
+ if network_name not in networks:
+ networks[network_name] = make_network(network_name, lab, grb, network_info['public'])
+
+ generic_interface.connections.add(NetworkConnection.objects.create(
+ network=networks[network_name],
+ vlan_is_tagged=network_info["tagged"]
+ ))
- ghost = GenericHost()
- ghost.resource = gresource
- ghost.profile = host_profile
- ghost.save()
+ return grb, host_set
- return ghost
+def make_generic_host(grb, host_profile, hostname):
+ if not re.match(r"(?=^.{1,253}$)(^([A-Za-z0-9-_]{1,62}\.)*[A-Za-z0-9-_]{1,63})$", hostname):
+ raise InvalidHostnameException("Hostname must comply to RFC 952 and all extensions")
+ gresource = GenericResource.objects.create(bundle=grb, name=hostname)
+
+ return GenericHost.objects.create(resource=gresource, profile=host_profile)
-def instantiate_user(is_superuser,
- username="testuser",
- password="testpassword",
- email="default_email@user.com"
- ):
+
+def make_user(is_superuser=False, username="testuser",
+ password="testpassword", email="default_email@user.com"):
user = User.objects.create_user(username=username, email=email, password=password)
user.is_superuser = is_superuser
-
user.save()
return user
-def instantiate_userprofile(user, email_addr="email@email.com", company="company", full_name="John Doe", booking_privledge=True, ssh_file=None):
- up = UserProfile()
- up.email_address = email_addr
- up.company = company
- up.full_name = full_name
- up.booking_privledge = booking_privledge
- up.user = user
- up.save()
- up.ssh_public_key.save("user_ssh_key", ssh_file if ssh_file else ContentFile("public key content string"))
+def make_user_profile(user=None, email_addr="email@email.com",
+ company="company", full_name="John Doe",
+ booking_privledge=True, ssh_file=None):
+ user = user or User.objects.first() or make_user()
+ profile = UserProfile.objects.create(
+ email_addr=email_addr,
+ company=company,
+ full_name=full_name,
+ booking_privledge=booking_privledge,
+ user=user
+ )
+ profile.ssh_public_key.save("user_ssh_key", ssh_file if ssh_file else ContentFile("public key content string"))
- return up
+ return profile
-def instantiate_vlanmanager(vlans=None,
- block_size=20,
- allow_overlapping=False,
- reserved_vlans=None
- ):
- vlanmanager = VlanManager()
+def make_vlan_manager(vlans=None, block_size=20, allow_overlapping=False, reserved_vlans=None):
if not vlans:
- vlans = []
- for vlan in range(0, 4095):
- vlans.append(vlan % 2)
- vlanmanager.vlans = json.dumps(vlans)
+ vlans = [vlan % 2 for vlan in range(4095)]
if not reserved_vlans:
- reserved_vlans = []
- for vlan in range(0, 4095):
- reserved_vlans.append(0)
- vlanmanager.reserved_vlans = json.dumps(vlans)
- vlanmanager.block_size = block_size
- vlanmanager.allow_overlapping = allow_overlapping
-
- vlanmanager.save()
+ reserved_vlans = [0 for i in range(4095)]
- return vlanmanager
+ return VlanManager.objects.create(
+ vlans=json.dumps(vlans),
+ reserved_vlans=json.dumps(vlans),
+ block_size=block_size,
+ allow_overlapping=allow_overlapping
+ )
-def instantiate_lab(user=None,
- name="Test Lab Instance",
- status=LabStatus.UP,
- vlan_manager=None
- ):
+def make_lab(user=None, name="Test Lab Instance",
+ status=LabStatus.UP, vlan_manager=None,
+ pub_net_count=5):
if not vlan_manager:
- vlan_manager = instantiate_vlanmanager()
+ vlan_manager = make_vlan_manager()
if not user:
- user = instantiate_user(True, 'test_user', 'test_pass', 'test_user@test_site.org')
-
- lab = Lab()
- lab.lab_user = user
- lab.name = name
- lab.contact_email = 'test_lab@test_site.org'
- lab.contact_phone = '603 123 4567'
- lab.status = status
- lab.vlan_manager = vlan_manager
- lab.description = 'test lab instantiation'
- lab.api_token = '12345678'
-
- lab.save()
+ user = make_user()
+
+ lab = Lab.objects.create(
+ lab_user=user,
+ name=name,
+ contact_email='test_lab@test_site.org',
+ contact_phone='603 123 4567',
+ status=status,
+ vlan_manager=vlan_manager,
+ description='test lab instantiation',
+ api_token='12345678'
+ )
+
+ for i in range(pub_net_count):
+ make_public_net(vlan=i * 2 + 1, lab=lab)
return lab
"""
-resource_inventory instantiation section for permenant resources
+resource_inventory instantiation section for permanent resources
"""
-def make_hostprofile_set(lab, name="test_hostprofile"):
- hostprof = instantiate_hostprofile(lab, name=name)
- instantiate_diskprofile(hostprof, 500, name=name)
- instantiate_cpuprofile(hostprof)
- instantiate_interfaceprofile(hostprof, name=name)
- instantiate_ramprofile(hostprof)
-
- return hostprof
-
-
-def instantiate_hostprofile(lab,
- host_type=0,
- name="test hostprofile instance"
- ):
- hostprof = HostProfile()
- hostprof.host_type = host_type
- hostprof.name = name
- hostprof.description = 'test hostprofile instance'
- hostprof.save()
- hostprof.labs.add(lab)
-
- hostprof.save()
-
- return hostprof
-
-
-def instantiate_ramprofile(host,
- channels=4,
- amount=256):
- ramprof = RamProfile()
- ramprof.host = host
- ramprof.amount = amount
- ramprof.channels = channels
- ramprof.save()
-
- return ramprof
-
-
-def instantiate_diskprofile(hostprofile,
- size=0,
- media_type="SSD",
- name="test diskprofile",
- rotation=0,
- interface="sata"):
-
- diskprof = DiskProfile()
- diskprof.name = name
- diskprof.size = size
- diskprof.media_type = media_type
- diskprof.host = hostprofile
- diskprof.rotation = rotation
- diskprof.interface = interface
-
- diskprof.save()
-
- return diskprof
-
-
-def instantiate_cpuprofile(hostprofile,
- cores=4,
- architecture="x86_64",
- cpus=4,
- ):
- cpuprof = CpuProfile()
- cpuprof.cores = cores
- cpuprof.architecture = architecture
- cpuprof.cpus = cpus
- cpuprof.host = hostprofile
- cpuprof.cflags = ''
-
- cpuprof.save()
-
- return cpuprof
-
-
-def instantiate_interfaceprofile(hostprofile,
- speed=1000,
- name="test interface profile",
- nic_type="pcie"
- ):
- intprof = InterfaceProfile()
- intprof.host = hostprofile
- intprof.name = name
- intprof.speed = speed
- intprof.nic_type = nic_type
-
- intprof.save()
-
- return intprof
-
-
-def instantiate_image(lab,
- lab_id,
- owner,
- os,
- host_profile,
- public=True,
- name="default image",
- description="default image"
- ):
- image = Image()
- image.from_lab = lab
- image.lab_id = lab_id
- image.os = os
- image.host_type = host_profile
- image.public = public
- image.name = name
- image.description = description
-
- image.save()
-
- return image
-
-
-def instantiate_scenario(name="test scenario"):
- scenario = Scenario()
- scenario.name = name
- scenario.save()
- return scenario
-
-
-def instantiate_installer(supported_scenarios,
- name="test installer"
- ):
- installer = Installer()
- installer.name = name
- installer.save()
- for scenario in supported_scenarios:
+def make_complete_host_profile(lab, name="test_hostprofile"):
+ host_profile = make_host_profile(lab, name=name)
+ make_disk_profile(host_profile, 500, name=name)
+ make_cpu_profile(host_profile)
+ make_interface_profile(host_profile, name=name)
+ make_ram_profile(host_profile)
+
+ return host_profile
+
+
+def make_host_profile(lab, host_type=0, name="test hostprofile"):
+ host_profile = HostProfile.objects.create(
+ host_type=host_type,
+ name=name,
+ description='test hostprofile instance'
+ )
+ host_profile.labs.add(lab)
+
+ return host_profile
+
+
+def make_ram_profile(host, channels=4, amount=256):
+ return RamProfile.objects.create(
+ host=host,
+ amount=amount,
+ channels=channels
+ )
+
+
+def make_disk_profile(hostprofile, size=0, media_type="SSD",
+ name="test diskprofile", rotation=0,
+ interface="sata"):
+ return DiskProfile.objects.create(
+ name=name,
+ size=size,
+ media_type=media_type,
+ host=hostprofile,
+ rotation=rotation,
+ interface=interface
+ )
+
+
+def make_cpu_profile(hostprofile,
+ cores=4,
+ architecture="x86_64",
+ cpus=4,):
+ return CpuProfile.objects.create(
+ cores=cores,
+ architecture=architecture,
+ cpus=cpus,
+ host=hostprofile,
+ cflags=''
+ )
+
+
+def make_interface_profile(hostprofile,
+ speed=1000,
+ name="test interface profile",
+ nic_type="pcie"):
+ return InterfaceProfile.objects.create(
+ host=hostprofile,
+ name=name,
+ speed=speed,
+ nic_type=nic_type
+ )
+
+
+def make_image(lab, lab_id, owner, os, host_profile,
+ public=True, name="default image", description="default image"):
+ return Image.objects.create(
+ from_lab=lab,
+ lab_id=lab_id,
+ os=os,
+ host_type=host_profile,
+ public=public,
+ name=name,
+ description=description
+ )
+
+
+def make_scenario(name="test scenario"):
+ return Scenario.objects.create(name=name)
+
+
+def make_installer(scenarios, name="test installer"):
+ installer = Installer.objects.create(name=name)
+ for scenario in scenarios:
installer.sup_scenarios.add(scenario)
- installer.save()
return installer
-def instantiate_os(supported_installers,
- name="test operating system",
- ):
- os = Opsys()
- os.name = name
- os.save()
- for installer in supported_installers:
+def make_os(installers, name="test OS"):
+ os = Opsys.objects.create(name=name)
+ for installer in installers:
os.sup_installers.add(installer)
- os.save()
+
return os
-def instantiate_host(host_profile,
- lab,
- labid="test_host",
- name="test_host",
- booked=False,
- working=True,
- config=None,
- template=None,
- bundle=None,
- model="Model 1",
- vendor="ACME"):
- host = Host()
- host.lab = lab
- host.profile = host_profile
- host.name = name
- host.booked = booked
- host.working = working
- host.config = config
- host.template = template
- host.bundle = bundle
- host.model = model
- host.vendor = vendor
-
- host.save()
-
- return host
-
-
-def instantiate_opnfvrole(name="Jumphost",
- description="test opnfvrole"):
- role = OPNFVRole()
- role.name = name
- role.description = description
- role.save()
-
- return role
-
-
-def instantiate_publicnet(vlan,
- lab,
- in_use=False,
- cidr="0.0.0.0/0",
- gateway="0.0.0.0"):
- pubnet = PublicNetwork()
- pubnet.lab = lab
- pubnet.vlan = vlan
- pubnet.cidr = cidr
- pubnet.gateway = gateway
- pubnet.save()
-
- return pubnet
+def make_host(host_profile, lab, labid="test_host", name="test_host",
+ booked=False, working=True, config=None, template=None,
+ bundle=None, model="Model 1", vendor="ACME"):
+ return Host.objects.create(
+ lab=lab,
+ profile=host_profile,
+ name=name,
+ booked=booked,
+ working=working,
+ config=config,
+ template=template,
+ bundle=bundle,
+ model=model,
+ vendor=vendor
+ )
+
+
+def make_opnfv_role(name="Jumphost", description="test opnfvrole"):
+ return OPNFVRole.objects.create(
+ name=name,
+ description=description
+ )
+
+
+def make_public_net(vlan, lab, in_use=False,
+ cidr="0.0.0.0/0", gateway="0.0.0.0"):
+ return PublicNetwork.objects.create(
+ lab=lab,
+ vlan=vlan,
+ cidr=cidr,
+ gateway=gateway
+ )
Code Review / pharos-tools.git / commitdiff