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
class CommandAddAuroraHost(CommandAddHost):
required_parameters = ["hostname"]
# Look for node name like <building><rack_id>c<chassis_id>n<node_num>
nodename_re = re.compile(r'^\s*([a-zA-Z]+)(\d+)c(\d+)n(\d+)\s*$')
def render(self, session, logger, hostname, osname, osversion, **kwargs):
# Pull relevant info out of dsdb...
dsdb_runner = DSDBRunner(logger=logger)
try:
fields = dsdb_runner.show_host(hostname)
except ProcessException, e:
raise ArgumentError("Could not find %s in DSDB: %s" %
(hostname, e))
fqdn = fields["fqdn"]
dsdb_lookup = fields["dsdb_lookup"]
if fields["node"]:
machine = fields["node"]
elif fields["primary_name"]:
machine = fields["primary_name"]
else:
machine = dsdb_lookup
# Create a machine
dbmodel = Model.get_unique(session, name="aurora_model",
vendor="aurora_vendor", compel=True)
dbmachine = Machine.get_unique(session, machine)
dbslot = None
if not dbmachine:
m = self.nodename_re.search(machine)
if m:
(building, rid, cid, nodenum) = m.groups()
dbbuilding = session.query(Building).filter_by(
name=building).first()
if not dbbuilding:
raise ArgumentError("Failed to find building %s for "
"node %s, please add an Aurora "
"machine manually and follow with "
"add_host." % (building, machine))
rack = building + rid
dbrack = session.query(Rack).filter_by(name=rack).first()
if not dbrack:
try:
rack_fields = dsdb_runner.show_rack(rack)
dbrack = Rack(name=rack, fullname=rack,
parent=dbbuilding,
rack_row=rack_fields["rack_row"],
rack_column=rack_fields["rack_col"])
session.add(dbrack)
except (ProcessException, ValueError), e:
logger.client_info("Rack %s not defined in DSDB." % rack)
dblocation = dbrack or dbbuilding
chassis = rack + "c" + cid
dbdns_domain = session.query(DnsDomain).filter_by(
name="ms.com").first()
dbchassis = Chassis.get_unique(session, chassis)
if not dbchassis:
dbchassis_model = Model.get_unique(session,
name="aurora_chassis_model",
vendor="aurora_vendor",
compel=True)
dbchassis = Chassis(label=chassis, location=dblocation,
model=dbchassis_model)
session.add(dbchassis)
dbfqdn = Fqdn.get_or_create(session, name=chassis,
dns_domain=dbdns_domain,
preclude=True)
dbdns_rec = ReservedName(fqdn=dbfqdn)
session.add(dbdns_rec)
dbchassis.primary_name = dbdns_rec
dbslot = session.query(ChassisSlot).filter_by(
chassis=dbchassis, slot_number=nodenum).first()
# Note: Could be even more persnickity here and check that
# the slot is currently empty. Seems like overkill.
if not dbslot:
dbslot = ChassisSlot(chassis=dbchassis,
slot_number=nodenum)
session.add(dbslot)
else:
dbnet_env = NetworkEnvironment.get_unique_or_default(session)
try:
host_ip = gethostbyname(hostname)
except gaierror, e:
raise ArgumentError("Error when looking up host: %d, %s" %
(e.errno, e.strerror))
dbnetwork = get_net_id_from_ip(session, IPv4Address(host_ip), dbnet_env)
dblocation = dbnetwork.location.building
