def render(self, session, logger, machine, dbuser, **arguments):
dbmachine = Machine.get_unique(session, machine, compel=True)
remove_plenaries = PlenaryCollection(logger=logger)
remove_plenaries.append(Plenary.get_plenary(dbmachine))
if dbmachine.vm_container:
remove_plenaries.append(Plenary.get_plenary(
dbmachine.vm_container))
dbcontainer = dbmachine.vm_container.holder.holder_object
else:
dbcontainer = None
if dbmachine.host:
raise ArgumentError("{0} is still in use by {1:l} and cannot be "
"deleted.".format(dbmachine, dbmachine.host))
addrs = []
for addr in dbmachine.all_addresses():
addrs.append("%s: %s" % (addr.logical_name, addr.ip))
if addrs:
addrmsg = ", ".join(addrs)
raise ArgumentError("{0} still provides the following addresses, "
"delete them first: {1}.".format(
dbmachine, addrmsg))
session.delete(dbmachine)
session.flush()
key = remove_plenaries.get_remove_key()
if dbcontainer:
plenary_container = Plenary.get_plenary(dbcontainer, logger=logger)
key = CompileKey.merge([key, plenary_container.get_write_key()])
try:
lock_queue.acquire(key)
remove_plenaries.stash()
if dbcontainer:
plenary_container.write(locked=True)
remove_plenaries.remove(locked=True)
except:
remove_plenaries.restore_stash()
if dbcontainer:
plenary_container.restore_stash()
raise
finally:
lock_queue.release(key)
return
def render(self, session, logger, machine, dbuser, **arguments):
dbmachine = Machine.get_unique(session, machine, compel=True)
remove_plenaries = PlenaryCollection(logger=logger)
remove_plenaries.append(Plenary.get_plenary(dbmachine))
if dbmachine.vm_container:
remove_plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
dbcontainer = dbmachine.vm_container.holder.holder_object
else:
dbcontainer = None
if dbmachine.host:
raise ArgumentError("{0} is still in use by {1:l} and cannot be "
"deleted.".format(dbmachine, dbmachine.host))
addrs = []
for addr in dbmachine.all_addresses():
addrs.append("%s: %s" % (addr.logical_name, addr.ip))
if addrs:
addrmsg = ", ".join(addrs)
raise ArgumentError("{0} still provides the following addresses, "
"delete them first: {1}.".format(dbmachine,
addrmsg))
session.delete(dbmachine)
session.flush()
key = remove_plenaries.get_remove_key()
if dbcontainer:
plenary_container = Plenary.get_plenary(dbcontainer, logger=logger)
key = CompileKey.merge([key, plenary_container.get_write_key()])
try:
lock_queue.acquire(key)
remove_plenaries.stash()
if dbcontainer:
plenary_container.write(locked=True)
remove_plenaries.remove(locked=True)
except:
remove_plenaries.restore_stash()
if dbcontainer:
plenary_container.restore_stash()
raise
finally:
lock_queue.release(key)
return
def del_cluster(session, logger, dbcluster, config):
cluster = str(dbcluster.name)
if hasattr(dbcluster, 'members') and dbcluster.members:
raise ArgumentError("%s is still in use by clusters: %s." %
(format(dbcluster),
", ".join([c.name for c in dbcluster.members])))
elif dbcluster.hosts:
hosts = ", ".join([h.fqdn for h in dbcluster.hosts])
raise ArgumentError("%s is still in use by hosts: %s." %
(format(dbcluster), hosts))
cluster_plenary = Plenary.get_plenary(dbcluster, logger=logger)
resources = PlenaryCollection(logger=logger)
if dbcluster.resholder:
for res in dbcluster.resholder.resources:
resources.append(Plenary.get_plenary(res))
domain = dbcluster.branch.name
session.delete(dbcluster)
session.flush()
key = cluster_plenary.get_remove_key()
with CompileKey.merge([key, resources.get_remove_key()]):
cluster_plenary.cleanup(domain, locked=True)
# And we also want to remove the profile itself
profiles = config.get("broker", "profilesdir")
# Only one of these should exist, but it doesn't hurt
# to try to clean up both.
xmlfile = os.path.join(profiles, "clusters", cluster + ".xml")
remove_file(xmlfile, logger=logger)
xmlgzfile = xmlfile + ".gz"
remove_file(xmlgzfile, logger=logger)
# And the cached template created by ant
remove_file(os.path.join(config.get("broker",
"quattordir"),
"objects", "clusters",
cluster + TEMPLATE_EXTENSION),
logger=logger)
resources.remove(locked=True)
build_index(config, session, profiles, logger=logger)
return
def del_cluster(session, logger, dbcluster, config):
cluster = str(dbcluster.name)
if hasattr(dbcluster, 'members') and dbcluster.members:
raise ArgumentError(
"%s is still in use by clusters: %s." %
(format(dbcluster), ", ".join([c.name
for c in dbcluster.members])))
elif dbcluster.hosts:
hosts = ", ".join([h.fqdn for h in dbcluster.hosts])
raise ArgumentError("%s is still in use by hosts: %s." %
(format(dbcluster), hosts))
cluster_plenary = Plenary.get_plenary(dbcluster, logger=logger)
resources = PlenaryCollection(logger=logger)
if dbcluster.resholder:
for res in dbcluster.resholder.resources:
resources.append(Plenary.get_plenary(res))
domain = dbcluster.branch.name
session.delete(dbcluster)
session.flush()
key = cluster_plenary.get_remove_key()
with CompileKey.merge([key, resources.get_remove_key()]):
cluster_plenary.cleanup(domain, locked=True)
# And we also want to remove the profile itself
profiles = config.get("broker", "profilesdir")
# Only one of these should exist, but it doesn't hurt
# to try to clean up both.
xmlfile = os.path.join(profiles, "clusters", cluster + ".xml")
remove_file(xmlfile, logger=logger)
xmlgzfile = xmlfile + ".gz"
remove_file(xmlgzfile, logger=logger)
# And the cached template created by ant
remove_file(os.path.join(config.get("broker", "quattordir"), "objects",
"clusters", cluster + TEMPLATE_EXTENSION),
logger=logger)
resources.remove(locked=True)
build_index(config, session, profiles, logger=logger)
return
def render(self, session, logger, machine, model, vendor, serial,
chassis, slot, clearchassis, multislot,
vmhost, cluster, allow_metacluster_change,
cpuname, cpuvendor, cpuspeed, cpucount, memory, ip,
**arguments):
dbmachine = Machine.get_unique(session, machine, compel=True)
plenaries = PlenaryCollection(logger=logger)
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
if clearchassis:
del dbmachine.chassis_slot[:]
remove_plenaries = PlenaryCollection(logger=logger)
if chassis:
dbchassis = Chassis.get_unique(session, chassis, compel=True)
if machine_plenary_will_move(old=dbmachine.location,
new=dbchassis.location):
remove_plenaries.append(Plenary.get_plenary(dbmachine))
dbmachine.location = dbchassis.location
if slot is None:
raise ArgumentError("Option --chassis requires --slot "
"information.")
self.adjust_slot(session, logger,
dbmachine, dbchassis, slot, multislot)
elif slot is not None:
dbchassis = None
for dbslot in dbmachine.chassis_slot:
if dbchassis and dbslot.chassis != dbchassis:
raise ArgumentError("Machine in multiple chassis, please "
"use --chassis argument.")
dbchassis = dbslot.chassis
if not dbchassis:
raise ArgumentError("Option --slot requires --chassis "
"information.")
self.adjust_slot(session, logger,
dbmachine, dbchassis, slot, multislot)
dblocation = get_location(session, **arguments)
if dblocation:
loc_clear_chassis = False
for dbslot in dbmachine.chassis_slot:
dbcl = dbslot.chassis.location
if dbcl != dblocation:
if chassis or slot is not None:
raise ArgumentError("{0} conflicts with chassis {1!s} "
"location {2}.".format(dblocation,
dbslot.chassis, dbcl))
else:
loc_clear_chassis = True
if loc_clear_chassis:
del dbmachine.chassis_slot[:]
if machine_plenary_will_move(old=dbmachine.location,
new=dblocation):
remove_plenaries.append(Plenary.get_plenary(dbmachine))
dbmachine.location = dblocation
if model or vendor:
# If overriding model, should probably overwrite default
# machine specs as well.
if not model:
model = dbmachine.model.name
if not vendor:
vendor = dbmachine.model.vendor.name
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
compel=True)
if dbmodel.machine_type not in ['blade', 'rackmount',
'workstation', 'aurora_node',
'virtual_machine']:
raise ArgumentError("The update_machine command cannot update "
"machines of type %s." %
dbmodel.machine_type)
# We probably could do this by forcing either cluster or
# location data to be available as appropriate, but really?
# Failing seems reasonable.
if dbmodel.machine_type != dbmachine.model.machine_type and \
'virtual_machine' in [dbmodel.machine_type,
dbmachine.model.machine_type]:
raise ArgumentError("Cannot change machine from %s to %s." %
(dbmachine.model.machine_type,
dbmodel.machine_type))
old_nic_model = dbmachine.model.nic_model
new_nic_model = dbmodel.nic_model
if old_nic_model != new_nic_model:
for iface in dbmachine.interfaces:
if iface.model == old_nic_model:
iface.model = new_nic_model
dbmachine.model = dbmodel
if cpuname or cpuvendor or cpuspeed is not None:
dbcpu = Cpu.get_unique(session, name=cpuname, vendor=cpuvendor,
speed=cpuspeed, compel=True)
dbmachine.cpu = dbcpu
if cpucount is not None:
dbmachine.cpu_quantity = cpucount
if memory is not None:
dbmachine.memory = memory
if serial:
dbmachine.serial_no = serial
if ip:
update_primary_ip(session, dbmachine, ip)
# FIXME: For now, if a machine has its interface(s) in a portgroup
# this command will need to be followed by an update_interface to
# re-evaluate the portgroup for overflow.
# It would be better to have --pg and --autopg options to let it
# happen at this point.
if cluster or vmhost:
if not dbmachine.vm_container:
raise ArgumentError("Cannot convert a physical machine to "
"virtual.")
old_holder = dbmachine.vm_container.holder.holder_object
resholder = get_resource_holder(session, hostname=vmhost,
cluster=cluster, compel=False)
new_holder = resholder.holder_object
# TODO: do we want to allow moving machines between the cluster and
# metacluster level?
if new_holder.__class__ != old_holder.__class__:
raise ArgumentError("Cannot move a VM between a cluster and a "
"stand-alone host.")
if cluster:
if new_holder.metacluster != old_holder.metacluster \
and not allow_metacluster_change:
raise ArgumentError("Current {0:l} does not match "
"new {1:l}."
.format(old_holder.metacluster,
new_holder.metacluster))
remove_plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
dbmachine.vm_container.holder = resholder
for dbdisk in dbmachine.disks:
if not isinstance(dbdisk, VirtualDisk):
continue
old_share = dbdisk.share
if isinstance(old_share.holder, BundleResource):
resourcegroup = old_share.holder.name
else:
resourcegroup = None
new_share = find_share(new_holder, resourcegroup, old_share.name,
error=ArgumentError)
# If the shares are registered at the metacluster level and both
# clusters are in the same metacluster, then there will be no
# real change here
if new_share != old_share:
old_share.disks.remove(dbdisk)
new_share.disks.append(dbdisk)
if isinstance(new_holder, Cluster):
dbmachine.location = new_holder.location_constraint
else:
dbmachine.location = new_holder.location
session.flush()
plenaries.append(Plenary.get_plenary(old_holder))
plenaries.append(Plenary.get_plenary(new_holder))
if dbmachine.vm_container:
plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
session.flush()
# Check if the changed parameters still meet cluster capacity
# requiremets
if dbmachine.cluster:
dbmachine.cluster.validate()
if allow_metacluster_change:
dbmachine.cluster.metacluster.validate()
if dbmachine.host and dbmachine.host.cluster:
dbmachine.host.cluster.validate()
# The check to make sure a plenary file is not written out for
# dummy aurora hardware is within the call to write(). This way
# it is consistent without altering (and forgetting to alter)
# all the calls to the method.
plenaries.append(Plenary.get_plenary(dbmachine))
if remove_plenaries.plenaries and dbmachine.host:
plenaries.append(Plenary.get_plenary(dbmachine.host))
key = CompileKey.merge([plenaries.get_write_key(),
remove_plenaries.get_remove_key()])
try:
lock_queue.acquire(key)
remove_plenaries.stash()
plenaries.write(locked=True)
remove_plenaries.remove(locked=True)
if dbmachine.host:
# XXX: May need to reconfigure.
pass
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not update machine in DSDB")
except:
plenaries.restore_stash()
remove_plenaries.restore_stash()
raise
finally:
lock_queue.release(key)
return
def render(
self,
session,
logger,
cluster,
personality,
max_members,
fix_location,
down_hosts_threshold,
maint_threshold,
comments,
# ESX specific options
switch,
memory_capacity,
clear_overrides,
vm_to_host_ratio,
**arguments):
dbcluster = Cluster.get_unique(session, cluster, compel=True)
if dbcluster.cluster_type == 'meta':
raise ArgumentError("%s should not be a metacluster." %
format(dbcluster))
cluster_updated = False
remove_plenaries = PlenaryCollection(logger=logger)
plenaries = PlenaryCollection(logger=logger)
(vm_count, host_count) = force_ratio("vm_to_host_ratio",
vm_to_host_ratio)
if down_hosts_threshold is not None:
(perc, dht) = Cluster.parse_threshold(down_hosts_threshold)
dbcluster.down_hosts_threshold = dht
dbcluster.down_hosts_percent = perc
cluster_updated = True
if dbcluster.cluster_type == "esx":
if vm_count is not None or down_hosts_threshold is not None:
if vm_count is None:
vm_count = dbcluster.vm_count
host_count = dbcluster.host_count
dht = dbcluster.down_hosts_threshold
perc = dbcluster.down_hosts_percent
dbcluster.validate(vm_part=vm_count,
host_part=host_count,
down_hosts_threshold=dht,
down_hosts_percent=perc)
dbcluster.vm_count = vm_count
dbcluster.host_count = host_count
cluster_updated = True
if switch is not None:
if switch:
# FIXME: Verify that any hosts are on the same network
dbswitch = Switch.get_unique(session, switch, compel=True)
plenaries.append(Plenary.get_plenary(dbswitch))
else:
dbswitch = None
dbcluster.switch = dbswitch
cluster_updated = True
if memory_capacity is not None:
dbcluster.memory_capacity = memory_capacity
dbcluster.validate()
cluster_updated = True
if clear_overrides is not None:
dbcluster.memory_capacity = None
dbcluster.validate()
cluster_updated = True
location_updated = update_cluster_location(session, logger, dbcluster,
fix_location, plenaries,
remove_plenaries,
**arguments)
if location_updated:
cluster_updated = True
if personality:
archetype = dbcluster.personality.archetype.name
dbpersonality = Personality.get_unique(session,
name=personality,
archetype=archetype,
compel=True)
if not dbpersonality.is_cluster:
raise ArgumentError("Personality {0} is not a cluster " +
"personality".format(dbpersonality))
dbcluster.personality = dbpersonality
cluster_updated = True
if max_members is not None:
current_members = len(dbcluster.hosts)
if max_members < current_members:
raise ArgumentError(
"%s has %d hosts bound, which exceeds "
"the requested limit %d." %
(format(dbcluster), current_members, max_members))
dbcluster.max_hosts = max_members
cluster_updated = True
if comments is not None:
dbcluster.comments = comments
cluster_updated = True
if down_hosts_threshold is not None:
(dbcluster.down_hosts_percent,
dbcluster.down_hosts_threshold) = \
Cluster.parse_threshold(down_hosts_threshold)
cluster_updated = True
if maint_threshold is not None:
(dbcluster.down_maint_percent,
dbcluster.down_maint_threshold) = \
Cluster.parse_threshold(maint_threshold)
cluster_updated = True
if not cluster_updated:
return
session.add(dbcluster)
session.flush()
plenaries.append(Plenary.get_plenary(dbcluster))
key = CompileKey.merge(
[plenaries.get_write_key(),
remove_plenaries.get_remove_key()])
try:
lock_queue.acquire(key)
remove_plenaries.stash()
plenaries.write(locked=True)
remove_plenaries.remove(locked=True)
except:
remove_plenaries.restore_stash()
plenaries.restore_stash()
raise
finally:
lock_queue.release(key)
return
def render(self, session, logger, hostname, **arguments):
# removing the plenary host requires a compile lock, however
# we want to avoid deadlock by the fact that we're messing
# with two locks here, so we want to be careful. We grab the
# plenaryhost early on (in order to get the filenames filled
# in from the db info before we delete it from the db. We then
# hold onto those references until we've completed the db
# cleanup and if all of that is successful, then we delete the
# plenary file (which doesn't require re-evaluating any stale
# db information) after we've released the delhost lock.
delplenary = False
# Any service bindings that we need to clean up afterwards
bindings = PlenaryCollection(logger=logger)
resources = PlenaryCollection(logger=logger)
with DeleteKey("system", logger=logger) as key:
# Check dependencies, translate into user-friendly message
dbhost = hostname_to_host(session, hostname)
host_plenary = Plenary.get_plenary(dbhost, logger=logger)
domain = dbhost.branch.name
deps = get_host_dependencies(session, dbhost)
if (len(deps) != 0):
deptext = "\n".join([" %s" % d for d in deps])
raise ArgumentError("Cannot delete host %s due to the "
"following dependencies:\n%s." %
(hostname, deptext))
archetype = dbhost.archetype.name
dbmachine = dbhost.machine
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
ip = dbmachine.primary_ip
fqdn = dbmachine.fqdn
for si in dbhost.services_used:
plenary = PlenaryServiceInstanceServer(si)
bindings.append(plenary)
logger.info("Before deleting host '%s', removing binding '%s'"
% (fqdn, si.cfg_path))
del dbhost.services_used[:]
if dbhost.resholder:
for res in dbhost.resholder.resources:
resources.append(Plenary.get_plenary(res))
# In case of Zebra, the IP may be configured on multiple interfaces
for iface in dbmachine.interfaces:
if ip in iface.addresses:
iface.addresses.remove(ip)
if dbhost.cluster:
dbcluster = dbhost.cluster
dbcluster.hosts.remove(dbhost)
set_committed_value(dbhost, '_cluster', None)
dbcluster.validate()
dbdns_rec = dbmachine.primary_name
dbmachine.primary_name = None
dbmachine.host = None
session.delete(dbhost)
delete_dns_record(dbdns_rec)
session.flush()
delplenary = True
if dbmachine.vm_container:
bindings.append(Plenary.get_plenary(dbmachine.vm_container))
if archetype != 'aurora' and ip is not None:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not remove host %s from "
"DSDB" % hostname)
if archetype == 'aurora':
logger.client_info("WARNING: removing host %s from AQDB and "
"*not* changing DSDB." % hostname)
# Past the point of no return... commit the transaction so
# that we can free the delete lock.
session.commit()
# Only if we got here with no exceptions do we clean the template
# Trying to clean up after any errors here is really difficult
# since the changes to dsdb have already been made.
if (delplenary):
key = host_plenary.get_remove_key()
with CompileKey.merge([key, bindings.get_write_key(),
resources.get_remove_key()]) as key:
host_plenary.cleanup(domain, locked=True)
# And we also want to remove the profile itself
profiles = self.config.get("broker", "profilesdir")
# Only one of these should exist, but it doesn't hurt
# to try to clean up both.
xmlfile = os.path.join(profiles, fqdn + ".xml")
remove_file(xmlfile, logger=logger)
xmlgzfile = xmlfile + ".gz"
remove_file(xmlgzfile, logger=logger)
# And the cached template created by ant
remove_file(os.path.join(self.config.get("broker",
"quattordir"),
"objects", fqdn + TEMPLATE_EXTENSION),
logger=logger)
bindings.write(locked=True)
resources.remove(locked=True)
build_index(self.config, session, profiles, logger=logger)
return
def render(self, session, logger, cluster, personality,
max_members, fix_location, down_hosts_threshold,
maint_threshold, comments,
# ESX specific options
switch, memory_capacity, clear_overrides, vm_to_host_ratio,
**arguments):
dbcluster = Cluster.get_unique(session, cluster, compel=True)
if dbcluster.cluster_type == 'meta':
raise ArgumentError("%s should not be a metacluster."
% format(dbcluster))
cluster_updated = False
remove_plenaries = PlenaryCollection(logger=logger)
plenaries = PlenaryCollection(logger=logger)
(vm_count, host_count) = force_ratio("vm_to_host_ratio",
vm_to_host_ratio)
if down_hosts_threshold is not None:
(perc, dht) = Cluster.parse_threshold(down_hosts_threshold)
dbcluster.down_hosts_threshold = dht
dbcluster.down_hosts_percent = perc
cluster_updated = True
if dbcluster.cluster_type == "esx":
if vm_count is not None or down_hosts_threshold is not None:
if vm_count is None:
vm_count = dbcluster.vm_count
host_count = dbcluster.host_count
dht = dbcluster.down_hosts_threshold
perc = dbcluster.down_hosts_percent
dbcluster.validate(vm_part=vm_count, host_part=host_count,
down_hosts_threshold=dht,
down_hosts_percent=perc)
dbcluster.vm_count = vm_count
dbcluster.host_count = host_count
cluster_updated = True
if switch is not None:
if switch:
# FIXME: Verify that any hosts are on the same network
dbswitch = Switch.get_unique(session, switch, compel=True)
plenaries.append(Plenary.get_plenary(dbswitch))
else:
dbswitch = None
dbcluster.switch = dbswitch
cluster_updated = True
if memory_capacity is not None:
dbcluster.memory_capacity = memory_capacity
dbcluster.validate()
cluster_updated = True
if clear_overrides is not None:
dbcluster.memory_capacity = None
dbcluster.validate()
cluster_updated = True
location_updated = update_cluster_location(session, logger,
dbcluster, fix_location,
plenaries, remove_plenaries,
**arguments)
if location_updated:
cluster_updated = True
if personality:
archetype = dbcluster.personality.archetype.name
dbpersonality = Personality.get_unique(session, name=personality,
archetype=archetype,
compel=True)
if not dbpersonality.is_cluster:
raise ArgumentError("Personality {0} is not a cluster " +
"personality".format(dbpersonality))
dbcluster.personality = dbpersonality
cluster_updated = True
if max_members is not None:
current_members = len(dbcluster.hosts)
if max_members < current_members:
raise ArgumentError("%s has %d hosts bound, which exceeds "
"the requested limit %d." %
(format(dbcluster), current_members,
max_members))
dbcluster.max_hosts = max_members
cluster_updated = True
if comments is not None:
dbcluster.comments = comments
cluster_updated = True
if down_hosts_threshold is not None:
(dbcluster.down_hosts_percent,
dbcluster.down_hosts_threshold) = \
Cluster.parse_threshold(down_hosts_threshold)
cluster_updated = True
if maint_threshold is not None:
(dbcluster.down_maint_percent,
dbcluster.down_maint_threshold) = \
Cluster.parse_threshold(maint_threshold)
cluster_updated = True
if not cluster_updated:
return
session.add(dbcluster)
session.flush()
plenaries.append(Plenary.get_plenary(dbcluster))
key = CompileKey.merge([plenaries.get_write_key(),
remove_plenaries.get_remove_key()])
try:
lock_queue.acquire(key)
remove_plenaries.stash()
plenaries.write(locked=True)
remove_plenaries.remove(locked=True)
except:
remove_plenaries.restore_stash()
plenaries.restore_stash()
raise
finally:
lock_queue.release(key)
return
def render(self, session, logger, hostname, **arguments):
# removing the plenary host requires a compile lock, however
# we want to avoid deadlock by the fact that we're messing
# with two locks here, so we want to be careful. We grab the
# plenaryhost early on (in order to get the filenames filled
# in from the db info before we delete it from the db. We then
# hold onto those references until we've completed the db
# cleanup and if all of that is successful, then we delete the
# plenary file (which doesn't require re-evaluating any stale
# db information) after we've released the delhost lock.
delplenary = False
# Any service bindings that we need to clean up afterwards
bindings = PlenaryCollection(logger=logger)
resources = PlenaryCollection(logger=logger)
with DeleteKey("system", logger=logger) as key:
# Check dependencies, translate into user-friendly message
dbhost = hostname_to_host(session, hostname)
host_plenary = Plenary.get_plenary(dbhost, logger=logger)
domain = dbhost.branch.name
deps = get_host_dependencies(session, dbhost)
if (len(deps) != 0):
deptext = "\n".join([" %s" % d for d in deps])
raise ArgumentError("Cannot delete host %s due to the "
"following dependencies:\n%s." %
(hostname, deptext))
archetype = dbhost.archetype.name
dbmachine = dbhost.machine
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
ip = dbmachine.primary_ip
fqdn = dbmachine.fqdn
for si in dbhost.services_used:
plenary = PlenaryServiceInstanceServer(si)
bindings.append(plenary)
logger.info(
"Before deleting host '%s', removing binding '%s'" %
(fqdn, si.cfg_path))
del dbhost.services_used[:]
if dbhost.resholder:
for res in dbhost.resholder.resources:
resources.append(Plenary.get_plenary(res))
# In case of Zebra, the IP may be configured on multiple interfaces
for iface in dbmachine.interfaces:
if ip in iface.addresses:
iface.addresses.remove(ip)
if dbhost.cluster:
dbcluster = dbhost.cluster
dbcluster.hosts.remove(dbhost)
set_committed_value(dbhost, '_cluster', None)
dbcluster.validate()
dbdns_rec = dbmachine.primary_name
dbmachine.primary_name = None
dbmachine.host = None
session.delete(dbhost)
delete_dns_record(dbdns_rec)
session.flush()
delplenary = True
if dbmachine.vm_container:
bindings.append(Plenary.get_plenary(dbmachine.vm_container))
if archetype != 'aurora' and ip is not None:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not remove host %s from "
"DSDB" % hostname)
if archetype == 'aurora':
logger.client_info("WARNING: removing host %s from AQDB and "
"*not* changing DSDB." % hostname)
# Past the point of no return... commit the transaction so
# that we can free the delete lock.
session.commit()
# Only if we got here with no exceptions do we clean the template
# Trying to clean up after any errors here is really difficult
# since the changes to dsdb have already been made.
if (delplenary):
key = host_plenary.get_remove_key()
with CompileKey.merge(
[key,
bindings.get_write_key(),
resources.get_remove_key()]) as key:
host_plenary.cleanup(domain, locked=True)
# And we also want to remove the profile itself
profiles = self.config.get("broker", "profilesdir")
# Only one of these should exist, but it doesn't hurt
# to try to clean up both.
xmlfile = os.path.join(profiles, fqdn + ".xml")
remove_file(xmlfile, logger=logger)
xmlgzfile = xmlfile + ".gz"
remove_file(xmlgzfile, logger=logger)
# And the cached template created by ant
remove_file(os.path.join(
self.config.get("broker", "quattordir"), "objects",
fqdn + TEMPLATE_EXTENSION),
logger=logger)
bindings.write(locked=True)
resources.remove(locked=True)
build_index(self.config, session, profiles, logger=logger)
return
