def render(self, session, logger, hostname, service, instance,
**arguments):
dbhost = hostname_to_host(session, hostname)
dbservice = Service.get_unique(session, service, compel=True)
dbinstance = get_service_instance(session, dbservice, instance)
if dbhost in dbinstance.server_hosts:
# FIXME: This should just be a warning. There is currently
# no way of returning output that would "do the right thing"
# on the client but still show status 200 (OK).
# The right thing would generally be writing to stderr for
# a CLI (either raw or csv), and some sort of generic error
# page for a web client.
raise ArgumentError("Server %s is already bound to service %s "
"instance %s." % (hostname, service, instance))
# The ordering_list will manage the position for us
dbinstance.server_hosts.append(dbhost)
session.flush()
plenary_info = Plenary.get_plenary(dbinstance, logger=logger)
plenary_info.write()
# XXX: Need to recompile...
return
def render(self, session, service, server, client, **arguments):
instance = arguments.get("instance", None)
dbserver = server and hostname_to_host(session, server) or None
dbclient = client and hostname_to_host(session, client) or None
dbservice = Service.get_unique(session, service, compel=True)
if dbserver:
q = session.query(ServiceInstance)
q = q.filter_by(service=dbservice)
q = q.join('servers')
q = q.filter_by(host=dbserver)
q = q.order_by(ServiceInstance.name)
return ServiceInstanceList(q.all())
elif dbclient:
service_instances = dbclient.services_used
service_instances = [
si for si in service_instances if si.service == dbservice
]
if instance:
service_instances = [
si for si in service_instances if si.name == instance
]
return ServiceInstanceList(service_instances)
if not instance:
return dbservice
return get_service_instance(session, dbservice, instance)
def render(self, session, logger, hostname, service, instance, **arguments):
dbhost = hostname_to_host(session, hostname)
dbservice = Service.get_unique(session, service, compel=True)
dbinstance = get_service_instance(session, dbservice, instance)
if dbhost in dbinstance.server_hosts:
# FIXME: This should just be a warning. There is currently
# no way of returning output that would "do the right thing"
# on the client but still show status 200 (OK).
# The right thing would generally be writing to stderr for
# a CLI (either raw or csv), and some sort of generic error
# page for a web client.
raise ArgumentError("Server %s is already bound to service %s "
"instance %s." %
(hostname, service, instance))
# The ordering_list will manage the position for us
dbinstance.server_hosts.append(dbhost)
session.flush()
plenary_info = Plenary.get_plenary(dbinstance, logger=logger)
plenary_info.write()
# XXX: Need to recompile...
return
def render(self, session, logger, hostname, service, instance, **arguments):
dbhost = hostname_to_host(session, hostname)
dbservice = Service.get_unique(session, service, compel=True)
msg = "Service %s" % service
if instance:
dbinstances = [get_service_instance(session, dbservice, instance)]
msg = "Service %s, instance %s" % (service, instance)
else:
q = session.query(ServiceInstance)
q = q.filter_by(service=dbservice)
q = q.join('servers')
q = q.filter_by(host=dbhost)
dbinstances = q.all()
for dbinstance in dbinstances:
if dbhost in dbinstance.server_hosts:
if (dbinstance.client_count > 0 and
len(dbinstance.server_hosts) <= 1):
logger.warning("WARNING: Server %s, is the last server "
"bound to %s which still has clients" %
(hostname, msg))
dbinstance.server_hosts.remove(dbhost)
session.expire(dbhost, ['_services_provided'])
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbhost))
for dbinstance in dbinstances:
plenaries.append(Plenary.get_plenary(dbinstance))
plenaries.write()
return
def render(self, session, logger, hostname, service, instance,
**arguments):
dbhost = hostname_to_host(session, hostname)
dbservice = Service.get_unique(session, service, compel=True)
msg = "Service %s" % service
if instance:
dbinstances = [get_service_instance(session, dbservice, instance)]
msg = "Service %s, instance %s" % (service, instance)
else:
q = session.query(ServiceInstance)
q = q.filter_by(service=dbservice)
q = q.join('servers')
q = q.filter_by(host=dbhost)
dbinstances = q.all()
for dbinstance in dbinstances:
if dbhost in dbinstance.server_hosts:
if (dbinstance.client_count > 0
and len(dbinstance.server_hosts) <= 1):
logger.warning("WARNING: Server %s, is the last server "
"bound to %s which still has clients" %
(hostname, msg))
dbinstance.server_hosts.remove(dbhost)
session.expire(dbhost, ['_services_provided'])
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbhost))
for dbinstance in dbinstances:
plenaries.append(Plenary.get_plenary(dbinstance))
plenaries.write()
return
def render(self, session, logger, service, instance, position, hostname,
cluster, ip, resourcegroup, service_address, alias, **arguments):
# Check for invalid combinations. We allow binding as a server:
# - a host, in which case the primary IP address will be used
# - an auxiliary IP address of a host
# - a service address of a host
# - a service address of a cluster
if ip:
if cluster or not hostname:
raise ArgumentError("Using the --ip option requires --hostname"
"to be specified.")
if cluster and not service_address:
raise ArgumentError("Binding a cluster requires --service_address "
"to be specified.")
dbservice = Service.get_unique(session, service, compel=True)
dbinstance = get_service_instance(session, dbservice, instance)
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbinstance))
params = lookup_target(session, plenaries, hostname, ip, cluster,
resourcegroup, service_address, alias)
# TODO: someday we should verify that the target really points to the
# host/cluster specified by the other options
if "alias" in params and ("host" in params or "cluster" in params):
logger.client_info("Warning: when using --alias, it is your "
"responsibility to ensure it really points to "
"the host/cluster you've specified - the broker "
"does not verify that.")
with session.no_autoflush:
dbsrv = find_server(dbinstance, params)
if dbsrv:
raise ArgumentError("The server binding already exists.")
dbsrv = ServiceInstanceServer(**params)
# The ordering_list will manage the position for us
if position is not None:
dbinstance.servers.insert(position, dbsrv)
else:
dbinstance.servers.append(dbsrv)
if dbsrv.host:
session.expire(dbsrv.host, ['services_provided'])
if dbsrv.cluster:
session.expire(dbsrv.cluster, ['services_provided'])
session.flush()
plenaries.write()
return
def render(self, session, logger, hostname, service, instance, force=False,
**arguments):
dbhost = hostname_to_host(session, hostname)
dbservice = Service.get_unique(session, service, compel=True)
chooser = Chooser(dbhost, logger=logger, required_only=False)
if instance:
dbinstance = get_service_instance(session, dbservice, instance)
chooser.set_single(dbservice, dbinstance, force=force)
else:
chooser.set_single(dbservice, force=force)
chooser.flush_changes()
chooser.write_plenary_templates()
return
def render(self, session, service, instance, archetype, personality,
networkip, **kwargs):
dbservice = Service.get_unique(session, service, compel=True)
dblocation = get_location(session, **kwargs)
dbinstance = get_service_instance(session, dbservice, instance)
if networkip:
dbnet_env = NetworkEnvironment.get_unique_or_default(session)
dbnetwork = get_network_byip(session, networkip, dbnet_env)
else:
dbnetwork = None
if archetype is None and personality:
# Can't get here with the standard aq client.
raise ArgumentError("Specifying --personality requires you to "
"also specify --archetype.")
kwargs = {}
if archetype and personality:
dbpersona = Personality.get_unique(session,
name=personality,
archetype=archetype,
compel=True)
map_class = PersonalityServiceMap
query = session.query(map_class).filter_by(personality=dbpersona)
kwargs["personality"] = dbpersona
else:
map_class = ServiceMap
query = session.query(map_class)
dbmap = query.filter_by(location=dblocation,
service_instance=dbinstance,
network=dbnetwork).first()
if not dbmap:
dbmap = map_class(service_instance=dbinstance,
location=dblocation,
network=dbnetwork,
**kwargs)
session.add(dbmap)
session.flush()
return
def render(self, session, service, instance, archetype, personality,
networkip, **kwargs):
dbservice = Service.get_unique(session, service, compel=True)
dblocation = get_location(session, **kwargs)
dbinstance = get_service_instance(session, dbservice, instance)
if networkip:
dbnet_env = NetworkEnvironment.get_unique_or_default(session)
dbnetwork = get_network_byip(session, networkip, dbnet_env)
else:
dbnetwork = None
if archetype is None and personality:
# Can't get here with the standard aq client.
raise ArgumentError("Specifying --personality requires you to "
"also specify --archetype.")
kwargs = {}
if archetype and personality:
dbpersona = Personality.get_unique(session, name=personality,
archetype=archetype, compel=True)
map_class = PersonalityServiceMap
query = session.query(map_class).filter_by(personality=dbpersona)
kwargs["personality"] = dbpersona
else:
map_class = ServiceMap
query = session.query(map_class)
dbmap = query.filter_by(location=dblocation,
service_instance=dbinstance,
network=dbnetwork).first()
if not dbmap:
dbmap = map_class(service_instance=dbinstance,
location=dblocation,
network=dbnetwork, **kwargs)
session.add(dbmap)
session.flush()
return
def render(self, session, logger, cluster, service, instance, **arguments):
dbservice = Service.get_unique(session, service, compel=True)
dbinstance = get_service_instance(session, dbservice, instance)
dbcluster = Cluster.get_unique(session, cluster, compel=True)
if dbinstance not in dbcluster.service_bindings:
raise NotFoundException("{0} is not bound to {1:l}."
.format(dbinstance, dbcluster))
if dbservice in dbcluster.required_services:
raise ArgumentError("Cannot remove cluster service instance "
"binding for %s cluster aligned service %s." %
(dbcluster.cluster_type, dbservice.name))
dbcluster.service_bindings.remove(dbinstance)
session.flush()
plenary = Plenary.get_plenary(dbcluster, logger=logger)
plenary.write()
return
def render(self, session, logger, service, instance, **arguments):
dbservice = Service.get_unique(session, service, compel=True)
dbsi = get_service_instance(session, dbservice, instance)
if dbsi.client_count > 0:
raise ArgumentError("Service %s, instance %s still has clients and "
"cannot be deleted." %
(dbservice.name, dbsi.name))
if dbsi.server_hosts:
msg = ", ".join([host.fqdn for host in dbsi.server_hosts])
raise ArgumentError("Service %s, instance %s is still being "
"provided by servers: %s." %
(dbservice.name, dbsi.name, msg))
# Depend on cascading to remove any mappings
session.delete(dbsi)
session.flush()
plenary_info = Plenary.get_plenary(dbsi, logger=logger)
plenary_info.remove()
return
def render(self, session, logger, service, instance, **arguments):
dbservice = Service.get_unique(session, service, compel=True)
dbsi = get_service_instance(session, dbservice, instance)
if dbsi.client_count > 0:
raise ArgumentError(
"Service %s, instance %s still has clients and "
"cannot be deleted." % (dbservice.name, dbsi.name))
if dbsi.server_hosts:
msg = ", ".join([host.fqdn for host in dbsi.server_hosts])
raise ArgumentError("Service %s, instance %s is still being "
"provided by servers: %s." %
(dbservice.name, dbsi.name, msg))
# Depend on cascading to remove any mappings
session.delete(dbsi)
session.flush()
plenary_info = Plenary.get_plenary(dbsi, logger=logger)
plenary_info.remove()
return
def render(self, session, service, server, client, **arguments):
instance = arguments.get("instance", None)
dbserver = server and hostname_to_host(session, server) or None
dbclient = client and hostname_to_host(session, client) or None
dbservice = Service.get_unique(session, service, compel=True)
if dbserver:
q = session.query(ServiceInstance)
q = q.filter_by(service=dbservice)
q = q.join('servers')
q = q.filter_by(host=dbserver)
q = q.order_by(ServiceInstance.name)
return ServiceInstanceList(q.all())
elif dbclient:
service_instances = dbclient.services_used
service_instances = [si for si in service_instances if si.service == dbservice]
if instance:
service_instances = [si for si in service_instances if si.name == instance]
return ServiceInstanceList(service_instances)
if not instance:
return dbservice
return get_service_instance(session, dbservice, instance)
def render(self, session, logger, service, instance, default, server,
generate, **kwargs):
dbservice = Service.get_unique(session, service, compel=True)
dbsi = get_service_instance(session, dbservice, instance)
if default:
if server:
plenary_info = PlenaryServiceInstanceServerDefault(dbsi,
logger=logger)
else:
plenary_info = PlenaryServiceInstanceClientDefault(dbsi,
logger=logger)
else:
if server:
plenary_info = PlenaryServiceInstanceServer(dbsi, logger=logger)
else:
plenary_info = PlenaryServiceInstanceToplevel(dbsi,
logger=logger)
if generate:
return plenary_info._generate_content()
else:
return plenary_info.read()
def render(self, session, logger, service, instance, default, server,
generate, **kwargs):
dbservice = Service.get_unique(session, service, compel=True)
dbsi = get_service_instance(session, dbservice, instance)
if default:
if server:
plenary_info = PlenaryServiceInstanceServerDefault(
dbsi, logger=logger)
else:
plenary_info = PlenaryServiceInstanceClientDefault(
dbsi, logger=logger)
else:
if server:
plenary_info = PlenaryServiceInstanceServer(dbsi,
logger=logger)
else:
plenary_info = PlenaryServiceInstanceToplevel(dbsi,
logger=logger)
if generate:
return plenary_info._generate_content()
else:
return plenary_info.read()
def render(self, session, logger, hostname, machine, archetype,
buildstatus, personality, osname, osversion, service, instance,
model, machine_type, vendor, serial, cluster,
guest_on_cluster, guest_on_share, member_cluster_share,
domain, sandbox, branch, sandbox_owner,
dns_domain, shortname, mac, ip, networkip, network_environment,
exact_location, server_of_service, server_of_instance, grn,
eon_id, fullinfo, **arguments):
dbnet_env = NetworkEnvironment.get_unique_or_default(session,
network_environment)
q = session.query(Host)
if machine:
dbmachine = Machine.get_unique(session, machine, compel=True)
q = q.filter_by(machine=dbmachine)
# Add the machine definition and the primary name. Use aliases to make
# sure the end result will be ordered by primary name.
PriDns = aliased(DnsRecord)
PriFqdn = aliased(Fqdn)
PriDomain = aliased(DnsDomain)
q = q.join(Machine,
(PriDns, PriDns.id == Machine.primary_name_id),
(PriFqdn, PriDns.fqdn_id == PriFqdn.id),
(PriDomain, PriFqdn.dns_domain_id == PriDomain.id))
q = q.order_by(PriFqdn.name, PriDomain.name)
q = q.options(contains_eager('machine'),
contains_eager('machine.primary_name', alias=PriDns),
contains_eager('machine.primary_name.fqdn', alias=PriFqdn),
contains_eager('machine.primary_name.fqdn.dns_domain',
alias=PriDomain))
q = q.reset_joinpoint()
# Hardware-specific filters
dblocation = get_location(session, **arguments)
if dblocation:
if exact_location:
q = q.filter(Machine.location == dblocation)
else:
childids = dblocation.offspring_ids()
q = q.filter(Machine.location_id.in_(childids))
if model or vendor or machine_type:
subq = Model.get_matching_query(session, name=model, vendor=vendor,
machine_type=machine_type,
compel=True)
q = q.filter(Machine.model_id.in_(subq))
if serial:
self.deprecated_option("serial", "Please use search machine --serial instead.",
logger=logger, **arguments)
q = q.filter(Machine.serial_no == serial)
# DNS IP address related filters
if mac or ip or networkip or hostname or dns_domain or shortname:
# Inner joins are cheaper than outer joins, so make some effort to
# use inner joins when possible
if mac or ip or networkip:
q = q.join(Interface)
else:
q = q.outerjoin(Interface)
if ip or networkip:
q = q.join(AddressAssignment, Network, from_joinpoint=True)
else:
q = q.outerjoin(AddressAssignment, Network, from_joinpoint=True)
if mac:
self.deprecated_option("mac", "Please use search machine "
"--mac instead.", logger=logger,
**arguments)
q = q.filter(Interface.mac == mac)
if ip:
q = q.filter(AddressAssignment.ip == ip)
q = q.filter(Network.network_environment == dbnet_env)
if networkip:
dbnetwork = get_network_byip(session, networkip, dbnet_env)
q = q.filter(AddressAssignment.network == dbnetwork)
dbdns_domain = None
if hostname:
(shortname, dbdns_domain) = parse_fqdn(session, hostname)
if dns_domain:
dbdns_domain = DnsDomain.get_unique(session, dns_domain, compel=True)
if shortname or dbdns_domain:
ARecAlias = aliased(ARecord)
ARecFqdn = aliased(Fqdn)
q = q.outerjoin((ARecAlias,
and_(ARecAlias.ip == AddressAssignment.ip,
ARecAlias.network_id == AddressAssignment.network_id)),
(ARecFqdn, ARecAlias.fqdn_id == ARecFqdn.id))
if shortname:
q = q.filter(or_(ARecFqdn.name == shortname,
PriFqdn.name == shortname))
if dbdns_domain:
q = q.filter(or_(ARecFqdn.dns_domain == dbdns_domain,
PriFqdn.dns_domain == dbdns_domain))
q = q.reset_joinpoint()
(dbbranch, dbauthor) = get_branch_and_author(session, logger,
domain=domain,
sandbox=sandbox,
branch=branch)
if sandbox_owner:
dbauthor = get_user_principal(session, sandbox_owner)
if dbbranch:
q = q.filter_by(branch=dbbranch)
if dbauthor:
q = q.filter_by(sandbox_author=dbauthor)
if archetype:
# Added to the searches as appropriate below.
dbarchetype = Archetype.get_unique(session, archetype, compel=True)
if personality and archetype:
dbpersonality = Personality.get_unique(session,
archetype=dbarchetype,
name=personality,
compel=True)
q = q.filter_by(personality=dbpersonality)
elif personality:
PersAlias = aliased(Personality)
q = q.join(PersAlias).filter_by(name=personality)
q = q.reset_joinpoint()
elif archetype:
PersAlias = aliased(Personality)
q = q.join(PersAlias).filter_by(archetype=dbarchetype)
q = q.reset_joinpoint()
if buildstatus:
dbbuildstatus = HostLifecycle.get_unique(session, buildstatus,
compel=True)
q = q.filter_by(status=dbbuildstatus)
if osname and osversion and archetype:
# archetype was already resolved above
dbos = OperatingSystem.get_unique(session, name=osname,
version=osversion,
archetype=dbarchetype,
compel=True)
q = q.filter_by(operating_system=dbos)
elif osname or osversion:
q = q.join('operating_system')
if osname:
q = q.filter_by(name=osname)
if osversion:
q = q.filter_by(version=osversion)
q = q.reset_joinpoint()
if service:
dbservice = Service.get_unique(session, service, compel=True)
if instance:
dbsi = get_service_instance(session, dbservice, instance)
q = q.filter(Host.services_used.contains(dbsi))
else:
q = q.join('services_used')
q = q.filter_by(service=dbservice)
q = q.reset_joinpoint()
elif instance:
q = q.join('services_used')
q = q.filter_by(name=instance)
q = q.reset_joinpoint()
if server_of_service:
dbserver_service = Service.get_unique(session, server_of_service,
compel=True)
if server_of_instance:
dbssi = get_service_instance(session, dbserver_service,
server_of_instance)
q = q.join('_services_provided')
q = q.filter_by(service_instance=dbssi)
q = q.reset_joinpoint()
else:
q = q.join('_services_provided', 'service_instance')
q = q.filter_by(service=dbserver_service)
q = q.reset_joinpoint()
elif server_of_instance:
q = q.join('_services_provided', 'service_instance')
q = q.filter_by(name=server_of_instance)
q = q.reset_joinpoint()
if cluster:
dbcluster = Cluster.get_unique(session, cluster, compel=True)
if isinstance(dbcluster, MetaCluster):
q = q.join('_cluster', 'cluster', '_metacluster')
q = q.filter_by(metacluster=dbcluster)
else:
q = q.filter_by(cluster=dbcluster)
q = q.reset_joinpoint()
if guest_on_cluster:
# TODO: this does not handle metaclusters according to Wes
dbcluster = Cluster.get_unique(session, guest_on_cluster,
compel=True)
q = q.join('machine', VirtualMachine, ClusterResource)
q = q.filter_by(cluster=dbcluster)
q = q.reset_joinpoint()
if guest_on_share:
#v2
v2shares = session.query(Share.id).filter_by(name=guest_on_share).all()
if not v2shares:
raise NotFoundException("No shares found with name {0}."
.format(guest_on_share))
NasAlias = aliased(VirtualDisk)
q = q.join('machine', 'disks', (NasAlias, NasAlias.id == Disk.id))
q = q.filter(
NasAlias.share_id.in_(map(lambda s: s[0], v2shares)))
q = q.reset_joinpoint()
if member_cluster_share:
#v2
v2shares = session.query(Share.id).filter_by(name=member_cluster_share).all()
if not v2shares:
raise NotFoundException("No shares found with name {0}."
.format(guest_on_share))
NasAlias = aliased(VirtualDisk)
q = q.join('_cluster', 'cluster', 'resholder', VirtualMachine,
'machine', 'disks', (NasAlias, NasAlias.id == Disk.id))
q = q.filter(
NasAlias.share_id.in_(map(lambda s: s[0], v2shares)))
q = q.reset_joinpoint()
if grn or eon_id:
dbgrn = lookup_grn(session, grn, eon_id, autoupdate=False)
persq = session.query(Personality.id)
persq = persq.outerjoin(PersonalityGrnMap)
persq = persq.filter(or_(Personality.owner_eon_id == dbgrn.eon_id,
PersonalityGrnMap.eon_id == dbgrn.eon_id))
q = q.outerjoin(HostGrnMap)
q = q.filter(or_(Host.owner_eon_id == dbgrn.eon_id,
HostGrnMap.eon_id == dbgrn.eon_id,
Host.personality_id.in_(persq.subquery())))
q = q.reset_joinpoint()
if fullinfo:
return q.all()
return SimpleHostList(q.all())
def render(self, session, logger, hostname, machine, archetype,
buildstatus, personality, osname, osversion, service, instance,
model, machine_type, vendor, serial, cluster, guest_on_cluster,
guest_on_share, member_cluster_share, domain, sandbox, branch,
sandbox_owner, dns_domain, shortname, mac, ip, networkip,
network_environment, exact_location, server_of_service,
server_of_instance, grn, eon_id, fullinfo, **arguments):
dbnet_env = NetworkEnvironment.get_unique_or_default(
session, network_environment)
q = session.query(Host)
if machine:
dbmachine = Machine.get_unique(session, machine, compel=True)
q = q.filter_by(machine=dbmachine)
# Add the machine definition and the primary name. Use aliases to make
# sure the end result will be ordered by primary name.
PriDns = aliased(DnsRecord)
PriFqdn = aliased(Fqdn)
PriDomain = aliased(DnsDomain)
q = q.join(Machine, (PriDns, PriDns.id == Machine.primary_name_id),
(PriFqdn, PriDns.fqdn_id == PriFqdn.id),
(PriDomain, PriFqdn.dns_domain_id == PriDomain.id))
q = q.order_by(PriFqdn.name, PriDomain.name)
q = q.options(
contains_eager('machine'),
contains_eager('machine.primary_name', alias=PriDns),
contains_eager('machine.primary_name.fqdn', alias=PriFqdn),
contains_eager('machine.primary_name.fqdn.dns_domain',
alias=PriDomain))
q = q.reset_joinpoint()
# Hardware-specific filters
dblocation = get_location(session, **arguments)
if dblocation:
if exact_location:
q = q.filter(Machine.location == dblocation)
else:
childids = dblocation.offspring_ids()
q = q.filter(Machine.location_id.in_(childids))
if model or vendor or machine_type:
subq = Model.get_matching_query(session,
name=model,
vendor=vendor,
machine_type=machine_type,
compel=True)
q = q.filter(Machine.model_id.in_(subq))
if serial:
self.deprecated_option(
"serial",
"Please use search machine --serial instead.",
logger=logger,
**arguments)
q = q.filter(Machine.serial_no == serial)
# DNS IP address related filters
if mac or ip or networkip or hostname or dns_domain or shortname:
# Inner joins are cheaper than outer joins, so make some effort to
# use inner joins when possible
if mac or ip or networkip:
q = q.join(Interface)
else:
q = q.outerjoin(Interface)
if ip or networkip:
q = q.join(AddressAssignment, Network, from_joinpoint=True)
else:
q = q.outerjoin(AddressAssignment,
Network,
from_joinpoint=True)
if mac:
self.deprecated_option("mac", "Please use search machine "
"--mac instead.",
logger=logger,
**arguments)
q = q.filter(Interface.mac == mac)
if ip:
q = q.filter(AddressAssignment.ip == ip)
q = q.filter(Network.network_environment == dbnet_env)
if networkip:
dbnetwork = get_network_byip(session, networkip, dbnet_env)
q = q.filter(AddressAssignment.network == dbnetwork)
dbdns_domain = None
if hostname:
(shortname, dbdns_domain) = parse_fqdn(session, hostname)
if dns_domain:
dbdns_domain = DnsDomain.get_unique(session,
dns_domain,
compel=True)
if shortname or dbdns_domain:
ARecAlias = aliased(ARecord)
ARecFqdn = aliased(Fqdn)
q = q.outerjoin(
(ARecAlias,
and_(ARecAlias.ip == AddressAssignment.ip,
ARecAlias.network_id
== AddressAssignment.network_id)),
(ARecFqdn, ARecAlias.fqdn_id == ARecFqdn.id))
if shortname:
q = q.filter(
or_(ARecFqdn.name == shortname,
PriFqdn.name == shortname))
if dbdns_domain:
q = q.filter(
or_(ARecFqdn.dns_domain == dbdns_domain,
PriFqdn.dns_domain == dbdns_domain))
q = q.reset_joinpoint()
(dbbranch, dbauthor) = get_branch_and_author(session,
logger,
domain=domain,
sandbox=sandbox,
branch=branch)
if sandbox_owner:
dbauthor = get_user_principal(session, sandbox_owner)
if dbbranch:
q = q.filter_by(branch=dbbranch)
if dbauthor:
q = q.filter_by(sandbox_author=dbauthor)
if archetype:
# Added to the searches as appropriate below.
dbarchetype = Archetype.get_unique(session, archetype, compel=True)
if personality and archetype:
dbpersonality = Personality.get_unique(session,
archetype=dbarchetype,
name=personality,
compel=True)
q = q.filter_by(personality=dbpersonality)
elif personality:
PersAlias = aliased(Personality)
q = q.join(PersAlias).filter_by(name=personality)
q = q.reset_joinpoint()
elif archetype:
PersAlias = aliased(Personality)
q = q.join(PersAlias).filter_by(archetype=dbarchetype)
q = q.reset_joinpoint()
if buildstatus:
dbbuildstatus = HostLifecycle.get_unique(session,
buildstatus,
compel=True)
q = q.filter_by(status=dbbuildstatus)
if osname and osversion and archetype:
# archetype was already resolved above
dbos = OperatingSystem.get_unique(session,
name=osname,
version=osversion,
archetype=dbarchetype,
compel=True)
q = q.filter_by(operating_system=dbos)
elif osname or osversion:
q = q.join('operating_system')
if osname:
q = q.filter_by(name=osname)
if osversion:
q = q.filter_by(version=osversion)
q = q.reset_joinpoint()
if service:
dbservice = Service.get_unique(session, service, compel=True)
if instance:
dbsi = get_service_instance(session, dbservice, instance)
q = q.filter(Host.services_used.contains(dbsi))
else:
q = q.join('services_used')
q = q.filter_by(service=dbservice)
q = q.reset_joinpoint()
elif instance:
q = q.join('services_used')
q = q.filter_by(name=instance)
q = q.reset_joinpoint()
if server_of_service:
dbserver_service = Service.get_unique(session,
server_of_service,
compel=True)
if server_of_instance:
dbssi = get_service_instance(session, dbserver_service,
server_of_instance)
q = q.join('_services_provided')
q = q.filter_by(service_instance=dbssi)
q = q.reset_joinpoint()
else:
q = q.join('_services_provided', 'service_instance')
q = q.filter_by(service=dbserver_service)
q = q.reset_joinpoint()
elif server_of_instance:
q = q.join('_services_provided', 'service_instance')
q = q.filter_by(name=server_of_instance)
q = q.reset_joinpoint()
if cluster:
dbcluster = Cluster.get_unique(session, cluster, compel=True)
if isinstance(dbcluster, MetaCluster):
q = q.join('_cluster', 'cluster', '_metacluster')
q = q.filter_by(metacluster=dbcluster)
else:
q = q.filter_by(cluster=dbcluster)
q = q.reset_joinpoint()
if guest_on_cluster:
# TODO: this does not handle metaclusters according to Wes
dbcluster = Cluster.get_unique(session,
guest_on_cluster,
compel=True)
q = q.join('machine', VirtualMachine, ClusterResource)
q = q.filter_by(cluster=dbcluster)
q = q.reset_joinpoint()
if guest_on_share:
#v2
v2shares = session.query(
Share.id).filter_by(name=guest_on_share).all()
if not v2shares:
raise NotFoundException(
"No shares found with name {0}.".format(guest_on_share))
NasAlias = aliased(VirtualDisk)
q = q.join('machine', 'disks', (NasAlias, NasAlias.id == Disk.id))
q = q.filter(NasAlias.share_id.in_(map(lambda s: s[0], v2shares)))
q = q.reset_joinpoint()
if member_cluster_share:
#v2
v2shares = session.query(
Share.id).filter_by(name=member_cluster_share).all()
if not v2shares:
raise NotFoundException(
"No shares found with name {0}.".format(guest_on_share))
NasAlias = aliased(VirtualDisk)
q = q.join('_cluster', 'cluster', 'resholder', VirtualMachine,
'machine', 'disks', (NasAlias, NasAlias.id == Disk.id))
q = q.filter(NasAlias.share_id.in_(map(lambda s: s[0], v2shares)))
q = q.reset_joinpoint()
if grn or eon_id:
dbgrn = lookup_grn(session, grn, eon_id, autoupdate=False)
persq = session.query(Personality.id)
persq = persq.outerjoin(PersonalityGrnMap)
persq = persq.filter(
or_(Personality.owner_eon_id == dbgrn.eon_id,
PersonalityGrnMap.eon_id == dbgrn.eon_id))
q = q.outerjoin(HostGrnMap)
q = q.filter(
or_(Host.owner_eon_id == dbgrn.eon_id,
HostGrnMap.eon_id == dbgrn.eon_id,
Host.personality_id.in_(persq.subquery())))
q = q.reset_joinpoint()
if fullinfo:
return q.all()
return SimpleHostList(q.all())
