def hostlist_to_hosts(session, hostlist):
dbdns_env = DnsEnvironment.get_unique_or_default(session)
failed = []
dbhosts = []
dns_domains = {}
for host in hostlist:
if "." not in host:
failed.append("%s: Not an FQDN." % host)
continue
short, dns_domain = host.split(".", 1)
try:
if dns_domain not in dns_domains:
dbdns_domain = DnsDomain.get_unique(session, dns_domain,
compel=True)
dns_domains[dns_domain] = dbdns_domain
dbdns_rec = DnsRecord.get_unique(session, name=short,
dns_domain=dns_domains[dns_domain],
dns_environment=dbdns_env,
query_options=[joinedload('hardware_entity')],
compel=True)
if not dbdns_rec.hardware_entity or \
not dbdns_rec.hardware_entity.host:
raise NotFoundException("Host %s not found." % host)
dbhosts.append(dbdns_rec.hardware_entity.host)
except NotFoundException, err:
failed.append("%s: %s" % (host, err))
continue
except ArgumentError, err:
failed.append("%s: %s" % (host, err))
continue
def render(self, session, hostname, machine, cpuname, cpuvendor, cpuspeed,
cpucount, memory, cluster, share, fullinfo, style, **arguments):
if fullinfo or style != 'raw':
q = search_hardware_entity_query(session, Machine, **arguments)
else:
q = search_hardware_entity_query(session, Machine.label, **arguments)
if machine:
q = q.filter_by(label=machine)
if hostname:
dns_rec = DnsRecord.get_unique(session, fqdn=hostname, compel=True)
q = q.filter(Machine.primary_name_id == dns_rec.id)
if cpuname or cpuvendor or cpuspeed is not None:
subq = Cpu.get_matching_query(session, name=cpuname,
vendor=cpuvendor, speed=cpuspeed,
compel=True)
q = q.filter(Machine.cpu_id.in_(subq))
if cpucount is not None:
q = q.filter_by(cpu_quantity=cpucount)
if memory is not None:
q = q.filter_by(memory=memory)
if cluster:
dbcluster = Cluster.get_unique(session, cluster, compel=True)
if isinstance(dbcluster, MetaCluster):
q = q.join('vm_container', ClusterResource, Cluster)
q = q.filter_by(metacluster=dbcluster)
else:
q = q.join('vm_container', ClusterResource)
q = q.filter_by(cluster=dbcluster)
q = q.reset_joinpoint()
if share:
v2shares = session.query(Share.id).filter_by(name=share)
if not v2shares.count():
raise NotFoundException("No shares found with name {0}."
.format(share))
NasAlias = aliased(VirtualNasDisk)
q = q.join('disks', (NasAlias, NasAlias.id == Disk.id))
q = q.filter(NasAlias.share_id.in_(v2shares.subquery()))
q = q.reset_joinpoint()
if fullinfo or style != "raw":
q = q.options(joinedload('location'),
subqueryload('interfaces'),
lazyload('interfaces.hardware_entity'),
joinedload('interfaces.assignments'),
joinedload('interfaces.assignments.dns_records'),
joinedload('chassis_slot'),
subqueryload('chassis_slot.chassis'),
subqueryload('disks'),
subqueryload('host'),
lazyload('host.hardware_entity'),
subqueryload('host.services_used'),
subqueryload('host._cluster'),
lazyload('host._cluster.host'))
return q.all()
return StringAttributeList(q.all(), "label")
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)
def render(self, session, hostname, machine, cpuname, cpuvendor, cpuspeed,
cpucount, memory, cluster, share, fullinfo, style, **arguments):
if fullinfo or style != 'raw':
q = search_hardware_entity_query(session, Machine, **arguments)
else:
q = search_hardware_entity_query(session, Machine.label, **arguments)
if machine:
q = q.filter_by(label=machine)
if hostname:
dns_rec = DnsRecord.get_unique(session, fqdn=hostname, compel=True)
q = q.filter(Machine.primary_name_id==dns_rec.id)
if cpuname or cpuvendor or cpuspeed is not None:
subq = Cpu.get_matching_query(session, name=cpuname,
vendor=cpuvendor, speed=cpuspeed,
compel=True)
q = q.filter(Machine.cpu_id.in_(subq))
if cpucount is not None:
q = q.filter_by(cpu_quantity=cpucount)
if memory is not None:
q = q.filter_by(memory=memory)
if cluster:
dbcluster = Cluster.get_unique(session, cluster, compel=True)
if isinstance(dbcluster, MetaCluster):
q = q.join('vm_container', ClusterResource, Cluster)
q = q.filter_by(metacluster=dbcluster)
else:
q = q.join('vm_container', ClusterResource)
q = q.filter_by(cluster=dbcluster)
q = q.reset_joinpoint()
if share:
#v2
v2shares = session.query(Share.id).filter_by(name=share).all()
if v2shares:
NasAlias = aliased(VirtualDisk)
q = q.join('disks', (NasAlias, NasAlias.id == Disk.id))
q = q.filter(
NasAlias.share_id.in_(map(lambda s: s[0], v2shares)))
q = q.reset_joinpoint()
if fullinfo:
q = q.options(joinedload('location'),
subqueryload('interfaces'),
joinedload('interfaces.assignments'),
joinedload('interfaces.assignments.dns_records'),
joinedload('chassis_slot'),
subqueryload('chassis_slot.chassis'),
subqueryload('disks'),
subqueryload('host'),
subqueryload('host.services_used'),
subqueryload('host._cluster'))
return q.all()
return SimpleMachineList(q.all())
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)
def render(self,
session,
fqdn,
record_type,
dns_environment,
network_environment=None,
**arguments):
if network_environment:
if not isinstance(network_environment, NetworkEnvironment):
network_environment = NetworkEnvironment.get_unique_or_default(
session, network_environment)
if not dns_environment:
dns_environment = network_environment.dns_environment
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
# No compel here. query(DnsRecord).filter_by(fqdn=None) will fail if the
# FQDN is invalid, and that will give a better error message.
dbfqdn = Fqdn.get_unique(session, fqdn=fqdn, dns_environment=dbdns_env)
if record_type:
if record_type in DNS_RRTYPE_MAP:
cls = DNS_RRTYPE_MAP[record_type]
else:
cls = DnsRecord.polymorphic_subclass(
record_type, "Unknown DNS record type")
else:
cls = DnsRecord
# We want to query(ARecord) instead of
# query(DnsRecord).filter_by(record_type='a_record'), because the former
# works for DynamicStub as well
q = session.query(cls)
if cls == DnsRecord:
q = q.with_polymorphic('*')
q = q.filter_by(fqdn=dbfqdn)
result = q.all()
if not result:
raise NotFoundException("%s %s not found." %
(cls._get_class_label(), fqdn))
return result
def render(self, session, fqdn, record_type, dns_environment,
network_environment=None, **arguments):
if network_environment:
if not isinstance(network_environment, NetworkEnvironment):
network_environment = NetworkEnvironment.get_unique_or_default(session,
network_environment)
if not dns_environment:
dns_environment = network_environment.dns_environment
dbdns_env = DnsEnvironment.get_unique_or_default(session,
dns_environment)
# No compel here. query(DnsRecord).filter_by(fqdn=None) will fail if the
# FQDN is invalid, and that will give a better error message.
dbfqdn = Fqdn.get_unique(session, fqdn=fqdn,
dns_environment=dbdns_env)
if record_type:
if record_type in DNS_RRTYPE_MAP:
cls = DNS_RRTYPE_MAP[record_type]
else:
cls = DnsRecord.polymorphic_subclass(record_type,
"Unknown DNS record type")
else:
cls = DnsRecord
# We want to query(ARecord) instead of
# query(DnsRecord).filter_by(record_type='a_record'), because the former
# works for DynamicStub as well
q = session.query(cls)
if cls == DnsRecord:
q = q.with_polymorphic('*')
q = q.filter_by(fqdn=dbfqdn)
result = q.all()
if not result:
raise NotFoundException("%s %s not found." %
(cls._get_class_label(), fqdn))
return result
def get_unique(cls, sess, name, hardware_type=None, compel=False,
preclude=False, query_options=None):
""" Returns a unique HardwareEntity given session and fqdn """
# If the hardware_type param isn't explicitly set and we have a
# polymorphic identity, assume we're querying only for items of our
# hardware_type.
if hardware_type:
if isclass(hardware_type):
clslabel = hardware_type._get_class_label()
hardware_type = hardware_type.__mapper_args__['polymorphic_identity']
else:
pcls = cls.__mapper__.polymorphic_map[hardware_type].class_
clslabel = pcls._get_class_label()
else:
if 'polymorphic_identity' in cls.__mapper_args__:
hardware_type = cls.__mapper_args__['polymorphic_identity']
clslabel = cls._get_class_label()
# The automagic DNS lookup does not really make sense with preclude=True
if preclude:
name = AqStr.normalize(name)
cls.check_label(name)
q = sess.query(cls)
if "." in name:
dns_rec = DnsRecord.get_unique(sess, fqdn=name, compel=True)
# We know the primary name, do not load it again
q = q.options(lazyload('primary_name'))
q = q.filter_by(primary_name=dns_rec)
else:
dns_rec = None
q = q.filter_by(label=name)
if query_options:
q = q.options(*query_options)
try:
hwe = q.one()
except NoResultFound:
# Check if the name is in use by a different hardware type
q = sess.query(HardwareEntity)
if dns_rec:
# We know the primary name, do not load it again
q = q.options(lazyload('primary_name'))
q = q.filter_by(primary_name=dns_rec)
else:
q = q.filter_by(label=name)
try:
hwe = q.one()
if dns_rec:
# We know the primary name, do not load it again
set_committed_value(hwe, 'primary_name', dns_rec)
raise ArgumentError("{0} exists, but is not a {1}."
.format(hwe, clslabel.lower()))
except NoResultFound:
hwe = None
if compel:
raise NotFoundException("%s %s not found." % (clslabel, name))
if hwe:
if preclude:
raise ArgumentError('{0} already exists.'.format(hwe))
if dns_rec:
# We know the primary name, do not load it again
set_committed_value(hwe, 'primary_name', dns_rec)
return hwe
def render(self, session, fqdn, dns_environment, dns_domain, shortname,
record_type, ip, network, network_environment, target,
target_domain, primary_name, used, reverse_override,
reverse_ptr, fullinfo, style, **kwargs):
if record_type:
record_type = record_type.strip().lower()
if record_type in DNS_RRTYPE_MAP:
cls = DNS_RRTYPE_MAP[record_type]
else:
cls = DnsRecord.polymorphic_subclass(
record_type, "Unknown DNS record type")
q = session.query(cls)
else:
q = session.query(DnsRecord)
q = q.with_polymorphic('*')
dbnet_env = NetworkEnvironment.get_unique_or_default(
session, network_environment)
if network_environment:
# The network environment determines the DNS environment
dbdns_env = dbnet_env.dns_environment
else:
dbdns_env = DnsEnvironment.get_unique_or_default(
session, dns_environment)
if fqdn:
dbfqdn = Fqdn.get_unique(session,
fqdn=fqdn,
dns_environment=dbdns_env,
compel=True)
q = q.filter_by(fqdn=dbfqdn)
q = q.join((Fqdn, DnsRecord.fqdn_id == Fqdn.id))
q = q.filter_by(dns_environment=dbdns_env)
q = q.options(contains_eager('fqdn'))
if dns_domain:
dbdns_domain = DnsDomain.get_unique(session,
dns_domain,
compel=True)
q = q.filter_by(dns_domain=dbdns_domain)
if shortname:
q = q.filter_by(name=shortname)
q = q.join(DnsDomain)
q = q.options(contains_eager('fqdn.dns_domain'))
q = q.order_by(Fqdn.name, DnsDomain.name)
q = q.reset_joinpoint()
if ip:
q = q.join(Network)
q = q.filter_by(network_environment=dbnet_env)
q = q.reset_joinpoint()
q = q.filter(ARecord.ip == ip)
if network:
dbnetwork = Network.get_unique(session,
network,
network_environment=dbnet_env,
compel=True)
q = q.filter(ARecord.network == dbnetwork)
if target:
dbtarget = Fqdn.get_unique(session,
fqdn=target,
dns_environment=dbdns_env,
compel=True)
q = q.filter(
or_(Alias.target == dbtarget, SrvRecord.target == dbtarget))
if target_domain:
dbdns_domain = DnsDomain.get_unique(session,
target_domain,
compel=True)
TargetFqdn = aliased(Fqdn)
q = q.join((TargetFqdn,
or_(Alias.target_id == TargetFqdn.id,
SrvRecord.target_id == TargetFqdn.id)))
q = q.filter(TargetFqdn.dns_domain == dbdns_domain)
if primary_name is not None:
if primary_name:
q = q.filter(DnsRecord.hardware_entity.has())
else:
q = q.filter(~DnsRecord.hardware_entity.has())
if used is not None:
if used:
q = q.join(
AddressAssignment,
and_(ARecord.network_id == AddressAssignment.network_id,
ARecord.ip == AddressAssignment.ip))
else:
q = q.outerjoin(
AddressAssignment,
and_(ARecord.network_id == AddressAssignment.network_id,
ARecord.ip == AddressAssignment.ip))
q = q.filter(AddressAssignment.id == None)
q = q.reset_joinpoint()
if reverse_override is not None:
if reverse_override:
q = q.filter(ARecord.reverse_ptr.has())
else:
q = q.filter(~ARecord.reverse_ptr.has())
if reverse_ptr:
dbtarget = Fqdn.get_unique(session,
fqdn=reverse_ptr,
dns_environment=dbdns_env,
compel=True)
q = q.filter(ARecord.reverse_ptr == dbtarget)
if fullinfo:
q = q.options(undefer('comments'))
q = q.options(subqueryload('hardware_entity'))
q = q.options(undefer('alias_cnt'))
return q.all()
elif style == "raw":
return StringAttributeList(q.all(), 'fqdn')
else:
# This is for the CSV formatter
return q.all()
def render(self, session, fqdn, dns_environment, dns_domain, shortname,
record_type, ip, network, network_environment, target,
target_domain, primary_name, used, reverse_override, reverse_ptr,
fullinfo, style, **kwargs):
if record_type:
record_type = record_type.strip().lower()
if record_type in DNS_RRTYPE_MAP:
cls = DNS_RRTYPE_MAP[record_type]
else:
cls = DnsRecord.polymorphic_subclass(record_type,
"Unknown DNS record type")
q = session.query(cls)
else:
q = session.query(DnsRecord)
q = q.with_polymorphic('*')
dbnet_env = NetworkEnvironment.get_unique_or_default(session,
network_environment)
if network_environment:
# The network environment determines the DNS environment
dbdns_env = dbnet_env.dns_environment
else:
dbdns_env = DnsEnvironment.get_unique_or_default(session,
dns_environment)
if fqdn:
dbfqdn = Fqdn.get_unique(session, fqdn=fqdn,
dns_environment=dbdns_env, compel=True)
q = q.filter_by(fqdn=dbfqdn)
q = q.join((Fqdn, DnsRecord.fqdn_id == Fqdn.id))
q = q.filter_by(dns_environment=dbdns_env)
q = q.options(contains_eager('fqdn'))
if dns_domain:
dbdns_domain = DnsDomain.get_unique(session, dns_domain,
compel=True)
q = q.filter_by(dns_domain=dbdns_domain)
if shortname:
q = q.filter_by(name=shortname)
q = q.join(DnsDomain)
q = q.options(contains_eager('fqdn.dns_domain'))
q = q.order_by(Fqdn.name, DnsDomain.name)
q = q.reset_joinpoint()
if ip:
q = q.join(Network)
q = q.filter_by(network_environment=dbnet_env)
q = q.reset_joinpoint()
q = q.filter(ARecord.ip == ip)
if network:
dbnetwork = Network.get_unique(session, network,
network_environment=dbnet_env, compel=True)
q = q.filter(ARecord.network == dbnetwork)
if target:
dbtarget = Fqdn.get_unique(session, fqdn=target,
dns_environment=dbdns_env, compel=True)
q = q.filter(or_(Alias.target == dbtarget,
SrvRecord.target == dbtarget))
if target_domain:
dbdns_domain = DnsDomain.get_unique(session, target_domain,
compel=True)
TargetFqdn = aliased(Fqdn)
q = q.join((TargetFqdn, or_(Alias.target_id == TargetFqdn.id,
SrvRecord.target_id == TargetFqdn.id)))
q = q.filter(TargetFqdn.dns_domain == dbdns_domain)
if primary_name is not None:
if primary_name:
q = q.filter(DnsRecord.hardware_entity.has())
else:
q = q.filter(~DnsRecord.hardware_entity.has())
if used is not None:
if used:
q = q.join(AddressAssignment,
and_(ARecord.network_id == AddressAssignment.network_id,
ARecord.ip == AddressAssignment.ip))
else:
q = q.outerjoin(AddressAssignment,
and_(ARecord.network_id == AddressAssignment.network_id,
ARecord.ip == AddressAssignment.ip))
q = q.filter(AddressAssignment.id == None)
q = q.reset_joinpoint()
if reverse_override is not None:
if reverse_override:
q = q.filter(ARecord.reverse_ptr.has())
else:
q = q.filter(~ARecord.reverse_ptr.has())
if reverse_ptr:
dbtarget = Fqdn.get_unique(session, fqdn=reverse_ptr,
dns_environment=dbdns_env, compel=True)
q = q.filter(ARecord.reverse_ptr == dbtarget)
if fullinfo or style != "raw":
q = q.options(undefer('comments'),
subqueryload('hardware_entity'),
lazyload('hardware_entity.primary_name'),
undefer('alias_cnt'))
return q.all()
else:
return StringAttributeList(q.all(), 'fqdn')
def refresh_windows_hosts(self, session, logger, containers):
conn = sqlite3.connect(self.config.get("broker", "windows_host_info"))
# Enable dictionary-style access to the rows.
conn.row_factory = sqlite3.Row
windows_hosts = {}
interfaces = {}
cur = conn.cursor()
# There are more fields in the dataset like machine and
# aqhostname that might be useful for error messages but these
# are sufficient.
cur.execute("select ether, windowshostname from machines")
for row in cur:
host = row["windowshostname"]
if host:
host = host.strip().lower()
else:
continue
mac = row["ether"]
if mac:
mac = mac.strip().lower()
windows_hosts[host] = mac
interfaces[mac] = host
success = []
failed = []
q = session.query(Host)
q = q.filter_by(comments='Created by refresh_windows_host')
for dbhost in q.all():
mac_addresses = [iface.mac for iface in dbhost.machine.interfaces]
if dbhost.fqdn in windows_hosts and \
windows_hosts[dbhost.fqdn] in mac_addresses:
# All is well
continue
deps = get_host_dependencies(session, dbhost)
if deps:
msg = "Skipping removal of host %s with dependencies: %s" % \
(dbhost.fqdn, ", ".join(deps))
failed.append(msg)
logger.info(msg)
continue
dbmachine = dbhost.machine
success.append("Removed host entry for %s (%s)" %
(dbmachine.label, dbmachine.fqdn))
if dbmachine.vm_container:
containers.add(dbmachine.vm_container)
session.delete(dbhost)
dbdns_rec = dbmachine.primary_name
dbmachine.primary_name = None
delete_dns_record(dbdns_rec)
session.flush()
# The Host() creations below fail when autoflush is enabled.
session.autoflush = False
dbdomain = Domain.get_unique(session,
self.config.get("archetype_windows",
"host_domain"),
compel=InternalError)
dbarchetype = Archetype.get_unique(session, "windows",
compel=InternalError)
dbpersonality = Personality.get_unique(session, archetype=dbarchetype,
name="generic",
compel=InternalError)
dbstatus = HostLifecycle.get_unique(session, "ready",
compel=InternalError)
dbos = OperatingSystem.get_unique(session, name="windows",
version="generic",
archetype=dbarchetype,
compel=InternalError)
for (host, mac) in windows_hosts.items():
try:
(short, dbdns_domain) = parse_fqdn(session, host)
except AquilonError, err:
msg = "Skipping host %s: %s" % (host, err)
failed.append(msg)
logger.info(msg)
continue
existing = DnsRecord.get_unique(session, name=short,
dns_domain=dbdns_domain)
if existing:
if not existing.hardware_entity:
msg = "Skipping host %s: It is not a primary name." % host
failed.append(msg)
logger.info(msg)
continue
# If these are invalid there should have been a deletion
# attempt above.
if not existing.hardware_entity.interfaces:
msg = "Skipping host %s: Host already exists but has " \
"no interface attached." % host
failed.append(msg)
logger.info(msg)
elif existing.hardware_entity.interfaces[0].mac != mac:
msg = "Skipping host %s: Host already exists but with " \
"MAC address %s and not %s." % \
(host, existing.hardware_entity.interfaces[0].mac,
mac)
failed.append(msg)
logger.info(msg)
continue
dbinterface = session.query(Interface).filter_by(mac=mac).first()
if not dbinterface:
msg = "Skipping host %s: MAC address %s is not present in " \
"AQDB." % (host, mac)
failed.append(msg)
logger.info(msg)
continue
q = session.query(Machine)
q = q.filter_by(id=dbinterface.hardware_entity.id)
dbmachine = q.first()
if not dbmachine:
msg = "Skipping host %s: The AQDB interface with MAC address " \
"%s is tied to hardware %s instead of a virtual " \
"machine." % \
(host, mac, dbinterface.hardware_entity.label)
failed.append(msg)
logger.info(msg)
continue
if dbinterface.assignments:
msg = "Skipping host %s: The AQDB interface with MAC address " \
"%s is already tied to %s." % \
(host, mac, dbinterface.assignments[0].fqdns[0])
failed.append(msg)
logger.info(msg)
continue
if dbmachine.host:
msg = "Skipping host %s: The AQDB interface with MAC address " \
"%s is already tied to %s." % \
(host, mac, dbmachine.fqdn)
failed.append(msg)
logger.info(msg)
continue
dbhost = Host(machine=dbmachine, branch=dbdomain,
status=dbstatus, owner_grn=dbpersonality.owner_grn,
personality=dbpersonality, operating_system=dbos,
comments="Created by refresh_windows_host")
session.add(dbhost)
if self.config.has_option("archetype_windows", "default_grn_target"):
dbhost.grns.append((dbhost, dbgrn,
self.config.get("archetype_",
"default_grn_target")))
dbfqdn = Fqdn.get_or_create(session, name=short,
dns_domain=dbdns_domain, preclude=True)
dbdns_rec = ReservedName(fqdn=dbfqdn)
session.add(dbdns_rec)
dbmachine.primary_name = dbdns_rec
success.append("Added host entry for %s (%s)." %
(dbmachine.label, dbdns_rec.fqdn))
if dbmachine.vm_container:
containers.add(dbmachine.vm_container)
session.flush()
name="generic",
compel=InternalError)
dbstatus = Ready.get_instance(session)
dbos = OperatingSystem.get_unique(session, name="windows",
version="generic",
archetype=dbarchetype,
compel=InternalError)
for (host, mac) in windows_hosts.items():
try:
(short, dbdns_domain) = parse_fqdn(session, host)
except AquilonError, err:
msg = "Skipping host %s: %s" % (host, err)
failed.append(msg)
logger.info(msg)
continue
existing = DnsRecord.get_unique(session, name=short,
dns_domain=dbdns_domain)
if existing:
if not existing.hardware_entity:
msg = "Skipping host %s: It is not a primary name." % host
failed.append(msg)
logger.info(msg)
continue
# If these are invalid there should have been a deletion
# attempt above.
if not existing.hardware_entity.interfaces:
msg = "Skipping host %s: Host already exists but has " \
"no interface attached." % host
failed.append(msg)
logger.info(msg)
elif existing.hardware_entity.interfaces[0].mac != mac:
msg = "Skipping host %s: Host already exists but with " \
def get_unique(cls,
sess,
name,
hardware_type=None,
compel=False,
preclude=False,
query_options=None):
""" Returns a unique HardwareEntity given session and fqdn """
# If the hardware_type param isn't explicitly set and we have a
# polymorphic identity, assume we're querying only for items of our
# hardware_type.
if hardware_type:
if isclass(hardware_type):
clslabel = hardware_type._get_class_label()
hardware_type = hardware_type.__mapper_args__[
'polymorphic_identity']
else:
pcls = cls.__mapper__.polymorphic_map[hardware_type].class_
clslabel = pcls._get_class_label()
else:
if 'polymorphic_identity' in cls.__mapper_args__:
hardware_type = cls.__mapper_args__['polymorphic_identity']
clslabel = cls._get_class_label()
# The automagic DNS lookup does not really make sense with preclude=True
if preclude:
name = AqStr.normalize(name)
cls.check_label(name)
q = sess.query(cls)
if "." in name:
dns_rec = DnsRecord.get_unique(sess, fqdn=name, compel=True)
# We know the primary name, do not load it again
q = q.options(lazyload('primary_name'))
q = q.filter_by(primary_name=dns_rec)
else:
dns_rec = None
q = q.filter_by(label=name)
if query_options:
q = q.options(*query_options)
try:
hwe = q.one()
except NoResultFound:
# Check if the name is in use by a different hardware type
q = sess.query(HardwareEntity)
if dns_rec:
# We know the primary name, do not load it again
q = q.options(lazyload('primary_name'))
q = q.filter_by(primary_name=dns_rec)
else:
q = q.filter_by(label=name)
try:
hwe = q.one()
if dns_rec:
# We know the primary name, do not load it again
set_committed_value(hwe, 'primary_name', dns_rec)
raise ArgumentError("{0} exists, but is not a {1}.".format(
hwe, hardware_type))
except NoResultFound:
hwe = None
if compel:
raise NotFoundException("%s %s not found." % (clslabel, name))
if hwe:
if preclude:
raise ArgumentError('{0} already exists.'.format(hwe))
if dns_rec:
# We know the primary name, do not load it again
set_committed_value(hwe, 'primary_name', dns_rec)
return hwe