Example #1
0
    def process(self, context, discoverer, dnsresolver, installpath):
        try:
            server = discoverer.getHanaDatabaseServer()
            instances = discoverer.getHanaDatabaseInstances()
            get_sql_ports = Sfn(discoverer.getHanaDatabaseInstanceSqlPorts)
            instance_ports_pairs = [(instance,
                                      get_sql_ports(instance.hostname))
                                        for instance in instances]

            resolve_ips = Sfn(dnsresolver.resolve_ips)
            instance_descriptors = []
            for instance, ports in instance_ports_pairs:
                instance_pdo = buildDatabaseInstancePdo(instance,
                                                        installpath,
                                                        server=server)

                host_pdo = hana_host.parse_from_address(instance.hostname,
                                                        resolve_ips)
                # ignore the name as it is could be an alias and not a real hostname
                host_pdo = host_pdo._replace(name=None)
                instance_descriptors.append((instance_pdo, host_pdo, ports))

            reporter = hana.DatabaseTopologyReporter()
            _, _, _, oshs = reporter.report_database_with_instances(server, instance_descriptors)

            context.resultsVector.addAll(oshs)
        except command.ExecuteException, e:
            raise Exception(e.result.output)
Example #2
0
    def process(self, context, discoverer, dnsresolver, installpath):
        try:
            server = discoverer.getHanaDatabaseServer()
            instances = discoverer.getHanaDatabaseInstances()
            get_sql_ports = Sfn(discoverer.getHanaDatabaseInstanceSqlPorts)
            instance_ports_pairs = [(instance,
                                     get_sql_ports(instance.hostname))
                                    for instance in instances]

            resolve_ips = Sfn(dnsresolver.resolve_ips)
            instance_descriptors = []
            for instance, ports in instance_ports_pairs:
                instance_pdo = buildDatabaseInstancePdo(instance,
                                                        installpath,
                                                        server=server)

                host_pdo = hana_host.parse_from_address(
                    instance.hostname, resolve_ips)
                # ignore the name as it is could be an alias and not a real hostname
                host_pdo = host_pdo._replace(name=None)
                instance_descriptors.append((instance_pdo, host_pdo, ports))

            reporter = hana.DatabaseTopologyReporter()
            _, _, _, oshs = reporter.report_database_with_instances(
                server, instance_descriptors)

            context.resultsVector.addAll(oshs)
        except command.ExecuteException, e:
            raise Exception(e.result.output)
Example #3
0
def get_common_topology_context(discoverer, dnsresolver, installpath, config):
    discovererRegistry = {}
    discovererRegistry[baseCits.node] = partial(discoverer.getDeploymentHosts,
                                                Sfn(dnsresolver.resolve_ips))
    discovererRegistry[baseCits.ip] = hana_host.Host.ips.fget
    discovererRegistry[cits.hanadb] = discoverer.getHanaDatabaseServer
    discovererRegistry[cits.hanadbInstance] = lambda host: discoverer.getHanaDatabaseInstance(host.name)
    discovererRegistry[baseCits.configFile] = lambda dbServer: discoverer.getHanaDbConfigFiles()
    discovererRegistry[baseCits.ipServiceEndpoint] = lambda host: discoverer.getHanaDbInstanceEndpoints(host.name)

    discovererRegistry[dbCits.schema] = lambda dbServer: discoverer.getHanaDbSchemas()
    discovererRegistry[dbCits.user] = lambda dbServer: discoverer.getHanaDbUsers()
    discovererRegistry[dbCits.dataFile] = lambda db_instance: discoverer.getHanaDbDataFiles(db_instance)
    discovererRegistry[dbCits.logFile] = lambda db_instance: discoverer.getHanaDbLogFiles(db_instance)
    discovererRegistry[dbCits.traceFile] = lambda db_instance: discoverer.getHanaDbTraceFiles(db_instance)

