def render(self, session, logger, interface, chassis, mac, iftype, type,
comments, **arguments):
if type:
self.deprecated_option("type", "Please use --iftype "
"instead.", logger=logger, **arguments)
if not iftype:
iftype = type
if iftype and iftype != "oa":
raise ArgumentError("Only 'oa' is allowed as the interface type "
"for chassis.")
for arg in self.invalid_parameters:
if arguments.get(arg) is not None:
raise ArgumentError("Cannot use argument --%s when adding an "
"interface to a chassis." % arg)
dbchassis = Chassis.get_unique(session, chassis, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbchassis)
get_or_create_interface(session, dbchassis, name=interface, mac=mac,
interface_type='oa', comments=comments,
preclude=True)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbchassis, oldinfo)
dsdb_runner.commit_or_rollback("Could not update chassis in DSDB")
return
def render(self, session, logger, interface, switch, mac, type, comments,
**arguments):
if type and type not in self.valid_interface_types:
raise ArgumentError("Interface type %s is not allowed for "
"switches." % type)
if not type:
if interface.lower().startswith("lo"):
type = "loopback"
else:
type = "oa"
for arg in self.invalid_parameters:
if arguments.get(arg) is not None:
raise ArgumentError("Cannot use argument --%s when adding an "
"interface to a switch." % arg)
dbswitch = Switch.get_unique(session, switch, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbswitch)
dbinterface = get_or_create_interface(session, dbswitch,
name=interface, mac=mac,
interface_type=type,
comments=comments, preclude=True)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbswitch, oldinfo)
dsdb_runner.commit_or_rollback("Could not update switch in DSDB")
return
def render(self, session, logger, interface, chassis, mac, type, comments,
**arguments):
if type and type != "oa":
raise ArgumentError("Only 'oa' is allowed as the interface type "
"for chassis.")
for arg in self.invalid_parameters:
if arguments.get(arg) is not None:
raise ArgumentError("Cannot use argument --%s when adding an "
"interface to a chassis." % arg)
dbchassis = Chassis.get_unique(session, chassis, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbchassis)
dbinterface = get_or_create_interface(session, dbchassis,
name=interface, mac=mac,
interface_type='oa',
comments=comments, preclude=True)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbchassis, oldinfo)
dsdb_runner.commit_or_rollback("Could not update chassis in DSDB")
return
def render(self, session, logger, switch, label, model, rack, type, ip,
interface, mac, vendor, serial, comments, **arguments):
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
machine_type='switch', compel=True)
dblocation = get_location(session, rack=rack)
dbdns_rec, newly_created = grab_address(session, switch, ip,
allow_restricted_domain=True,
allow_reserved=True,
preclude=True)
if not label:
label = dbdns_rec.fqdn.name
try:
Switch.check_label(label)
except ArgumentError:
raise ArgumentError("Could not deduce a valid hardware label "
"from the switch name. Please specify "
"--label.")
# FIXME: What do the error messages for an invalid enum (switch_type)
# look like?
dbswitch = Switch(label=label, switch_type=type, location=dblocation,
model=dbmodel, serial_no=serial, comments=comments)
session.add(dbswitch)
dbswitch.primary_name = dbdns_rec
# FIXME: get default name from the model
iftype = "oa"
if not interface:
interface = "xge"
ifcomments = "Created automatically by add_switch"
else:
ifcomments = None
if interface.lower().startswith("lo"):
iftype = "loopback"
dbinterface = get_or_create_interface(session, dbswitch,
name=interface, mac=mac,
interface_type=iftype,
comments=ifcomments)
dbnetwork = get_net_id_from_ip(session, ip)
# TODO: should we call check_ip_restrictions() here?
assign_address(dbinterface, ip, dbnetwork)
session.flush()
plenary = PlenarySwitch(dbswitch, logger=logger)
with plenary.get_write_key() as key:
plenary.stash()
try:
plenary.write(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbswitch, None)
dsdb_runner.commit_or_rollback("Could not add switch to DSDB")
except:
plenary.restore_stash()
raise
return
def render(self, session, logger, network_device, label, model, type, ip,
interface, iftype, mac, vendor, serial, comments, **arguments):
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
compel=True)
if not dbmodel.model_type.isNetworkDeviceType():
raise ArgumentError("This command can only be used to "
"add network devices.")
dblocation = get_location(session, compel=True, **arguments)
dbdns_rec, newly_created = grab_address(session, network_device, ip,
allow_restricted_domain=True,
allow_reserved=True,
preclude=True)
if not label:
label = dbdns_rec.fqdn.name
try:
NetworkDevice.check_label(label)
except ArgumentError:
raise ArgumentError("Could not deduce a valid hardware label "
"from the network device name. Please specify "
"--label.")
# FIXME: What do the error messages for an invalid enum (switch_type)
# look like?
dbnetdev = NetworkDevice(label=label, switch_type=type,
location=dblocation, model=dbmodel,
serial_no=serial, comments=comments)
session.add(dbnetdev)
dbnetdev.primary_name = dbdns_rec
check_netdev_iftype(iftype)
dbinterface = get_or_create_interface(session, dbnetdev,
name=interface, mac=mac,
interface_type=iftype)
dbnetwork = get_net_id_from_ip(session, ip)
# TODO: should we call check_ip_restrictions() here?
assign_address(dbinterface, ip, dbnetwork, logger=logger)
session.flush()
plenary = Plenary.get_plenary(dbnetdev, logger=logger)
with plenary.get_key():
plenary.stash()
try:
plenary.write(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbnetdev, None)
dsdb_runner.commit_or_rollback("Could not add network device to DSDB")
except:
plenary.restore_stash()
raise
return
def render(self, session, logger, chassis, label, rack, model, vendor, ip,
interface, mac, serial, comments, **arguments):
dbdns_rec, newly_created = grab_address(session,
chassis,
ip,
allow_restricted_domain=True,
allow_reserved=True,
preclude=True)
if not label:
label = dbdns_rec.fqdn.name
try:
Chassis.check_label(label)
except ArgumentError:
raise ArgumentError("Could not deduce a valid hardware label "
"from the chassis name. Please specify "
"--label.")
dblocation = get_location(session, rack=rack)
dbmodel = Model.get_unique(session,
name=model,
vendor=vendor,
machine_type='chassis',
compel=True)
# FIXME: Precreate chassis slots?
dbchassis = Chassis(label=label,
location=dblocation,
model=dbmodel,
serial_no=serial,
comments=comments)
session.add(dbchassis)
dbchassis.primary_name = dbdns_rec
# FIXME: get default name from the model
if not interface:
interface = "oa"
ifcomments = "Created automatically by add_chassis"
else:
ifcomments = None
dbinterface = get_or_create_interface(session,
dbchassis,
name=interface,
mac=mac,
interface_type="oa",
comments=ifcomments)
if ip:
dbnetwork = get_net_id_from_ip(session, ip)
check_ip_restrictions(dbnetwork, ip)
assign_address(dbinterface, ip, dbnetwork)
session.flush()
if ip:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbchassis, None)
dsdb_runner.commit_or_rollback("Could not add chassis to DSDB")
return
def add_interface(ifname, iftype):
""" Helper for adding a new interface, honouring dryrun """
if dryrun:
aqcmd("add_interface", "--interface", ifname, "--type", iftype)
# There's no Interface instace we could return here, but fortunately
# nothing will use the returned value in dryrun mode
return None
else:
return get_or_create_interface(session, dbswitch, name=ifname,
interface_type=iftype)
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, interface, network_device,
mac, iftype, comments, **arguments):
for arg in self.invalid_parameters:
if arguments.get(arg) is not None:
raise ArgumentError("Cannot use argument --%s when adding an "
"interface to a network device." % arg)
check_netdev_iftype(iftype)
dbnetdev = NetworkDevice.get_unique(session, network_device, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbnetdev)
get_or_create_interface(session, dbnetdev, name=interface, mac=mac,
interface_type=iftype, comments=comments,
preclude=True)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbnetdev, oldinfo)
dsdb_runner.commit_or_rollback("Could not update network device in DSDB")
return
def render(self, session, logger, chassis, label, rack, model, vendor,
ip, interface, mac, serial, comments, **arguments):
dbdns_rec, newly_created = grab_address(session, chassis, ip,
allow_restricted_domain=True,
allow_reserved=True,
preclude=True)
if not label:
label = dbdns_rec.fqdn.name
try:
Chassis.check_label(label)
except ArgumentError:
raise ArgumentError("Could not deduce a valid hardware label "
"from the chassis name. Please specify "
"--label.")
dblocation = get_location(session, rack=rack)
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
machine_type='chassis', compel=True)
# FIXME: Precreate chassis slots?
dbchassis = Chassis(label=label, location=dblocation, model=dbmodel,
serial_no=serial, comments=comments)
session.add(dbchassis)
dbchassis.primary_name = dbdns_rec
# FIXME: get default name from the model
if not interface:
interface = "oa"
ifcomments = "Created automatically by add_chassis"
else:
ifcomments = None
dbinterface = get_or_create_interface(session, dbchassis,
name=interface, mac=mac,
interface_type="oa",
comments=ifcomments)
if ip:
dbnetwork = get_net_id_from_ip(session, ip)
check_ip_restrictions(dbnetwork, ip)
assign_address(dbinterface, ip, dbnetwork)
session.flush()
if ip:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbchassis, None)
dsdb_runner.commit_or_rollback("Could not add chassis to DSDB")
return
def render(self, session, logger, interface, machine, mac, automac, model,
vendor, pg, autopg, type, comments, **arguments):
dbmachine = Machine.get_unique(session, machine, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
audit_results = []
q = session.query(Interface)
q = q.filter_by(name=interface, hardware_entity=dbmachine)
if q.first():
raise ArgumentError(
"Machine %s already has an interface named %s." %
(machine, interface))
if not type:
type = 'public'
management_types = ['bmc', 'ilo', 'ipmi']
for mtype in management_types:
if interface.startswith(mtype):
type = 'management'
break
if interface.startswith("bond"):
type = 'bonding'
elif interface.startswith("br"):
type = 'bridge'
# Test it last, VLANs can be added on top of almost anything
if '.' in interface:
type = 'vlan'
if type == "oa" or type == "loopback":
raise ArgumentError("Interface type '%s' is not valid for "
"machines." % type)
bootable = None
if type == 'public':
if interface == 'eth0':
bootable = True
else:
bootable = False
dbmanager = None
pending_removals = PlenaryCollection()
dsdb_runner = DSDBRunner(logger=logger)
if mac:
prev = session.query(Interface).filter_by(mac=mac).first()
if prev and prev.hardware_entity == dbmachine:
raise ArgumentError("{0} already has an interface with MAC "
"address {1}.".format(dbmachine, mac))
# Is the conflicting interface something that can be
# removed? It is if:
# - we are currently attempting to add a management interface
# - the old interface belongs to a machine
# - the old interface is associated with a host
# - that host was blindly created, and thus can be removed safely
if prev and type == 'management' and \
prev.hardware_entity.hardware_type == 'machine' and \
prev.hardware_entity.host and \
prev.hardware_entity.host.status.name == 'blind':
# FIXME: Is this just always allowed? Maybe restrict
# to only aqd-admin and the host itself?
dummy_machine = prev.hardware_entity
dummy_ip = dummy_machine.primary_ip
old_fqdn = str(dummy_machine.primary_name)
old_iface = prev.name
old_mac = prev.mac
old_network = get_net_id_from_ip(session, dummy_ip)
self.remove_prev(session, logger, prev, pending_removals)
session.flush()
dsdb_runner.delete_host_details(old_fqdn, dummy_ip, old_iface,
old_mac)
self.consolidate_names(session, logger, dbmachine,
dummy_machine.label, pending_removals)
# It seems like a shame to throw away the IP address that
# had been allocated for the blind host. Try to use it
# as it should be used...
dbmanager = self.add_manager(session, logger, dbmachine,
dummy_ip, old_network)
elif prev:
msg = describe_interface(session, prev)
raise ArgumentError("MAC address %s is already in use: %s." %
(mac, msg))
elif automac:
mac = self.generate_mac(session, dbmachine)
audit_results.append(('mac', mac))
else:
#Ignore now that Mac Address can be null
pass
if pg is not None:
port_group = verify_port_group(dbmachine, pg)
elif autopg:
port_group = choose_port_group(session, logger, dbmachine)
audit_results.append(('pg', port_group))
else:
port_group = None
dbinterface = get_or_create_interface(session,
dbmachine,
name=interface,
vendor=vendor,
model=model,
interface_type=type,
mac=mac,
bootable=bootable,
port_group=port_group,
comments=comments,
preclude=True)
# So far, we're *only* creating a manager if we happen to be
# removing a blind entry and we can steal its IP address.
if dbmanager:
assign_address(dbinterface, dbmanager.ip, dbmanager.network)
session.add(dbinterface)
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbmachine))
if pending_removals and dbmachine.host:
# Not an exact test, but the file won't be re-written
# if the contents are the same so calling too often is
# not a major expense.
plenaries.append(Plenary.get_plenary(dbmachine.host))
# Even though there may be removals going on the write key
# should be sufficient here.
key = plenaries.get_write_key()
try:
lock_queue.acquire(key)
pending_removals.stash()
plenaries.write(locked=True)
pending_removals.remove(locked=True)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not update host in DSDB")
except:
plenaries.restore_stash()
pending_removals.restore_stash()
raise
finally:
lock_queue.release(key)
if dbmachine.host:
# FIXME: reconfigure host
pass
for name, value in audit_results:
self.audit_result(session, name, value, **arguments)
return
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,
interface,
machine,
mac,
automac,
model,
vendor,
pg,
autopg,
iftype,
type,
comments,
**arguments
):
dbmachine = Machine.get_unique(session, machine, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
audit_results = []
if type:
self.deprecated_option("type", "Please use --iftype" "instead.", logger=logger, **arguments)
if not iftype:
iftype = type
if not iftype:
iftype = "public"
management_types = ["bmc", "ilo", "ipmi"]
for mtype in management_types:
if interface.startswith(mtype):
iftype = "management"
break
if interface.startswith("bond"):
iftype = "bonding"
elif interface.startswith("br"):
iftype = "bridge"
# Test it last, VLANs can be added on top of almost anything
if "." in interface:
iftype = "vlan"
if iftype == "oa" or iftype == "loopback":
raise ArgumentError("Interface type '%s' is not valid for " "machines." % iftype)
bootable = None
if iftype == "public":
if interface == "eth0":
bootable = True
else:
bootable = False
dbmanager = None
pending_removals = PlenaryCollection()
dsdb_runner = DSDBRunner(logger=logger)
if mac:
prev = session.query(Interface).filter_by(mac=mac).first()
if prev and prev.hardware_entity == dbmachine:
raise ArgumentError("{0} already has an interface with MAC " "address {1}.".format(dbmachine, mac))
# Is the conflicting interface something that can be
# removed? It is if:
# - we are currently attempting to add a management interface
# - the old interface belongs to a machine
# - the old interface is associated with a host
# - that host was blindly created, and thus can be removed safely
if (
prev
and iftype == "management"
and prev.hardware_entity.hardware_type == "machine"
and prev.hardware_entity.host
and prev.hardware_entity.host.status.name == "blind"
):
# FIXME: Is this just always allowed? Maybe restrict
# to only aqd-admin and the host itself?
dummy_machine = prev.hardware_entity
dummy_ip = dummy_machine.primary_ip
old_fqdn = str(dummy_machine.primary_name)
old_iface = prev.name
old_mac = prev.mac
old_network = get_net_id_from_ip(session, dummy_ip)
self.remove_prev(session, logger, prev, pending_removals)
session.flush()
dsdb_runner.delete_host_details(old_fqdn, dummy_ip, old_iface, old_mac)
self.consolidate_names(session, logger, dbmachine, dummy_machine.label, pending_removals)
# It seems like a shame to throw away the IP address that
# had been allocated for the blind host. Try to use it
# as it should be used...
dbmanager = self.add_manager(session, logger, dbmachine, dummy_ip, old_network)
elif prev:
msg = describe_interface(session, prev)
raise ArgumentError("MAC address %s is already in use: %s." % (mac, msg))
elif automac:
mac = self.generate_mac(session, dbmachine)
audit_results.append(("mac", mac))
else:
# Ignore now that Mac Address can be null
pass
if pg is not None:
port_group = verify_port_group(dbmachine, pg)
elif autopg:
port_group = choose_port_group(session, logger, dbmachine)
audit_results.append(("pg", port_group))
else:
port_group = None
dbinterface = get_or_create_interface(
session,
dbmachine,
name=interface,
vendor=vendor,
model=model,
interface_type=iftype,
mac=mac,
bootable=bootable,
port_group=port_group,
comments=comments,
preclude=True,
)
# So far, we're *only* creating a manager if we happen to be
# removing a blind entry and we can steal its IP address.
if dbmanager:
assign_address(dbinterface, dbmanager.ip, dbmanager.network, logger=logger)
session.add(dbinterface)
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbmachine))
if pending_removals and dbmachine.host:
# Not an exact test, but the file won't be re-written
# if the contents are the same so calling too often is
# not a major expense.
plenaries.append(Plenary.get_plenary(dbmachine.host))
# Even though there may be removals going on the write key
# should be sufficient here.
with plenaries.get_key():
pending_removals.stash()
try:
plenaries.write(locked=True)
pending_removals.remove(locked=True)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not update host in DSDB")
except:
plenaries.restore_stash()
pending_removals.restore_stash()
raise
if dbmachine.host:
# FIXME: reconfigure host
pass
for name, value in audit_results:
self.audit_result(session, name, value, **arguments)
return
