def all(self):
"""returning all Snapshot objects for respective storage manager type"""
view = navigate_to(self, 'All')
view.toolbar.view_selector.select("List View")
snapshots = []
try:
if 'provider' in self.filters:
for item in view.entities.elements.read():
if self.filters.get(
'provider').name in item['Storage Manager']:
snapshots.append(
self.instantiate(
name=item['Name'],
provider=self.filters.get('provider')))
else:
for item in view.entities.elements.read():
provider_name = item['Storage Manager'].split()[0]
provider = get_crud_by_name(provider_name)
snapshots.append(
self.instantiate(name=item['Name'], provider=provider))
except NoSuchElementException:
if snapshots:
logger.error(
'VolumeSnapshotCollection: '
'NoSuchElementException in the middle of entities read')
else:
logger.warning(
'The snapshot table is probably not present or empty')
return snapshots
def test_cluster_relationships(appliance, soft_assert):
"""Tests vm power options from on
Metadata:
test_flag: inventory
Polarion:
assignee: pvala
casecomponent: Reporting
caseimportance: high
initialEstimate: 1/6h
"""
report = appliance.collections.reports.instantiate(
type="Relationships",
subtype="Virtual Machines, Folders, Clusters",
menu_name="Cluster Relationships").queue(wait_for_finish=True)
for relation in report.data.rows:
name = relation["Name"]
provider_name = relation["Provider Name"]
if not provider_name.strip():
# If no provider name specified, ignore it
continue
provider = get_crud_by_name(provider_name)
host_name = relation["Host Name"].strip()
cluster_list = provider.mgmt.list_clusters() if isinstance(
provider, SCVMMProvider) else provider.mgmt.list_cluster()
verified_cluster = [item for item in cluster_list if name in item]
soft_assert(verified_cluster,
"Cluster {} not found in {}".format(name, provider_name))
if not host_name:
continue # No host name
host_ip = resolve_hostname(host_name, force=True)
if host_ip is None:
# Don't check
continue
host_list = provider.mgmt.list_host()
for host in host_list:
if ip_address.match(host) is None:
host_is_ip = False
ip_from_provider = resolve_hostname(host, force=True)
else:
host_is_ip = True
ip_from_provider = host
if not host_is_ip:
# Strings first
if host == host_name:
break
elif host_name.startswith(host):
break
elif ip_from_provider is not None and ip_from_provider == host_ip:
break
else:
if host_ip == ip_from_provider:
break
else:
soft_assert(
False,
"Hostname {} not found in {}".format(host_name, provider_name))
def all(self):
"""returning all backup objects for respective storage manager type"""
view = navigate_to(self, 'All')
view.toolbar.view_selector.select("List View")
backups = []
try:
if 'provider' in self.filters:
for item in view.entities.elements.read():
if self.filters.get(
'provider').name in item['Storage Manager']:
backups.append(
self.instantiate(
name=item['Name'],
provider=self.filters.get('provider')))
else:
for item in view.entities.elements.read():
provider_name = item['Storage Manager'].split()[0]
provider = get_crud_by_name(provider_name)
backups.append(
self.instantiate(name=item['Name'], provider=provider))
except NoSuchElementException:
if backups:
# In the middle of reading, that may be bad
logger.error(
'VolumeBackupCollection: NoSuchElementException in the middle of entities read'
)
raise
else:
# This is probably fine, just warn
logger.warning(
'The volume backup table is probably not present (=empty)')
return backups
def all(self):
# container_routes table has ems_id, join with ext_mgmgt_systems on id for provider name
# Then join with container_projects on the id for the project
route_table = self.appliance.db.client['container_routes']
ems_table = self.appliance.db.client['ext_management_systems']
project_table = self.appliance.db.client['container_projects']
route_query = (self.appliance.db.client.session.query(
route_table.name, project_table.name, ems_table.name).join(
ems_table, route_table.ems_id == ems_table.id).join(
project_table,
route_table.container_project_id == project_table.id))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
route_query = route_query.filter(ems_table.name == provider.name)
routes = []
for name, project_name, ems_name in route_query.all():
routes.append(
self.instantiate(name=name,
project_name=project_name,
provider=provider
or get_crud_by_name(ems_name)))
return routes
def all(self):
# container_images has ems_id, join with ext_mgmgt_systems on id for provider name
# TODO Update to use REST API instead of DB queries
image_table = self.appliance.db.client['container_images']
ems_table = self.appliance.db.client['ext_management_systems']
image_registry_table = self.appliance.db.client['container_image_registries']
image_query = (
self.appliance.db.client.session
.query(image_table.name, image_table.image_ref, ems_table.name,
image_registry_table.name)
.join(ems_table, image_table.ems_id == ems_table.id)
.join(image_registry_table,
image_table.container_image_registry_id == image_registry_table.id))
if self.filters.get('archived'):
image_query = image_query.filter(image_table.deleted_on.isnot(None))
if self.filters.get('active'):
image_query = image_query.filter(image_table.deleted_on.is_(None))
# filter for containers images from openShift local redhat registry
if self.filters.get('redhat_registry'):
image_query = image_query.filter(
image_registry_table.name.contains("registry.access.redhat.com")
)
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
image_query = image_query.filter(ems_table.name == provider.name)
images = []
for name, image_ref, ems_name, _ in image_query.all():
images.append(self.instantiate(name=name, id=image_ref,
provider=provider or get_crud_by_name(ems_name)))
return images
def all(self):
"""Return entities for all items in collection"""
# Pretty much same as image, but defining at VMCollection would only work for cloud
# provider filter means we're viewing instances through provider details relationships
provider = self.filters.get(
'provider') # None if no filter, need for entity instantiation
view = navigate_to(provider or self,
'Instances' if provider else 'All')
# iterate pages here instead of use surf_pages=True because data is needed
entities = []
for _ in view.entities.paginator.pages(): # auto-resets to first page
page_entities = [
entity for entity in view.entities.get_all(surf_pages=False)
]
entities.extend(
# when provider filtered view, there's no provider data value
[
self.instantiate(
e.data['name'], provider
or get_crud_by_name(e.data['provider']))
for e in page_entities if e.data.get('provider') != ''
] # safe provider check, archived shows no provider
)
# filtering
if self.filters.get("names"):
names = self.filters["names"]
entities = [e for e in entities if e.name in names]
if self.filters.get("name"):
name = self.filters["name"]
entities = [e for e in entities if e.name == name]
return entities
def all(self):
"""returning all Snapshot objects for respective storage manager type"""
view = navigate_to(self, 'All')
view.toolbar.view_selector.select("List View")
snapshots = []
try:
if 'provider' in self.filters:
for item in view.entities.elements.read():
if self.filters.get('provider').name in item['Storage Manager']:
snapshots.append(self.instantiate(name=item['Name'],
provider=self.filters.get('provider')))
else:
for item in view.entities.elements.read():
provider_name = item['Storage Manager'].split()[0]
provider = get_crud_by_name(provider_name)
snapshots.append(self.instantiate(name=item['Name'], provider=provider))
except NoSuchElementException:
if snapshots:
logger.error('VolumeSnapshotCollection: '
'NoSuchElementException in the middle of entities read')
else:
logger.warning('The snapshot table is probably not present or empty')
return snapshots
def all(self):
"""returning all block storage manager objects and support filtering as per provider"""
provider = self.filters.get("provider")
blocks = ("Cinder Manager", "EBS Storage Manager")
prov_db = {
prov.id: prov
for prov in self.appliance.rest_api.collections.providers.all
}
managers = [
prov for prov in prov_db.values()
if any(block in prov.name for block in blocks)
]
if provider:
return [
self.instantiate(name=mag.name, provider=provider)
for mag in managers if provider.id == mag.parent_ems_id
]
else:
return [
self.instantiate(name=mag.name,
provider=get_crud_by_name(
prov_db[mag.parent_ems_id].name))
for mag in managers
]
def all(self):
"Returning all datastore objects with filtering support as per provider"
provider = self.filters.get("provider")
datastores = self.appliance.rest_api.collections.data_stores.all_include_attributes(
attributes=["hosts"]
)
datastore_db = {}
for ds in datastores:
for host in ds.hosts:
if host.get("ems_id"):
datastore_db.update({ds.name: host.get("ems_id")})
break
provider_db = {
prov.id: get_crud_by_name(prov.name)
for prov in self.appliance.rest_api.collections.providers.all
if not (getattr(prov, "parent_ems_id", False) or ("Manager" in prov.name))
}
datastores = [
self.instantiate(name=name, provider=provider_db[prov_id])
for name, prov_id in datastore_db.items()
]
return (
[ds for ds in datastores if ds.provider.id == provider.id] if provider else datastores
)
def all(self):
"""returning all backup objects for respective storage manager type"""
view = navigate_to(self, 'All')
view.toolbar.view_selector.select("List View")
backups = []
try:
if 'provider' in self.filters:
for item in view.entities.elements.read():
if self.filters.get('provider').name in item['Storage Manager']:
backups.append(self.instantiate(name=item['Name'],
provider=self.filters.get('provider')))
else:
for item in view.entities.elements.read():
provider_name = item['Storage Manager'].split()[0]
provider = get_crud_by_name(provider_name)
backups.append(self.instantiate(name=item['Name'], provider=provider))
except NoSuchElementException:
if backups:
# In the middle of reading, that may be bad
logger.error(
'VolumeBackupCollection: NoSuchElementException in the middle of entities read')
raise
else:
# This is probably fine, just warn
logger.warning('The volume backup table is probably not present (=empty)')
return backups
def all(self, provider):
"""
Return all `physical_chassis` objects of the given provider.
Args:
provider: the provider that the physical chassis belongs to
"""
physical_chassis_table = self.appliance.db.client['physical_chassis']
ems_table = self.appliance.db.client['ext_management_systems']
physical_chassis_query = (self.appliance.db.client.session.query(
physical_chassis_table.name,
physical_chassis_table.ems_ref, ems_table.name).join(
ems_table, physical_chassis_table.ems_id == ems_table.id))
if self.filters.get('provider'):
physical_chassis_query = physical_chassis_query.filter(
ems_table.name == provider.name)
physical_chassiss = []
for name, ems_ref, ems_name in physical_chassis_query.all():
physical_chassiss.append(
self.instantiate(name=name,
ems_ref=ems_ref,
provider=provider
or get_crud_by_name(ems_name)))
return physical_chassiss
def all(self):
"""Return entities for all items in collection"""
# Pretty much same as image, but defining at VMCollection would only work for cloud
# provider filter means we're viewing instances through provider details relationships
provider = self.filters.get('provider') # None if no filter, need for entity instantiation
view = navigate_to(provider or self,
'Instances' if provider else 'All')
# iterate pages here instead of use surf_pages=True because data is needed
entities = []
for _ in view.entities.paginator.pages(): # auto-resets to first page
page_entities = [entity for entity in view.entities.get_all(surf_pages=False)]
entities.extend(
# when provider filtered view, there's no provider data value
[self.instantiate(e.data['name'], provider or get_crud_by_name(e.data['provider']))
for e in page_entities
if e.data.get('provider') != ''] # safe provider check, archived shows no provider
)
# filtering
if self.filters.get("names"):
names = self.filters["names"]
entities = [e for e in entities if e.name in names]
if self.filters.get("name"):
name = self.filters["name"]
entities = [e for e in entities if e.name == name]
return entities
def all(self):
# containers table has ems_id, join with ext_mgmgt_systems on id for provider name
# Then join with container_groups on the id for the pod
# TODO Update to use REST API instead of DB queries
container_table = self.appliance.db.client['containers']
ems_table = self.appliance.db.client['ext_management_systems']
pod_table = self.appliance.db.client['container_groups']
container_pod_id = (
VersionPick({
Version.lowest(): getattr(container_table, 'container_definition_id', None),
'5.9': getattr(container_table, 'container_group_id', None)})
.pick(self.appliance.version))
container_query = (
self.appliance.db.client.session
.query(container_table.name, pod_table.name, ems_table.name)
.join(ems_table, container_table.ems_id == ems_table.id)
.join(pod_table, container_pod_id == pod_table.id))
if self.filters.get('archived'):
container_query = container_query.filter(container_table.deleted_on.isnot(None))
if self.filters.get('active'):
container_query = container_query.filter(container_table.deleted_on.is_(None))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
container_query = container_query.filter(ems_table.name == provider.name)
containers = []
for name, pod_name, ems_name in container_query.all():
containers.append(
self.instantiate(name=name, pod=pod_name,
provider=provider or get_crud_by_name(ems_name)))
return containers
def all(self):
"""returning all cluster objects and support filtering as per provider"""
provider = self.filters.get("provider")
clusters = self.appliance.rest_api.collections.clusters.all
if provider:
cluster_obj = [
self.instantiate(name=cluster.name, provider=provider)
for cluster in clusters
if provider.id == cluster.ems_id
]
else:
providers = self.appliance.rest_api.collections.providers
providers_db = {
prov.id: get_crud_by_name(prov.name)
for prov in providers
if not (
getattr(prov, "parent_ems_id", False)
or ("Manager" in prov.name or prov.name == "Embedded Ansible")
)
}
cluster_obj = [
self.instantiate(name=cluster.name, provider=providers_db[cluster.ems_id])
for cluster in clusters
]
return cluster_obj
def all(self):
# container_groups table has ems_id, join with ext_mgmgt_systems on id for provider name
# Then join with container_projects on the id for the project
# TODO Update to use REST API instead of DB queries
pod_table = self.appliance.db.client['container_groups']
ems_table = self.appliance.db.client['ext_management_systems']
project_table = self.appliance.db.client['container_projects']
pod_query = (
self.appliance.db.client.session
.query(pod_table.name, project_table.name, ems_table.name)
.join(ems_table, pod_table.ems_id == ems_table.id)
.join(project_table, pod_table.container_project_id == project_table.id))
if self.filters.get('archived'):
pod_query = pod_query.filter(pod_table.deleted_on.isnot(None))
if self.filters.get('active'):
pod_query = pod_query.filter(pod_table.deleted_on.is_(None))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
pod_query = pod_query.filter(ems_table.name == provider.name)
pods = []
for name, project_name, ems_name, in pod_query.all():
pods.append(self.instantiate(name=name,
project_name=project_name,
provider=provider or get_crud_by_name(ems_name)))
return pods
def all(self):
# container_images has ems_id, join with ext_mgmgt_systems on id for provider name
# TODO Update to use REST API instead of DB queries
image_table = self.appliance.db.client['container_images']
ems_table = self.appliance.db.client['ext_management_systems']
image_registry_table = self.appliance.db.client['container_image_registries']
image_query = (
self.appliance.db.client.session
.query(image_table.name, image_table.image_ref, ems_table.name,
image_registry_table.name)
.join(ems_table, image_table.ems_id == ems_table.id)
.join(image_registry_table,
image_table.container_image_registry_id == image_registry_table.id))
if self.filters.get('archived'):
image_query = image_query.filter(image_table.deleted_on.isnot(None))
if self.filters.get('active'):
image_query = image_query.filter(image_table.deleted_on.is_(None))
# filter for containers images from openShift local redhat registry
if self.filters.get('redhat_registry'):
image_query = image_query.filter(
image_registry_table.name.contains("registry.access.redhat.com")
)
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
image_query = image_query.filter(ems_table.name == provider.name)
images = []
for name, image_ref, ems_name, _ in image_query.all():
images.append(self.instantiate(name=name, id=image_ref,
provider=provider or get_crud_by_name(ems_name)))
return images
def servers_in_db(cls,
name=None,
feed=None,
provider=None,
product=None,
server_group=None,
strict=True):
servers = []
rows = _db_select_query(name=name,
feed=feed,
provider=provider,
product=product,
server_group=server_group).all()
_provider = provider
for server in rows:
if strict:
_provider = get_crud_by_name(server.provider_name)
servers.append(
MiddlewareServer(name=server.name,
hostname=server.hostname,
feed=unquote(server.feed),
product=server.product,
db_id=server.id,
provider=_provider,
properties=parse_properties(
server.properties)))
return servers
def all(self):
# containers table has ems_id, join with ext_mgmgt_systems on id for provider name
# Then join with container_groups on the id for the pod
container_table = self.appliance.db.client['containers']
ems_table = self.appliance.db.client['ext_management_systems']
pod_table = self.appliance.db.client['container_groups']
container_pod_id = (VersionPick({
Version.lowest():
getattr(container_table, 'container_definition_id', None),
'5.9':
getattr(container_table, 'container_group_id', None)
}).pick(self.appliance.version))
container_query = (self.appliance.db.client.session.query(
container_table.name, pod_table.name,
ems_table.name).join(ems_table,
container_table.ems_id == ems_table.id).join(
pod_table,
container_pod_id == pod_table.id))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
container_query = container_query.filter(
ems_table.name == provider.name)
containers = []
for name, pod_name, ems_name in container_query.all():
containers.append(
self.instantiate(name=name,
pod=pod_name,
provider=provider
or get_crud_by_name(ems_name)))
return containers
def all(self):
"Returning all datastore objects with filtering support as per provider"
provider = self.filters.get("provider")
datastores = self.appliance.rest_api.collections.data_stores.all_include_attributes(
attributes=["hosts"]
)
datastore_db = {}
for ds in datastores:
for host in ds.hosts:
if host.get("ems_id"):
datastore_db.update({ds.name: host.get("ems_id")})
break
provider_db = {
prov.id: get_crud_by_name(prov.name)
for prov in self.appliance.rest_api.collections.providers.all
if not (getattr(prov, "parent_ems_id", False) or ("Manager" in prov.name))
}
datastores = [
self.instantiate(name=name, provider=provider_db[prov_id])
for name, prov_id in datastore_db.items()
]
return (
[ds for ds in datastores if ds.provider.id == provider.id] if provider else datastores
)
def all(self):
# container_groups table has ems_id, join with ext_mgmgt_systems on id for provider name
# Then join with container_projects on the id for the project
# TODO Update to use REST API instead of DB queries
pod_table = self.appliance.db.client['container_groups']
ems_table = self.appliance.db.client['ext_management_systems']
project_table = self.appliance.db.client['container_projects']
pod_query = (
self.appliance.db.client.session
.query(pod_table.name, project_table.name, ems_table.name)
.join(ems_table, pod_table.ems_id == ems_table.id)
.join(project_table, pod_table.container_project_id == project_table.id))
if self.filters.get('archived'):
pod_query = pod_query.filter(pod_table.deleted_on.isnot(None))
if self.filters.get('active'):
pod_query = pod_query.filter(pod_table.deleted_on.is_(None))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
pod_query = pod_query.filter(ems_table.name == provider.name)
pods = []
for name, project_name, ems_name, in pod_query.all():
pods.append(self.instantiate(name=name,
project_name=project_name,
provider=provider or get_crud_by_name(ems_name)))
return pods
def test_cluster_relationships(appliance, soft_assert):
"""Tests vm power options from on
Metadata:
test_flag: inventory
Polarion:
assignee: pvala
casecomponent: Reporting
caseimportance: high
initialEstimate: 1/6h
"""
report = appliance.collections.reports.instantiate(
type="Relationships",
subtype="Virtual Machines, Folders, Clusters",
menu_name="Cluster Relationships"
).queue(wait_for_finish=True)
for relation in report.data.rows:
name = relation["Name"]
provider_name = relation["Provider Name"]
if not provider_name.strip():
# If no provider name specified, ignore it
continue
provider = get_crud_by_name(provider_name)
host_name = relation["Host Name"].strip()
cluster_list = provider.mgmt.list_clusters() if isinstance(
provider, SCVMMProvider) else provider.mgmt.list_cluster()
verified_cluster = [item for item in cluster_list if name in item]
soft_assert(verified_cluster, "Cluster {} not found in {}".format(name, provider_name))
if not host_name:
continue # No host name
host_ip = resolve_hostname(host_name, force=True)
if host_ip is None:
# Don't check
continue
host_list = provider.mgmt.list_hosts() if isinstance(
provider, SCVMMProvider) else provider.mgmt.list_host()
for host in host_list:
if ip_address.match(host) is None:
host_is_ip = False
ip_from_provider = resolve_hostname(host, force=True)
else:
host_is_ip = True
ip_from_provider = host
if not host_is_ip:
# Strings first
if host == host_name:
break
elif host_name.startswith(host):
break
elif ip_from_provider is not None and ip_from_provider == host_ip:
break
else:
if host_ip == ip_from_provider:
break
else:
soft_assert(False, "Hostname {} not found in {}".format(host_name, provider_name))
def parent_provider(self):
""" Return object of parent cloud provider """
view = navigate_to(self, 'Details')
parent_cloud_text = VersionPick({Version.lowest(): 'Parent ems cloud',
'5.10': 'Parent Cloud Provider'}
).pick(self.appliance.version)
provider_name = view.entities.relationships.get_text_of(parent_cloud_text)
return providers.get_crud_by_name(provider_name)
def parent_provider(self):
""" Return object of parent cloud provider """
view = navigate_to(self, 'Details')
parent_cloud_text = VersionPick({Version.lowest(): 'Parent ems cloud',
'5.10': 'Parent Cloud Provider'}
).pick(self.appliance.version)
provider_name = view.entities.relationships.get_text_of(parent_cloud_text)
return providers.get_crud_by_name(provider_name)
def domains(cls, provider=None, strict=True):
domains = []
view = _get_domains_page(provider=provider)
_provider = provider # In deployment UI, we cannot get provider name on list all page
for _ in view.entities.paginator.pages():
for row in view.entities.elements:
if strict:
_provider = get_crud_by_name(row.provider.text)
domains.append(MiddlewareDomain(
name=row.domain_name.text,
feed=row.feed.text,
provider=_provider))
return domains
def domains(cls, provider=None, strict=True):
domains = []
view = _get_domains_page(provider=provider)
_provider = provider # In deployment UI, we cannot get provider name on list all page
for _ in view.entities.paginator.pages():
for row in view.entities.elements:
if strict:
_provider = get_crud_by_name(row.provider.text)
domains.append(
MiddlewareDomain(name=row.domain_name.text,
feed=row.feed.text,
provider=_provider))
return domains
def domains_in_db(cls, name=None, feed=None, provider=None, strict=True):
domains = []
rows = _db_select_query(name=name, feed=feed, provider=provider).all()
_provider = provider
for domain in rows:
if strict:
_provider = get_crud_by_name(domain.provider_name)
domains.append(MiddlewareDomain(
name=domain.name,
feed=domain.feed,
db_id=domain.id,
provider=_provider,
properties=parse_properties(domain.properties)))
return domains
def all(self):
provider = self.filters.get('provider') # None if no filter, need for entity instantiation
view = navigate_to(self, 'All')
result = []
for _ in view.entities.paginator.pages():
flavors = view.entities.get_all()
for flavor in flavors:
if provider is not None:
if flavor.data['cloud_provider'] == provider.name:
entity = self.instantiate(flavor.data['name'], provider)
else:
entity = self.instantiate(flavor.data['name'],
get_crud_by_name(flavor.data['cloud_provider']))
result.append(entity)
return result
def servers(cls, provider=None, server_group=None, strict=True):
servers = []
view = _get_servers_page(provider=provider, server_group=server_group)
_provider = provider # In deployment UI, we cannot get provider name on list all page
for _ in view.entities.paginator.pages():
for row in view.entities.elements:
if strict:
_provider = get_crud_by_name(row.provider.text)
servers.append(MiddlewareServer(
name=row.server_name.text,
feed=row.feed.text,
hostname=row.host_name.text,
product=row.product.text
if row.product.text else None,
provider=_provider))
return servers
def all(self):
"""returning all Cloud Network objects and support filtering as per provider"""
provider_id = self.filters.get("provider").id if self.filters.get("provider") else None
networks_all = self.appliance.rest_api.collections.cloud_networks.all
prov_db = {prov.id: prov for prov in self.appliance.rest_api.collections.providers}
nw_objs = []
for nw in networks_all:
prov_name = prov_db[prov_db[nw.ems_id].parent_ems_id]["name"]
prov = providers.get_crud_by_name(prov_name)
nw_objs.append(self.instantiate(name=nw.name, provider_obj=prov))
if provider_id:
return [nw for nw in nw_objs if nw.provider_obj.id == provider_id]
else:
return nw_objs
def all(self):
view = navigate_to(self, 'All')
list_networks = view.entities.get_all(surf_pages=True)
network_providers = []
if 'provider' in self.filters:
for item in list_networks:
if self.filters.get('provider').name in item.name:
network_providers.append(self.instantiate(name=item.name,
provider=self.filters.get('provider')))
else:
for item in list_networks:
provider = get_crud_by_name(item.name.split()[0])
network_providers.append(self.instantiate(name=item.name, provider=provider))
return network_providers
def find_by(self, ph_name, provider=None):
"""returning all physical_switches objects"""
physical_switch_table = self.appliance.db.client['switches']
ems_table = self.appliance.db.client['ext_management_systems']
physical_switch_query = (
self.appliance.db.client.session
.query(physical_switch_table.name, ems_table.name)
.join(ems_table, physical_switch_table.ems_id == ems_table.id))
if self.filters.get('provider'):
provider = self.filters.get('provider')
physical_switch_query = physical_switch_query.filter(ems_table.name == provider.name)
for name, ems_name in physical_switch_query.all():
if ph_name == name:
return self.instantiate(name=name, provider=provider or get_crud_by_name(ems_name))
def all(self):
"""returning all Cloud Network objects and support filtering as per provider"""
provider_id = self.filters.get("provider").id if self.filters.get("provider") else None
networks_all = self.appliance.rest_api.collections.cloud_networks.all
prov_db = {prov.id: prov for prov in self.appliance.rest_api.collections.providers}
nw_objs = []
for nw in networks_all:
prov_name = prov_db[prov_db[nw.ems_id].parent_ems_id]["name"]
prov = providers.get_crud_by_name(prov_name)
nw_objs.append(self.instantiate(name=nw.name, provider_obj=prov))
if provider_id:
return [nw for nw in nw_objs if nw.provider_obj.id == provider_id]
else:
return nw_objs
def all(self):
"""returning all physical_storages objects"""
physical_storage_table = self.appliance.db.client['physical_storages']
ems_table = self.appliance.db.client['ext_management_systems']
physical_storage_query = (
self.appliance.db.client.session
.query(physical_storage_table.name, ems_table.name)
.join(ems_table, physical_storage_table.id == ems_table.id))
provider = self.filters.get('provider')
if provider:
physical_storage_query = physical_storage_query.filter(ems_table.name == provider.name)
physical_storages = []
for name, ems_name in physical_storage_query.all():
physical_storages.append(self.instantiate(name=name,
provider=provider or get_crud_by_name(ems_name)))
return physical_storages
def servers(cls, provider=None, server_group=None, strict=True):
servers = []
view = _get_servers_page(provider=provider, server_group=server_group)
_provider = provider # In deployment UI, we cannot get provider name on list all page
for _ in view.entities.paginator.pages():
for row in view.entities.elements:
if strict:
_provider = get_crud_by_name(row.provider.text)
servers.append(
MiddlewareServer(
name=row.server_name.text,
feed=row.feed.text,
hostname=row.host_name.text,
product=row.product.text if row.product.text else None,
provider=_provider))
return servers
def test_cluster_relationships(soft_assert):
path = [
"Relationships", "Virtual Machines, Folders, Clusters",
"Cluster Relationships"
]
report = CannedSavedReport.new(path)
for relation in report.data.rows:
name = relation["Name"]
provider_name = relation["Provider Name"]
if not provider_name.strip():
# If no provider name specified, ignore it
continue
provider = get_crud_by_name(provider_name).mgmt
host_name = relation["Host Name"].strip()
verified_cluster = [
item for item in provider.list_cluster() if name in item
]
soft_assert(verified_cluster,
"Cluster {} not found in {}".format(name, provider_name))
if not host_name:
continue # No host name
host_ip = resolve_hostname(host_name, force=True)
if host_ip is None:
# Don't check
continue
for host in provider.list_host():
if ip_address.match(host) is None:
host_is_ip = False
ip_from_provider = resolve_hostname(host, force=True)
else:
host_is_ip = True
ip_from_provider = host
if not host_is_ip:
# Strings first
if host == host_name:
break
elif host_name.startswith(host):
break
elif ip_from_provider is not None and ip_from_provider == host_ip:
break
else:
if host_ip == ip_from_provider:
break
else:
soft_assert(
False,
"Hostname {} not found in {}".format(host_name, provider_name))
def deployment_in_db(self):
deployment = _db_select_query(name=self.name,
server=self.server,
provider=self.provider).first()
if deployment:
_provider = get_crud_by_name(deployment.provider_name)
_server = MiddlewareServer(name=deployment.server_name,
feed=deployment.feed,
provider=_provider)
return MiddlewareDeployment(nativeid=deployment.nativeid,
name=deployment.name,
hostname=deployment.host_name,
status=deployment.status,
server=_server,
provider=_provider,
db_id=deployment.id)
return None
def all(self):
"Returning all datastore objects with filtering support as per provider"
provider = self.filters.get("provider")
datastores = self.appliance.rest_api.collections.data_stores
datastores = datastores.all_include_attributes(attributes=["hosts"])
datastore_db = {ds.name: ds.hosts[0]["ems_id"] for ds in datastores}
provider_db = {
prov.id: get_crud_by_name(prov.name)
for prov in self.appliance.rest_api.collections.providers.all
if not getattr(prov, "parent_ems_id", False)
}
datastores = [
self.instantiate(name=name, provider=provider_db[prov_id])
for name, prov_id in datastore_db.items()
]
return ([ds for ds in datastores
if ds.provider.id == provider.id] if provider else datastores)
def test_cluster_relationships(appliance, soft_assert):
report = appliance.collections.reports.instantiate(
type="Relationships",
subtype="Virtual Machines, Folders, Clusters",
menu_name="Cluster Relationships").queue(wait_for_finish=True)
for relation in report.data.rows:
name = relation["Name"]
provider_name = relation["Provider Name"]
if not provider_name.strip():
# If no provider name specified, ignore it
continue
provider = get_crud_by_name(provider_name).mgmt
host_name = relation["Host Name"].strip()
verified_cluster = [
item for item in provider.list_cluster() if name in item
]
soft_assert(verified_cluster,
"Cluster {} not found in {}".format(name, provider_name))
if not host_name:
continue # No host name
host_ip = resolve_hostname(host_name, force=True)
if host_ip is None:
# Don't check
continue
for host in provider.list_host():
if ip_address.match(host) is None:
host_is_ip = False
ip_from_provider = resolve_hostname(host, force=True)
else:
host_is_ip = True
ip_from_provider = host
if not host_is_ip:
# Strings first
if host == host_name:
break
elif host_name.startswith(host):
break
elif ip_from_provider is not None and ip_from_provider == host_ip:
break
else:
if host_ip == ip_from_provider:
break
else:
soft_assert(
False,
"Hostname {} not found in {}".format(host_name, provider_name))
def find_by(self, provider, ph_name):
"""returning all physical_servers objects"""
physical_server_table = self.appliance.db.client['physical_servers']
ems_table = self.appliance.db.client['ext_management_systems']
physical_server_query = (
self.appliance.db.client.session
.query(physical_server_table.name, ems_table.name)
.join(ems_table, physical_server_table.ems_id == ems_table.id))
provider = None
if self.filters.get('provider'):
provider = self.filters.get('provider')
physical_server_query = physical_server_query.filter(ems_table.name == provider.name)
for name, ems_name in physical_server_query.all():
if ph_name == name:
return self.instantiate(name=name, provider=provider or get_crud_by_name(ems_name))
def all(self, provider):
"""returning all physical_servers objects"""
physical_server_table = self.appliance.db.client['physical_servers']
ems_table = self.appliance.db.client['ext_management_systems']
physical_server_query = (
self.appliance.db.client.session
.query(physical_server_table.name, physical_server_table.ems_ref, ems_table.name)
.join(ems_table, physical_server_table.ems_id == ems_table.id))
provider = None
if self.filters.get('provider'):
provider = self.filters.get('provider')
physical_server_query = physical_server_query.filter(ems_table.name == provider.name)
physical_servers = []
for name, ems_ref, ems_name in physical_server_query.all():
physical_servers.append(self.instantiate(name=name, ems_ref=ems_ref,
provider=provider or get_crud_by_name(ems_name)))
return physical_servers
def deployment_in_db(self):
deployment = _db_select_query(name=self.name, server=self.server,
provider=self.provider).first()
if deployment:
_provider = get_crud_by_name(deployment.provider_name)
_server = MiddlewareServer(
name=deployment.server_name,
feed=deployment.feed,
provider=_provider)
return MiddlewareDeployment(
nativeid=deployment.nativeid,
name=deployment.name,
hostname=deployment.host_name,
status=deployment.status,
server=_server,
provider=_provider,
db_id=deployment.id)
return None
def servers_in_db(cls, name=None, feed=None, provider=None, product=None,
server_group=None, strict=True):
servers = []
rows = _db_select_query(name=name, feed=feed, provider=provider,
product=product, server_group=server_group).all()
_provider = provider
for server in rows:
if strict:
_provider = get_crud_by_name(server.provider_name)
servers.append(MiddlewareServer(
name=server.name,
hostname=server.hostname,
feed=unquote(server.feed),
product=server.product,
db_id=server.id,
provider=_provider,
properties=parse_properties(server.properties)))
return servers
def all(self):
# container_images has ems_id, join with ext_mgmgt_systems on id for provider name
image_table = self.appliance.db.client['container_images']
ems_table = self.appliance.db.client['ext_management_systems']
image_query = (
self.appliance.db.client.session
.query(image_table.name, image_table.image_ref, ems_table.name)
.join(ems_table, image_table.ems_id == ems_table.id))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
image_query = image_query.filter(ems_table.name == provider.name)
images = []
for name, image_ref, ems_name in image_query.all():
images.append(self.instantiate(name=name, id=image_ref,
provider=provider or get_crud_by_name(ems_name)))
return images
def all(self):
# container_images has ems_id, join with ext_mgmgt_systems on id for provider name
image_table = self.appliance.db.client['container_images']
ems_table = self.appliance.db.client['ext_management_systems']
image_query = (
self.appliance.db.client.session
.query(image_table.name, image_table.image_ref, ems_table.name)
.join(ems_table, image_table.ems_id == ems_table.id))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
image_query = image_query.filter(ems_table.name == provider.name)
images = []
for name, image_ref, ems_name in image_query.all():
images.append(self.instantiate(name=name, id=image_ref,
provider=provider or get_crud_by_name(ems_name)))
return images
def test_custom_vm_report(soft_assert, report_vms):
"""
Polarion:
assignee: pvala
casecomponent: Reporting
caseimportance: low
initialEstimate: 1/16h
"""
cluster = "Cluster / Deployment Role Name"
host = "Host / Node Name"
for row in report_vms:
if row["Name"].startswith("test_"):
continue # Might disappear meanwhile
provider_name = row["Provider Name"]
provider_mgmt = get_crud_by_name(provider_name).mgmt
provider_hosts_and_ips = cfme.utils.net.resolve_ips(
provider_mgmt.list_host())
provider_datastores = provider_mgmt.list_datastore()
provider_clusters = provider_mgmt.list_cluster()
soft_assert(
provider_mgmt.does_vm_exist(row["Name"]),
"VM {} does not exist in {}!".format(row["Name"], provider_name))
if row[cluster]:
soft_assert(
row[cluster] in provider_clusters,
"Cluster {} not found in {}!".format(row[cluster],
str(provider_clusters)))
if row["Datastore Name"]:
soft_assert(
row["Datastore Name"] in provider_datastores,
"Datastore {} not found in {}!".format(
row["Datastore Name"], str(provider_datastores)))
# Because of mixing long and short host names, we have to use both-directional `in` op.
if row[host]:
found = False
possible_ips_or_hosts = cfme.utils.net.resolve_ips((row[host], ))
for possible_ip_or_host in possible_ips_or_hosts:
for host_ip in provider_hosts_and_ips:
if possible_ip_or_host in host_ip or host_ip in possible_ip_or_host:
found = True
soft_assert(
found,
"Host {} not found in {}!".format(possible_ips_or_hosts,
provider_hosts_and_ips))
def all(self, provider=None):
"""returning all physical_racks objects"""
physical_rack_table = self.appliance.db.client['physical_racks']
ems_table = self.appliance.db.client['ext_management_systems']
physical_rack_query = (
self.appliance.db.client.session
.query(physical_rack_table.name, physical_rack_table.ems_ref, ems_table.name)
.join(ems_table, physical_rack_table.ems_id == ems_table.id))
if provider is None:
provider = self.filters.get('provider')
if provider:
physical_rack_query = physical_rack_query.filter(ems_table.name == provider.name)
return [
self.instantiate(name=name, ems_ref=ems_ref, provider=provider
or get_crud_by_name(ems_name))
for name, ems_ref, ems_name in physical_rack_query.all()
]
def all(self):
# container_projects table has ems_id, join with ext_mgmgt_systems on id for provider name
project_table = self.appliance.db.client['container_projects']
ems_table = self.appliance.db.client['ext_management_systems']
project_query = (
self.appliance.db.client.session
.query(project_table.name, ems_table.name)
.join(ems_table, project_table.ems_id == ems_table.id))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
project_query = project_query.filter(ems_table.name == provider.name)
projects = []
for name, ems_name in project_query.all():
projects.append(self.instantiate(name=name,
provider=provider or get_crud_by_name(ems_name)))
return projects
def deployments_in_db(cls, server=None, provider=None, strict=True):
deployments = []
rows = _db_select_query(server=server, provider=provider).all()
_provider = provider
for deployment in rows:
if strict:
_provider = get_crud_by_name(deployment.provider_name)
_server = MiddlewareServer(name=deployment.server_name,
feed=deployment.feed,
provider=provider)
deployments.append(
MiddlewareDeployment(nativeid=deployment.nativeid,
name=deployment.name,
db_id=deployment.id,
hostname=deployment.host_name,
status=deployment.status,
server=_server,
provider=_provider))
return deployments
def all(self):
view = navigate_to(self, 'All')
list_networks = view.entities.get_all(surf_pages=True)
network_providers = []
if 'provider' in self.filters:
for item in list_networks:
if self.filters.get('provider').name in item.name:
network_providers.append(self.instantiate(prov_class=self.ENTITY,
name=item.name,
provider=self.filters.get('provider')))
else:
for item in list_networks:
provider = get_crud_by_name(item.name.split()[0])
network_providers.append(self.instantiate(prov_class=self.ENTITY,
name=item.name,
provider=provider))
return network_providers
def test_custom_vm_report(soft_assert, report_vms):
"""
Polarion:
assignee: pvala
casecomponent: Reporting
caseimportance: low
initialEstimate: 1/16h
"""
cluster = "Cluster / Deployment Role Name"
host = "Host / Node Name"
for row in report_vms:
if row["Name"].startswith("test_"):
continue # Might disappear meanwhile
provider_name = row["Provider Name"]
provider_mgmt = get_crud_by_name(provider_name).mgmt
provider_hosts_and_ips = cfme.utils.net.resolve_ips(provider_mgmt.list_host())
provider_datastores = provider_mgmt.list_datastore()
provider_clusters = provider_mgmt.list_cluster()
soft_assert(provider_mgmt.does_vm_exist(row["Name"]),
"VM {} does not exist in {}!".format(row["Name"], provider_name))
if row[cluster]:
soft_assert(
row[cluster] in provider_clusters,
"Cluster {} not found in {}!".format(row[cluster], str(provider_clusters))
)
if row["Datastore Name"]:
soft_assert(
row["Datastore Name"] in provider_datastores,
"Datastore {} not found in {}!".format(
row["Datastore Name"], str(provider_datastores))
)
# Because of mixing long and short host names, we have to use both-directional `in` op.
if row[host]:
found = False
possible_ips_or_hosts = cfme.utils.net.resolve_ips((row[host], ))
for possible_ip_or_host in possible_ips_or_hosts:
for host_ip in provider_hosts_and_ips:
if possible_ip_or_host in host_ip or host_ip in possible_ip_or_host:
found = True
soft_assert(
found,
"Host {} not found in {}!".format(possible_ips_or_hosts, provider_hosts_and_ips)
)
def test_cluster_relationships(appliance, soft_assert):
report = appliance.collections.reports.instantiate(
type="Relationships",
subtype="Virtual Machines, Folders, Clusters",
menu_name="Cluster Relationships"
).queue(wait_for_finish=True)
for relation in report.data.rows:
name = relation["Name"]
provider_name = relation["Provider Name"]
if not provider_name.strip():
# If no provider name specified, ignore it
continue
provider = get_crud_by_name(provider_name).mgmt
host_name = relation["Host Name"].strip()
verified_cluster = [item for item in provider.list_cluster() if name in item]
soft_assert(verified_cluster, "Cluster {} not found in {}".format(name, provider_name))
if not host_name:
continue # No host name
host_ip = resolve_hostname(host_name, force=True)
if host_ip is None:
# Don't check
continue
for host in provider.list_host():
if ip_address.match(host) is None:
host_is_ip = False
ip_from_provider = resolve_hostname(host, force=True)
else:
host_is_ip = True
ip_from_provider = host
if not host_is_ip:
# Strings first
if host == host_name:
break
elif host_name.startswith(host):
break
elif ip_from_provider is not None and ip_from_provider == host_ip:
break
else:
if host_ip == ip_from_provider:
break
else:
soft_assert(False, "Hostname {} not found in {}".format(host_name, provider_name))
def all(self):
# container_volumes table has ems_id, join with ext_mgmgt_systems on id for provider name
volume_table = self.appliance.db.client['container_volumes']
ems_table = self.appliance.db.client['ext_management_systems']
volume_query = (
self.appliance.db.client.session
.query(volume_table.name, ems_table.name)
.join(ems_table, volume_table.parent_id == ems_table.id)
.filter(volume_table.type == 'PersistentVolume'))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
volume_query = volume_query.filter(ems_table.name == provider.name)
volumes = []
for name, ems_name in volume_query.all():
volumes.append(self.instantiate(name=name,
provider=provider or get_crud_by_name(ems_name)))
return volumes
def deployments_in_db(cls, server=None, provider=None, strict=True):
deployments = []
rows = _db_select_query(server=server, provider=provider).all()
_provider = provider
for deployment in rows:
if strict:
_provider = get_crud_by_name(deployment.provider_name)
_server = MiddlewareServer(
name=deployment.server_name,
feed=deployment.feed,
provider=provider)
deployments.append(MiddlewareDeployment(
nativeid=deployment.nativeid,
name=deployment.name,
db_id=deployment.id,
hostname=deployment.host_name,
status=deployment.status,
server=_server,
provider=_provider))
return deployments
def datasources_in_db(cls, server=None, provider=None, strict=True):
datasources = []
rows = _db_select_query(server=server, provider=provider).all()
_provider = provider
for datasource in rows:
if strict:
_provider = get_crud_by_name(datasource.provider_name)
_server = MiddlewareServer(
name=datasource.server_name,
feed=datasource.feed,
provider=provider)
datasources.append(MiddlewareDatasource(
nativeid=datasource.nativeid,
name=datasource.name,
db_id=datasource.id,
server=_server,
provider=_provider,
hostname=datasource.hostname,
properties=parse_properties(datasource.properties)))
return datasources
def messagings_in_db(cls, server=None, provider=None, strict=True):
messagings = []
rows = _db_select_query(server=server, provider=provider).all()
_provider = provider
for messaging in rows:
if strict:
_provider = get_crud_by_name(messaging.provider_name)
_server = MiddlewareServer(
name=messaging.server_name,
feed=messaging.feed,
provider=provider)
messagings.append(MiddlewareMessaging(
nativeid=messaging.nativeid,
name=messaging.name,
db_id=messaging.id,
server=_server,
provider=_provider,
messaging_type=messaging.messaging_type,
properties=parse_properties(messaging.properties)))
return messagings
def all(self):
# container_volumes table has ems_id, join with ext_mgmgt_systems on id for provider name
volume_table = self.appliance.db.client['container_volumes']
ems_table = self.appliance.db.client['ext_management_systems']
volume_query = (
self.appliance.db.client.session
.query(volume_table.name, ems_table.name)
.join(ems_table, volume_table.parent_id == ems_table.id)
.filter(volume_table.type == 'PersistentVolume'))
provider = None
# filtered
if self.filters.get('provider'):
provider = self.filters.get('provider')
volume_query = volume_query.filter(ems_table.name == provider.name)
volumes = []
for name, ems_name in volume_query.all():
volumes.append(self.instantiate(name=name,
provider=provider or get_crud_by_name(ems_name)))
return volumes
def all(self):
"""returning all object storage manager objects and support filtering as per provider"""
provider = self.filters.get("provider")
prov_db = {prov.id: prov for prov in self.appliance.rest_api.collections.providers.all}
managers = [
prov for prov in prov_db.values() if "Swift Manager" in prov.name
]
if provider:
return [
self.instantiate(name=mag.name, provider=provider)
for mag in managers
if provider.id == mag.parent_ems_id
]
else:
return [
self.instantiate(
name=mag.name, provider=get_crud_by_name(prov_db[mag.parent_ems_id].name)
)
for mag in managers
]
def all(self):
"""returning all Object Store Objects"""
view = navigate_to(self, 'All')
view.entities.paginator.set_items_per_page(500)
objects = []
try:
if 'provider'in self.filters:
for item in view.entities.elements.read():
if self.filters['provider'].name in item['Cloud Provider']:
objects.append(self.instantiate(key=item['Key'],
provider=self.filters['provider']))
else:
for item in view.entities.elements.read():
provider_name = item['Cloud Provider'].split()[0]
provider = get_crud_by_name(provider_name)
objects.append(self.instantiate(key=item['Key'], provider=provider))
return objects
except NoSuchElementException:
return None
