def render(self, session, logger, machine, generate, **kwargs):
dbmachine = Machine.get_unique(session, machine, compel=True)
if dbmachine.model.machine_type not in ['blade', 'virtual_machine',
'workstation', 'rackmount']:
raise ArgumentError("Plenary file not available for %s machines." %
dbmachine.model.machine_type)
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
if generate:
return plenary_info._generate_content()
else:
return plenary_info.read()
def render(self, session, logger, auxiliary, **arguments):
dbmachine = None
with DeleteKey("system", logger=logger):
# Check dependencies, translate into user-friendly message
dbauxiliary = ARecord.get_unique(session,
fqdn=auxiliary,
compel=True)
is_aux = True
if not dbauxiliary.assignments or len(dbauxiliary.assignments) > 1:
is_aux = False
else:
assignment = dbauxiliary.assignments[0]
dbmachine = assignment.interface.hardware_entity
if assignment.ip == dbmachine.primary_ip:
is_aux = False
if assignment.interface.interface_type == 'management':
is_aux = False
if not is_aux:
raise ArgumentError(
"{0:a} is not an auxiliary.".format(dbauxiliary))
# FIXME: Look for dependencies...
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
session.delete(assignment)
delete_dns_record(dbauxiliary)
session.flush()
session.expire(dbmachine)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback(
"Could not remove host %s from DSDB" % auxiliary)
# Past the point of no return here (DSDB has been updated)...
# probably not much of an issue if writing the plenary failed.
# Commit the session so that we can free the delete lock.
session.commit()
if dbmachine:
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
# This may create a new lock, so we free first above.
plenary_info.write()
if dbmachine.host:
# FIXME: Reconfigure
pass
return
def render(self, session, logger, auxiliary, **arguments):
dbmachine = None
with DeleteKey("system", logger=logger):
# Check dependencies, translate into user-friendly message
dbauxiliary = ARecord.get_unique(session, fqdn=auxiliary, compel=True)
is_aux = True
if not dbauxiliary.assignments or len(dbauxiliary.assignments) > 1:
is_aux = False
else:
assignment = dbauxiliary.assignments[0]
dbmachine = assignment.interface.hardware_entity
if assignment.ip == dbmachine.primary_ip:
is_aux = False
if assignment.interface.interface_type == "management":
is_aux = False
if not is_aux:
raise ArgumentError("{0:a} is not an auxiliary.".format(dbauxiliary))
# FIXME: Look for dependencies...
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
session.delete(assignment)
delete_dns_record(dbauxiliary)
session.flush()
session.expire(dbmachine)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not remove host %s from DSDB" % auxiliary)
# Past the point of no return here (DSDB has been updated)...
# probably not much of an issue if writing the plenary failed.
# Commit the session so that we can free the delete lock.
session.commit()
if dbmachine:
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
# This may create a new lock, so we free first above.
plenary_info.write()
if dbmachine.host:
# FIXME: Reconfigure
pass
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, model, vendor, newmodel, newvendor,
comments, leave_existing, **arguments):
for (arg, value) in arguments.items():
# Cleaning the strings isn't strictly necessary but allows
# for simple equality checks below and removes the need to
# call refresh().
if arg in [
'newmodel', 'newvendor', 'machine_type', 'cpuname',
'cpuvendor', 'disktype', 'diskcontroller', 'nicmodel',
'nicvendor'
]:
if value is not None:
arguments[arg] = value.lower().strip()
dbmodel = Model.get_unique(session,
name=model,
vendor=vendor,
compel=True)
if leave_existing and (newmodel or newvendor):
raise ArgumentError("Cannot update model name or vendor without "
"updating any existing machines.")
fix_existing = not leave_existing
dbmachines = set()
# The sub-branching here is a little difficult to read...
# Basically, there are three different checks to handle
# setting a new vendor, a new name, or both.
if newvendor:
dbnewvendor = Vendor.get_unique(session, newvendor, compel=True)
if newmodel:
Model.get_unique(session,
name=newmodel,
vendor=dbnewvendor,
preclude=True)
else:
Model.get_unique(session,
name=dbmodel.name,
vendor=dbnewvendor,
preclude=True)
dbmodel.vendor = dbnewvendor
if newmodel:
if not newvendor:
Model.get_unique(session,
name=newmodel,
vendor=dbmodel.vendor,
preclude=True)
dbmodel.name = newmodel
if newvendor or newmodel:
q = session.query(Machine).filter_by(model=dbmodel)
dbmachines.update(q.all())
# For now, can't update machine_type. There are too many spots
# that special case things like aurora_node or virtual_machine to
# know that the transistion is safe. If there is enough need we
# can always add those transitions later.
if arguments['machine_type'] is not None:
raise UnimplementedError("Cannot (yet) change a model's "
"machine type.")
if comments:
dbmodel.comments = comments
# The comments also do not affect the templates.
cpu_args = ['cpuname', 'cpuvendor', 'cpuspeed']
cpu_info = dict([(self.argument_lookup[arg], arguments[arg])
for arg in cpu_args])
cpu_values = [v for v in cpu_info.values() if v is not None]
nic_args = ['nicmodel', 'nicvendor']
nic_info = dict([(self.argument_lookup[arg], arguments[arg])
for arg in nic_args])
nic_values = [v for v in nic_info.values() if v is not None]
spec_args = [
'cpunum', 'memory', 'disktype', 'diskcontroller', 'disksize',
'nics'
]
specs = dict([(self.argument_lookup[arg], arguments[arg])
for arg in spec_args])
spec_values = [v for v in specs.values() if v is not None]
if not dbmodel.machine_specs:
if cpu_values or nic_values or spec_values:
if not cpu_values or len(spec_values) < len(spec_args):
raise ArgumentError("Missing required parameters to store "
"machine specs for the model. Please "
"give all CPU, disk, RAM, and NIC "
"count information.")
dbcpu = Cpu.get_unique(session, compel=True, **cpu_info)
if nic_values:
dbnic = Model.get_unique(session,
compel=True,
machine_type='nic',
**nic_info)
else:
dbnic = Model.default_nic_model(session)
dbmachine_specs = MachineSpecs(model=dbmodel,
cpu=dbcpu,
nic_model=dbnic,
**specs)
session.add(dbmachine_specs)
# Anything below that updates specs should have been verified above.
if cpu_values:
dbcpu = Cpu.get_unique(session, compel=True, **cpu_info)
self.update_machine_specs(model=dbmodel,
dbmachines=dbmachines,
attr='cpu',
value=dbcpu,
fix_existing=fix_existing)
for arg in ['memory', 'cpunum']:
if arguments[arg] is not None:
self.update_machine_specs(model=dbmodel,
dbmachines=dbmachines,
attr=self.argument_lookup[arg],
value=arguments[arg],
fix_existing=fix_existing)
if arguments['disktype']:
if fix_existing:
raise ArgumentError("Please specify --leave_existing to "
"change the model disktype. This cannot "
"be converted automatically.")
dbmodel.machine_specs.disk_type = arguments['disktype']
for arg in ['diskcontroller', 'disksize']:
if arguments[arg] is not None:
self.update_disk_specs(model=dbmodel,
dbmachines=dbmachines,
attr=self.argument_lookup[arg],
value=arguments[arg],
fix_existing=fix_existing)
if nic_values:
dbnic = Model.get_unique(session, compel=True, **nic_info)
self.update_interface_specs(model=dbmodel,
dbmachines=dbmachines,
value=dbnic,
fix_existing=fix_existing)
if arguments['nics'] is not None:
dbmodel.machine_specs.nic_count = arguments['nics']
session.flush()
plenaries = PlenaryCollection(logger=logger)
for dbmachine in dbmachines:
plenaries.append(PlenaryMachineInfo(dbmachine, logger=logger))
plenaries.write()
return
def render(self, session, logger, interface, machine, switch, chassis, mac,
user, **arguments):
if not (machine or switch or chassis or mac):
raise ArgumentError("Please specify at least one of --chassis, "
"--machine, --switch or --mac.")
if machine:
dbhw_ent = Machine.get_unique(session, machine, compel=True)
elif switch:
dbhw_ent = Switch.get_unique(session, switch, compel=True)
elif chassis:
dbhw_ent = Chassis.get_unique(session, chassis, compel=True)
else:
dbhw_ent = None
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent,
name=interface, mac=mac, compel=True)
if not dbhw_ent:
dbhw_ent = dbinterface.hardware_entity
if dbinterface.vlans:
vlans = ", ".join([iface.name for iface in
dbinterface.vlans.values()])
raise ArgumentError("{0} is the parent of the following VLAN "
"interfaces, delete them first: "
"{1}.".format(dbinterface, vlans))
if dbinterface.slaves:
slaves = ", ".join([iface.name for iface in dbinterface.slaves])
raise ArgumentError("{0} is the master of the following slave "
"interfaces, delete them first: "
"{1}.".format(dbinterface, slaves))
try:
for addr in dbinterface.assignments:
if addr.ip != dbhw_ent.primary_ip:
continue
# Special handling: if this interface was created automatically,
# and there is exactly one other interface with no IP address,
# then re-assign the primary address to that interface
if not dbinterface.mac and dbinterface.comments is not None and \
dbinterface.comments.startswith("Created automatically") and \
len(dbhw_ent.interfaces) == 2:
if dbinterface == dbhw_ent.interfaces[0]:
other = dbhw_ent.interfaces[1]
else:
other = dbhw_ent.interfaces[0]
if len(other.assignments) == 0:
assign_address(other, dbhw_ent.primary_ip,
dbhw_ent.primary_name.network)
dbinterface.addresses.remove(dbhw_ent.primary_ip)
raise _Goto
# If this is a machine, it is possible to delete the host to get rid
# of the primary name
if dbhw_ent.hardware_type == "machine":
msg = " You should delete the host first."
else:
msg = ""
raise ArgumentError("{0} holds the primary address of the {1:cl}, "
"therefore it cannot be deleted."
"{2}".format(dbinterface, dbhw_ent, msg))
except _Goto:
pass
addrs = ", ".join(["%s: %s" % (addr.logical_name, addr.ip) for addr in
dbinterface.assignments])
if addrs:
raise ArgumentError("{0} still has the following addresses "
"configured, delete them first: "
"{1}.".format(dbinterface, addrs))
dbhw_ent.interfaces.remove(dbinterface)
session.flush()
if dbhw_ent.hardware_type == 'machine':
plenary_info = PlenaryMachineInfo(dbhw_ent, logger=logger)
plenary_info.write()
return
def render(self, session, logger, building, city, address, fullname,
default_dns_domain, comments, **arguments):
dbbuilding = get_location(session, building=building)
old_city = dbbuilding.city
dsdb_runner = DSDBRunner(logger=logger)
if address is not None:
old_address = dbbuilding.address
dbbuilding.address = address
dsdb_runner.update_building(dbbuilding.name, dbbuilding.address,
old_address)
if fullname is not None:
dbbuilding.fullname = fullname
if comments is not None:
dbbuilding.comments = comments
if default_dns_domain is not None:
if default_dns_domain:
dbdns_domain = DnsDomain.get_unique(session,
default_dns_domain,
compel=True)
dbbuilding.default_dns_domain = dbdns_domain
else:
dbbuilding.default_dns_domain = None
plenaries = PlenaryCollection(logger=logger)
if city:
dbcity = get_location(session, city=city)
# This one would change the template's locations hence forbidden
if dbcity.hub != dbbuilding.hub:
# Doing this both to reduce user error and to limit
# testing required.
raise ArgumentError("Cannot change hubs. {0} is in {1} "
"while {2} is in {3}.".format(
dbcity, dbcity.hub, dbbuilding,
dbbuilding.hub))
# issue svcmap warnings
maps = 0
for map_type in [ServiceMap, PersonalityServiceMap]:
maps = maps + session.query(map_type).\
filter_by(location=old_city).count()
if maps > 0:
logger.client_info("There are {0} service(s) mapped to the "
"old location of the ({1:l}), please "
"review and manually update mappings for "
"the new location as needed.".format(
maps, dbbuilding.city))
dbbuilding.update_parent(parent=dbcity)
if old_city.campus and (old_city.campus != dbcity.campus):
dsdb_runner.del_campus_building(old_city.campus, building)
if dbcity.campus and (old_city.campus != dbcity.campus):
dsdb_runner.add_campus_building(dbcity.campus, building)
query = session.query(Machine)
query = query.filter(
Machine.location_id.in_(dbcity.offspring_ids()))
for dbmachine in query:
plenaries.append(PlenaryMachineInfo(dbmachine, logger=logger))
session.flush()
if plenaries.plenaries:
with plenaries.get_write_key() as key:
plenaries.stash()
try:
plenaries.write(locked=True)
dsdb_runner.commit_or_rollback()
except:
plenaries.restore_stash()
else:
dsdb_runner.commit_or_rollback()
return
def render(
self,
session,
logger,
interface,
machine,
mac,
model,
vendor,
boot,
pg,
autopg,
comments,
master,
clear_master,
default_route,
rename_to,
**arguments
):
"""This command expects to locate an interface based only on name
and machine - all other fields, if specified, are meant as updates.
If the machine has a host, dsdb may need to be updated.
The boot flag can *only* be set to true. This is mostly technical,
as at this point in the interface it is difficult to tell if the
flag was unset or set to false. However, it also vastly simplifies
the dsdb logic - we never have to worry about a user trying to
remove the boot flag from a host in dsdb.
"""
audit_results = []
dbhw_ent = Machine.get_unique(session, machine, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent, name=interface, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if arguments.get("hostname", None):
# Hack to set an intial interface for an aurora host...
dbhost = dbhw_ent.host
if dbhost.archetype.name == "aurora" and dbhw_ent.primary_ip and not dbinterface.addresses:
assign_address(dbinterface, dbhw_ent.primary_ip, dbhw_ent.primary_name.network)
# We may need extra IP verification (or an autoip option)...
# This may also throw spurious errors if attempting to set the
# port_group to a value it already has.
if pg is not None and dbinterface.port_group != pg.lower().strip():
dbinterface.port_group = verify_port_group(dbinterface.hardware_entity, pg)
elif autopg:
dbinterface.port_group = choose_port_group(session, logger, dbinterface.hardware_entity)
audit_results.append(("pg", dbinterface.port_group))
if master:
if dbinterface.addresses:
# FIXME: as a special case, if the only address is the
# primary IP, then we could just move it to the master
# interface. However this can be worked around by bonding
# the interface before calling "add host", so don't bother
# for now.
raise ArgumentError("Can not enslave {0:l} because it has " "addresses.".format(dbinterface))
dbmaster = Interface.get_unique(session, hardware_entity=dbhw_ent, name=master, compel=True)
if dbmaster in dbinterface.all_slaves():
raise ArgumentError(
"Enslaving {0:l} would create a circle, " "which is not allowed.".format(dbinterface)
)
dbinterface.master = dbmaster
if clear_master:
if not dbinterface.master:
raise ArgumentError("{0} is not a slave.".format(dbinterface))
dbinterface.master = None
if comments:
dbinterface.comments = comments
if boot:
# Should we also transfer the primary IP to the new boot interface?
# That could get tricky if the new interface already has an IP
# address...
for i in dbhw_ent.interfaces:
if i == dbinterface:
i.bootable = True
i.default_route = True
else:
i.bootable = False
i.default_route = False
if default_route is not None:
dbinterface.default_route = default_route
if not first_of(dbhw_ent.interfaces, lambda x: x.default_route):
logger.client_info("Warning: {0:l} has no default route, hope " "that's ok.".format(dbhw_ent))
# Set this mac address last so that you can update to a bootable
# interface *before* adding a mac address. This is so the validation
# that takes place in the interface class doesn't have to be worried
# about the order of update to bootable=True and mac address
if mac:
q = session.query(Interface).filter_by(mac=mac)
other = q.first()
if other and other != dbinterface:
raise ArgumentError("MAC address {0} is already in use by " "{1:l}.".format(mac, other))
dbinterface.mac = mac
if model or vendor:
if not dbinterface.model_allowed:
raise ArgumentError("Model/vendor can not be set for a {0:lc}.".format(dbinterface))
dbmodel = Model.get_unique(session, name=model, vendor=vendor, machine_type="nic", compel=True)
dbinterface.model = dbmodel
if rename_to:
rename_interface(session, dbinterface, rename_to)
session.flush()
session.refresh(dbhw_ent)
plenary_info = PlenaryMachineInfo(dbhw_ent, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
plenary_info.write(locked=True)
if dbhw_ent.host and dbhw_ent.host.archetype.name != "aurora":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback()
except AquilonError, err:
plenary_info.restore_stash()
raise ArgumentError(err)
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 _write_plenary_info(self, dbmachine, logger):
"""write template files"""
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
plenary_info.write()
def _write_plenary_info(self, dbmachine, logger):
"""write template files"""
plenary_info = PlenaryMachineInfo(dbmachine, logger=logger)
plenary_info.write()
def render(self, session, logger, interface, machine, mac, model, vendor,
boot, pg, autopg, comments, master, clear_master, default_route,
rename_to, **arguments):
"""This command expects to locate an interface based only on name
and machine - all other fields, if specified, are meant as updates.
If the machine has a host, dsdb may need to be updated.
The boot flag can *only* be set to true. This is mostly technical,
as at this point in the interface it is difficult to tell if the
flag was unset or set to false. However, it also vastly simplifies
the dsdb logic - we never have to worry about a user trying to
remove the boot flag from a host in dsdb.
"""
audit_results = []
dbhw_ent = Machine.get_unique(session, machine, compel=True)
dbinterface = Interface.get_unique(session,
hardware_entity=dbhw_ent,
name=interface,
compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if arguments.get('hostname', None):
# Hack to set an intial interface for an aurora host...
dbhost = dbhw_ent.host
if dbhost.archetype.name == 'aurora' and \
dbhw_ent.primary_ip and not dbinterface.addresses:
assign_address(dbinterface, dbhw_ent.primary_ip,
dbhw_ent.primary_name.network)
# We may need extra IP verification (or an autoip option)...
# This may also throw spurious errors if attempting to set the
# port_group to a value it already has.
if pg is not None and dbinterface.port_group != pg.lower().strip():
dbinterface.port_group = verify_port_group(
dbinterface.hardware_entity, pg)
elif autopg:
dbinterface.port_group = choose_port_group(
session, logger, dbinterface.hardware_entity)
audit_results.append(('pg', dbinterface.port_group))
if master:
if dbinterface.addresses:
# FIXME: as a special case, if the only address is the
# primary IP, then we could just move it to the master
# interface. However this can be worked around by bonding
# the interface before calling "add host", so don't bother
# for now.
raise ArgumentError("Can not enslave {0:l} because it has "
"addresses.".format(dbinterface))
dbmaster = Interface.get_unique(session,
hardware_entity=dbhw_ent,
name=master,
compel=True)
if dbmaster in dbinterface.all_slaves():
raise ArgumentError(
"Enslaving {0:l} would create a circle, "
"which is not allowed.".format(dbinterface))
dbinterface.master = dbmaster
if clear_master:
if not dbinterface.master:
raise ArgumentError("{0} is not a slave.".format(dbinterface))
dbinterface.master = None
if comments:
dbinterface.comments = comments
if boot:
# Should we also transfer the primary IP to the new boot interface?
# That could get tricky if the new interface already has an IP
# address...
for i in dbhw_ent.interfaces:
if i == dbinterface:
i.bootable = True
i.default_route = True
else:
i.bootable = False
i.default_route = False
if default_route is not None:
dbinterface.default_route = default_route
if not first_of(dbhw_ent.interfaces, lambda x: x.default_route):
logger.client_info("Warning: {0:l} has no default route, hope "
"that's ok.".format(dbhw_ent))
#Set this mac address last so that you can update to a bootable
#interface *before* adding a mac address. This is so the validation
#that takes place in the interface class doesn't have to be worried
#about the order of update to bootable=True and mac address
if mac:
q = session.query(Interface).filter_by(mac=mac)
other = q.first()
if other and other != dbinterface:
raise ArgumentError("MAC address {0} is already in use by "
"{1:l}.".format(mac, other))
dbinterface.mac = mac
if model or vendor:
if not dbinterface.model_allowed:
raise ArgumentError(
"Model/vendor can not be set for a {0:lc}.".format(
dbinterface))
dbmodel = Model.get_unique(session,
name=model,
vendor=vendor,
machine_type='nic',
compel=True)
dbinterface.model = dbmodel
if rename_to:
rename_interface(session, dbinterface, rename_to)
session.flush()
session.refresh(dbhw_ent)
plenary_info = PlenaryMachineInfo(dbhw_ent, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
plenary_info.write(locked=True)
if dbhw_ent.host and dbhw_ent.host.archetype.name != "aurora":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback()
except AquilonError, err:
plenary_info.restore_stash()
raise ArgumentError(err)
