Example #1
0
    def setUpTestData(cls):

        cluster_types = (
            ClusterType(name='Cluster Type 1', slug='cluster-type-1'),
            ClusterType(name='Cluster Type 2', slug='cluster-type-2'),
            ClusterType(name='Cluster Type 3', slug='cluster-type-3'),
        )
        ClusterType.objects.bulk_create(cluster_types)

        clusters = (
            Cluster(name='Cluster 1', type=cluster_types[0]),
            Cluster(name='Cluster 2', type=cluster_types[1]),
            Cluster(name='Cluster 3', type=cluster_types[2]),
        )
        Cluster.objects.bulk_create(clusters)

        vms = (
            VirtualMachine(name='Virtual Machine 1', cluster=clusters[0]),
            VirtualMachine(name='Virtual Machine 2', cluster=clusters[1]),
            VirtualMachine(name='Virtual Machine 3', cluster=clusters[2]),
        )
        VirtualMachine.objects.bulk_create(vms)

        interfaces = (
            VMInterface(virtual_machine=vms[0], name='Interface 1', enabled=True, mtu=100, mac_address='00-00-00-00-00-01'),
            VMInterface(virtual_machine=vms[1], name='Interface 2', enabled=True, mtu=200, mac_address='00-00-00-00-00-02'),
            VMInterface(virtual_machine=vms[2], name='Interface 3', enabled=False, mtu=300, mac_address='00-00-00-00-00-03'),
        )
        VMInterface.objects.bulk_create(interfaces)
Example #2
0
    def run(self, data):
        vm = VirtualMachine(
            name=data["vm_name"],
            role=data["role"],
            status=data["status"],
            cluster=data["cluster"],
            platform=data["platform"],
            vcpus=data["vcpus"],
            memory=data["memory"],
            disk=data["disk"],
            comments=data["comments"],
            tenant=data.get("tenant"),
        )
        vm.save()

        vminterface = VMInterface(
            name=data["interface_name"],
            mac_address=data["mac_address"],
            virtual_machine=vm,
        )
        vminterface.save()

        def add_addr(addr, expect_family):
            if not addr:
                return
            if addr.version != expect_family:
                raise RuntimeError("Wrong family for %r" % a)
            try:
                a = IPAddress.objects.get(
                    address=addr,
                    vrf=data.get("vrf"),
                )
                result = "Assigned"
            except ObjectDoesNotExist:
                a = IPAddress(
                    address=addr,
                    vrf=data.get("vrf"),
                )
                result = "Created"
            a.status = IPAddressStatusChoices.STATUS_ACTIVE
            a.dns_name = data["dns_name"]
            if a.assigned_object:
                raise RuntimeError("Address %s is already assigned" % addr)
            a.assigned_object = vminterface
            a.tenant = data.get("tenant")
            a.save()
            self.log_info("%s IP address %s %s" %
                          (result, a.address, a.vrf or ""))
            setattr(vm, "primary_ip%d" % a.family, a)

        add_addr(data["primary_ip4"], 4)
        add_addr(data["primary_ip6"], 6)
        vm.save()
        self.log_success("Created VM %s" % vm.name)
Example #3
0
    def test_virtualmachine_interfaces(self):
        virtualmachine = VirtualMachine.objects.first()
        vminterfaces = (
            VMInterface(virtual_machine=virtualmachine, name='Interface 1'),
            VMInterface(virtual_machine=virtualmachine, name='Interface 2'),
            VMInterface(virtual_machine=virtualmachine, name='Interface 3'),
        )
        VMInterface.objects.bulk_create(vminterfaces)

        url = reverse('virtualization:virtualmachine_interfaces', kwargs={'pk': virtualmachine.pk})
        self.assertHttpStatus(self.client.get(url), 200)
