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 refresh_windows_hosts(self, session, logger, containers):
conn = sqlite3.connect(self.config.get("broker", "windows_host_info"))
# Enable dictionary-style access to the rows.
conn.row_factory = sqlite3.Row
windows_hosts = {}
interfaces = {}
cur = conn.cursor()
# There are more fields in the dataset like machine and
# aqhostname that might be useful for error messages but these
# are sufficient.
cur.execute("select ether, windowshostname from machines")
for row in cur:
host = row["windowshostname"]
if host:
host = host.strip().lower()
else:
continue
mac = row["ether"]
if mac:
mac = mac.strip().lower()
windows_hosts[host] = mac
interfaces[mac] = host
success = []
failed = []
q = session.query(Host)
q = q.filter_by(comments='Created by refresh_windows_host')
for dbhost in q.all():
mac_addresses = [iface.mac for iface in dbhost.machine.interfaces]
if dbhost.fqdn in windows_hosts and \
windows_hosts[dbhost.fqdn] in mac_addresses:
# All is well
continue
deps = get_host_dependencies(session, dbhost)
if deps:
msg = "Skipping removal of host %s with dependencies: %s" % \
(dbhost.fqdn, ", ".join(deps))
failed.append(msg)
logger.info(msg)
continue
dbmachine = dbhost.machine
success.append("Removed host entry for %s (%s)" %
(dbmachine.label, dbmachine.fqdn))
if dbmachine.vm_container:
containers.add(dbmachine.vm_container)
session.delete(dbhost)
dbdns_rec = dbmachine.primary_name
dbmachine.primary_name = None
delete_dns_record(dbdns_rec)
session.flush()
# The Host() creations below fail when autoflush is enabled.
session.autoflush = False
dbdomain = Domain.get_unique(session,
self.config.get("archetype_windows",
"host_domain"),
compel=InternalError)
dbarchetype = Archetype.get_unique(session, "windows",
compel=InternalError)
dbpersonality = Personality.get_unique(session, archetype=dbarchetype,
name="generic",
compel=InternalError)
dbstatus = HostLifecycle.get_unique(session, "ready",
compel=InternalError)
dbos = OperatingSystem.get_unique(session, name="windows",
version="generic",
archetype=dbarchetype,
compel=InternalError)
for (host, mac) in windows_hosts.items():
try:
(short, dbdns_domain) = parse_fqdn(session, host)
except AquilonError, err:
msg = "Skipping host %s: %s" % (host, err)
failed.append(msg)
logger.info(msg)
continue
existing = DnsRecord.get_unique(session, name=short,
dns_domain=dbdns_domain)
if existing:
if not existing.hardware_entity:
msg = "Skipping host %s: It is not a primary name." % host
failed.append(msg)
logger.info(msg)
continue
# If these are invalid there should have been a deletion
# attempt above.
if not existing.hardware_entity.interfaces:
msg = "Skipping host %s: Host already exists but has " \
"no interface attached." % host
failed.append(msg)
logger.info(msg)
elif existing.hardware_entity.interfaces[0].mac != mac:
msg = "Skipping host %s: Host already exists but with " \
"MAC address %s and not %s." % \
(host, existing.hardware_entity.interfaces[0].mac,
mac)
failed.append(msg)
logger.info(msg)
continue
dbinterface = session.query(Interface).filter_by(mac=mac).first()
if not dbinterface:
msg = "Skipping host %s: MAC address %s is not present in " \
"AQDB." % (host, mac)
failed.append(msg)
logger.info(msg)
continue
q = session.query(Machine)
q = q.filter_by(id=dbinterface.hardware_entity.id)
dbmachine = q.first()
if not dbmachine:
msg = "Skipping host %s: The AQDB interface with MAC address " \
"%s is tied to hardware %s instead of a virtual " \
"machine." % \
(host, mac, dbinterface.hardware_entity.label)
failed.append(msg)
logger.info(msg)
continue
if dbinterface.assignments:
msg = "Skipping host %s: The AQDB interface with MAC address " \
"%s is already tied to %s." % \
(host, mac, dbinterface.assignments[0].fqdns[0])
failed.append(msg)
logger.info(msg)
continue
if dbmachine.host:
msg = "Skipping host %s: The AQDB interface with MAC address " \
"%s is already tied to %s." % \
(host, mac, dbmachine.fqdn)
failed.append(msg)
logger.info(msg)
continue
dbhost = Host(machine=dbmachine, branch=dbdomain,
status=dbstatus, owner_grn=dbpersonality.owner_grn,
personality=dbpersonality, operating_system=dbos,
comments="Created by refresh_windows_host")
session.add(dbhost)
if self.config.has_option("archetype_windows", "default_grn_target"):
dbhost.grns.append((dbhost, dbgrn,
self.config.get("archetype_",
"default_grn_target")))
dbfqdn = Fqdn.get_or_create(session, name=short,
dns_domain=dbdns_domain, preclude=True)
dbdns_rec = ReservedName(fqdn=dbfqdn)
session.add(dbdns_rec)
dbmachine.primary_name = dbdns_rec
success.append("Added host entry for %s (%s)." %
(dbmachine.label, dbdns_rec.fqdn))
if dbmachine.vm_container:
containers.add(dbmachine.vm_container)
session.flush()
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