#        linkage condition
    discovererRegistry[(dbCits.user, baseCits.ownership, dbCits.schema)] = lambda user, schema: schema.owner == user.name
    discovererRegistry[(cits.hanadbInstance, baseCits.usage, baseCits.ipServiceEndpoint)] = lambda hana_instance, endpoint: endpoint.getAddress() == hana_instance.hostname and endpoint.getPortType() == hana.PortTypeEnum.HANA
    discovererRegistry[(cits.hanadb, baseCits.membership, cits.hanadbInstance)] = lambda hanaDb, hanaInstance: True
    discovererRegistry[(baseCits.node, baseCits.containment, baseCits.ip)] = lambda host, ip: ip in host.ips

    pdoBuilderRegistry = {}
    pdoBuilderRegistry[cits.hanadbInstance] = lambda instance: buildDatabaseInstancePdo(instance, installpath, sid=config.sid)
    pdoBuilderRegistry[dbCits.user] = buildDbUserPdoFromDatabaseUser
    pdoBuilderRegistry[baseCits.ipServiceEndpoint] = partial(buildEndpointPdoFromEndpoint, Sfn(dnsresolver.resolve_ips))

    #Should be coming from core hana_topology module
    baseTopologyBuilderRegistry = {
       # ignore the name as it is could be an alias and not a real hostname
       baseCits.node: lambda node_pdo: hana_host.Builder().build_host(node_pdo._replace(name=None)),
       baseCits.ip: modeling.createIpOSH,
       baseCits.configFile: fptools.partiallyApply(modeling.createConfigurationDocumentOshByFile, fptools._, None),
       baseCits.ipServiceEndpoint: netutils.ServiceEndpointBuilder().visitEndpoint
    }

    linkReporter = hana.LinkReporter()
    linkReporterRegistry = {
        baseCits.containment: linkReporter.reportContainment,
        baseCits.composition: linkReporter.reportComposition,
        baseCits.membership: lambda do1, osh1, do2, osh2: linkReporter.reportMembership(osh1, osh2),
        baseCits.ownership: lambda do1, osh1, do2, osh2: linkReporter.reportOwnership(osh1, osh2),
        baseCits.usage: lambda do1, osh1, do2, osh2: linkReporter.reportUsage(osh1, osh2),
        baseCits.replicated: hana.DatabaseTopologyReporter().reportReplication,
    }

    topologyBuilderRegistry = {}
    topologyBuilderRegistry.update(baseTopologyBuilderRegistry)
    topologyBuilderRegistry.update(linkReporterRegistry)

    dbTopologyBuilder = hana.DatabaseTopologyBuilder()
    topologyBuilderRegistry[cits.hanadb] = lambda _: modeling.createOshByCmdbIdString(cits.hanadb, config.hanadb_cmdbid)
    topologyBuilderRegistry[cits.hanadbInstance] = dbTopologyBuilder.buildDatabaseInstanceOsh
    topologyBuilderRegistry[dbCits.schema] = dbTopologyBuilder.buildSchemaOsh
    topologyBuilderRegistry[dbCits.user] = dbTopologyBuilder.buildUserOsh
    topologyBuilderRegistry[dbCits.dataFile] = dbTopologyBuilder.buildDataFileOsh
    topologyBuilderRegistry[dbCits.logFile] = dbTopologyBuilder.buildLogFileOsh
    topologyBuilderRegistry[dbCits.traceFile] = dbTopologyBuilder.buildTraceFileOsh

    return discovererRegistry, pdoBuilderRegistry, topologyBuilderRegistry