Example #4
0
    def setUpTestData(cls):

        clustertype = ClusterType.objects.create(name='Test Cluster Type 1',
                                                 slug='test-cluster-type-1')
        cluster = Cluster.objects.create(name='Test Cluster 1',
                                         type=clustertype)
        virtualmachine = VirtualMachine.objects.create(cluster=cluster,
                                                       name='Test VM 1')

        interfaces = (
            VMInterface(virtual_machine=virtualmachine, name='Interface 1'),
            VMInterface(virtual_machine=virtualmachine, name='Interface 2'),
            VMInterface(virtual_machine=virtualmachine, name='Interface 3'),
        )
        VMInterface.objects.bulk_create(interfaces)

        vlans = (
            VLAN(name='VLAN 1', vid=1),
            VLAN(name='VLAN 2', vid=2),
            VLAN(name='VLAN 3', vid=3),
        )
        VLAN.objects.bulk_create(vlans)

        cls.create_data = [
            {
                'virtual_machine': virtualmachine.pk,
                'name': 'Interface 4',
                'mode': InterfaceModeChoices.MODE_TAGGED,
                'tagged_vlans': [vlans[0].pk, vlans[1].pk],
                'untagged_vlan': vlans[2].pk,
            },
            {
                'virtual_machine': virtualmachine.pk,
                'name': 'Interface 5',
                'mode': InterfaceModeChoices.MODE_TAGGED,
                'bridge': interfaces[0].pk,
                'tagged_vlans': [vlans[0].pk, vlans[1].pk],
                'untagged_vlan': vlans[2].pk,
            },
            {
                'virtual_machine': virtualmachine.pk,
                'name': 'Interface 6',
                'mode': InterfaceModeChoices.MODE_TAGGED,
                'parent': interfaces[1].pk,
                'tagged_vlans': [vlans[0].pk, vlans[1].pk],
                'untagged_vlan': vlans[2].pk,
            },
        ]
Example #5
0
    def test_parent(self):
        # Create child interfaces
        parent_interface = VMInterface.objects.first()
        child_interfaces = (
            VMInterface(virtual_machine=parent_interface.virtual_machine,
                        name='Child 1',
                        parent=parent_interface),
            VMInterface(virtual_machine=parent_interface.virtual_machine,
                        name='Child 2',
                        parent=parent_interface),
            VMInterface(virtual_machine=parent_interface.virtual_machine,
                        name='Child 3',
                        parent=parent_interface),
        )
        VMInterface.objects.bulk_create(child_interfaces)

        params = {'parent_id': [parent_interface.pk]}
        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
Example #6
0
    def test_bridge(self):
        # Create bridged interfaces
        bridge_interface = VMInterface.objects.first()
        bridged_interfaces = (
            VMInterface(virtual_machine=bridge_interface.virtual_machine,
                        name='Bridged 1',
                        bridge=bridge_interface),
            VMInterface(virtual_machine=bridge_interface.virtual_machine,
                        name='Bridged 2',
                        bridge=bridge_interface),
            VMInterface(virtual_machine=bridge_interface.virtual_machine,
                        name='Bridged 3',
                        bridge=bridge_interface),
        )
        VMInterface.objects.bulk_create(bridged_interfaces)

        params = {'bridge_id': [bridge_interface.pk]}
        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
