def _discoverDatabases(solman, sysPairsBySysName, sendVector, reportError,
resolveIps):
try:
logger.info("Discover Databases")
query = GetDatabaseUsages()
queryExecutor = TableQueryExecutor(solman)
dbName = second
usagePairsByDbName = groupby(dbName, queryExecutor.executeQuery(query))
logger.info("Found %s databases in use" % len(usagePairsByDbName))
query = GetDatabaseInstances()
inDiscoveredSystems = F(_inDiscoveredSystems, fptools._, sysPairsBySysName)
isUsedDb = comp(inDiscoveredSystems,
usagePairsByDbName.get,
_getDbInstance)
findPlatform = comp(db_platform.findPlatformBySignature, _getDbVendor)
dbInsts = queryExecutor.executeQuery(query)
logger.info("Found %s database instances" % len(dbInsts))
dbs_1, dbs_2, dbs_3 = tee(ifilter(isUsedDb, dbInsts), 3)
platforms = imap(findPlatform, dbs_1)
ips = imap(comp(resolveIps, _getAddress), dbs_2)
dbs = ifilter(all, izip(dbs_3, platforms, ips))
reported = len(map(comp(sendVector, _reportDatabase), dbs))
logger.info("Reported %s databases" % reported)
except Exception:
msg = 'Failed to discover databases'
logger.debugException(msg)
reportError(msg)
def _discoverHostToAddressMapping(solman, reportError):
r'@types: ?, (str -> None) -> dict[str, sap.Address]'
logger.info("Discovery hostname to IP mapping")
mapping = {}
try:
query = GetHostToAddressMapping()
queryExecutor = TableQueryExecutor(solman)
addresses = queryExecutor.executeQuery(query)
getHostname = lambda a: a.hostname
mapping = applyMapping(getHostname, addresses)
except (Exception, JException):
msg = "Failed to discovery mappings"
logger.warn(msg)
reportError(msg)
return mapping
def _discoverTmsDomain(sapUtils):
logger.info("Find out the configuration of TMS")
query = TmsDomainConfigurationQuery()
tmsDomain = TableQueryExecutor(sapUtils).executeQuery(query)
if tmsDomain:
logger.info("Found TMS Domain: %s" % tmsDomain)
return tmsDomain
def _discoverSoftwareCmps(solman):
''''''
logger.info("Discover Software Components")
getCmpsQuery = GetComponents()
executeQuery = TableQueryExecutor(solman).executeQuery
sysNameToCmpPairs = executeQuery(getCmpsQuery)
# get descriptions of components
discoverer = SoftCmpDiscoverer(solman)
localizedDescrs = discoverer.getComponentLocalizedDescriptions()
isEn = SoftCmpDiscoverer.isEnglishCmpDescription
descrs = ifilter(isEn, localizedDescrs)
DescrClass = SoftCmpDiscoverer.ComponentLocalizedDescription
descrByName = fptools.applyMapping(DescrClass.getName, descrs)
r = [__fillInCmpDescription(p, descrByName) for p in sysNameToCmpPairs]
logger.info("Discovered %s components" % len(r))
return r
def _discoverServers(solman, hostnameToAddress, sysPairsBySysName, sendVector,
reportError, resolveIps):
'''
Discover SAP instances related to already discovered systems
@type hostnameToAddress: dict[str, sap.Address]
@type sysPairsBySysName: dict[str, tuple[System, osh]]
'''
try:
# get servers by one of the specified queries
queries = (GetServersWithNotActiveFlag(), GetServers())
queryExecutor = TableQueryExecutor(solman)
result = imap(Sfn(queryExecutor.executeQuery), queries)
servers = findFirst(truth, result) or ()
# group servers by system name
pairsBySysName = groupby(GetServers.Server.systemName.fget, servers)
inDiscoveredSystems = comp(sysPairsBySysName.get, first)
pairs = ifilter(inDiscoveredSystems, pairsBySysName.iteritems())
resolveIps = comp(resolveIps, GetServers.Server.hostname.fget)
for sysName, servers in pairs:
logger.info("Found %s servers for %s system" %
(len(servers), sysName))
# collect parsed names for each server
parseServerName = comp(GetServers.parseServerName,
GetServers.Server.name.fget)
parsedServerNames = imap(parseServerName, servers)
# resolve IPs for each server
ips = imap(resolveIps, servers)
# get information for each server where name and IPs are present
infoSeq = ifilter(all, izip(servers, parsedServerNames, ips))
# not interested in server nodes - only instances
infoSeq = ifilterfalse(isServerNode, infoSeq)
# report each server
system, systemOsh = sysPairsBySysName.get(sysName)
reportServer = F(_reportServer, fptools._, fptools._, fptools._,
system, systemOsh)
vector = ObjectStateHolderVector()
each(vector.addAll, starmap(reportServer, infoSeq))
sendVector(vector)
except (Exception, JException):
msg = "Failed to discover servers"
logger.warnException(msg)
reportError(msg)
def _discoverClients(solman, sysPairsBySysName, sendVector, reportError):
try:
logger.info("Discover Clients")
getClientsQuery = GetClients()
executeQuery = TableQueryExecutor(solman).executeQuery
sysNameToClientPairs = executeQuery(getClientsQuery)
pairsBySysName = groupby(first, sysNameToClientPairs)
logger.info("Discovered %s clients for %s systems" % (
len(sysNameToClientPairs), len(pairsBySysName)))
reporter = sap.ClientReporter(sap.ClientBuilder())
for systemName in ifilter(sysPairsBySysName.get, pairsBySysName.iterkeys()):
_, systemOsh = sysPairsBySysName.get(systemName)
report = F(reporter.report, fptools._, systemOsh)
clients = imap(second, pairsBySysName.get(systemName))
vector = ObjectStateHolderVector()
each(vector.add, imap(report, clients))
sendVector(vector)
except (Exception, JException):
msg = "Failed to discover clients"
logger.warnException(msg)
reportError(msg)
def _discover_business_objects(framework, solman, component_to_system,
should_discover_processes,
should_discover_steps, reportCIsInChunks,
sap_system_osh):
queryExecutor = TableQueryExecutor(solman)
execute = queryExecutor.executeQuery
# get projects
projects = execute(sap_solman_discoverer.GetProjects())
processesByScenarioId = {}
business_objects_tree = []
for projectId, responsible in projects:
# get project objects
objectIds = execute(sap_solman_discoverer.GetProjectObjects(projectId))
if not objectIds:
continue
objectId = first(objectIds)
logger.debug("Project Name %s" % projectId)
logger.debug("Project ObjectId %s" % objectId)
project = BusinessProject(projectId, responsible, objectId)
business_objects_tree.append(project)
nameToIdPairs = discoverNodeIdToName(execute, objectId)
scenarioInfo = findFirst(_isBusinessScenario, nameToIdPairs)
if scenarioInfo:
scenarioId, _, _, _ = scenarioInfo
logger.debug("Scenario Structure ID %s" % scenarioId)
businessScenarious = discoverNodeIdToName(execute, scenarioId)
for sId, sName, s_node_id, s_ref_node_id in businessScenarious:
logger.debug("Scenario Name %s" % sName)
logger.debug("Scenario Node ID %s" % s_node_id)
logger.debug("Scenario Ref. Node ID %s" % s_ref_node_id)
logger.debug("Scenario Ref. Structure ID %s" % sId)
scenario = BusinessScenario(sName, s_node_id, s_ref_node_id)
project.add_child(scenario)
if not should_discover_processes:
continue
buisinessProcesses = discoverNodeIdToName(execute, sId)
processInfo = findFirst(_isBusinessProcess, buisinessProcesses)
if processInfo:
processId, _, _, _ = processInfo
logger.debug("Process Structure ID %s" % processId)
processes = discoverNodeIdToName(execute, processId)
processesByScenarioId[sName] = processes
for pId, pName, p_node_id, p_ref_node_id in processes:
logger.debug("Process Name %s" % pName)
logger.debug("Process Node ID %s" % p_node_id)
logger.debug("Process Ref. Node ID %s" % p_ref_node_id)
logger.debug("Process Ref. Structure ID %s" % pId)
process = BusinessProcess(pName, p_node_id)
scenario.add_child(process)
if not should_discover_steps:
continue
process_steps = discoverProcessStepNodeIdToName(
execute, pId)
process_steps_tree = []
process_steps_tree.append(process)
if process_steps:
for step_ref_tree_id, step_name, step_node_id, step_ref_node_id in process_steps:
logger.debug("Process Step Name %s" %
step_name)
logger.debug("Process Step Node ID %s" %
step_node_id)
logger.debug("Process Step Ref. Node ID %s" %
step_ref_node_id)
logger.debug(
"Process Step Ref. Structure ID %s" %
step_ref_tree_id)
process_step = BusinessProcessStep(
step_name, step_node_id)
process.add_child(process_step)
process_step_info = execute(
sap_solman_discoverer.
GetProcessSubStepById(step_ref_tree_id))
process_sub_steps_node_ids = []
system_name = None
# process_step_info should have length of 1
for process_step_ref_tree_id, node_id, tree_id, ref_node_id, component in process_step_info:
logger.debug("Component %s" % component)
process_step.set_component(component)
process_sub_steps_node_ids.append(node_id)
system_name = component_to_system.get(
component)
logger.debug('unit test:',
process_sub_steps_node_ids)
process_sub_sub_steps = execute(
sap_solman_discoverer.
GetProcessRefIdsByNodeIds(
process_sub_steps_node_ids,
only_tree=True))
process_sub_sub_steps_ref_objects = [
a[0] for a in process_sub_sub_steps
]
if process_sub_sub_steps_ref_objects:
process_sub_sub_steps_tree = execute(
sap_solman_discoverer.
GetProcessNodeByTreeIds(
process_sub_sub_steps_ref_objects))
process_sub_sub_steps_tree_node_ids = [
a[0]
for a in process_sub_sub_steps_tree
]
if process_sub_sub_steps_tree_node_ids:
transactions = execute(
sap_solman_discoverer.
GetProcessRefIdsByNodeIds(
process_sub_sub_steps_tree_node_ids
))
for transaction_ref_obj, transaction_node in transactions:
logger.debug(
"Transaction Ref Object %s" %
transaction_ref_obj)
transaction = BusinessTransaction(
transaction_ref_obj,
system_name)
process_step.add_child(transaction)
if reportCIsInChunks:
report_chunk(framework, project, scenario,
process_steps_tree, sap_system_osh)
process.clear_children()
return business_objects_tree
def _discoverIsSolutionManager(sapUtils):
query = IsSolutionManagerQuery()
isSolMan = TableQueryExecutor(sapUtils).executeQuery(query)
logger.info('System %s solution manager' %
(isSolMan and "contains" or "dosn't contain"))
return isSolMan