Example #4
0
def get_hsr_topology_context(discoverer, dnsresolver, installpath, config):
    discovererRegistry = {}

    discovererRegistry['repl_node'] = lambda: discoverer.getReplicationHosts(Sfn(dnsresolver.resolve_ips))
    discovererRegistry['repl_hanadb'] = discoverer.getReplicationDatabaseServer
    discovererRegistry['repl_hanainstance'] = lambda host: discoverer.getReplicationDatabaseInstance(host.name)
    discovererRegistry['repl_ipse'] = lambda host: discoverer.getHanaReplicationEndpoints(host.name)

    discovererRegistry[(cits.hanadb, baseCits.replicated, 'repl_hanadb')] = lambda _, __: True

    discovererRegistry[('repl_hanainstance', baseCits.usage, 'repl_ipse')] =  lambda hana_instance, endpoint: endpoint.getAddress() == hana_instance.hostname and endpoint.getPortType() == hana.PortTypeEnum.HANA
    discovererRegistry[('repl_hanadb', baseCits.membership, 'repl_hanainstance')] = lambda hanaDb, hanaInstance: True

    pdoBuilderRegistry = {}
    pdoBuilderRegistry['repl_hanainstance'] = lambda instance: buildDatabaseInstancePdo(instance, sid=config.sid)

    linkReporterRegistry = {
        baseCits.replicated: hana.DatabaseTopologyReporter().reportReplication,
    }

    topologyBuilderRegistry = {}
    dbTopologyBuilder = hana.DatabaseTopologyBuilder()
    topologyBuilderRegistry.update(linkReporterRegistry)

    topologyBuilderRegistry['repl_hanadb'] = dbTopologyBuilder.buildReplicationDatabaseServerOsh

    return discovererRegistry, pdoBuilderRegistry, topologyBuilderRegistry
Example #5
0
def get_hsr_topology_context(discoverer, dnsresolver, installpath, config):
    discovererRegistry = {}

    discovererRegistry['repl_node'] = lambda: discoverer.getReplicationHosts(
        Sfn(dnsresolver.resolve_ips))
    discovererRegistry['repl_hanadb'] = discoverer.getReplicationDatabaseServer
    discovererRegistry[
        'repl_hanainstance'] = lambda host: discoverer.getReplicationDatabaseInstance(
            host.name)
    discovererRegistry[
        'repl_ipse'] = lambda host: discoverer.getHanaReplicationEndpoints(
            host.name)

    discovererRegistry[(cits.hanadb, baseCits.replicated,
                        'repl_hanadb')] = lambda _, __: True

    discovererRegistry[(
        'repl_hanainstance', baseCits.usage,
        'repl_ipse')] = lambda hana_instance, endpoint: endpoint.getAddress(
        ) == hana_instance.hostname and endpoint.getPortType(
        ) == hana.PortTypeEnum.HANA
    discovererRegistry[(
        'repl_hanadb', baseCits.membership,
        'repl_hanainstance')] = lambda hanaDb, hanaInstance: True

    pdoBuilderRegistry = {}
    pdoBuilderRegistry[
        'repl_hanainstance'] = lambda instance: buildDatabaseInstancePdo(
            instance, sid=config.sid)

    linkReporterRegistry = {
        baseCits.replicated: hana.DatabaseTopologyReporter().reportReplication,
    }

    topologyBuilderRegistry = {}
    dbTopologyBuilder = hana.DatabaseTopologyBuilder()
    topologyBuilderRegistry.update(linkReporterRegistry)

    topologyBuilderRegistry[
        'repl_hanadb'] = dbTopologyBuilder.buildReplicationDatabaseServerOsh

    return discovererRegistry, pdoBuilderRegistry, topologyBuilderRegistry