Example #7
0
    def setUpTestData(cls):

        cluster_types = (
            ClusterType(name='Cluster Type 1', slug='cluster-type-1'),
            ClusterType(name='Cluster Type 2', slug='cluster-type-2'),
            ClusterType(name='Cluster Type 3', slug='cluster-type-3'),
        )
        ClusterType.objects.bulk_create(cluster_types)

        cluster_groups = (
            ClusterGroup(name='Cluster Group 1', slug='cluster-group-1'),
            ClusterGroup(name='Cluster Group 2', slug='cluster-group-2'),
            ClusterGroup(name='Cluster Group 3', slug='cluster-group-3'),
        )
        ClusterGroup.objects.bulk_create(cluster_groups)

        regions = (
            Region(name='Test Region 1', slug='test-region-1'),
            Region(name='Test Region 2', slug='test-region-2'),
            Region(name='Test Region 3', slug='test-region-3'),
        )
        for r in regions:
            r.save()

        site_groups = (
            SiteGroup(name='Site Group 1', slug='site-group-1'),
            SiteGroup(name='Site Group 2', slug='site-group-2'),
            SiteGroup(name='Site Group 3', slug='site-group-3'),
        )
        for site_group in site_groups:
            site_group.save()

        sites = (
            Site(name='Test Site 1',
                 slug='test-site-1',
                 region=regions[0],
                 group=site_groups[0]),
            Site(name='Test Site 2',
                 slug='test-site-2',
                 region=regions[1],
                 group=site_groups[1]),
            Site(name='Test Site 3',
                 slug='test-site-3',
                 region=regions[2],
                 group=site_groups[2]),
        )
        Site.objects.bulk_create(sites)

        clusters = (
            Cluster(name='Cluster 1',
                    type=cluster_types[0],
                    group=cluster_groups[0],
                    site=sites[0]),
            Cluster(name='Cluster 2',
                    type=cluster_types[1],
                    group=cluster_groups[1],
                    site=sites[1]),
            Cluster(name='Cluster 3',
                    type=cluster_types[2],
                    group=cluster_groups[2],
                    site=sites[2]),
        )
        Cluster.objects.bulk_create(clusters)

        platforms = (
            Platform(name='Platform 1', slug='platform-1'),
            Platform(name='Platform 2', slug='platform-2'),
            Platform(name='Platform 3', slug='platform-3'),
        )
        Platform.objects.bulk_create(platforms)

        roles = (
            DeviceRole(name='Device Role 1', slug='device-role-1'),
            DeviceRole(name='Device Role 2', slug='device-role-2'),
            DeviceRole(name='Device Role 3', slug='device-role-3'),
        )
        DeviceRole.objects.bulk_create(roles)

        tenant_groups = (
            TenantGroup(name='Tenant group 1', slug='tenant-group-1'),
            TenantGroup(name='Tenant group 2', slug='tenant-group-2'),
            TenantGroup(name='Tenant group 3', slug='tenant-group-3'),
        )
        for tenantgroup in tenant_groups:
            tenantgroup.save()

        tenants = (
            Tenant(name='Tenant 1', slug='tenant-1', group=tenant_groups[0]),
            Tenant(name='Tenant 2', slug='tenant-2', group=tenant_groups[1]),
            Tenant(name='Tenant 3', slug='tenant-3', group=tenant_groups[2]),
        )
        Tenant.objects.bulk_create(tenants)

        vms = (
            VirtualMachine(name='Virtual Machine 1',
                           cluster=clusters[0],
                           platform=platforms[0],
                           role=roles[0],
                           tenant=tenants[0],
                           status=VirtualMachineStatusChoices.STATUS_ACTIVE,
                           vcpus=1,
                           memory=1,
                           disk=1,
                           local_context_data={"foo": 123}),
            VirtualMachine(name='Virtual Machine 2',
                           cluster=clusters[1],
                           platform=platforms[1],
                           role=roles[1],
                           tenant=tenants[1],
                           status=VirtualMachineStatusChoices.STATUS_STAGED,
                           vcpus=2,
                           memory=2,
                           disk=2),
            VirtualMachine(name='Virtual Machine 3',
                           cluster=clusters[2],
                           platform=platforms[2],
                           role=roles[2],
                           tenant=tenants[2],
                           status=VirtualMachineStatusChoices.STATUS_OFFLINE,
                           vcpus=3,
                           memory=3,
                           disk=3),
        )
        VirtualMachine.objects.bulk_create(vms)

        interfaces = (
            VMInterface(virtual_machine=vms[0],
                        name='Interface 1',
                        mac_address='00-00-00-00-00-01'),
            VMInterface(virtual_machine=vms[1],
                        name='Interface 2',
                        mac_address='00-00-00-00-00-02'),
            VMInterface(virtual_machine=vms[2],
                        name='Interface 3',
                        mac_address='00-00-00-00-00-03'),
        )
        VMInterface.objects.bulk_create(interfaces)

        # Assign primary IPs for filtering
        ipaddresses = (
            IPAddress(address='192.0.2.1/24', assigned_object=interfaces[0]),
            IPAddress(address='192.0.2.2/24', assigned_object=interfaces[1]),
        )
        IPAddress.objects.bulk_create(ipaddresses)
        VirtualMachine.objects.filter(pk=vms[0].pk).update(
            primary_ip4=ipaddresses[0])
        VirtualMachine.objects.filter(pk=vms[1].pk).update(
            primary_ip4=ipaddresses[1])
