def render(self, session, logger, fqdn, dns_environment,
network_environment, reverse_ptr, comments, **arguments):
dbnet_env, dbdns_env = get_net_dns_env(session, network_environment,
dns_environment)
audit_results = []
ip = generate_ip(session, logger, compel=True, dbinterface=None,
network_environment=dbnet_env,
audit_results=audit_results, **arguments)
# TODO: add allow_multi=True
dbdns_rec, newly_created = grab_address(session, fqdn, ip, dbnet_env,
dbdns_env, comments=comments,
preclude=True)
if reverse_ptr:
set_reverse_ptr(session, logger, dbdns_rec, reverse_ptr)
session.flush()
if dbdns_rec.fqdn.dns_environment.is_default:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_host_details(dbdns_rec.fqdn, ip, comments=comments)
dsdb_runner.commit_or_rollback("Could not add address to DSDB")
for name, value in audit_results:
self.audit_result(session, name, value, **arguments)
return
def render(self, session, logger, hostname, manager, interface, mac,
comments, **arguments):
dbhost = hostname_to_host(session, hostname)
dbmachine = dbhost.machine
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
if not manager:
manager = "%sr.%s" % (dbmachine.primary_name.fqdn.name,
dbmachine.primary_name.fqdn.dns_domain.name)
dbinterface = get_or_create_interface(session, dbmachine,
name=interface, mac=mac,
interface_type='management')
addrs = ", ".join(["%s [%s]" % (addr.logical_name, addr.ip) for addr
in dbinterface.assignments])
if addrs:
raise ArgumentError("{0} already has the following addresses: "
"{1}.".format(dbinterface, addrs))
audit_results = []
ip = generate_ip(session, logger, dbinterface, compel=True,
audit_results=audit_results, **arguments)
dbdns_rec, newly_created = grab_address(session, manager, ip,
comments=comments,
preclude=True)
assign_address(dbinterface, ip, dbdns_rec.network)
session.flush()
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
plenary_info.write(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
finally:
lock_queue.release(key)
if dbmachine.host:
# XXX: Host needs to be reconfigured.
pass
for name, value in audit_results:
self.audit_result(session, name, value, **arguments)
return
def render(self,
session,
logger,
hostname,
machine,
archetype,
domain,
sandbox,
osname,
osversion,
buildstatus,
personality,
comments,
zebra_interfaces,
grn,
eon_id,
skip_dsdb_check=False,
**arguments):
dbarchetype = Archetype.get_unique(session, archetype, compel=True)
section = "archetype_" + dbarchetype.name
# This is for the various add_*_host commands
if not domain and not sandbox:
domain = self.config.get(section, "host_domain")
(dbbranch, dbauthor) = get_branch_and_author(session,
logger,
domain=domain,
sandbox=sandbox,
compel=True)
if hasattr(dbbranch, "allow_manage") and not dbbranch.allow_manage:
raise ArgumentError(
"Adding hosts to {0:l} is not allowed.".format(dbbranch))
if not buildstatus:
buildstatus = 'build'
dbstatus = HostLifecycle.get_unique(session, buildstatus, compel=True)
dbmachine = Machine.get_unique(session, machine, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
if not personality:
if self.config.has_option(section, "default_personality"):
personality = self.config.get(section, "default_personality")
else:
personality = 'generic'
dbpersonality = Personality.get_unique(session,
name=personality,
archetype=dbarchetype,
compel=True)
if not osname:
if self.config.has_option(section, "default_osname"):
osname = self.config.get(section, "default_osname")
if not osversion:
if self.config.has_option(section, "default_osversion"):
osversion = self.config.get(section, "default_osversion")
if not osname or not osversion:
raise ArgumentError("Can not determine a sensible default OS "
"for archetype %s. Please use the "
"--osname and --osversion parameters." %
(dbarchetype.name))
dbos = OperatingSystem.get_unique(session,
name=osname,
version=osversion,
archetype=dbarchetype,
compel=True)
if (dbmachine.model.machine_type == 'aurora_node'
and dbpersonality.archetype.name != 'aurora'):
raise ArgumentError("Machines of type aurora_node can only be "
"added with archetype aurora.")
if dbmachine.host:
raise ArgumentError("{0:c} {0.label} is already allocated to "
"{1:l}.".format(dbmachine, dbmachine.host))
if grn or eon_id:
dbgrn = lookup_grn(session,
grn,
eon_id,
logger=logger,
config=self.config)
else:
dbgrn = dbpersonality.owner_grn
dbhost = Host(machine=dbmachine,
branch=dbbranch,
owner_grn=dbgrn,
sandbox_author=dbauthor,
personality=dbpersonality,
status=dbstatus,
operating_system=dbos,
comments=comments)
session.add(dbhost)
if self.config.has_option("archetype_" + archetype,
"default_grn_target"):
dbhost.grns.append((dbhost, dbgrn,
self.config.get("archetype_" + archetype,
"default_grn_target")))
if zebra_interfaces:
# --autoip does not make sense for Zebra (at least not the way it's
# implemented currently)
dbinterface = None
else:
dbinterface = get_boot_interface(dbmachine)
# This method is allowed to return None. This can only happen
# (currently) using add_aurora_host, add_windows_host, or possibly by
# bypassing the aq client and posting a request directly.
audit_results = []
ip = generate_ip(session,
logger,
dbinterface,
audit_results=audit_results,
**arguments)
dbdns_rec, newly_created = grab_address(session,
hostname,
ip,
allow_restricted_domain=True,
allow_reserved=True,
preclude=True)
dbmachine.primary_name = dbdns_rec
# Fix up auxiliary addresses to point to the primary name by default
if ip:
dns_env = dbdns_rec.fqdn.dns_environment
for addr in dbmachine.all_addresses():
if addr.interface.interface_type == "management":
continue
if addr.service_address_id: # pragma: no cover
continue
for rec in addr.dns_records:
if rec.fqdn.dns_environment == dns_env:
rec.reverse_ptr = dbdns_rec.fqdn
if zebra_interfaces:
if not ip:
raise ArgumentError(
"Zebra configuration requires an IP address.")
dbsrv_addr = self.assign_zebra_address(session, dbmachine,
dbdns_rec, zebra_interfaces)
else:
if ip:
if not dbinterface:
raise ArgumentError(
"You have specified an IP address for the "
"host, but {0:l} does not have a bootable "
"interface.".format(dbmachine))
assign_address(dbinterface, ip, dbdns_rec.network)
dbsrv_addr = None
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbmachine))
if dbmachine.vm_container:
plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
if dbsrv_addr:
plenaries.append(Plenary.get_plenary(dbsrv_addr))
key = plenaries.get_write_key()
try:
lock_queue.acquire(key)
plenaries.write(locked=True)
# XXX: This (and some of the code above) is horrible. There
# should be a generic/configurable hook here that could kick
# in based on archetype and/or domain.
dsdb_runner = DSDBRunner(logger=logger)
if dbhost.archetype.name == 'aurora':
# For aurora, check that DSDB has a record of the host.
if not skip_dsdb_check:
try:
dsdb_runner.show_host(hostname)
except ProcessException, e:
raise ArgumentError("Could not find host in DSDB: %s" %
e)
elif not dbmachine.primary_ip:
logger.info("No IP for %s, not adding to DSDB." %
dbmachine.fqdn)
def render(self, session, logger, hostname, machine, auxiliary, interface,
mac, comments, **arguments):
if machine:
dbmachine = Machine.get_unique(session, machine, compel=True)
if hostname:
dbhost = hostname_to_host(session, hostname)
if machine and dbhost.machine != dbmachine:
raise ArgumentError("Use either --hostname or --machine to "
"uniquely identify a system.")
dbmachine = dbhost.machine
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
dbinterface = get_or_create_interface(session, dbmachine,
name=interface, mac=mac,
interface_type='public',
bootable=False)
# Multiple addresses will only be allowed with the "add interface
# address" command
addrs = ", ".join(["%s [%s]" % (addr.logical_name, addr.ip) for addr
in dbinterface.assignments])
if addrs:
raise ArgumentError("{0} already has the following addresses: "
"{1}.".format(dbinterface, addrs))
audit_results = []
ip = generate_ip(session, logger, dbinterface, compel=True,
audit_results=audit_results, **arguments)
dbdns_rec, newly_created = grab_address(session, auxiliary, ip,
comments=comments,
preclude=True)
if dbmachine.primary_name:
# This command cannot use a non-default DNS environment, so no extra
# checks are necessary
dbdns_rec.reverse_ptr = dbmachine.primary_name.fqdn
assign_address(dbinterface, ip, dbdns_rec.network)
session.flush()
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
plenary_info.write(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
finally:
lock_queue.release(key)
if dbmachine.host:
# XXX: Host needs to be reconfigured.
pass
for name, value in audit_results:
self.audit_result(session, name, value, **arguments)
return
def render(self, session, logger, hostname, manager, interface, mac,
comments, **arguments):
dbhost = hostname_to_host(session, hostname)
dbmachine = dbhost.machine
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
if not manager:
manager = "%sr.%s" % (dbmachine.primary_name.fqdn.name,
dbmachine.primary_name.fqdn.dns_domain.name)
dbinterface = get_or_create_interface(session,
dbmachine,
name=interface,
mac=mac,
interface_type='management')
addrs = ", ".join([
"%s [%s]" % (addr.logical_name, addr.ip)
for addr in dbinterface.assignments
])
if addrs:
raise ArgumentError("{0} already has the following addresses: "
"{1}.".format(dbinterface, addrs))
audit_results = []
ip = generate_ip(session,
logger,
dbinterface,
compel=True,
audit_results=audit_results,
**arguments)
dbdns_rec, newly_created = grab_address(session,
manager,
ip,
comments=comments,
preclude=True)
assign_address(dbinterface, ip, dbdns_rec.network)
session.flush()
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
plenary_info.write(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
finally:
lock_queue.release(key)
if dbmachine.host:
# XXX: Host needs to be reconfigured.
pass
for name, value in audit_results:
self.audit_result(session, name, value, **arguments)
return
def render(self, session, logger, hostname, machine, archetype, domain,
sandbox, osname, osversion, buildstatus, personality, comments,
zebra_interfaces, grn, eon_id, skip_dsdb_check=False,
**arguments):
dbarchetype = Archetype.get_unique(session, archetype, compel=True)
section = "archetype_" + dbarchetype.name
# This is for the various add_*_host commands
if not domain and not sandbox:
domain = self.config.get(section, "host_domain")
(dbbranch, dbauthor) = get_branch_and_author(session, logger,
domain=domain,
sandbox=sandbox,
compel=True)
if hasattr(dbbranch, "allow_manage") and not dbbranch.allow_manage:
raise ArgumentError("Adding hosts to {0:l} is not allowed."
.format(dbbranch))
if not buildstatus:
buildstatus = 'build'
dbstatus = HostLifecycle.get_unique(session, buildstatus, compel=True)
dbmachine = Machine.get_unique(session, machine, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
if not personality:
if self.config.has_option(section, "default_personality"):
personality = self.config.get(section, "default_personality")
else:
personality = 'generic'
dbpersonality = Personality.get_unique(session, name=personality,
archetype=dbarchetype, compel=True)
if not osname:
if self.config.has_option(section, "default_osname"):
osname = self.config.get(section, "default_osname")
if not osversion:
if self.config.has_option(section, "default_osversion"):
osversion = self.config.get(section, "default_osversion")
if not osname or not osversion:
raise ArgumentError("Can not determine a sensible default OS "
"for archetype %s. Please use the "
"--osname and --osversion parameters." %
(dbarchetype.name))
dbos = OperatingSystem.get_unique(session, name=osname,
version=osversion,
archetype=dbarchetype, compel=True)
if (dbmachine.model.machine_type == 'aurora_node' and
dbpersonality.archetype.name != 'aurora'):
raise ArgumentError("Machines of type aurora_node can only be "
"added with archetype aurora.")
if dbmachine.host:
raise ArgumentError("{0:c} {0.label} is already allocated to "
"{1:l}.".format(dbmachine, dbmachine.host))
if grn or eon_id:
dbgrn = lookup_grn(session, grn, eon_id, logger=logger,
config=self.config)
else:
dbgrn = dbpersonality.owner_grn
dbhost = Host(machine=dbmachine, branch=dbbranch, owner_grn=dbgrn,
sandbox_author=dbauthor, personality=dbpersonality,
status=dbstatus, operating_system=dbos, comments=comments)
session.add(dbhost)
if self.config.has_option("archetype_" + archetype, "default_grn_target"):
dbhost.grns.append((dbhost, dbgrn,
self.config.get("archetype_" + archetype,
"default_grn_target")))
if zebra_interfaces:
# --autoip does not make sense for Zebra (at least not the way it's
# implemented currently)
dbinterface = None
else:
dbinterface = get_boot_interface(dbmachine)
# This method is allowed to return None. This can only happen
# (currently) using add_aurora_host, add_windows_host, or possibly by
# bypassing the aq client and posting a request directly.
audit_results = []
ip = generate_ip(session, logger, dbinterface,
audit_results=audit_results, **arguments)
dbdns_rec, newly_created = grab_address(session, hostname, ip,
allow_restricted_domain=True,
allow_reserved=True,
preclude=True)
dbmachine.primary_name = dbdns_rec
# Fix up auxiliary addresses to point to the primary name by default
if ip:
dns_env = dbdns_rec.fqdn.dns_environment
for addr in dbmachine.all_addresses():
if addr.interface.interface_type == "management":
continue
if addr.service_address_id: # pragma: no cover
continue
for rec in addr.dns_records:
if rec.fqdn.dns_environment == dns_env:
rec.reverse_ptr = dbdns_rec.fqdn
if zebra_interfaces:
if not ip:
raise ArgumentError("Zebra configuration requires an IP address.")
dbsrv_addr = self.assign_zebra_address(session, dbmachine, dbdns_rec,
zebra_interfaces)
else:
if ip:
if not dbinterface:
raise ArgumentError("You have specified an IP address for the "
"host, but {0:l} does not have a bootable "
"interface.".format(dbmachine))
assign_address(dbinterface, ip, dbdns_rec.network)
dbsrv_addr = None
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbmachine))
if dbmachine.vm_container:
plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
if dbsrv_addr:
plenaries.append(Plenary.get_plenary(dbsrv_addr))
key = plenaries.get_write_key()
try:
lock_queue.acquire(key)
plenaries.write(locked=True)
# XXX: This (and some of the code above) is horrible. There
# should be a generic/configurable hook here that could kick
# in based on archetype and/or domain.
dsdb_runner = DSDBRunner(logger=logger)
if dbhost.archetype.name == 'aurora':
# For aurora, check that DSDB has a record of the host.
if not skip_dsdb_check:
try:
dsdb_runner.show_host(hostname)
except ProcessException, e:
raise ArgumentError("Could not find host in DSDB: %s" % e)
elif not dbmachine.primary_ip:
logger.info("No IP for %s, not adding to DSDB." % dbmachine.fqdn)
def render(self, session, logger, machine, chassis, switch, fqdn,
interface, label, network_environment, map_to_primary,
**kwargs):
if machine:
hwtype = 'machine'
hwname = machine
elif chassis:
hwtype = 'chassis'
hwname = chassis
elif switch:
hwtype = 'switch'
hwname = switch
dbnet_env = NetworkEnvironment.get_unique_or_default(
session, network_environment)
dbhw_ent = HardwareEntity.get_unique(session,
hwname,
hardware_type=hwtype,
compel=True)
dbinterface = Interface.get_unique(session,
hardware_entity=dbhw_ent,
name=interface,
compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
audit_results = []
ip = generate_ip(session,
logger,
dbinterface,
network_environment=dbnet_env,
audit_results=audit_results,
**kwargs)
if dbinterface.interface_type == "loopback":
# Switch loopback interfaces may use e.g. the network address as an
# IP address
relaxed = True
else:
relaxed = False
if not fqdn:
if not dbhw_ent.primary_name:
raise ArgumentError("{0} has no primary name, can not "
"auto-generate the DNS record. "
"Please specify --fqdn.".format(dbhw_ent))
if label:
name = "%s-%s-%s" % (dbhw_ent.primary_name.fqdn.name,
interface, label)
else:
name = "%s-%s" % (dbhw_ent.primary_name.fqdn.name, interface)
fqdn = "%s.%s" % (name, dbhw_ent.primary_name.fqdn.dns_domain)
if label is None:
label = ""
elif label == "hostname":
# When add_host sets up Zebra, it always uses the label 'hostname'.
# Due to the primary IP being special, add_interface_address cannot
# really emulate what add_host does, so tell the user where to look.
raise ArgumentError("The 'hostname' label can only be managed "
"by add_host/del_host.")
# The label will be used as an nlist key
if label:
validate_basic("label", label)
# TODO: add allow_multi=True
dbdns_rec, newly_created = grab_address(session,
fqdn,
ip,
dbnet_env,
relaxed=relaxed)
ip = dbdns_rec.ip
dbnetwork = dbdns_rec.network
delete_old_dsdb_entry = not newly_created and not dbdns_rec.assignments
# Reverse PTR control. Auxiliary addresses should point to the primary
# name by default, with some exceptions.
if (map_to_primary is None and dbhw_ent.primary_name
and dbinterface.interface_type != "management"
and dbdns_rec.fqdn.dns_environment
== dbhw_ent.primary_name.fqdn.dns_environment):
map_to_primary = True
if map_to_primary:
if not dbhw_ent.primary_name:
raise ArgumentError(
"{0} does not have a primary name, cannot "
"set the reverse DNS mapping.".format(dbhw_ent))
if (dbhw_ent.primary_name.fqdn.dns_environment !=
dbdns_rec.fqdn.dns_environment):
raise ArgumentError("{0} lives in {1:l}, not {2:l}.".format(
dbhw_ent, dbhw_ent.primary_name.fqdn.dns_environment,
dbdns_rec.fqdn.dns_environment))
if dbinterface.interface_type == "management":
raise ArgumentError("The reverse PTR for management addresses "
"should not point to the primary name.")
dbdns_rec.reverse_ptr = dbhw_ent.primary_name.fqdn
# Check that the network ranges assigned to different interfaces
# do not overlap even if the network environments are different, because
# that would confuse routing on the host. E.g. if eth0 is an internal
# and eth1 is an external interface, then using 192.168.1.10/24 on eth0
# and using 192.168.1.20/26 on eth1 won't work.
for addr in dbhw_ent.all_addresses():
if addr.network != dbnetwork and \
addr.network.network.overlaps(dbnetwork.network):
raise ArgumentError("{0} in {1:l} used on {2:l} overlaps "
"requested {3:l} in "
"{4:l}.".format(
addr.network,
addr.network.network_environment,
addr.interface, dbnetwork,
dbnetwork.network_environment))
assign_address(dbinterface, ip, dbnetwork, label=label)
session.flush()
dbhost = getattr(dbhw_ent, "host", None)
if dbhost:
plenary_info = PlenaryHost(dbhost, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
try:
plenary_info.write(locked=True)
except IncompleteError:
# FIXME: if this command is used after "add host" but before
# "make", then writing out the template will fail due to
# required services not being assigned. Ignore this error
# for now.
plenary_info.restore_stash()
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
finally:
lock_queue.release(key)
else:
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
for name, value in audit_results:
self.audit_result(session, name, value, **kwargs)
return
def render(self, session, logger, machine, chassis, network_device, fqdn,
interface, label, network_environment, map_to_primary, **kwargs):
if machine:
hwtype = 'machine'
hwname = machine
elif chassis:
hwtype = 'chassis'
hwname = chassis
elif network_device:
hwtype = 'network_device'
hwname = network_device
dbnet_env = NetworkEnvironment.get_unique_or_default(session,
network_environment)
dbhw_ent = HardwareEntity.get_unique(session, hwname,
hardware_type=hwtype, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent,
name=interface, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
audit_results = []
ip = generate_ip(session, logger, dbinterface,
network_environment=dbnet_env,
audit_results=audit_results, **kwargs)
if dbinterface.interface_type == "loopback":
# Switch loopback interfaces may use e.g. the network address as an
# IP address
relaxed = True
else:
relaxed = False
if not fqdn:
if not dbhw_ent.primary_name:
raise ArgumentError("{0} has no primary name, can not "
"auto-generate the DNS record. "
"Please specify --fqdn.".format(dbhw_ent))
if label:
name = "%s-%s-%s" % (dbhw_ent.primary_name.fqdn.name, interface,
label)
else:
name = "%s-%s" % (dbhw_ent.primary_name.fqdn.name, interface)
fqdn = "%s.%s" % (name, dbhw_ent.primary_name.fqdn.dns_domain)
if label is None:
label = ""
elif label == "hostname":
# When add_host sets up Zebra, it always uses the label 'hostname'.
# Due to the primary IP being special, add_interface_address cannot
# really emulate what add_host does, so tell the user where to look.
raise ArgumentError("The 'hostname' label can only be managed "
"by add_host/del_host.")
# The label will be used as an nlist key
if label:
validate_nlist_key("label", label)
# TODO: add allow_multi=True
dbdns_rec, newly_created = grab_address(session, fqdn, ip, dbnet_env,
relaxed=relaxed)
ip = dbdns_rec.ip
dbnetwork = dbdns_rec.network
delete_old_dsdb_entry = not newly_created and not dbdns_rec.assignments
# Reverse PTR control. Auxiliary addresses should point to the primary
# name by default, with some exceptions.
if (map_to_primary is None and dbhw_ent.primary_name and
dbinterface.interface_type != "management" and
dbdns_rec.fqdn.dns_environment == dbhw_ent.primary_name.fqdn.dns_environment):
map_to_primary = True
if map_to_primary:
if not dbhw_ent.primary_name:
raise ArgumentError("{0} does not have a primary name, cannot "
"set the reverse DNS mapping."
.format(dbhw_ent))
if (dbhw_ent.primary_name.fqdn.dns_environment !=
dbdns_rec.fqdn.dns_environment):
raise ArgumentError("{0} lives in {1:l}, not {2:l}."
.format(dbhw_ent,
dbhw_ent.primary_name.fqdn.dns_environment,
dbdns_rec.fqdn.dns_environment))
if dbinterface.interface_type == "management":
raise ArgumentError("The reverse PTR for management addresses "
"should not point to the primary name.")
dbdns_rec.reverse_ptr = dbhw_ent.primary_name.fqdn
# Check that the network ranges assigned to different interfaces
# do not overlap even if the network environments are different, because
# that would confuse routing on the host. E.g. if eth0 is an internal
# and eth1 is an external interface, then using 192.168.1.10/24 on eth0
# and using 192.168.1.20/26 on eth1 won't work.
for addr in dbhw_ent.all_addresses():
if addr.network != dbnetwork and \
addr.network.network.overlaps(dbnetwork.network):
raise ArgumentError("{0} in {1:l} used on {2:l} overlaps "
"requested {3:l} in "
"{4:l}.".format(addr.network,
addr.network.network_environment,
addr.interface,
dbnetwork,
dbnetwork.network_environment))
assign_address(dbinterface, ip, dbnetwork, label=label, logger=logger)
session.flush()
dbhost = getattr(dbhw_ent, "host", None)
if dbhost:
plenary_info = Plenary.get_plenary(dbhost, logger=logger)
with plenary_info.get_key():
try:
try:
plenary_info.write(locked=True)
except IncompleteError:
# FIXME: if this command is used after "add host" but
# before "make", then writing out the template will fail
# due to required services not being assigned. Ignore
# this error for now.
plenary_info.restore_stash()
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
else:
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
for name, value in audit_results:
self.audit_result(session, name, value, **kwargs)
return