def test_get_hostname(self):
"""get_hostname() should return the hostname for a given FQDN."""
fqdn = 'foo.bar'
assert get_hostname(fqdn) == 'foo'
fqdn = 'foo.bar.suse.de'
assert get_hostname(fqdn) == 'foo'
fqdn = 'foo.bar.foobar.suse.de'
assert get_hostname(fqdn) == 'foo'
def get_bmc_command(machine, cobbler_path):
if not hasattr(machine, 'bmc') or not machine.bmc:
logger.error("Tried to get bmc command for %s, which does not have one", machine.fqdn)
bmc = machine.bmc
bmc_command = """{cobbler} system edit --name={name} --interface=bmc --interface-type=bmc"""\
.format(cobbler=cobbler_path, name=machine.fqdn)
bmc_command += """ --ip-address="{ip}" --mac="{mac}" --dns-name="{dns}" """.format(
ip=get_ip(bmc.fqdn)[0], mac=bmc.mac, dns=get_hostname(bmc.fqdn))
return bmc_command
def machine_post_init(sender, instance, *args, **kwargs):
"""Post init action for machine. Set non-database saved values here."""
if instance.pk:
try:
instance.hostname = get_hostname(instance.fqdn)
if instance.get_primary_networkinterface():
instance.mac_address = instance.get_primary_networkinterface().mac_address
except Exception as e:
logger.warning("Errors occurred during machine init: '{}': {}".format(instance, e))
def save(self, *args, **kwargs):
"""
Save machine object.
Set FQDN to lower case, check if FQDN is resolvable by DNS and set
domain and enclosure correctly (create if necessary).
"""
self.fqdn = self.fqdn.lower()
if not self.mac_address:
raise ValidationError("'{}' has no MAC address!".format(self))
validate_mac_address(self.mac_address)
# create & assign network domain and ensure that the FQDN always matches the fqdn_domain
domain, created = Domain.objects.get_or_create(
name=get_domain(self.fqdn))
if created:
domain.save()
self.fqdn_domain = domain
# create & assign enclosure according to naming convention if no enclosure given
if not hasattr(self, 'enclosure'):
name = re.split(r'-(\d|sp)+$', get_hostname(self.fqdn))[0]
enclosure, created = Enclosure.objects.get_or_create(name=name)
self.enclosure = enclosure
if isinstance(self.virtualization_api, VirtualizationAPI):
self.virtualization_api = self.virtualization_api.get_type()
super(Machine, self).save(*args, **kwargs)
# check if DHCP needs to be regenerated
if self._original is not None:
try:
assert self.mac_address == self._original.mac_address
assert self.fqdn == self._original.fqdn
assert self.fqdn_domain == self._original.fqdn_domain
assert self.architecture == self._original.architecture
assert self.group == self._original.group
assert self.dhcp_filename == self._original.dhcp_filename
assert self.dhcpv4_write == self._original.dhcpv4_write
assert self.dhcpv6_write == self._original.dhcpv6_write
except AssertionError:
from orthos2.data.signals import signal_cobbler_regenerate
# regenerate DHCP on all domains (deletion/registration) if domain changed
if self.fqdn_domain == self._original.fqdn_domain:
domain_id = self.fqdn_domain.pk
else:
domain_id = None
signal_cobbler_regenerate.send(sender=self.__class__,
domain_id=domain_id)
def save(self, *args, **kwargs):
"""
Save machine object.
Set FQDN to lower case, check if FQDN is resolvable by DNS and set
domain and enclosure correctly (create if necessary).
"""
self.fqdn = self.fqdn.lower()
if not self.mac_address and not self.unknown_mac:
raise ValidationError(
"'{}' You must select 'MAC Unkown' for systems without MAC".
format(self))
if self.mac_address and self.unknown_mac:
raise ValidationError(
"'{}' You must not select 'MAC Unkown' for systems with a MAC".
format(self))
if self.unknown_mac and not self.bmc_allowed():
raise ValidationError(
"You may only skip the MAC for systems with BMC")
if self.mac_address:
validate_mac_address(self.mac_address)
if not self.system.virtual and self.hypervisor:
raise ValidationError("Only virtual machines may have hypervisors")
if hasattr(self, 'bmc') and not self.bmc_allowed():
raise ValidationError("{} systems cannot use a BMC".format(
self.system.name))
# create & assign network domain and ensure that the FQDN always matches the fqdn_domain
domain, created = Domain.objects.get_or_create(
name=get_domain(self.fqdn))
if created:
domain.save()
self.fqdn_domain = domain
# create & assign enclosure according to naming convention if no enclosure given
if not hasattr(self, 'enclosure'):
name = re.split(r'-(\d|sp)+$', get_hostname(self.fqdn))[0]
enclosure, created = Enclosure.objects.get_or_create(name=name)
self.enclosure = enclosure
super(Machine, self).save(*args, **kwargs)
# check if DHCP needs to be regenerated
if self._original is not None:
try:
assert self.mac_address == self._original.mac_address
assert self.fqdn == self._original.fqdn
assert self.fqdn_domain == self._original.fqdn_domain
assert self.architecture == self._original.architecture
assert self.group == self._original.group
assert self.dhcp_filename == self._original.dhcp_filename
assert self.kernel_options == self._original.kernel_options
if self.has_remotepower():
assert hasattr(self._original, 'remotepower')
assert self.remotepower.fence_name == self._original.remotepower.fence_name
assert self.remotepower.options == self._original.remotepower.options
if hasattr(self.remotepower, 'remote_power_device'):
assert hasattr(self._original.remotepower,
'remote_power_device')
assert self.remotepower.remote_power_device == \
self._original.remotepower.remote_power_device
if hasattr(self, 'bmc'):
assert hasattr(self._original, 'bmc')
assert self.bmc.username == self._original.bmc.username
assert self.bmc.password == self._original.bmc.password
assert self.bmc.mac == self._original.bmc.mac
assert self.bmc.fqdn == self._original.bmc.fqdn
if self.has_serialconsole():
assert hasattr(self._original, 'serialconsole')
assert self.serialconsole.baud_rate == self._original.serialconsole.baud_rate
assert self.serialconsole.kernel_device_num == \
self._original.serialconsole.kernel_device_num
except AssertionError:
if ServerConfig.objects.bool_by_key("orthos.cobblersync.full"):
from orthos2.data.signals import signal_cobbler_regenerate
# regenerate DHCP on all domains (deletion/registration) if domain changed
if self.fqdn_domain == self._original.fqdn_domain:
domain_id = self.fqdn_domain.pk
else:
domain_id = None
signal_cobbler_regenerate.send(sender=self.__class__,
domain_id=domain_id)
else:
from orthos2.data.signals import signal_cobbler_machine_update
if self.fqdn_domain == self._original.fqdn_domain:
domain_id = self.fqdn_domain.pk
machine_id = self.pk
signal_cobbler_machine_update.send(
sender=self.__class__,
domain_id=domain_id,
machine_id=machine_id)
else:
raise NotImplementedError(
"Moving machines between domains with quick cobbler synchronization "
"is not implemented yet")
def save(self, *args, **kwargs):
"""
Save machine object.
Set FQDN to lower case, check if FQDN is resolvable by DNS and set
domain and enclosure correctly (create if necessary).
"""
self.fqdn = self.fqdn.lower()
if not self.mac_address:
raise ValidationError("'{}' has no MAC address!".format(self))
validate_mac_address(self.mac_address)
if not self.system.virtual and self.hypervisor:
raise ValidationError("Only virtuals machines may have hypervisors")
if self.system.virtual and self.use_bmc:
raise ValidationError("Virtual machines can not use a BMC")
# create & assign network domain and ensure that the FQDN always matches the fqdn_domain
domain, created = Domain.objects.get_or_create(name=get_domain(self.fqdn))
if created:
domain.save()
self.fqdn_domain = domain
# create & assign enclosure according to naming convention if no enclosure given
if not hasattr(self, 'enclosure'):
name = re.split(r'-(\d|sp)+$', get_hostname(self.fqdn))[0]
enclosure, created = Enclosure.objects.get_or_create(name=name)
self.enclosure = enclosure
if isinstance(self.virtualization_api, VirtualizationAPI):
self.virtualization_api = self.virtualization_api.get_type()
super(Machine, self).save(*args, **kwargs)
# check if DHCP needs to be regenerated
if self._original is not None:
try:
assert self.mac_address == self._original.mac_address
assert self.fqdn == self._original.fqdn
assert self.fqdn_domain == self._original.fqdn_domain
assert self.architecture == self._original.architecture
assert self.group == self._original.group
assert self.dhcp_filename == self._original.dhcp_filename
assert self.dhcpv4_write == self._original.dhcpv4_write
assert self.dhcpv6_write == self._original.dhcpv6_write
except AssertionError:
if ServerConfig.bool_by_key("orthos.cobblersync.full"):
from orthos2.data.signals import signal_cobbler_regenerate
# regenerate DHCP on all domains (deletion/registration) if domain changed
if self.fqdn_domain == self._original.fqdn_domain:
domain_id = self.fqdn_domain.pk
else:
domain_id = None
signal_cobbler_regenerate.send(sender=self.__class__, domain_id=domain_id)
else:
from orthos2.data.signals import signal_cobbler_machine_update
if self.fqdn_domain == self._original.fqdn_domain:
domain_id = self.fqdn_domain.pk
machine_id = self.pk
signal_cobbler_machine_update.send(
sender=self.__class__, domain_id=domain_id, machine_id=machine_id)
else:
raise NotImplementedError(
"Moving machines between domains with quick cobbler synchronization "
"is not implemented yet")