Example #8
0
    def setUpTestData(cls):

        site = Site.objects.create(name='Site 1', slug='site-1')
        devicerole = DeviceRole.objects.create(name='Device Role 1',
                                               slug='device-role-1')
        clustertype = ClusterType.objects.create(name='Cluster Type 1',
                                                 slug='cluster-type-1')
        cluster = Cluster.objects.create(name='Cluster 1',
                                         type=clustertype,
                                         site=site)
        virtualmachines = (
            VirtualMachine(name='Virtual Machine 1',
                           cluster=cluster,
                           role=devicerole),
            VirtualMachine(name='Virtual Machine 2',
                           cluster=cluster,
                           role=devicerole),
        )
        VirtualMachine.objects.bulk_create(virtualmachines)

        VMInterface.objects.bulk_create([
            VMInterface(virtual_machine=virtualmachines[0],
                        name='Interface 1'),
            VMInterface(virtual_machine=virtualmachines[0],
                        name='Interface 2'),
            VMInterface(virtual_machine=virtualmachines[0],
                        name='Interface 3'),
        ])

        vlans = (
            VLAN(vid=1, name='VLAN1', site=site),
            VLAN(vid=101, name='VLAN101', site=site),
            VLAN(vid=102, name='VLAN102', site=site),
            VLAN(vid=103, name='VLAN103', site=site),
        )
        VLAN.objects.bulk_create(vlans)

        tags = create_tags('Alpha', 'Bravo', 'Charlie')

        cls.form_data = {
            'virtual_machine': virtualmachines[1].pk,
            'name': 'Interface X',
            'enabled': False,
            'mac_address': EUI('01-02-03-04-05-06'),
            'mtu': 2000,
            'description': 'New description',
            'mode': InterfaceModeChoices.MODE_TAGGED,
            'untagged_vlan': vlans[0].pk,
            'tagged_vlans': [v.pk for v in vlans[1:4]],
            'tags': [t.pk for t in tags],
        }

        cls.bulk_create_data = {
            'virtual_machine': virtualmachines[1].pk,
            'name_pattern': 'Interface [4-6]',
            'enabled': False,
            'mac_address': EUI('01-02-03-04-05-06'),
            'mtu': 2000,
            'description': 'New description',
            'mode': InterfaceModeChoices.MODE_TAGGED,
            'untagged_vlan': vlans[0].pk,
            'tagged_vlans': [v.pk for v in vlans[1:4]],
            'tags': [t.pk for t in tags],
        }

        cls.csv_data = (
            "virtual_machine,name",
            "Virtual Machine 2,Interface 4",
            "Virtual Machine 2,Interface 5",
            "Virtual Machine 2,Interface 6",
        )

        cls.bulk_edit_data = {
            'enabled': False,
            'mtu': 2000,
            'description': 'New description',
            'mode': InterfaceModeChoices.MODE_TAGGED,
            'untagged_vlan': vlans[0].pk,
            'tagged_vlans': [v.pk for v in vlans[1:4]],
        }
Example #9
0
    def setUpTestData(cls):

        vrfs = (
            VRF(name='VRF 1', rd='65000:100'),
            VRF(name='VRF 2', rd='65000:200'),
            VRF(name='VRF 3', rd='65000:300'),
        )
        VRF.objects.bulk_create(vrfs)

        site = Site.objects.create(name='Site 1', slug='site-1')
        manufacturer = Manufacturer.objects.create(name='Manufacturer 1',
                                                   slug='manufacturer-1')
        device_type = DeviceType.objects.create(manufacturer=manufacturer,
                                                model='Device Type 1')
        device_role = DeviceRole.objects.create(name='Device Role 1',
                                                slug='device-role-1')

        devices = (
            Device(device_type=device_type,
                   name='Device 1',
                   site=site,
                   device_role=device_role),
            Device(device_type=device_type,
                   name='Device 2',
                   site=site,
                   device_role=device_role),
            Device(device_type=device_type,
                   name='Device 3',
                   site=site,
                   device_role=device_role),
        )
        Device.objects.bulk_create(devices)

        interfaces = (
            Interface(device=devices[0], name='Interface 1'),
            Interface(device=devices[1], name='Interface 2'),
            Interface(device=devices[2], name='Interface 3'),
        )
        Interface.objects.bulk_create(interfaces)

        clustertype = ClusterType.objects.create(name='Cluster Type 1',
                                                 slug='cluster-type-1')
        cluster = Cluster.objects.create(type=clustertype, name='Cluster 1')

        virtual_machines = (
            VirtualMachine(name='Virtual Machine 1', cluster=cluster),
            VirtualMachine(name='Virtual Machine 2', cluster=cluster),
            VirtualMachine(name='Virtual Machine 3', cluster=cluster),
        )
        VirtualMachine.objects.bulk_create(virtual_machines)

        vminterfaces = (
            VMInterface(virtual_machine=virtual_machines[0],
                        name='Interface 1'),
            VMInterface(virtual_machine=virtual_machines[1],
                        name='Interface 2'),
            VMInterface(virtual_machine=virtual_machines[2],
                        name='Interface 3'),
        )
        VMInterface.objects.bulk_create(vminterfaces)

        tenant_groups = (
            TenantGroup(name='Tenant group 1', slug='tenant-group-1'),
            TenantGroup(name='Tenant group 2', slug='tenant-group-2'),
            TenantGroup(name='Tenant group 3', slug='tenant-group-3'),
        )
        for tenantgroup in tenant_groups:
            tenantgroup.save()

        tenants = (
            Tenant(name='Tenant 1', slug='tenant-1', group=tenant_groups[0]),
            Tenant(name='Tenant 2', slug='tenant-2', group=tenant_groups[1]),
            Tenant(name='Tenant 3', slug='tenant-3', group=tenant_groups[2]),
        )
        Tenant.objects.bulk_create(tenants)

        ipaddresses = (
            IPAddress(address='10.0.0.1/24',
                      tenant=None,
                      vrf=None,
                      assigned_object=None,
                      status=IPAddressStatusChoices.STATUS_ACTIVE,
                      dns_name='ipaddress-a'),
            IPAddress(address='10.0.0.2/24',
                      tenant=tenants[0],
                      vrf=vrfs[0],
                      assigned_object=interfaces[0],
                      status=IPAddressStatusChoices.STATUS_ACTIVE,
                      dns_name='ipaddress-b'),
            IPAddress(address='10.0.0.3/24',
                      tenant=tenants[1],
                      vrf=vrfs[1],
                      assigned_object=interfaces[1],
                      status=IPAddressStatusChoices.STATUS_RESERVED,
                      role=IPAddressRoleChoices.ROLE_VIP,
                      dns_name='ipaddress-c'),
            IPAddress(address='10.0.0.4/24',
                      tenant=tenants[2],
                      vrf=vrfs[2],
                      assigned_object=interfaces[2],
                      status=IPAddressStatusChoices.STATUS_DEPRECATED,
                      role=IPAddressRoleChoices.ROLE_SECONDARY,
                      dns_name='ipaddress-d'),
            IPAddress(address='10.0.0.1/25',
                      tenant=None,
                      vrf=None,
                      assigned_object=None,
                      status=IPAddressStatusChoices.STATUS_ACTIVE),
            IPAddress(address='2001:db8::1/64',
                      tenant=None,
                      vrf=None,
                      assigned_object=None,
                      status=IPAddressStatusChoices.STATUS_ACTIVE,
                      dns_name='ipaddress-a'),
            IPAddress(address='2001:db8::2/64',
                      tenant=tenants[0],
                      vrf=vrfs[0],
                      assigned_object=vminterfaces[0],
                      status=IPAddressStatusChoices.STATUS_ACTIVE,
                      dns_name='ipaddress-b'),
            IPAddress(address='2001:db8::3/64',
                      tenant=tenants[1],
                      vrf=vrfs[1],
                      assigned_object=vminterfaces[1],
                      status=IPAddressStatusChoices.STATUS_RESERVED,
                      role=IPAddressRoleChoices.ROLE_VIP,
                      dns_name='ipaddress-c'),
            IPAddress(address='2001:db8::4/64',
                      tenant=tenants[2],
                      vrf=vrfs[2],
                      assigned_object=vminterfaces[2],
                      status=IPAddressStatusChoices.STATUS_DEPRECATED,
                      role=IPAddressRoleChoices.ROLE_SECONDARY,
                      dns_name='ipaddress-d'),
            IPAddress(address='2001:db8::1/65',
                      tenant=None,
                      vrf=None,
                      assigned_object=None,
                      status=IPAddressStatusChoices.STATUS_ACTIVE),
        )
        IPAddress.objects.bulk_create(ipaddresses)
