def get_credentials(self):
"""
Return username and password for a login on the switching device
Use Values from the approrpriate device object, If they don't exist
fall back to the server config. If that does not exist either, raise an
exception.
Returns a Tuple (username, password)
"""
password = None
username = None
fence = RemotePowerType.from_fence(self.fence_name)
if fence.device == "bmc":
username = self.management_bmc.username
password = self.management_bmc.password
elif fence.device == "rpower_device":
username = self.remote_power_device.username
password = self.remote_power_device.password
if not username:
username = ServerConfig.objects.by_key('remotepower.default.username')
if not password:
password = ServerConfig.objects.by_key('remotepower.default.password')
if not username:
raise ValueError("Username not available")
if not password:
raise ValueError("Password not available")
return username, password
def change_view(self, request, object_id, form_url='', extra_context=None):
"""Return changes view with inlines for non-administrative systems."""
machine = Machine.objects.get(pk=object_id)
fence = None
if machine.has_remotepower():
fence = RemotePowerType.from_fence(machine.remotepower.fence_name)
if not self.get_object(request, object_id):
messages.add_message(request,
messages.ERROR,
'You are not allowed to edit this machine!',
extra_tags='error')
self.inlines = (NetworkInterfaceInline, SerialConsoleInline)
if machine.bmc_allowed():
self.inlines += (BMCInline, )
if hasattr(machine, 'bmc'):
if not fence or fence.device == "bmc":
self.inlines += (RemotePowerInlineBMC, )
if machine.is_virtual_machine():
self.inlines += (RemotePowerInlineHypervisor, )
else:
# Only show rpower device to add/modify if we do not
# have one yet or if it's a rpower_device already
if not fence or fence.device == "rpower_device":
self.inlines += (RemotePowerInlineRpower, )
if not machine.system.administrative:
self.inlines += (AnnotationInline, )
return super(MachineAdmin, self).change_view(request, object_id,
form_url, extra_context)
def get_power_address(self):
logging.debug("getting fence object for %s in get_power_adress", self.fence_name)
fence = RemotePowerType.from_fence(self.fence_name)
if fence.device == "bmc":
return self.management_bmc.fqdn
if fence.device == "rpower_device":
return self.remote_power_device.fqdn
if fence.device == "hypervisor":
return self.hypervisor.fqdn
def clean(self):
"""
Check for every remote power type if all required fields are set and deletes unutilized
values.
"""
errors = []
self.fence_name = self._get_remotepower_fence_name()
logging.debug("getting fence object for %s", self.fence_name)
fence = RemotePowerType.from_fence(self.fence_name)
if fence.device == "rpower_device":
if self.remote_power_device:
self.fence_name = self.remote_power_device.fence_name
self.management_bmc = None
self.hypervisor = None
else:
errors.append(ValidationError("Please provide a remote power device!"))
elif fence.device == "bmc":
if self.machine.bmc:
self.management_bmc = self.machine.bmc
self.fence_name = self.management_bmc.fence_name
self.hypervisor = None
self.remote_power_device = None
else:
errors.append(ValidationError("The machine needs to have an associated BMC"))
elif fence.device == "hypervisor":
if not self.machine.hypervisor:
errors.append(ValidationError("No hypervisor found!"))
else:
self.hypervisor = self.machine.hypervisor
self.management_bmc = None
self.remote_power_device = None
else:
errors.append(ValidationError(
"{} is not a valid switching device".format(fence['switching_device'])))
if fence.use_port:
if self.port is None: # test for None, as port may be 0
errors.append(ValidationError("Please provide a port!"))
else:
self.port = None
if errors:
raise ValidationError(errors)
def get_power_options(machine):
if not machine.remotepower:
logger.error("machine %s has no remotepower", machine.fqdn)
raise ValueError("machine {0} has no remotepower".format(machine.fqdn))
remotepower = machine.remotepower
fence = RemotePowerType.from_fence(remotepower.fence_name)
options = " --power-type={} ".format(fence.fence)
if fence.use_identity_file:
options += " --power-user={user} --power-identity-file={key}".format(
user=fence.username, key=fence.identity_file)
else:
username, password = remotepower.get_credentials()
options += " --power-user={username} --power-pass={password} ".format(username=username,
password=password)
if fence.use_port:
options += " --power-id={port}".format(port=remotepower.port)
elif fence.device == "hypervisor":
options += " --power-id={name}".format(name=machine.hostname)
options += " --power-address={address}".format(address=remotepower.get_power_address())
if fence.options:
options += " --power-options={options}".format(options=fence.options)
return options
def __str__(self):
logging.debug("getting fence object for %s in __str___", self.fence_name)
fence = RemotePowerType.from_fence(self.fence_name)
return fence.fence + "@" + fence.device
def name(self):
if self.fence_name is None:
return None
logging.debug("getting fence object for %s", self.fence_name)
return str(RemotePowerType.from_fence(self.fence_name).device)