def render(self, session, logger, city, country, fullname, comments,
timezone, campus,
**arguments):
if country:
dbparent = Country.get_unique(session, country, compel=True)
else:
dbparent = Campus.get_unique(session, campus, compel=True)
dbcity = add_location(session, City, city, dbparent, fullname=fullname,
comments=comments, timezone=timezone)
session.flush()
plenary = Plenary.get_plenary(dbcity, logger=logger)
with plenary.get_key():
try:
plenary.write(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_city(city, dbcity.country.name, fullname)
dsdb_runner.commit_or_rollback()
except:
plenary.restore_stash()
raise
return
def render(self, session, logger, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(session,
dns_environment)
dbalias = Alias.get_unique(session, fqdn=fqdn,
dns_environment=dbdns_env, compel=True)
old_target_fqdn = str(dbalias.target.fqdn)
old_comments = dbalias.comments
if target:
old_target = dbalias.target
dbalias.target = create_target_if_needed(session, logger,
target, dbdns_env)
if dbalias.target != old_target:
delete_target_if_needed(session, old_target)
if comments is not None:
dbalias.comments = comments
session.flush()
if dbdns_env.is_default and dbalias.fqdn.dns_domain.name == "ms.com":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_alias(fqdn, dbalias.target.fqdn,
dbalias.comments, old_target_fqdn,
old_comments)
dsdb_runner.commit_or_rollback("Could not update alias in DSDB")
return
def render(self, session, logger, city, timezone, campus,
default_dns_domain, comments, **arguments):
dbcity = get_location(session, city=city)
# Updating machine templates is expensive, so only do that if needed
update_machines = False
if timezone is not None:
dbcity.timezone = timezone
if comments is not None:
dbcity.comments = comments
if default_dns_domain is not None:
if default_dns_domain:
dbdns_domain = DnsDomain.get_unique(session, default_dns_domain,
compel=True)
dbcity.default_dns_domain = dbdns_domain
else:
dbcity.default_dns_domain = None
prev_campus = None
dsdb_runner = None
dsdb_runner = DSDBRunner(logger=logger)
if campus is not None:
dbcampus = get_location(session, campus=campus)
# This one would change the template's locations hence forbidden
if dbcampus.hub != dbcity.hub:
# Doing this both to reduce user error and to limit
# testing required.
raise ArgumentError("Cannot change campus. {0} is in {1:l}, "
"while {2:l} is in {3:l}.".format(
dbcampus, dbcampus.hub,
dbcity, dbcity.hub))
if dbcity.campus:
prev_campus = dbcity.campus
dbcity.update_parent(parent=dbcampus)
update_machines = True
session.flush()
if campus is not None:
if prev_campus:
prev_name = prev_campus.name
else:
prev_name = None
dsdb_runner.update_city(city, dbcampus.name, prev_name)
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbcity))
if update_machines:
q = session.query(Machine)
q = q.filter(Machine.location_id.in_(dbcity.offspring_ids()))
logger.client_info("Updating %d machines..." % q.count())
for dbmachine in q:
plenaries.append(Plenary.get_plenary(dbmachine))
count = plenaries.write()
dsdb_runner.commit_or_rollback()
logger.client_info("Flushed %d templates." % count)
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))
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))
def del_dynamic_stubs(self, session, logger, dbstubs):
dsdb_runner = DSDBRunner(logger=logger)
for stub in dbstubs:
dsdb_runner.delete_host_details(str(stub.fqdn), stub.ip)
delete_dns_record(stub)
session.flush()
# This may take some time if the range is big, so be verbose
dsdb_runner.commit_or_rollback(verbose=True)
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, network_device, **arguments):
dbnetdev = NetworkDevice.get_unique(session, network_device, compel=True)
# Check and complain if the network device has any other addresses than its
# primary address
addrs = []
for addr in dbnetdev.all_addresses():
if addr.ip == dbnetdev.primary_ip:
continue
addrs.append(str(addr.ip))
if addrs:
raise ArgumentError("{0} still provides the following addresses, "
"delete them first: {1}.".format
(dbnetdev, ", ".join(addrs)))
dbdns_rec = dbnetdev.primary_name
ip = dbnetdev.primary_ip
old_fqdn = str(dbnetdev.primary_name.fqdn)
old_comments = dbnetdev.comments
session.delete(dbnetdev)
if dbdns_rec:
delete_dns_record(dbdns_rec)
session.flush()
# Any network device ports hanging off this network device should be deleted with
# the cascade delete of the network device.
netdev_plenary = Plenary.get_plenary(dbnetdev, logger=logger)
# clusters connected to this network device
plenaries = PlenaryCollection(logger=logger)
for dbcluster in dbnetdev.esx_clusters:
plenaries.append(Plenary.get_plenary(dbcluster))
with CompileKey.merge([netdev_plenary.get_key(), plenaries.get_key()]):
netdev_plenary.stash()
try:
plenaries.write(locked=True)
netdev_plenary.remove(locked=True)
if ip:
dsdb_runner = DSDBRunner(logger=logger)
# FIXME: restore interface name/MAC on rollback
dsdb_runner.delete_host_details(old_fqdn, ip,
comments=old_comments)
dsdb_runner.commit_or_rollback("Could not remove network device "
"from DSDB")
except:
plenaries.restore_stash()
netdev_plenary.restore_stash()
raise
return
def render(self, session, logger, campus, country, fullname, comments, **arguments):
dbcountry = Country.get_unique(session, country, compel=True)
add_location(session, Campus, campus, dbcountry, fullname=fullname, comments=comments)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_campus(campus, comments)
dsdb_runner.commit_or_rollback()
return
def add_srv_dsdb_callback(session, logger, dbsrv, real_holder=None, oldinfo=None, newly_created=None, comments=None):
dsdb_runner = DSDBRunner(logger=logger)
if not newly_created:
dsdb_runner.delete_host_details(dbsrv.dns_record.fqdn, dbsrv.dns_record.ip)
if isinstance(real_holder, Host):
dsdb_runner.update_host(real_holder.machine, oldinfo)
else:
dsdb_runner.add_host_details(dbsrv.dns_record.fqdn, dbsrv.dns_record.ip, comments=comments)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
def del_srv_dsdb_callback(session, logger, holder, dbsrv_addr, oldinfo, keep_dns):
dsdb_runner = DSDBRunner(logger=logger)
toplevel_holder = holder.toplevel_holder_object
if isinstance(toplevel_holder, Host):
dsdb_runner.update_host(toplevel_holder.hardware_entity, oldinfo)
if keep_dns:
dsdb_runner.add_host_details(
dbsrv_addr.dns_record.fqdn, dbsrv_addr.dns_record.ip, comments=dbsrv_addr.dns_record.comments
)
elif not keep_dns:
dsdb_runner.delete_host_details(str(dbsrv_addr.dns_record.fqdn), dbsrv_addr.dns_record.ip)
dsdb_runner.commit_or_rollback("Could not delete host from DSDB")
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, 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, interface, chassis, mac, comments,
rename_to, **arguments):
for arg in self.invalid_parameters:
if arguments.get(arg) is not None:
raise UnimplementedError("update_interface --chassis cannot use "
"the --%s option." % arg)
dbchassis = Chassis.get_unique(session, chassis, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbchassis,
name=interface, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbchassis)
if comments:
dbinterface.comments = comments
if mac:
dbinterface.mac = mac
if rename_to:
rename_interface(session, dbinterface, rename_to)
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, chassis, model, rack, ip, vendor, serial,
comments, **arguments):
dbchassis = Chassis.get_unique(session, chassis, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbchassis)
if vendor and not model:
model = dbchassis.model.name
if model:
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
machine_type='chassis', compel=True)
dbchassis.model = dbmodel
dblocation = get_location(session, rack=rack)
if dblocation:
dbchassis.location = dblocation
if serial is not None:
dbchassis.serial_no = serial
if ip:
update_primary_ip(session, dbchassis, ip)
if comments is not None:
dbchassis.comments = comments
session.add(dbchassis)
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 del_srv_dsdb_callback(session, logger, holder, dbsrv_addr, oldinfo,
keep_dns):
real_holder = holder.holder_object
if isinstance(real_holder, ResourceGroup):
real_holder = real_holder.holder.holder_object
dsdb_runner = DSDBRunner(logger=logger)
if isinstance(real_holder, Host):
dsdb_runner.update_host(real_holder.machine, oldinfo)
if keep_dns:
dsdb_runner.add_host_details(
dbsrv_addr.dns_record.fqdn,
dbsrv_addr.dns_record.ip,
comments=dbsrv_addr.dns_record.comments)
elif not keep_dns:
dsdb_runner.delete_host_details(str(dbsrv_addr.dns_record.fqdn),
dbsrv_addr.dns_record.ip)
dsdb_runner.commit_or_rollback("Could not delete host from DSDB")
def render(self, session, logger, fqdn, dns_environment, **kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(session, dns_environment)
dbdns_rec = Alias.get_unique(session, fqdn=fqdn, dns_environment=dbdns_env, compel=True)
domain = dbdns_rec.fqdn.dns_domain.name
old_target_fqdn = str(dbdns_rec.target)
old_comments = dbdns_rec.comments
target_is_restricted = dbdns_rec.target.dns_domain.restricted
delete_dns_record(dbdns_rec)
session.flush()
if dbdns_env.is_default and domain == "ms.com" and not target_is_restricted:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.del_alias(fqdn, old_target_fqdn, old_comments)
dsdb_runner.commit_or_rollback("Could not delete alias from DSDB")
return
def render(self, session, logger, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(session,
dns_environment)
dbalias = Alias.get_unique(session, fqdn=fqdn,
dns_environment=dbdns_env, compel=True)
old_target_fqdn = str(dbalias.target.fqdn)
old_comments = dbalias.comments
if target:
old_target = dbalias.target
dbalias.target = create_target_if_needed(session, logger,
target, dbdns_env)
# TODO: at some day we should verify that the new target is also
# bound as a server, and modify the ServiceInstanceServer bindings
# accordingly
for srv in dbalias.services_provided:
if srv.host or srv.cluster:
provider = srv.host or srv.cluster
logger.client_info("Warning: {0} provides {1:l}, and is "
"bound to {2:l}. Updating the target of "
"the alias may leave that server "
"binding in an inconsistent state."
.format(dbalias, srv.service_instance,
provider))
if dbalias.target != old_target:
delete_target_if_needed(session, old_target)
if comments is not None:
dbalias.comments = comments
session.flush()
if dbdns_env.is_default and dbalias.fqdn.dns_domain.name == "ms.com":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_alias(fqdn, dbalias.target.fqdn,
dbalias.comments, old_target_fqdn,
old_comments)
dsdb_runner.commit_or_rollback("Could not update alias in DSDB")
return
def add_srv_dsdb_callback(session,
logger,
dbsrv,
real_holder=None,
oldinfo=None,
newly_created=None,
comments=None):
dsdb_runner = DSDBRunner(logger=logger)
if not newly_created:
dsdb_runner.delete_host_details(dbsrv.dns_record.fqdn,
dbsrv.dns_record.ip)
if isinstance(real_holder, Host):
dsdb_runner.update_host(real_holder.machine, oldinfo)
else:
dsdb_runner.add_host_details(dbsrv.dns_record.fqdn,
dbsrv.dns_record.ip,
comments=comments)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
def del_srv_dsdb_callback(session, logger, holder, dbsrv_addr, oldinfo,
keep_dns):
real_holder = holder.holder_object
if isinstance(real_holder, ResourceGroup):
real_holder = real_holder.holder.holder_object
dsdb_runner = DSDBRunner(logger=logger)
if isinstance(real_holder, Host):
dsdb_runner.update_host(real_holder.machine, oldinfo)
if keep_dns:
dsdb_runner.add_host_details(dbsrv_addr.dns_record.fqdn,
dbsrv_addr.dns_record.ip,
comments=dbsrv_addr.dns_record.comments)
elif not keep_dns:
dsdb_runner.delete_host_details(str(dbsrv_addr.dns_record.fqdn),
dbsrv_addr.dns_record.ip)
dsdb_runner.commit_or_rollback("Could not delete host from DSDB")
def render(self, session, logger, city, **arguments):
dbcity = get_location(session, city=city)
name = dbcity.name
country = dbcity.country.name
fullname = dbcity.fullname
plenary = PlenaryCity(dbcity, logger=logger)
CommandDelLocation.render(self, session=session, name=city,
type='city', **arguments)
session.flush()
key = plenary.get_remove_key()
try:
lock_queue.acquire(key)
plenary.remove(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.del_city(name, country, fullname)
dsdb_runner.commit_or_rollback()
except:
plenary.restore_stash()
raise
finally:
lock_queue.release(key)
return
def render(self, session, logger, city, country, fullname, comments,
timezone, campus, **arguments):
if country:
dbparent = Country.get_unique(session, country, compel=True)
else:
dbparent = Campus.get_unique(session, campus, compel=True)
dbcity = add_location(session,
City,
city,
dbparent,
fullname=fullname,
comments=comments,
timezone=timezone)
session.flush()
plenary = PlenaryCity(dbcity, logger=logger)
key = plenary.get_write_key()
try:
lock_queue.acquire(key)
plenary.write(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_city(city, dbcity.country.name, fullname)
dsdb_runner.commit_or_rollback()
except:
plenary.restore_stash()
raise
finally:
lock_queue.release(key)
def render(self, session, logger, chassis, model, rack, ip, vendor, serial,
comments, **arguments):
dbchassis = Chassis.get_unique(session, chassis, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbchassis)
if vendor and not model:
model = dbchassis.model.name
if model:
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
model_type=ChassisType.Chassis,
compel=True)
dbchassis.model = dbmodel
dblocation = get_location(session, rack=rack)
if dblocation:
dbchassis.location = dblocation
if serial is not None:
dbchassis.serial_no = serial
if ip:
update_primary_ip(session, logger, dbchassis, ip)
if comments is not None:
dbchassis.comments = comments
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, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
dbalias = Alias.get_unique(session,
fqdn=fqdn,
dns_environment=dbdns_env,
compel=True)
old_target_fqdn = str(dbalias.target.fqdn)
old_comments = dbalias.comments
if target:
old_target = dbalias.target
dbalias.target = create_target_if_needed(session, logger, target,
dbdns_env)
if dbalias.target != old_target:
delete_target_if_needed(session, old_target)
if comments is not None:
dbalias.comments = comments
session.flush()
if dbdns_env.is_default and dbalias.fqdn.dns_domain.name == "ms.com":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_alias(fqdn, dbalias.target.fqdn,
dbalias.comments, old_target_fqdn,
old_comments)
dsdb_runner.commit_or_rollback("Could not update alias in DSDB")
return
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, 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, 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, dns_domain, **arguments):
dbdns_domain = DnsDomain.get_unique(session, dns_domain, compel=True)
q = session.query(Fqdn)
q = q.filter_by(dns_domain=dbdns_domain)
if q.first():
raise ArgumentError("DNS domain %s cannot be deleted while still "
"in use." % dns_domain)
if dbdns_domain.dns_maps:
raise ArgumentError("{0} is still mapped to locations and cannot "
"be deleted.".format(dbdns_domain))
comments = dbdns_domain.comments
session.delete(dbdns_domain)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.delete_dns_domain(dns_domain, comments)
dsdb_runner.commit_or_rollback()
return
def render(self, session, logger, name, hostname, cluster, resourcegroup,
keep_dns, **arguments):
validate_basic("name", name)
if name == "hostname":
raise ArgumentError("The primary address of the host cannot "
"be deleted.")
holder = get_resource_holder(session,
hostname,
cluster,
resourcegroup,
compel=False)
dbsrv = ServiceAddress.get_unique(session,
name=name,
holder=holder,
compel=True)
if isinstance(holder.holder_object, Host):
oldinfo = DSDBRunner.snapshot_hw(holder.holder_object.machine)
else:
oldinfo = None
dbdns_rec = dbsrv.dns_record
for addr in dbsrv.assignments:
addr.interface.assignments.remove(addr)
session.expire(dbsrv, ['assignments'])
session.flush()
# Check if the address was assigned to multiple interfaces, and remove
# the DNS entries if this was the last use
q = session.query(AddressAssignment)
q = q.filter_by(network=dbdns_rec.network)
q = q.filter_by(ip=dbdns_rec.ip)
other_uses = q.all()
del_resource(session,
logger,
dbsrv,
dsdb_callback=del_srv_dsdb_callback,
oldinfo=oldinfo,
keep_dns=other_uses or keep_dns)
if not other_uses and not keep_dns:
delete_dns_record(dbdns_rec)
return
def render(self, session, logger, switch, **arguments):
dbswitch = Switch.get_unique(session, switch, compel=True)
# Check and complain if the switch has any other addresses than its
# primary address
addrs = []
for addr in dbswitch.all_addresses():
if addr.ip == dbswitch.primary_ip:
continue
addrs.append(str(addr.ip))
if addrs:
raise ArgumentError("{0} still provides the following addresses, "
"delete them first: {1}.".format
(dbswitch, ", ".join(addrs)))
dbdns_rec = dbswitch.primary_name
ip = dbswitch.primary_ip
old_fqdn = str(dbswitch.primary_name.fqdn)
old_comments = dbswitch.comments
session.delete(dbswitch)
if dbdns_rec:
delete_dns_record(dbdns_rec)
session.flush()
# Any switch ports hanging off this switch should be deleted with
# the cascade delete of the switch.
switch_plenary = Plenary.get_plenary(dbswitch, logger=logger)
# clusters connected to this switch
plenaries = PlenaryCollection(logger=logger)
for dbcluster in dbswitch.esx_clusters:
plenaries.append(Plenary.get_plenary(dbcluster))
key = CompileKey.merge([switch_plenary.get_remove_key(),
plenaries.get_write_key()])
try:
lock_queue.acquire(key)
switch_plenary.stash()
plenaries.write(locked=True)
switch_plenary.remove(locked=True)
if ip:
dsdb_runner = DSDBRunner(logger=logger)
# FIXME: restore interface name/MAC on rollback
dsdb_runner.delete_host_details(old_fqdn, ip, comments=old_comments)
dsdb_runner.commit_or_rollback("Could not remove switch from DSDB")
return
except:
plenaries.restore_stash()
switch_plenary.restore_stash()
raise
finally:
lock_queue.release(key)
def render(self, session, logger, city, **arguments):
dbcity = get_location(session, city=city)
name = dbcity.name
country = dbcity.country.name
fullname = dbcity.fullname
plenary = Plenary.get_plenary(dbcity, logger=logger)
CommandDelLocation.render(self, session=session, name=city,
type='city', **arguments)
session.flush()
with plenary.get_key():
try:
plenary.remove(locked=True)
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.del_city(name, country, fullname)
dsdb_runner.commit_or_rollback()
except:
plenary.restore_stash()
raise
return
def del_dynamic_stubs(self, session, logger, dbstubs):
dsdb_runner = DSDBRunner(logger=logger)
for stub in dbstubs:
dsdb_runner.delete_host_details(str(stub.fqdn), stub.ip)
delete_dns_record(stub)
session.flush()
# This may take some time if the range is big, so be verbose
dsdb_runner.commit_or_rollback(verbose=True)
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, 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, building, city, fullname, comments,
address, **arguments):
dbcity = City.get_unique(session, city, compel=True)
add_location(session, Building, building, dbcity, fullname=fullname,
address=address, comments=comments)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_building(building, city, address)
if dbcity.campus:
dsdb_runner.add_campus_building(dbcity.campus, building)
dsdb_runner.commit_or_rollback()
return
def render(self, session, logger, campus, **arguments):
dbcampus = get_location(session, campus=campus)
name = dbcampus.name
result = CommandDelLocation.render(self, session=session, name=name,
type='campus', **arguments)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.del_campus(name)
dsdb_runner.commit_or_rollback()
return result
def render(self, session, logger, building, city, fullname, comments,
address, **arguments):
dbcity = City.get_unique(session, city, compel=True)
add_location(session,
Building,
building,
dbcity,
fullname=fullname,
address=address,
comments=comments)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_building(building, city, address)
if dbcity.campus:
dsdb_runner.add_campus_building(dbcity.campus, building)
dsdb_runner.commit_or_rollback()
return
def render(self, session, logger, name, hostname, cluster, resourcegroup,
keep_dns, **arguments):
validate_basic("name", name)
if name == "hostname":
raise ArgumentError("The primary address of the host cannot "
"be deleted.")
holder = get_resource_holder(session, hostname, cluster,
resourcegroup, compel=False)
dbsrv = ServiceAddress.get_unique(session, name=name, holder=holder,
compel=True)
if isinstance(holder.holder_object, Host):
oldinfo = DSDBRunner.snapshot_hw(holder.holder_object.machine)
else:
oldinfo = None
dbdns_rec = dbsrv.dns_record
for addr in dbsrv.assignments:
addr.interface.assignments.remove(addr)
session.expire(dbsrv, ['assignments'])
session.flush()
# Check if the address was assigned to multiple interfaces, and remove
# the DNS entries if this was the last use
q = session.query(AddressAssignment)
q = q.filter_by(network=dbdns_rec.network)
q = q.filter_by(ip=dbdns_rec.ip)
other_uses = q.all()
del_resource(session, logger, dbsrv,
dsdb_callback=del_srv_dsdb_callback, oldinfo=oldinfo,
keep_dns=other_uses or keep_dns)
if not other_uses and not keep_dns:
delete_dns_record(dbdns_rec)
return
def render(self, session, logger, dns_domain, restricted, comments,
**arguments):
DnsDomain.get_unique(session, dns_domain, preclude=True)
dbdns_domain = DnsDomain(name=dns_domain, comments=comments)
if restricted:
dbdns_domain.restricted = True
session.add(dbdns_domain)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_dns_domain(dbdns_domain.name, comments)
dsdb_runner.commit_or_rollback()
return
def render(self, session, logger, building, **arguments):
dbbuilding = get_location(session, building=building)
city = dbbuilding.city
address = dbbuilding.address
campus = dbbuilding.campus
result = CommandDelLocation.render(self,
session=session,
name=building,
type='building',
**arguments)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
if campus:
dsdb_runner.del_campus_building(campus.name, building)
dsdb_runner.del_building(building, city.name, address)
dsdb_runner.commit_or_rollback()
return result
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, campus, country, fullname, comments,
**arguments):
dbcountry = Country.get_unique(session, country, compel=True)
add_location(session,
Campus,
campus,
dbcountry,
fullname=fullname,
comments=comments)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_campus(campus, comments)
dsdb_runner.commit_or_rollback()
return
class CommandAddAlias(BrokerCommand):
required_parameters = ["fqdn", "target"]
def render(self, session, logger, fqdn, dns_environment, target, comments,
**kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
dbfqdn = Fqdn.get_or_create(session,
dns_environment=dbdns_env,
fqdn=fqdn)
if dbfqdn.dns_domain.restricted:
raise ArgumentError(
"{0} is restricted, aliases are not allowed.".format(
dbfqdn.dns_domain))
DnsRecord.get_unique(session, fqdn=dbfqdn, preclude=True)
dbtarget = create_target_if_needed(session, logger, target, dbdns_env)
try:
db_record = Alias(fqdn=dbfqdn, target=dbtarget, comments=comments)
session.add(db_record)
except ValueError, err:
raise ArgumentError(err.message)
session.flush()
if dbdns_env.is_default and dbfqdn.dns_domain.name == "ms.com" and \
not dbtarget.dns_domain.restricted:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.add_alias(fqdn, target, comments)
dsdb_runner.commit_or_rollback("Could not add alias to DSDB")
return
def render(self, session, logger, chassis, clear_slots, **arguments):
dbchassis = Chassis.get_unique(session, chassis, compel=True)
# Check and complain if the chassis has any other addresses than its
# primary address
addrs = []
for addr in dbchassis.all_addresses():
if addr.ip == dbchassis.primary_ip:
continue
addrs.append(str(addr.ip))
if addrs:
raise ArgumentError("{0} still provides the following addresses, "
"delete them first: {1}.".format
(dbchassis, ", ".join(addrs)))
q = session.query(ChassisSlot)
q = q.filter_by(chassis=dbchassis)
q = q.filter(ChassisSlot.machine_id != None)
machine_count = q.count()
if machine_count > 0 and not clear_slots:
raise ArgumentError("{0} is still in use by {1} machines. Use "
"--clear_slots if you really want to delete "
"it.".format(dbchassis, machine_count))
# Order matters here
dbdns_rec = dbchassis.primary_name
ip = dbchassis.primary_ip
old_fqdn = str(dbchassis.primary_name.fqdn)
old_comments = dbchassis.primary_name.comments
session.delete(dbchassis)
if dbdns_rec:
delete_dns_record(dbdns_rec)
session.flush()
if ip:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.delete_host_details(old_fqdn, ip, comments=old_comments)
dsdb_runner.commit_or_rollback("Could not remove chassis from DSDB")
return
def render(self, session, logger, fqdn, dns_environment, **kwargs):
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
dbdns_rec = Alias.get_unique(session,
fqdn=fqdn,
dns_environment=dbdns_env,
compel=True)
domain = dbdns_rec.fqdn.dns_domain.name
old_target_fqdn = str(dbdns_rec.target)
old_comments = dbdns_rec.comments
target_is_restricted = dbdns_rec.target.dns_domain.restricted
delete_dns_record(dbdns_rec)
session.flush()
if dbdns_env.is_default and domain == "ms.com" and not target_is_restricted:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.del_alias(fqdn, old_target_fqdn, old_comments)
dsdb_runner.commit_or_rollback("Could not delete alias from DSDB")
return
def render(self, session, logger, dns_domain, **arguments):
dbdns_domain = DnsDomain.get_unique(session, dns_domain, compel=True)
q = session.query(Fqdn)
q = q.filter_by(dns_domain=dbdns_domain)
if q.first():
raise ArgumentError("DNS domain %s cannot be deleted while still "
"in use." % dns_domain)
if dbdns_domain.dns_maps:
raise ArgumentError("{0} is still mapped to locations and cannot "
"be deleted.".format(dbdns_domain))
comments = dbdns_domain.comments
session.delete(dbdns_domain)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.delete_dns_domain(dns_domain, comments)
dsdb_runner.commit_or_rollback()
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, interface,
fqdn, ip, label, keep_dns, network_environment, **kwargs):
if machine:
hwtype = 'machine'
hwname = machine
elif chassis:
hwtype = 'chassis'
hwname = chassis
elif switch:
hwtype = 'switch'
hwname = switch
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)
dbnet_env = NetworkEnvironment.get_unique_or_default(
session, network_environment)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if fqdn:
dbdns_rec = ARecord.get_unique(
session,
fqdn=fqdn,
dns_environment=dbnet_env.dns_environment,
compel=True)
ip = dbdns_rec.ip
addr = None
if ip:
addr = first_of(dbinterface.assignments, lambda x: x.ip == ip)
if not addr:
raise ArgumentError(
"{0} does not have IP address {1} assigned to "
"it.".format(dbinterface, ip))
elif label is not None:
addr = first_of(dbinterface.assignments,
lambda x: x.label == label)
if not addr:
raise ArgumentError("{0} does not have an address with label "
"{1}.".format(dbinterface, label))
if not addr:
raise ArgumentError("Please specify the address to be removed "
"using either --ip, --label, or --fqdn.")
dbnetwork = addr.network
ip = addr.ip
if dbnetwork.network_environment != dbnet_env:
raise ArgumentError("The specified address lives in {0:l}, not in "
"{1:l}. Use the --network_environment option "
"to select the correct environment.".format(
dbnetwork.network_environment, dbnet_env))
# Forbid removing the primary name
if ip == dbhw_ent.primary_ip:
raise ArgumentError("The primary IP address of a hardware entity "
"cannot be removed.")
dbinterface.assignments.remove(addr)
# Check if the address was assigned to multiple interfaces, and remove
# the DNS entries if this was the last use
q = session.query(AddressAssignment)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
other_uses = q.all()
if not other_uses and not keep_dns:
q = session.query(ARecord)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
q = q.join(ARecord.fqdn)
q = q.filter_by(dns_environment=dbnet_env.dns_environment)
map(delete_dns_record, q.all())
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)
dsdb_runner.update_host(dbhw_ent, oldinfo)
if not other_uses and keep_dns:
q = session.query(ARecord)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
dbdns_rec = q.first()
dsdb_runner.add_host_details(dbdns_rec.fqdn, ip)
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)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
return
def render(self, session, logger, machine, model, vendor, serial,
chassis, slot, clearchassis, multislot,
vmhost, cluster, allow_metacluster_change,
cpuname, cpuvendor, cpuspeed, cpucount, memory, ip,
**arguments):
dbmachine = Machine.get_unique(session, machine, compel=True)
plenaries = PlenaryCollection(logger=logger)
oldinfo = DSDBRunner.snapshot_hw(dbmachine)
if clearchassis:
del dbmachine.chassis_slot[:]
remove_plenaries = PlenaryCollection(logger=logger)
if chassis:
dbchassis = Chassis.get_unique(session, chassis, compel=True)
if machine_plenary_will_move(old=dbmachine.location,
new=dbchassis.location):
remove_plenaries.append(Plenary.get_plenary(dbmachine))
dbmachine.location = dbchassis.location
if slot is None:
raise ArgumentError("Option --chassis requires --slot "
"information.")
self.adjust_slot(session, logger,
dbmachine, dbchassis, slot, multislot)
elif slot is not None:
dbchassis = None
for dbslot in dbmachine.chassis_slot:
if dbchassis and dbslot.chassis != dbchassis:
raise ArgumentError("Machine in multiple chassis, please "
"use --chassis argument.")
dbchassis = dbslot.chassis
if not dbchassis:
raise ArgumentError("Option --slot requires --chassis "
"information.")
self.adjust_slot(session, logger,
dbmachine, dbchassis, slot, multislot)
dblocation = get_location(session, **arguments)
if dblocation:
loc_clear_chassis = False
for dbslot in dbmachine.chassis_slot:
dbcl = dbslot.chassis.location
if dbcl != dblocation:
if chassis or slot is not None:
raise ArgumentError("{0} conflicts with chassis {1!s} "
"location {2}.".format(dblocation,
dbslot.chassis, dbcl))
else:
loc_clear_chassis = True
if loc_clear_chassis:
del dbmachine.chassis_slot[:]
if machine_plenary_will_move(old=dbmachine.location,
new=dblocation):
remove_plenaries.append(Plenary.get_plenary(dbmachine))
dbmachine.location = dblocation
if model or vendor:
# If overriding model, should probably overwrite default
# machine specs as well.
if not model:
model = dbmachine.model.name
if not vendor:
vendor = dbmachine.model.vendor.name
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
compel=True)
if dbmodel.machine_type not in ['blade', 'rackmount',
'workstation', 'aurora_node',
'virtual_machine']:
raise ArgumentError("The update_machine command cannot update "
"machines of type %s." %
dbmodel.machine_type)
# We probably could do this by forcing either cluster or
# location data to be available as appropriate, but really?
# Failing seems reasonable.
if dbmodel.machine_type != dbmachine.model.machine_type and \
'virtual_machine' in [dbmodel.machine_type,
dbmachine.model.machine_type]:
raise ArgumentError("Cannot change machine from %s to %s." %
(dbmachine.model.machine_type,
dbmodel.machine_type))
old_nic_model = dbmachine.model.nic_model
new_nic_model = dbmodel.nic_model
if old_nic_model != new_nic_model:
for iface in dbmachine.interfaces:
if iface.model == old_nic_model:
iface.model = new_nic_model
dbmachine.model = dbmodel
if cpuname or cpuvendor or cpuspeed is not None:
dbcpu = Cpu.get_unique(session, name=cpuname, vendor=cpuvendor,
speed=cpuspeed, compel=True)
dbmachine.cpu = dbcpu
if cpucount is not None:
dbmachine.cpu_quantity = cpucount
if memory is not None:
dbmachine.memory = memory
if serial:
dbmachine.serial_no = serial
if ip:
update_primary_ip(session, dbmachine, ip)
# FIXME: For now, if a machine has its interface(s) in a portgroup
# this command will need to be followed by an update_interface to
# re-evaluate the portgroup for overflow.
# It would be better to have --pg and --autopg options to let it
# happen at this point.
if cluster or vmhost:
if not dbmachine.vm_container:
raise ArgumentError("Cannot convert a physical machine to "
"virtual.")
old_holder = dbmachine.vm_container.holder.holder_object
resholder = get_resource_holder(session, hostname=vmhost,
cluster=cluster, compel=False)
new_holder = resholder.holder_object
# TODO: do we want to allow moving machines between the cluster and
# metacluster level?
if new_holder.__class__ != old_holder.__class__:
raise ArgumentError("Cannot move a VM between a cluster and a "
"stand-alone host.")
if cluster:
if new_holder.metacluster != old_holder.metacluster \
and not allow_metacluster_change:
raise ArgumentError("Current {0:l} does not match "
"new {1:l}."
.format(old_holder.metacluster,
new_holder.metacluster))
remove_plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
dbmachine.vm_container.holder = resholder
for dbdisk in dbmachine.disks:
if not isinstance(dbdisk, VirtualDisk):
continue
old_share = dbdisk.share
if isinstance(old_share.holder, BundleResource):
resourcegroup = old_share.holder.name
else:
resourcegroup = None
new_share = find_share(new_holder, resourcegroup, old_share.name,
error=ArgumentError)
# If the shares are registered at the metacluster level and both
# clusters are in the same metacluster, then there will be no
# real change here
if new_share != old_share:
old_share.disks.remove(dbdisk)
new_share.disks.append(dbdisk)
if isinstance(new_holder, Cluster):
dbmachine.location = new_holder.location_constraint
else:
dbmachine.location = new_holder.location
session.flush()
plenaries.append(Plenary.get_plenary(old_holder))
plenaries.append(Plenary.get_plenary(new_holder))
if dbmachine.vm_container:
plenaries.append(Plenary.get_plenary(dbmachine.vm_container))
session.flush()
# Check if the changed parameters still meet cluster capacity
# requiremets
if dbmachine.cluster:
dbmachine.cluster.validate()
if allow_metacluster_change:
dbmachine.cluster.metacluster.validate()
if dbmachine.host and dbmachine.host.cluster:
dbmachine.host.cluster.validate()
# The check to make sure a plenary file is not written out for
# dummy aurora hardware is within the call to write(). This way
# it is consistent without altering (and forgetting to alter)
# all the calls to the method.
plenaries.append(Plenary.get_plenary(dbmachine))
if remove_plenaries.plenaries and dbmachine.host:
plenaries.append(Plenary.get_plenary(dbmachine.host))
key = CompileKey.merge([plenaries.get_write_key(),
remove_plenaries.get_remove_key()])
try:
lock_queue.acquire(key)
remove_plenaries.stash()
plenaries.write(locked=True)
remove_plenaries.remove(locked=True)
if dbmachine.host:
# XXX: May need to reconfigure.
pass
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbmachine, oldinfo)
dsdb_runner.commit_or_rollback("Could not update machine in DSDB")
except:
plenaries.restore_stash()
remove_plenaries.restore_stash()
raise
finally:
lock_queue.release(key)
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