Example #10
0
    def run(self, data, commit):
        vm = VirtualMachine(
            name=data["vm_name"],
            role=data["role"],
            status=data["status"],
            cluster=data["cluster"],
            platform=data["platform"],
            vcpus=data["vcpus"],
            memory=data["memory"],
            disk=data["disk"],
            comments=data["comments"],
            tenant=data.get("tenant"),
        )
        vm.full_clean()
        vm.save()
        vm.tags.set(data["vm_tags"])

        vminterface = VMInterface(
            name=data["interface_name"],
            mac_address=data["mac_address"],
            virtual_machine=vm,
        )
        vminterface.full_clean()
        vminterface.save()

        def add_addr(addr, family):
            if not addr:
                return
            if addr.version != family:
                raise RuntimeError(f"Wrong family for {a}")
            try:
                a = IPAddress.objects.get(
                    address=addr,
                    vrf=data.get("vrf"),
                )
                result = "Assigned"
            except ObjectDoesNotExist:
                a = IPAddress(
                    address=addr,
                    vrf=data.get("vrf"),
                )
                result = "Created"
            a.status = IPAddressStatusChoices.STATUS_ACTIVE
            a.dns_name = data["dns_name"]
            if a.assigned_object:
                raise RuntimeError(f"Address {addr} is already assigned")
            a.assigned_object = vminterface
            a.tenant = data.get("tenant")
            a.full_clean()
            a.save()
            #a.tags.set(data[f"primary_ip{family}_tags"])
            self.log_info(f"{result} IP address {a.address} {a.vrf or ''}")
            setattr(vm, f"primary_ip{family}", a)

        add_addr(data["primary_ip4"], 4)
        add_addr(data["primary_ip6"], 6)
        vm.full_clean()
        vm.save()
        self.log_success(
            f"Created VM [{vm.name}](/virtualization/virtual-machines/{vm.id}/)"
        )