def triggered_on_ipse_only(client, framework, dns_resolver, cred_id, ip,
dbname, port, ipse_id):
db_oshs, oshs, warnings = _discover(client, framework, dns_resolver,
cred_id, dbname, port)
config = DiscoveryConfig(framework, cred_id)
reporter = db2_topology.Reporter()
link_reporter = db2_topology.LinkReporter()
node_osh = modeling.createOshByCmdbId('node', config.host_id)
oshs.append(node_osh)
instance = db.DatabaseServer(ip, port)
inst_osh, _, _, vector = reporter.reportServerAndDatabases(
instance, node_osh)
oshs.extend(vector)
alias_osh = reporter.reportDbAlias(dbname, inst_osh)
db2_topology.Builder.update_credential_id(alias_osh, cred_id)
oshs.append(alias_osh)
if db_oshs:
db_osh = db_oshs.pop()
realization_osh = link_reporter.report_realization(alias_osh, db_osh)
oshs.append(realization_osh)
return oshs, warnings
def _discover_local_databases(self, context, instance_name, application_port, db2_home_path,
discoverer, executor, interpreter):
db2_instance_osh = context.application.applicationOsh
get_local_databases = safeFn(discoverer.get_local_databases)
local_dbs = get_local_databases(executor,
interpreter,
instance_name,
db2_home_path=db2_home_path)
if local_dbs:
reporter = db2_topology.Reporter()
address = context.application.getApplicationIp()
if not application_port:
resolve_servicename = safeFn(discoverer.resolve_servicename)
get_svcename = safeFn(discoverer.get_svcename_by_instancename)
svce_name = get_svcename(executor, interpreter, instance_name, db2_home_path=db2_home_path)
if svce_name:
net_service = resolve_servicename(executor, svce_name)
if net_service:
application_port = net_service.port
inst = DatabaseServer(address, application_port)
local_dbs = [db2_topology.build_database_pdo(inst, db)
for db in local_dbs]
oshs = reporter.updateInstanceDatabases(db2_instance_osh, local_dbs, context.hostOsh)
context.resultsVector.addAll(oshs)
else:
logger.debug('No local databases found for %s' % instance_name)
def _discover_remote_databases(self, context, instname, db2_home_path,
discoverer, executor, interpreter):
local_dbserver_osh = context.application.applicationOsh
get_remote_databases = safeFn(discoverer.get_remote_databases)
node_db_pairs = get_remote_databases(executor, interpreter, instname, db2_home_path=db2_home_path) or ()
get_node = safeFn(discoverer.get_node)
reporter = db2_topology.Reporter()
node_reporter = host_topology.Reporter()
shell = context.client
resolvers = (NsLookupDnsResolver(shell), SocketDnsResolver())
resolve_ips_fn = FallbackResolver(resolvers).resolve_ips
for nodename, remote_dbs in node_db_pairs:
node = get_node(executor, interpreter, instname,
nodename, db2_home_path=db2_home_path)
if node:
host_osh = None
address = None
instance_name_ = None
if node.is_local():
host_osh = context.hostOsh
address = context.application.getApplicationIp()
instance_name_ = node.instance_name
else:
host = host_base_parser.parse_from_address(node.hostname,
fptools.safeFunc(resolve_ips_fn))
if host and host.ips:
instance_name_ = node.remote_instance_name
address = first(host.ips)
host_osh, _, oshs_ = node_reporter.report_host_with_ips(host.ips)
context.resultsVector.addAll(oshs_)
if host_osh:
get_port_fn = safeFn(discoverer.get_instance_port_by_node)
port = get_port_fn(executor, interpreter, node, db2_home_path=db2_home_path)
remote_instance = DatabaseServer(address, port)
remote_inst_osh, endpoint_osh, _, vector = reporter.reportServerAndDatabases(remote_instance, host_osh)
if instance_name_:
SoftwareBuilder.updateName(remote_inst_osh, instance_name_)
context.resultsVector.addAll(vector)
_, oshs = reporter.reportRemoteDatabases(remote_dbs, local_dbserver_osh, remote_inst_osh)
context.resultsVector.addAll(oshs)
else:
logger.debug('No instance name')
if endpoint_osh:
context.resultsVector.add(endpoint_osh)
else:
logger.debug('Host is not resolved %s' % node.hostname)
else:
logger.debug('No node found with name %s' % nodename)
def _report_ipse(config, ip, svcename, container, db_osh):
oshs = []
endpoint_osh = None
if config.ipse_id:
endpoint_osh = modeling.createOshByCmdbIdString('ip_service_endpoint', config.ipse_id)
oshs.append(endpoint_osh)
else:
port = resolve_svcename_to_port_nr(svcename)
if port:
db2_reporter = db2_topology.Reporter()
link_reporter = db2_topology.LinkReporter()
endpoint_osh = db2_reporter.reportDb2IpServiceEndpoint(ip, port, container)
oshs.append(link_reporter.report_usage(db_osh, endpoint_osh))
oshs.append(endpoint_osh)
return endpoint_osh, oshs
def _report_instance(config, instance_name, version, db_osh, node_osh, endpoint_osh=None):
instance_osh = None
oshs = []
if config.db2_id:
instance_osh = modeling.createOshByCmdbIdString('db2_instance', config.db2_id)
oshs.append(instance_osh)
elif instance_name:
db2_builder = db2_topology.Builder()
db2_reporter = db2_topology.Reporter(db2_builder)
db2 = db.DatabaseServer(instance=instance_name, version=version)
instance_osh, _, oshs_ = db2_reporter.reportServer(db2, node_osh)
oshs.extend(oshs_)
link_reporter = db2_topology.LinkReporter()
oshs.append(link_reporter.report_lifecycle(db_osh, instance_osh))
if endpoint_osh:
oshs.append(link_reporter.report_usage(instance_osh, endpoint_osh))
return instance_osh, oshs
def _report(node_osh,
ip,
svcename,
instance_name=None,
version=None,
dbname=None):
oshs = []
db2_builder = db2_topology.Builder()
db2_reporter = db2_topology.Reporter(db2_builder)
port = resolve_svcename_to_port_nr(svcename)
db2 = db.DatabaseServer(address=ip,
port=port,
instance=instance_name,
version=version)
if dbname:
database = db2_model.Database(dbname)
database_pdo = db2_topology.build_database_pdo(db2, database)
db2.addDatabases(database_pdo)
_, _, db_oshs, oshs_ = db2_reporter.reportServerAndDatabases(db2, node_osh)
oshs.extend(oshs_)
return oshs, db_oshs
def _report(ip, config, version_info, partition_groups, partitions,
pg_names_by_partition_number, buffer_pools_by_partition_nr,
tablespaces, partition_numbers_by_pg_name, mountpoint_by_container,
containers_by_tablespace_id, partition_nr_by_container,
schemas, tables, sessions, inst_name=None, svcename=None, version=None):
oshs = []
add_all_to_result = Fn(_add_vector_and_return, oshs, fptools._)
add_to_result = Fn(_add_osh_and_return, oshs, fptools._)
link_reporter = db2_topology.LinkReporter()
report_usage_link = comp(add_to_result, link_reporter.report_usage)
report_client_server_link = comp(add_to_result,
link_reporter.report_client_server)
report_dbclient_link = comp(add_to_result,
link_reporter.report_dbclient)
host_reporter = db2_host.Reporter(db2_host.Builder())
report_host = comp(add_to_result, modeling.createHostOSH, str)
process_reporter = process.Reporter()
report_process = Fn(process_reporter.report,
fptools._,
fptools._,
process.ProcessBuilder())
report_process = comp(add_all_to_result, report_process)
host_osh = modeling.createOshByCmdbIdString('node', config.host_id)
db_osh = modeling.createOshByCmdbIdString('db2_database', config.db_id)
oshs.append(host_osh)
oshs.append(db_osh)
endpoint_osh, oshs_ = _report_ipse(config, ip, svcename, host_osh, db_osh)
oshs.extend(oshs_)
db2_rs_osh, oshs_ = _report_instance(config, inst_name, version, db_osh, host_osh, endpoint_osh)
oshs.extend(oshs_)
if version_info:
if db2_rs_osh:
db2_topology.SoftwareBuilder.updateVersionDescription(db2_rs_osh,
str(version_info))
db2_topology.SoftwareBuilder.updateVersionDescription(db_osh,
str(version_info))
db2_reporter = db2_topology.Reporter()
report_dbschema = Fn(db2_reporter.reportDbSchema,
fptools._,
db_osh)
report_dbschema = comp(add_to_result, report_dbschema)
report_datafile = comp(add_all_to_result, db2_reporter.reportDatafile)
report_tablespace = comp(add_all_to_result, db2_reporter.reportTablespace)
report_table = comp(add_all_to_result, db2_reporter.reportTable)
report_partition_group = Fn(db2_reporter.reportPartitionGroup,
fptools._,
db_osh)
report_partition_group = comp(add_to_result, report_partition_group)
report_partition = comp(add_all_to_result, db2_reporter.reportPartition)
report_buffer_pool = comp(add_all_to_result,
Fn(db2_reporter.reportBufferPool,
fptools._, db_osh, fptools._,))
file_system_builder = db2_topology.FileSystemBuilder()
file_system_reporter = db2_topology.FileSystemReporter(file_system_builder)
report_file_system = comp(add_to_result, file_system_reporter.report_file_system)
pg_osh_by_pg_name = _report_pgs(partition_groups, report_partition_group)
partition_osh_by_number, node_osh_by_partition_nr = _report_partitions(partitions, db2_rs_osh, oshs, pg_names_by_partition_number, pg_osh_by_pg_name, report_partition, host_reporter)
bp_osh_by_partition_nr_and_bp_id = _report_bufferpools(buffer_pools_by_partition_nr,
partition_osh_by_number,
report_buffer_pool)
container_oshes_by_tablespace = _report_data_files(mountpoint_by_container,
containers_by_tablespace_id,
partition_nr_by_container,
tablespaces,
partition_osh_by_number,
node_osh_by_partition_nr,
report_datafile,
report_file_system)
tablespace_osh_by_tablespace = _report_tablespaces(tablespaces,
db_osh,
pg_osh_by_pg_name,
partition_numbers_by_pg_name,
bp_osh_by_partition_nr_and_bp_id,
container_oshes_by_tablespace,
report_tablespace,
report_usage_link)
schema_osh_by_name = {}
for schema in schemas:
schema_osh_by_name[schema.name] = report_dbschema(schema)
for table, tablespace, schema_name, owner in tables:
table_pdo = db2_topology.Builder.TablePdo(table.name, owner)
tablespace_osh = tablespace_osh_by_tablespace.get(tablespace)
schemaOsh = schema_osh_by_name.get(schema_name)
if schemaOsh:
report_table(table_pdo, schemaOsh, tablespaceOsh=tablespace_osh)
else:
logger.warn("Schema '%s' not found, table '%s' is not reported" %
(schema_name, table.name))
port = config.port or resolve_svcename_to_port_nr(svcename)
_report_sessions(sessions, endpoint_osh, db2_rs_osh, port, report_host, report_process, report_client_server_link, report_dbclient_link)
return oshs