Example #6
0
def get_common_topology_context(discoverer, dnsresolver, installpath, config):
    discovererRegistry = {}
    discovererRegistry[baseCits.node] = partial(discoverer.getDeploymentHosts,
                                                Sfn(dnsresolver.resolve_ips))
    discovererRegistry[baseCits.ip] = hana_host.Host.ips.fget
    discovererRegistry[cits.hanadb] = discoverer.getHanaDatabaseServer
    discovererRegistry[
        cits.hanadbInstance] = lambda host: discoverer.getHanaDatabaseInstance(
            host.name)
    discovererRegistry[
        baseCits.
        configFile] = lambda dbServer: discoverer.getHanaDbConfigFiles()
    discovererRegistry[
        baseCits.
        ipServiceEndpoint] = lambda host: discoverer.getHanaDbInstanceEndpoints(
            host.name)

    discovererRegistry[
        dbCits.schema] = lambda dbServer: discoverer.getHanaDbSchemas()
    discovererRegistry[
        dbCits.user] = lambda dbServer: discoverer.getHanaDbUsers()
    discovererRegistry[
        dbCits.dataFile] = lambda db_instance: discoverer.getHanaDbDataFiles(
            db_instance)
    discovererRegistry[
        dbCits.logFile] = lambda db_instance: discoverer.getHanaDbLogFiles(
            db_instance)
    discovererRegistry[
        dbCits.traceFile] = lambda db_instance: discoverer.getHanaDbTraceFiles(
            db_instance)

    #        linkage condition
    discovererRegistry[(
        dbCits.user, baseCits.ownership,
        dbCits.schema)] = lambda user, schema: schema.owner == user.name
    discovererRegistry[(
        cits.hanadbInstance, baseCits.usage, baseCits.ipServiceEndpoint
    )] = lambda hana_instance, endpoint: endpoint.getAddress(
    ) == hana_instance.hostname and endpoint.getPortType(
    ) == hana.PortTypeEnum.HANA
    discovererRegistry[(
        cits.hanadb, baseCits.membership,
        cits.hanadbInstance)] = lambda hanaDb, hanaInstance: True
    discovererRegistry[(baseCits.node, baseCits.containment,
                        baseCits.ip)] = lambda host, ip: ip in host.ips

    pdoBuilderRegistry = {}
    pdoBuilderRegistry[
        cits.hanadbInstance] = lambda instance: buildDatabaseInstancePdo(
            instance, installpath, sid=config.sid)
    pdoBuilderRegistry[dbCits.user] = buildDbUserPdoFromDatabaseUser
    pdoBuilderRegistry[baseCits.ipServiceEndpoint] = partial(
        buildEndpointPdoFromEndpoint, Sfn(dnsresolver.resolve_ips))

    #Should be coming from core hana_topology module
    baseTopologyBuilderRegistry = {
        # ignore the name as it is could be an alias and not a real hostname
        baseCits.node:
        lambda node_pdo: hana_host.Builder().build_host(
            node_pdo._replace(name=None)),
        baseCits.ip:
        modeling.createIpOSH,
        baseCits.configFile:
        fptools.partiallyApply(modeling.createConfigurationDocumentOshByFile,
                               fptools._, None),
        baseCits.ipServiceEndpoint:
        netutils.ServiceEndpointBuilder().visitEndpoint
    }

    linkReporter = hana.LinkReporter()
    linkReporterRegistry = {
        baseCits.containment:
        linkReporter.reportContainment,
        baseCits.composition:
        linkReporter.reportComposition,
        baseCits.membership:
        lambda do1, osh1, do2, osh2: linkReporter.reportMembership(osh1, osh2),
        baseCits.ownership:
        lambda do1, osh1, do2, osh2: linkReporter.reportOwnership(osh1, osh2),
        baseCits.usage:
        lambda do1, osh1, do2, osh2: linkReporter.reportUsage(osh1, osh2),
        baseCits.replicated:
        hana.DatabaseTopologyReporter().reportReplication,
    }

    topologyBuilderRegistry = {}
    topologyBuilderRegistry.update(baseTopologyBuilderRegistry)
    topologyBuilderRegistry.update(linkReporterRegistry)

    dbTopologyBuilder = hana.DatabaseTopologyBuilder()
    topologyBuilderRegistry[
        cits.hanadb] = lambda _: modeling.createOshByCmdbIdString(
            cits.hanadb, config.hanadb_cmdbid)
    topologyBuilderRegistry[
        cits.hanadbInstance] = dbTopologyBuilder.buildDatabaseInstanceOsh
    topologyBuilderRegistry[dbCits.schema] = dbTopologyBuilder.buildSchemaOsh
    topologyBuilderRegistry[dbCits.user] = dbTopologyBuilder.buildUserOsh
    topologyBuilderRegistry[
        dbCits.dataFile] = dbTopologyBuilder.buildDataFileOsh
    topologyBuilderRegistry[dbCits.logFile] = dbTopologyBuilder.buildLogFileOsh
    topologyBuilderRegistry[
        dbCits.traceFile] = dbTopologyBuilder.buildTraceFileOsh

    return discovererRegistry, pdoBuilderRegistry, topologyBuilderRegistry