def test_gen_mac_6(self):
"""
@Test: Generate a MAC address using a number as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is not generated using an invalid delimiter
"""
with self.assertRaises(ValueError):
gen_mac(delimiter=random.randint(0, 10))
def test_gen_mac_5(self):
"""
@Test: Generate a MAC address using \" \" as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is not generated using an invalid delimiter
"""
with self.assertRaises(ValueError):
gen_mac(delimiter=" ")
def test_gen_mac_6(self):
"""
@Test: Generate a MAC address using a number as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is not generated using an invalid delimiter
"""
with self.assertRaises(ValueError):
gen_mac(delimiter=random.randint(0, 10))
def test_gen_mac_7(self):
"""
@Test: Generate a MAC address using a letter as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is not generated using an invalid delimiter
"""
with self.assertRaises(ValueError):
gen_mac(delimiter=random.choice(string.ascii_letters))
def test_gen_mac_5(self):
"""
@Test: Generate a MAC address using \" \" as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is not generated using an invalid delimiter
"""
with self.assertRaises(ValueError):
gen_mac(delimiter=" ")
def test_gen_mac_7(self):
"""
@Test: Generate a MAC address using a letter as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is not generated using an invalid delimiter
"""
with self.assertRaises(ValueError):
gen_mac(
delimiter=random.choice(string.ascii_letters))
def create_discovered_host(name=None,
ip_address=None,
mac_address=None,
options=None):
"""Creates a discovered host.
:param str name: Name of discovered host.
:param str ip_address: A valid ip address.
:param str mac_address: A valid mac address.
:param dict options: additional facts to add to discovered host
:return: dict of ``entities.DiscoveredHost`` facts.
"""
if name is None:
name = gen_string('alpha')
if ip_address is None:
ip_address = gen_ipaddr()
if mac_address is None:
mac_address = gen_mac(multicast=False)
if options is None:
options = {}
facts = {
'name': name,
'discovery_bootip': ip_address,
'discovery_bootif': mac_address,
'interfaces': 'eth0',
'ipaddress': ip_address,
'ipaddress_eth0': ip_address,
'macaddress': mac_address,
'macaddress_eth0': mac_address,
}
facts.update(options)
return entities.DiscoveredHost().facts(json={'facts': facts})
def create_discovered_host(name=None, ip_address=None, mac_address=None,
options=None):
"""Creates a discovered host.
:param str name: Name of discovered host.
:param str ip_address: A valid ip address.
:param str mac_address: A valid mac address.
:param dict options: additional facts to add to discovered host
:returns dict of ``entities.DiscoveredHost`` facts.
"""
if name is None:
name = gen_string('alpha')
if ip_address is None:
ip_address = gen_ipaddr()
if mac_address is None:
mac_address = gen_mac(multicast=False)
if options is None:
options = {}
facts = {
'name': name,
'discovery_bootip': ip_address,
'discovery_bootif': mac_address,
'interfaces': 'eth0',
'ipaddress': ip_address,
'ipaddress_eth0': ip_address,
'macaddress': mac_address,
'macaddress_eth0': mac_address,
}
facts.update(options)
return entities.DiscoveredHost().facts(json={'facts': facts})
def generate_system_facts(name=None):
"""Generate random system facts for registration.
:param str name: A valid FQDN for a system. If one is not
provided, then a random value will be generated.
:return: A dictionary with random system facts
:rtype: dict
"""
if name is None:
name = f'{gen_alpha().lower()}.example.net'
# Make a copy of the system facts 'template'
new_facts = copy.deepcopy(SYSTEM_FACTS)
# Select a random RHEL version...
distro = gen_choice(DISTRO_IDS)
# ...and update our facts
new_facts['distribution.id'] = distro['id']
new_facts['distribution.version'] = distro['version']
new_facts['dmi.bios.relase_date'] = _bios_date().strftime('%m/%d/%Y')
new_facts['dmi.memory.maximum_capacity'] = gen_choice(MEMORY_CAPACITY)
new_facts['dmi.memory.size'] = gen_choice(MEMORY_SIZE)
new_facts['dmi.system.uuid'] = gen_uuid()
new_facts['dmi.system.version'] = 'RHEL'
new_facts['lscpu.architecture'] = distro['architecture']
new_facts['net.interface.eth1.hwaddr'] = gen_mac(multicast=False)
new_facts['net.interface.eth1.ipaddr'] = gen_ipaddr()
new_facts['network.hostname'] = name
new_facts['network.ipaddr'] = new_facts['net.interface.eth1.ipaddr']
new_facts['uname.machine'] = distro['architecture']
new_facts['uname.nodename'] = name
new_facts['uname.release'] = distro['kernel']
new_facts['virt.uuid'] = new_facts['dmi.system.uuid']
return new_facts
def _create_discovered_host(name=None, ipaddress=None, macaddress=None):
"""Creates discovered host by uploading few fake facts.
:param str name: Name of discovered host. If ``None`` then a random
value will be generated.
:param str ipaddress: A valid ip address.
If ``None`` then then a random value will be generated.
:param str macaddress: A valid mac address.
If ``None`` then then a random value will be generated.
:return: A ``dict`` of ``DiscoveredHost`` facts.
"""
if name is None:
name = gen_string('alpha')
if ipaddress is None:
ipaddress = gen_ipaddr()
if macaddress is None:
macaddress = gen_mac(multicast=False)
return entities.DiscoveredHost().facts(json={
u'facts': {
u'name': name,
u'discovery_bootip': ipaddress,
u'discovery_bootif': macaddress,
u'interfaces': 'eth0',
u'ipaddress': ipaddress,
u'macaddress': macaddress,
u'macaddress_eth0': macaddress,
u'ipaddress_eth0': ipaddress,
}
})
def attach_nic(self):
"""Add a new NIC to existing host"""
if not self._created:
raise LibvirtGuestError(
'The virtual guest should be created before updating it'
)
nic_mac = gen_mac(multicast=False, locally=True)
command_args = [
'virsh attach-interface',
'--domain={vm_name}',
'--type=bridge',
'--source={vm_bridge}',
'--model=virtio',
'--mac={vm_mac}',
'--config',
]
command = u' '.join(command_args).format(
vm_name=self.hostname,
vm_bridge=self.bridge,
vm_mac=nic_mac,
)
result = ssh.command(command, self.libvirt_server)
if result.return_code != 0:
raise LibvirtGuestError(
u'Failed to run virsh attach-interface: {0}'
.format(result.stderr))
def _create_discovered_host(name=None, ipaddress=None, macaddress=None):
"""Creates discovered host by uploading few fake facts.
:param str name: Name of discovered host. If ``None`` then a random
value will be generated.
:param str ipaddress: A valid ip address.
If ``None`` then then a random value will be generated.
:param str macaddress: A valid mac address.
If ``None`` then then a random value will be generated.
:return: A ``dict`` of ``DiscoveredHost`` facts.
"""
if name is None:
name = gen_string('alpha')
if ipaddress is None:
ipaddress = gen_ipaddr()
if macaddress is None:
macaddress = gen_mac(multicast=False)
return entities.DiscoveredHost().facts(
json={
u'facts': {
u'name': name,
u'discovery_bootip': ipaddress,
u'discovery_bootif': macaddress,
u'interfaces': 'eth0',
u'ipaddress': ipaddress,
u'macaddress': macaddress,
u'macaddress_eth0': macaddress,
u'ipaddress_eth0': ipaddress,
}
})
def test_positive_create_and_update_mac():
"""Create host with MAC address and update it
:id: 72e3b020-7347-4500-8669-c6ddf6dfd0b6
:expectedresults: A host is created with MAC address updated with a new MAC address
:CaseImportance: Critical
"""
mac = gen_mac(multicast=False)
host = entities.Host(mac=mac).create()
assert host.mac == mac
new_mac = gen_mac(multicast=False)
host.mac = new_mac
host = host.update(['mac'])
assert host.mac == new_mac
def _gen_mac_for_libvirt():
# fe:* MAC range is considered reserved in libvirt
for _ in range(0, 10):
mac = gen_mac(multicast=False, locally=True)
if not mac.startswith('fe'):
return mac
mac = None
if not mac:
raise ValueError('Unable to generate a valid MAC address')
def test_gen_mac_multicast_globally_unique(self):
"""
@Test: Generate a multicast and globally unique MAC address
@Feature: MAC Generator
@Assert: A multicast and globally unique MAC address is generated
"""
mac = gen_mac(multicast=True, locally=False)
first_octect = int(mac.split(':', 1)[0], 16)
mask = 0b00000011
self.assertEqual(first_octect & mask, 1)
def test_gen_mac_multicast_locally_administered(self):
"""
@Test: Generate a multicast and locally administered MAC address
@Feature: MAC Generator
@Assert: A multicast and locally administered MAC address is generated
"""
mac = gen_mac(multicast=True, locally=True)
first_octect = int(mac.split(':', 1)[0], 16)
mask = 0b00000011
self.assertEqual(first_octect & mask, 3)
def test_positive_update_mac(self):
"""Update a host with a new MAC address
@id: 72e3b020-7347-4500-8669-c6ddf6dfd0b6
@assert: A host is updated with a new MAC address
"""
host = entities.Host().create()
new_mac = gen_mac()
host.mac = new_mac
host = host.update(['mac'])
self.assertEqual(host.mac, new_mac)
def test_positive_update_mac(self):
"""Update a host with a new MAC address
@feature: Hosts
@assert: A host is updated with a new MAC address
"""
host = entities.Host().create()
new_mac = gen_mac()
host.mac = new_mac
host = host.update(['mac'])
self.assertEqual(host.mac, new_mac)
def test_positive_update_mac(self):
"""Update a host with a new MAC address
@id: 72e3b020-7347-4500-8669-c6ddf6dfd0b6
@assert: A host is updated with a new MAC address
"""
host = entities.Host().create()
new_mac = gen_mac()
host.mac = new_mac
host = host.update(['mac'])
self.assertEqual(host.mac, new_mac)
def test_gen_mac_3(self):
"""
@Test: Generate a MAC address using \"-\" as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is generated using \"-\" as the delimiter
"""
result = gen_mac(delimiter="-")
self.assertTrue(
len(result.split("-")) == 6, "Did not generate a MAC addrss")
self.assertIsNotNone(
mac.match(result),
"Did not match regular expression for MAC address")
def test_gen_mac_3(self):
"""
@Test: Generate a MAC address using \"-\" as the delimiter
@Feature: MAC Generator
@Assert: A MAC address is generated using \"-\" as the delimiter
"""
result = gen_mac(delimiter="-")
self.assertTrue(
len(result.split("-")) == 6,
"Did not generate a MAC addrss")
self.assertIsNotNone(
mac.match(result),
"Did not match regular expression for MAC address")
def test_positive_discovered_host(session):
"""Check if the Discovered Host widget is working in the Dashboard UI
:id: 74afef58-71f4-49e1-bbb6-6d4355d385f8
:Steps:
1. Create a Discovered Host.
2. Navigate Monitor -> Dashboard
3. Review the Discovered Host Status.
:expectedresults: The widget is updated with all details.
:CaseLevel: Integration
"""
org = entities.Organization().create()
loc = entities.Location(organization=[org]).create()
ipaddress = gen_ipaddr()
macaddress = gen_mac(multicast=False)
model = gen_string('alpha', length=5)
host_name = 'mac{0}'.format(macaddress.replace(':', ''))
entities.DiscoveredHost().facts(json={
u'facts': {
u'name': gen_string('alpha'),
u'discovery_bootip': ipaddress,
u'discovery_bootif': macaddress,
u'interfaces': 'eth0',
u'ipaddress': ipaddress,
u'macaddress': macaddress,
u'macaddress_eth0': macaddress,
u'ipaddress_eth0': ipaddress,
u'foreman_organization': org.name,
u'foreman_location': loc.name,
u'model': model,
u'memorysize_mb': 1000,
u'physicalprocessorcount': 2,
}
})
with session:
session.organization.select(org_name=org.name)
session.location.select(loc_name=loc.name)
values = session.dashboard.read('DiscoveredHosts')
assert len(values['hosts']) == 1
assert values['hosts_count'] == '1 Discovered Host'
assert values['hosts'][0]['Host'] == host_name
assert values['hosts'][0]['Model'] == model
assert values['hosts'][0]['CPUs'] == '2'
assert values['hosts'][0]['Memory'] == '1000 MB'
def test_positive_discovered_host(session):
"""Check if the Discovered Host widget is working in the Dashboard UI
:id: 74afef58-71f4-49e1-bbb6-6d4355d385f8
:Steps:
1. Create a Discovered Host.
2. Navigate Monitor -> Dashboard
3. Review the Discovered Host Status.
:expectedresults: The widget is updated with all details.
:CaseLevel: Integration
"""
org = entities.Organization().create()
loc = entities.Location(organization=[org]).create()
ipaddress = gen_ipaddr()
macaddress = gen_mac(multicast=False)
model = gen_string('alpha', length=5)
host_name = 'mac{0}'.format(macaddress.replace(':', ''))
entities.DiscoveredHost().facts(json={
u'facts': {
u'name': gen_string('alpha'),
u'discovery_bootip': ipaddress,
u'discovery_bootif': macaddress,
u'interfaces': 'eth0',
u'ipaddress': ipaddress,
u'macaddress': macaddress,
u'macaddress_eth0': macaddress,
u'ipaddress_eth0': ipaddress,
u'foreman_organization': org.name,
u'foreman_location': loc.name,
u'model': model,
u'memorysize_mb': 1000,
u'physicalprocessorcount': 2,
}
})
with session:
session.organization.select(org_name=org.name)
session.location.select(loc_name=loc.name)
values = session.dashboard.read('DiscoveredHosts')
assert len(values['hosts']) == 1
assert values['hosts_count'] == '1 Discovered Host'
assert values['hosts'][0]['Host'] == host_name
assert values['hosts'][0]['Model'] == model
assert values['hosts'][0]['CPUs'] == '2'
assert values['hosts'][0]['Memory'] == '1000 MB'
def test_positive_update_mac_by_name(self):
"""A host can be updated with a new random MAC address. Use name
to access the host
@id: a422788d-5473-4846-a86b-90d8f236285a
@assert: A host is updated and the MAC address matches
"""
new_mac = gen_mac()
Host.update({
'mac': new_mac,
'name': self.host['name'],
})
self.host = Host.info({'name': self.host['name']})
self.assertEqual(self.host['network']['mac'], new_mac)
def test_positive_update_mac_by_id(self):
"""A host can be updated with a new random MAC address. Use id
to access the host
@id: 72ed9ae8-989a-46d1-8b7d-46f5db106e75
@assert: A host is updated and the MAC address matches
"""
new_mac = gen_mac()
Host.update({
'id': self.host['id'],
'mac': new_mac,
})
self.host = Host.info({'id': self.host['id']})
self.assertEqual(self.host['network']['mac'], new_mac)
def test_positive_update_mac_by_name(self):
"""A host can be updated with a new random MAC address. Use name
to access the host
@id: a422788d-5473-4846-a86b-90d8f236285a
@assert: A host is updated and the MAC address matches
"""
new_mac = gen_mac()
Host.update({
'mac': new_mac,
'name': self.host['name'],
})
self.host = Host.info({'name': self.host['name']})
self.assertEqual(self.host['network']['mac'], new_mac)
def test_positive_update_mac_by_name(self):
"""A host can be updated with a new random MAC address. Use name
to access the host
@feature: Hosts
@assert: A host is updated and the MAC address matches
"""
new_mac = gen_mac()
Host.update({
'mac': new_mac,
'name': self.host['name'],
})
self.host = Host.info({'name': self.host['name']})
self.assertEqual(self.host['mac'], new_mac)
def test_positive_update_mac_by_id(self):
"""A host can be updated with a new random MAC address. Use id
to access the host
@id: 72ed9ae8-989a-46d1-8b7d-46f5db106e75
@assert: A host is updated and the MAC address matches
"""
new_mac = gen_mac()
Host.update({
'id': self.host['id'],
'mac': new_mac,
})
self.host = Host.info({'id': self.host['id']})
self.assertEqual(self.host['network']['mac'], new_mac)
def test_positive_update_mac_by_name(self):
"""A host can be updated with a new random MAC address. Use name
to access the host
@feature: Hosts
@assert: A host is updated and the MAC address matches
"""
new_mac = gen_mac()
Host.update({
'mac': new_mac,
'name': self.host['name'],
})
self.host = Host.info({'name': self.host['name']})
self.assertEqual(self.host['mac'], new_mac)
def test_delete_discovered_host_1(self):
"""@Test: Delete the selected discovered host
@Feature: Foreman Discovery
@Setup: Host should already be discovered
@Assert: Selected host should be removed successfully
"""
mac = gen_mac(multicast=True, locally=True)
hostname = 'mac{0}'.format(mac.replace(':', ""))
self._pxe_boot_host(mac)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
self.discoveredhosts.delete(hostname)
def test_host_discovery(self):
"""@Test: Discover a host via proxy by setting "proxy.type=proxy" in
PXE default
@Feature: Foreman Discovery
@Setup: Provisioning should be configured
@Steps: PXE boot a host/VM
@Assert: Host should be successfully discovered
"""
mac = gen_mac(multicast=True, locally=True)
hostname = 'mac{0}'.format(mac.replace(':', ""))
self._pxe_boot_host(mac)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
self.assertIsNotNone(self.discoveredhosts.search(hostname))
def __init__(
self, cpu=1, ram=1024, boot_iso=False, extra_nic=False,
libvirt_server=None, image_dir=None, mac=None, bridge=None):
self.cpu = cpu
self.ram = ram
if libvirt_server is None:
self.libvirt_server = settings.compute_resources.libvirt_hostname
else:
self.libvirt_server = libvirt_server
if self.libvirt_server is None or self.libvirt_server == '':
raise LibvirtGuestError(
'A libvirt server must be provided. Make sure to fill '
'"libvirt_server" on compute_resources section of your '
'robottelo configuration. Or provide a not None '
'libvirt_server argument.'
)
if image_dir is None:
self.image_dir = settings.compute_resources.libvirt_image_dir
else:
self.image_dir = image_dir
if mac is None:
self.mac = gen_mac(multicast=False, locally=True)
else:
self.mac = mac
if bridge is None:
self.bridge = settings.vlan_networking.bridge
else:
self.bridge = bridge
if not self.bridge:
raise LibvirtGuestError(
'A bridge name must be provided. Make sure to fill '
'"bridge" on vlan_networking section of your robottelo '
'configuration. Or provide a not None bridge '
'argument.'
)
self.boot_iso = boot_iso
self.extra_nic = extra_nic
self.hostname = None
self.ip_addr = None
self._domain = None
self._created = False
self.guest_name = 'mac{0}'.format(self.mac.replace(':', ""))
def test_positive_upload_facts(self):
"""Upload fake facts to create a discovered host
:id: c1f40204-bbb0-46d0-9b60-e42f00ad1649
:Steps: POST /api/v2/discovered_hosts/facts
:expectedresults: Host should be created successfully
:CaseLevel: Integration
"""
for name in valid_data_list():
with self.subTest(name):
mac_address = gen_mac()
host = _create_discovered_host(name, macaddress=mac_address)
if bz_bug_is_open(1392919):
host_name = 'mac{0}'.format(mac_address.replace(':', ''))
else:
host_name = 'mac{0}'.format(host['mac'].replace(':', ''))
self.assertEqual(host['name'], host_name)
def test_positive_upload_facts(self):
"""Upload fake facts to create a discovered host
:id: c1f40204-bbb0-46d0-9b60-e42f00ad1649
:Steps: POST /api/v2/discovered_hosts/facts
:expectedresults: Host should be created successfully
:CaseLevel: Integration
"""
for name in valid_data_list():
with self.subTest(name):
mac_address = gen_mac()
host = _create_discovered_host(name, macaddress=mac_address)
if bz_bug_is_open(1392919):
host_name = 'mac{0}'.format(mac_address.replace(':', ''))
else:
host_name = 'mac{0}'.format(host['mac'].replace(':', ''))
self.assertEqual(host['name'], host_name)
def __init__(
self, cpu=1, ram=1024, boot_iso=False, libvirt_server=None,
image_dir=None, mac=None, bridge=None):
self.cpu = cpu
self.ram = ram
if libvirt_server is None:
self.libvirt_server = settings.compute_resources.libvirt_hostname
else:
self.libvirt_server = libvirt_server
if self.libvirt_server is None or self.libvirt_server == '':
raise LibvirtGuestError(
'A libvirt server must be provided. Make sure to fill '
'"libvirt_server" on compute_resources section of your '
'robottelo configuration. Or provide a not None '
'libvirt_server argument.'
)
if image_dir is None:
self.image_dir = settings.compute_resources.libvirt_image_dir
else:
self.image_dir = image_dir
if mac is None:
self.mac = gen_mac(multicast=False, locally=True)
else:
self.mac = mac
if bridge is None:
self.bridge = settings.vlan_networking.bridge
else:
self.bridge = bridge
if not self.bridge:
raise LibvirtGuestError(
'A bridge name must be provided. Make sure to fill '
'"bridge" on vlan_networking section of your robottelo '
'configuration. Or provide a not None bridge '
'argument.'
)
self.boot_iso = boot_iso
self.hostname = None
self.ip_addr = None
self._domain = None
self._created = False
self.guest_name = 'mac{0}'.format(self.mac.replace(':', ""))
def _create_discovered_host(name=None, ipaddress=None, discovery_bootif=None):
"""Creates discovered host by uploading few fake facts.
:param str name: Name of discovered host. If ``None`` then a random
value will be generated.
:param str ipaddress: A valid ip address.
If ``None`` then then a random value will be generated.
:return: A ``dict`` of ``DiscoveredHost`` facts.
"""
if name is None:
name = gen_string('alpha')
if ipaddress is None:
ipaddress = gen_ipaddr()
if discovery_bootif is None:
discovery_bootif = gen_mac()
return entities.DiscoveredHost().facts(data={
u'facts': {
u'name': name,
u'ipaddress': ipaddress,
u'discovery_bootif': discovery_bootif,
}
})
def generate_system_facts(name=None):
"""Generate random system facts for registration.
:param str name: A valid FQDN for a system. If one is not
provided, then a random value will be generated.
:return: A dictionary with random system facts
:rtype: dict
"""
if name is None:
name = u'{0}.example.net'.format(
gen_alpha().lower())
# Make a copy of the system facts 'template'
new_facts = copy.deepcopy(SYSTEM_FACTS)
# Select a random RHEL version...
distro = gen_choice(DISTRO_IDS)
# ...and update our facts
new_facts['distribution.id'] = distro['id']
new_facts['distribution.version'] = distro['version']
new_facts['dmi.bios.relase_date'] = _bios_date().strftime('%m/%d/%Y')
new_facts['dmi.memory.maximum_capacity'] = gen_choice(
MEMORY_CAPACITY)
new_facts['dmi.memory.size'] = gen_choice(MEMORY_SIZE)
new_facts['dmi.system.uuid'] = gen_uuid()
new_facts['dmi.system.version'] = u'RHEL'
new_facts['lscpu.architecture'] = distro['architecture']
new_facts['net.interface.eth1.hwaddr'] = gen_mac()
new_facts['net.interface.eth1.ipaddr'] = gen_ipaddr()
new_facts['network.hostname'] = name
new_facts['network.ipaddr'] = new_facts['net.interface.eth1.ipaddr']
new_facts['uname.machine'] = distro['architecture']
new_facts['uname.nodename'] = name
new_facts['uname.release'] = distro['kernel']
new_facts['virt.uuid'] = new_facts['dmi.system.uuid']
return new_facts
def create(self):
"""Creates a virtual machine on the libvirt server using
virt-install
:raises robottelo.vm.LibvirtGuestError: Whenever a virtual guest
could not be executed.
"""
if self._created:
return
command_args = [
'virt-install',
'--hvm',
'--network=bridge:{vm_bridge}',
'--mac={vm_mac}',
'--name={vm_name}',
'--ram={vm_ram}',
'--vcpus={vm_cpu}',
'--os-type=linux',
'--os-variant=rhel7',
'--disk path={image_name},size=8',
'--noautoconsole',
]
if not self.boot_iso:
# Required for PXE-based host discovery
command_args.append('--pxe')
else:
# Required for PXE-less host discovery, where we boot the host
# with bootable discovery ISO
self.boot_iso_name = settings.discovery.discovery_iso
boot_iso_dir = u'{0}/{1}'.format(
self.image_dir, self.boot_iso_name)
command_args.append('--cdrom={0}'.format(boot_iso_dir))
if self.extra_nic:
nic_mac = gen_mac(multicast=False, locally=True)
command_args.append('--network=bridge:{vm_bridge}')
command_args.append('--mac={0}'.format(nic_mac))
if self._domain is None:
try:
self._domain = self.libvirt_server.split('.', 1)[1]
except IndexError:
raise LibvirtGuestError(
u"Failed to fetch domain from libvirt server: {0} "
.format(self.libvirt_server))
self.hostname = u'{0}.{1}'.format(self.guest_name, self._domain)
command = u' '.join(command_args).format(
vm_bridge=self.bridge,
vm_mac=self.mac,
vm_name=self.hostname,
vm_ram=self.ram,
vm_cpu=self.cpu,
image_name=u'{0}/{1}.img'.format(self.image_dir, self.hostname)
)
result = ssh.command(command, self.libvirt_server)
if result.return_code != 0:
raise LibvirtGuestError(
u'Failed to run virt-install: {0}'.format(result.stderr))
self._created = True
def test_gen_mac_multicast_locally_administered():
"""Generate a multicast and locally administered MAC address."""
mac = gen_mac(multicast=True, locally=True)
first_octect = int(mac.split(':', 1)[0], 16)
mask = 0b00000011
assert first_octect & mask == 3
def test_gen_mac_multicast_globally_unique():
"""Generate a multicast and globally unique MAC address."""
mac = gen_mac(multicast=True, locally=False)
first_octect = int(mac.split(':', 1)[0], 16)
mask = 0b00000011
assert first_octect & mask == 1
def test_gen_mac_3():
r"""Generate a MAC address using \"-\" as the delimiter."""
result = gen_mac(delimiter='-')
assert len(result.split('-')) == 6
assert MAC.match(result) is not None
def test_gen_mac_5():
r"""Generate a MAC address using \" \" as the delimiter."""
with pytest.raises(ValueError):
gen_mac(delimiter=' ')
def test_gen_mac_6():
"""Generate a MAC address using a number as the delimiter."""
with pytest.raises(ValueError):
gen_mac(delimiter=random.randint(0, 10))
def test_gen_mac_7():
"""Generate a MAC address using a letter as the delimiter."""
with pytest.raises(ValueError):
gen_mac(delimiter=random.choice(string.ascii_letters))
def gen_value(self):
"""Return a value suitable for a :class:`MACAddressField`."""
return gen_mac()
def gen_value(self):
"""Return a value suitable for a :class:`MACAddressField`."""
return gen_mac(multicast=False)
