Пример #1
0
    def reportServerWithDatabases(self, hana_instance, container, dependants=None):
        r""" Report database server with specified container used databases
        and service end-points

        @types: db_buidler.HanaDb.InstancePdo, ObjectStateHolder, seq[ObjectStateHolder] -> ObjectStateHolderVector"""
        if not hana_instance:
            raise ValueError("Hana instance pdo is not specified")
        if not container:
            raise ValueError("Container for database server is not specified")

        oshs = []
        server_osh = self._builder.buildDatabaseServerOsh(sid=hana_instance.instance)
        oshs.append(server_osh)

        ipseOsh = None

        instance_osh, oshs_ = self.report_database_instance(hana_instance, container)
        oshs.extend(oshs_)

        linkosh = modeling.createLinkOSH("membership", server_osh, instance_osh)
        oshs.append(linkosh)
        if hana_instance.address and hana_instance.getPort():
            ipseOsh, oshs_ = self.reportServerIpServiceEndpoint(
                hana_instance.address, hana_instance.getPort(), instance_osh, container
            )
            oshs.extend(oshs_)

        for slave in dependants or ():
            for master in (server_osh,):
                link = modeling.createLinkOSH("dependency", slave, master)
                oshs.append(link)

        return server_osh, ipseOsh, instance_osh, oshs
    def reporterMSCluster(self, vector, ms_cluster, groups, ipDictByGroupName, nodesWithIP):
        clusterOsh = ms_cluster.create_osh()
        vector.add(clusterOsh)
        vector.add(modeling.createLinkOSH('membership', clusterOsh, self.applicationOsh))

        for node in nodesWithIP:
            ips = nodesWithIP[node]
            hostOsh = (modeling.createHostOSH(str(ips[0]), 'nt')
                       or ObjectStateHolder('nt'))
            hostOsh.setStringAttribute('name', node)
            hostOsh.setStringAttribute('os_family', 'windows')
            for ip_obj in ips:
                ipOSH = modeling.createIpOSH(ip_obj)
                vector.add(ipOSH)
                vector.add(modeling.createLinkOSH('containment', hostOsh, ipOSH))
            softwareOsh = modeling.createClusterSoftwareOSH(hostOsh,
                                                            'Microsoft Cluster SW', ms_cluster.version)
            softwareOsh.setAttribute("application_version_number", ms_cluster.version)
            vector.add(softwareOsh)
            vector.add(modeling.createLinkOSH('membership', clusterOsh, softwareOsh))

        for group in groups:
            ips = ipDictByGroupName.get(group.name, None)
            if ips:
                for ip in ips:
                    groupOsh = group.create_osh()
                    vector.add(groupOsh)
                    vector.add(modeling.createLinkOSH('contained', clusterOsh, groupOsh))

                    ipOsh = modeling.createIpOSH(ip)
                    vector.add(modeling.createLinkOSH('contained', groupOsh, ipOsh))
                    vector.add(ipOsh)
                    self.__crgMap[str(ip)] = groupOsh
Пример #3
0
def createTransportPathObjects(cluster, hostOshByName, resultsVector, framework):
    for tPath in cluster.transportPaths:
        sourceInterfaceResult = createTransportInterfaceObject(tPath.fromNode, tPath.fromInterface, cluster, hostOshByName)
        targetInterfaceResult = createTransportInterfaceObject(tPath.toNode, tPath.toInterface, cluster, hostOshByName)
        if sourceInterfaceResult and targetInterfaceResult:
            (sourceInterfaceOsh, sourceAdapter) = sourceInterfaceResult
            (targetInterfaceOsh, targetAdapter) = targetInterfaceResult
            resultsVector.add(sourceInterfaceOsh)
            resultsVector.add(targetInterfaceOsh)
            
            versionAsDouble = logger.Version().getVersion(framework)
            if versionAsDouble >= 9:
                layer2Osh = ObjectStateHolder('layer2_connection')
                linkId = "%s:%s" % (sourceAdapter.mac, targetAdapter.mac)
                linkId = str(hash(linkId))
                layer2Osh.setAttribute('layer2_connection_id', linkId)
                
                sourceMemberLink = modeling.createLinkOSH('member', layer2Osh, sourceInterfaceOsh)
                targetMemberLink = modeling.createLinkOSH('member', layer2Osh, targetInterfaceOsh)
                
                resultsVector.add(layer2Osh)
                resultsVector.add(sourceMemberLink)
                resultsVector.add(targetMemberLink)
            else:
                layer2Link = modeling.createLinkOSH('layertwo', sourceInterfaceOsh, targetInterfaceOsh)
                resultsVector.add(layer2Link)
 def build(self):
     lbcOsh = ObjectStateHolder('loadbalancecluster')
     lbcOsh.setStringAttribute('name', self.vServer.name)
     containment_link = modeling.createLinkOSH('containment', lbcOsh, self.crgOsh)
     membershipLink = modeling.createLinkOSH('membership', lbcOsh, self.netscaler_software_osh)
     self.osh = lbcOsh
     return self.newVector(lbcOsh, containment_link, membershipLink)
Пример #5
0
def build_layer2_connection(net_device_osh, net_device_interface_name, net_device_ip_address, end_node_osh, end_node_mac_address, end_node_interface_osh):
    '''
    Build Layer 2 connection topology.
    @type param: str,str,osh,str -> OSHV
    '''
    net_device_id = net_device_ip_address or net_device_osh.getCmdbId().toString()
    end_node_id = end_node_mac_address
    #is it enough data to build Layer 2 topology
    if net_device_id and end_node_id and net_device_osh and net_device_interface_name and end_node_osh and end_node_interface_osh:
        oshv = ObjectStateHolderVector()
        net_device_interface_osh = ObjectStateHolder('interface')
        net_device_interface_osh.setContainer(net_device_osh)
        net_device_interface_osh.setAttribute('interface_name', net_device_interface_name)

        layer2_osh = ObjectStateHolder('layer2_connection')
        layer2_osh.setAttribute('layer2_connection_id',str(hash(net_device_id + end_node_id)))
        layer2_member_net_device_interface_osh = modeling.createLinkOSH('member', layer2_osh, net_device_interface_osh)
        layer2_member_end_node_interface_osh = modeling.createLinkOSH('member', layer2_osh, end_node_interface_osh)

        oshv.add(net_device_osh)
        oshv.add(net_device_interface_osh)
        oshv.add(end_node_osh)
        oshv.add(end_node_interface_osh)
        oshv.add(layer2_osh)
        oshv.add(layer2_member_net_device_interface_osh)
        oshv.add(layer2_member_end_node_interface_osh)
        return oshv
Пример #6
0
 def buildSwitches(self):
     for switch in self.switches.values():
         switchOSHV = ObjectStateHolderVector()
         switchOsh, switchVector = switch.buildOshAndIps()
         switchOSHV.addAll(switchVector)
         hbaIdToOsh = {}
         for hba in switch.fcHBAs.values():
             hbaOsh = hba.build()
             hbaOsh.setContainer(switchOsh)
             hbaIdToOsh[hba.hbaId] = hbaOsh
             self.addWwnOsh(hba.wwn, hbaOsh)
             switchOSHV.add(hbaOsh)
         for port in switch.fcPorts.values():
             portOsh = port.build()
             portOsh.setContainer(switchOsh)
             self.portIdToOsh[port.portId] = portOsh
             if port.nodeId and port.nodeId in hbaIdToOsh.keys():
                 containmentLinkOsh = modeling.createLinkOSH('containment', hbaIdToOsh[port.nodeId], portOsh)
                 self.OSHVResult.add(containmentLinkOsh)
             self.addWwnOsh(port.wwn, portOsh)
             switchOSHV.add(portOsh)
         if not (str(switch.fabricId) == str(-1)):
             fabricMembership = modeling.createLinkOSH('membership', self.fabrics[switch.fabricId].build(), switchOsh)
             switchOSHV.add(fabricMembership)
         self.framework.sendObjects(switchOSHV)
         self.framework.flushObjects()
def getServers(client, username, enterprise, gatewayOSH, siteOSH, Framework, OSHVResult):
	#serverListing = srvrmgr.sendCommand('list servers')
	serverListing = client.executeCmd('list servers show SBLSRVR_NAME, HOST_NAME, INSTALL_DIR, SBLMGR_PID, SV_DISP_STATE, SBLSRVR_STATE, START_TIME, END_TIME, SBLSRVR_STATUS, SV_SRVRID')#@@CMD_PERMISION siebel protocol execution
	serverTbl = siebel_common.makeTable(serverListing)
	# sample output
	#SBLSRVR_NAME  HOST_NAME  INSTALL_DIR         SBLMGR_PID  SV_DISP_STATE  SBLSRVR_STATE  START_TIME           END_TIME  SBLSRVR_STATUS
	#------------  ---------  ------------------  ----------  -------------  -------------  -------------------  --------  --------------------------------
	#sblapp1_AS    sblapp1    d:\sea752\siebsrvr  1904        Running        Running        2004-08-10 15:43:46            7.5.3.3 [16172] LANG_INDEPENDENT
	#sblapp2       sblapp2    d:\sea752\siebsrvr  1336        Running        Running        2004-08-01 03:29:42            7.5.3.3 [16172] LANG_INDEPENDENT
	#sblapp1       sblapp1    d:\sea752\siebsrvr              LIBMsg: No strings available for this language setting
	#
	#3 rows returned.

	svrcount = 0
	for serverEntry in serverTbl:
		try:
			# jython doesn't have out parameters, so this is a bypass with
			# and ArrayList return value that has 2 items.
			serverObj = serverEntry[0]
			serverDataRow = serverEntry[1]
			serverOSH = makeAppServer(client, username, enterprise, serverObj, serverDataRow, siteOSH, Framework, OSHVResult)
			if serverOSH != None:
				OSHVResult.add(modeling.createLinkOSH('depend', serverOSH,gatewayOSH))
				OSHVResult.add(modeling.createLinkOSH('member', siteOSH,serverOSH))
				svrcount += 1
		except:
			logger.errorException('Failed to get server')
	logger.debug('parsed ', str(svrcount), 'app servers')
Пример #8
0
 def buildFabrics(self):
     for fabric in self.fabrics.values():
         fabricOsh = fabric.build()
         for zoneSet in fabric.zoneSets.values():
             zoneSetOsh = zoneSet.build()
             zoneSetOsh.setContainer(fabricOsh)
             compositionLink = modeling.createLinkOSH('composition', fabricOsh, zoneSetOsh)
             if zoneSet.zoneSetId == fabric.activeZoneSet:
                 compositionLink.setAttribute('name', 'Active Zone Set')
             else:
                 compositionLink.setAttribute('name', 'Inactive Zone Set')
             for zone in zoneSet.zones:
                 zoneOsh = zone.build()
                 zoneOsh.setContainer(fabricOsh)
                 logger.debug('Have [%s] Members on the Zone [%s] - Processing' % (len(zone.members), zone.name))
                 for zoneMember in zone.members.values():
                     memberOsh = self.memberWwnToOsh.get(zoneMember.wwn.lower())
                     if memberOsh is None:
                         logger.warn("Found ZoneMember with WWN:[%s] on Zone[%s] which doesn't belong to discovered entities" % (zoneMember.wwn, zone.name))
                         continue
                     memberLink = modeling.createLinkOSH('membership', zoneOsh, memberOsh)
                     self.OSHVResult.add(memberOsh)
                     self.OSHVResult.add(memberLink)
                 self.OSHVResult.add(zoneOsh)
             self.OSHVResult.add(zoneSetOsh)
             self.OSHVResult.add(compositionLink)
         for switch in fabric.switches.values():
             switchOsh = switch.build()
             membershipLink = modeling.createLinkOSH('membership', fabricOsh, switchOsh)
             self.OSHVResult.add(membershipLink)
         self.OSHVResult.add(fabricOsh)
Пример #9
0
 def buildHosts(self):
     for host in self.hosts.values():
         hostOSHV = ObjectStateHolderVector()
         hostOsh, hostVector = host.buildOshAndIps()
         hostOSHV.addAll(hostVector)
         hbaIdToOsh = {}
         for hba in host.hbas.values():
             hbaOsh = hba.build()
             hbaOsh.setContainer(hostOsh)
             hbaIdToOsh[hba.hbaId] = hbaOsh
             self.addWwnOsh(hba.wwn, hbaOsh)
             hostOSHV.add(hbaOsh)
         for port in host.ports.values():
             portOsh = port.build()
             portOsh.setContainer(hostOsh)
             self.portIdToOsh[port.portId] = portOsh
             if port.nodeId and port.nodeId in hbaIdToOsh.keys():
                 containmentLinkOsh = modeling.createLinkOSH('containment', hbaIdToOsh[port.nodeId], portOsh)
                 hostOSHV.add(containmentLinkOsh)
             hostOSHV.add(portOsh)
             self.addWwnOsh(port.wwn, portOsh)
         for path in host.paths.values():
             localVolumeOsh = self.storageArrays[self.volumeIdToStorageId[path.volumeId]].volumes[path.volumeId].build()
             localVolumeOsh.setContainer(hostOsh)
             dependencyLink = modeling.createLinkOSH('dependency', localVolumeOsh, self.volumeIdToOsh[path.volumeId])
             hostOSHV.add(dependencyLink)
             hostOSHV.add(localVolumeOsh)
             hostOSHV.add(self.volumeIdToOsh[path.volumeId])
         self.framework.sendObjects(hostOSHV)
         self.framework.flushObjects()
Пример #10
0
def build_layer2_connection(layer2_connection):
    '''
    Build Layer 2 connection topology.
    @type param: SNMP_CDP_LLDP.Laer2Connwction -> OSHV
    '''
    oshv = ObjectStateHolderVector()
    (local_device_osh,
      local_device_ip_address_osh,
       local_device_interface_osh,
        local_device_member_ip_osh) = build_network_device(layer2_connection.local_device)

    (remote_device_osh,
      remote_device_ip_address_osh,
       remote_device_interface_osh,
        remote_device_member_ip_osh) = build_network_device(layer2_connection.remote_device)

    if local_device_osh and local_device_interface_osh and remote_device_osh and remote_device_interface_osh:
        layer2_osh = ObjectStateHolder('layer2_connection')
        layer2_osh.setAttribute('layer2_connection_id',str(hash(layer2_connection.local_device.address_id + layer2_connection.remote_device.address_id)))
        layer2_member_local_interface_osh = modeling.createLinkOSH('member', layer2_osh, local_device_interface_osh)
        layer2_member_remote_interface_osh = modeling.createLinkOSH('member', layer2_osh, remote_device_interface_osh)
        oshv.add(local_device_osh)
        oshv.add(local_device_interface_osh)
        if (local_device_ip_address_osh):
            oshv.add(local_device_ip_address_osh)
            oshv.add(local_device_member_ip_osh)
        oshv.add(remote_device_osh)
        oshv.add(remote_device_interface_osh)
        if (remote_device_ip_address_osh):
            oshv.add(remote_device_ip_address_osh)
            oshv.add(remote_device_member_ip_osh)
        oshv.add(layer2_osh)
        oshv.add(layer2_member_local_interface_osh)
        oshv.add(layer2_member_remote_interface_osh)
        return oshv
Пример #11
0
def osh_createIpOsh(lparOsh, tcpStacks):
    
    ipstoexclude = ['127.0.0.1']
    # tcpStacks  [ip, network, mask, interface name, status, type, mac address]str_name = 'name'    
    str_name = 'name'
    str_mac_address = 'mac_address'
    _vector = ObjectStateHolderVector()
    for mac, tcpentry in tcpStacks.items():
        ipAddress = tcpentry[0].strip()
        if ipAddress not in ipstoexclude:       
            ipOsh = modeling.createIpOSH(ipAddress)
            probeName = CollectorsParameters.getValue(CollectorsParameters.KEY_COLLECTORS_PROBE_NAME) 
            if isNotNull(probeName):
                ipOsh.setAttribute('ip_probename', probeName)   
                containedOsh = modeling.createLinkOSH('contained', lparOsh, ipOsh)         
            _vector.add(lparOsh)
            _vector.add(ipOsh)
            _vector.add(containedOsh)
         
            # create interface ----------------------------------------------------
        
            ifOsh = ObjectStateHolder('interface')
            interfacename = tcpentry[3].strip()
            ifOsh.setAttribute(str_name,  interfacename)       
            # default the mac address attribute to linkName and update later if MAC found 
            ifOsh.setAttribute(str_mac_address, mac) # if MAC not found for set #linkName as key       
            ifOsh.setContainer(lparOsh)
            _vector.add(ifOsh)
            if tcpStacks.has_key(mac):
                parentLinkOsh = modeling.createLinkOSH('containment', ifOsh, ipOsh)
                _vector.add(parentLinkOsh)
    return _vector
Пример #12
0
def processIpsAndSubnets(_vector, hostIpMap, hostId, ipMap, nwMap, hostOSH):
	if hostIpMap.has_key(hostId):
		iplist = hostIpMap[hostId]
		for ip in iplist:
			if ipMap.has_key(ip):
				ipObj = ipMap[ip]
				## create IPs and contained links for the rest of the IPs of that host
				ipOSH = modeling.createIpOSH(ipObj.ipValue)
				containedLink = modeling.createLinkOSH('contained', hostOSH, ipOSH)
				_vector.add(ipOSH)
				_vector.add(containedLink)

				## create the network for each IP
				ipSubnetId = ipObj.ipSubnetId
				if nwMap.has_key(ipSubnetId):
					netmaskPrefixLength = nwMap[ipSubnetId].prefixLength
					if notNull(netmaskPrefixLength):
						netOSH = modeling.createNetworkOSH(ipObj.ipValue, computeStringNetmaskFromPrefix(netmaskPrefixLength))
						_vector.add(netOSH)

						## create member link between ip and network
						memberLink = modeling.createLinkOSH('member', netOSH, ipOSH)
						_vector.add(memberLink)

						## create member link between host and network
						memberLink = modeling.createLinkOSH('member', netOSH, hostOSH)
						_vector.add(memberLink)
	return _vector
Пример #13
0
    def report(self, region_osh, event_osh=None):
        vector = ObjectStateHolderVector()

        osh = ObjectStateHolder('host_node')
        osh.setAttribute('name', self.name)
        logger.debug("self.id:", self.id)
        vector.add(osh)
        if self.ips:
            for ip in self.ips:
                ip_osh = modeling.createIpOSH(str(ip))
                vector.add(ip_osh)
                vector.add(modeling.createLinkOSH('contained', osh, ip_osh))
        if self.image:
            imageOsh, image_vector = self.image.report(region_osh)
            vector.addAll(image_vector)
            vector.add(modeling.createLinkOSH('dependency', osh, imageOsh))
        if self.hypervisorHostName:
            hypervisorOsh, hypervisor_vector = Hypervisor(self.hypervisorHostName).report(region_osh)
            vector.addAll(hypervisor_vector)
            vector.add(modeling.createLinkOSH('execution_environment', hypervisorOsh, osh))
        if self.flavor:
            flavorOsh, flavor_vector = self.flavor.report(region_osh)
            vector.addAll(flavor_vector)
            vector.add(modeling.createLinkOSH('dependency', osh, flavorOsh))
        if event_osh:
            vector.add(modeling.createLinkOSH('dependency', osh, event_osh))
        return osh, vector
Пример #14
0
def createOAMRunningSoftwareOsh(scpId, ip, port, protocolId, version, apacheOsh, vector):
    """
    Create OAM osh on oam endpoint, oam node & client server relation
    """
    logger.debug('submit OAM endpoint: %s:%s' % (ip, port))
    endpoint = netutils.createTcpEndpoint(ip, port)
    builder = netutils.ServiceEndpointBuilder()
    reporter = netutils.EndpointReporter(builder)
    nodeOsh = reporter.reportHostFromEndpoint(endpoint)
    endpointOsh = reporter.reportEndpoint(endpoint, nodeOsh)
    linkOsh = modeling.createLinkOSH('client_server', apacheOsh, endpointOsh)
    linkOsh.setStringAttribute('clientserver_protocol', 'tcp')
    oamServerOsh = modeling.createApplicationOSH('running_software', 'Oracle Access Management', nodeOsh, None, 'oracle_corp')
    oamServerOsh.setStringAttribute('credentials_id', protocolId)
    oamServerOsh.setStringAttribute('version', version)
    usageOsh = modeling.createLinkOSH('usage', oamServerOsh, endpointOsh)
    vector.add(nodeOsh)
    vector.add(endpointOsh)
    vector.add(linkOsh)
    vector.add(oamServerOsh)
    vector.add(usageOsh)
    logger.debug("create ownership between runningsoftware and scp")
    vector.addAll(scp.createOwnerShip(scpId, oamServerOsh))
    logger.debug("create consumer-provider link between apache and runningsoftware")
    reference = 'connection_type=oam, server_host=%s, server_ip=%s, server_port=%s' % (ip, ip, port)
    vector.addAll(scp.createCPLinkByOsh(apacheOsh, oamServerOsh, scpId, reference))
Пример #15
0
    def report(self, oshVector, interaction):
        if self.acceptorEngine.accepts(interaction.srcNode) and\
           self.acceptorEngine.accepts(interaction.dstNode) and interaction.isClientServerRelationDefined():

            client, server, connection = interaction.getClient(), interaction.getServer(), interaction.connection

            server.serviceAddressOsh = server.serviceAddressOsh or self._buildAndReportServiceAddress(server, connection, self.knownPortsConfigFile, oshVector)

            client.processOsh = client.processOsh or self._buildAndReportProcess(client, oshVector)

            serverPortNames = self.getPortNamesByPortNr(server.port, server.ip, connection.protocol, self.knownPortsConfigFile)

            csLink = None
            if client.processOsh is not None and server.serviceAddressOsh is not None:
                csLink = modeling.createLinkOSH('client_server', client.processOsh, server.serviceAddressOsh)
            elif client.hostOsh is not None and server.serviceAddressOsh is not None:
                csLink = modeling.createLinkOSH('client_server', client.hostOsh, server.serviceAddressOsh)
            if not csLink:
                return

            csLink.setStringAttribute('clientserver_protocol', connection.protocol == modeling.TCP_PROTOCOL and 'TCP' or 'UDP')
            if serverPortNames:
                csLink.setStringAttribute('data_name', first(serverPortNames))
            csLink.setLongAttribute('clientserver_destport', int(server.port))

            if self.reportTrafficDetails:
                connection.dPkgs and csLink.setLongAttribute('clientserver_pkts', connection.dPkgs)
                connection.dOctets and csLink.setLongAttribute('clientserver_octets', connection.dOctets)

            oshVector.add(csLink)
Пример #16
0
	def discoverContentRules(self):
		contentRuleQueryBuilder = SnmpQueryBuilder(CNT_OID_OFFSET)
		contentRuleQueryBuilder.addQueryElement(2, 'cnt_name')
		contentRuleQueryBuilder.addQueryElement(4, 'ipserver_address')
		contentRuleQueryBuilder.addQueryElement(5, 'ipport_type')
		contentRuleQueryBuilder.addQueryElement(6, 'ipport_number')
		contentRuleQueryBuilder.addQueryElement(68, 'ip_range')
		snmpRowElements = self.snmpAgent.getSnmpData(contentRuleQueryBuilder)
		
		for snmpRowElement in snmpRowElements:
			virtualServer = modeling.createHostOSH(snmpRowElement.ipserver_address, 'clusteredservice')
			virtualServerHostKey = virtualServer.getAttributeValue('host_key')
			virtualServer.setAttribute('data_name', virtualServerHostKey)
			self.OSHVResult.add(modeling.createLinkOSH('owner', self.css, virtualServer))
			self.OSHVResult.add(virtualServer)			
			
			resourcePool = ObjectStateHolder('loadbalancecluster')
			resourcePool.setStringAttribute('data_name', snmpRowElement.cnt_name)
			self.OSHVResult.add(modeling.createLinkOSH('contained', resourcePool, virtualServer))
			self.OSHVResult.add(resourcePool)
			self.resourcePools[snmpRowElement.cnt_name] = resourcePool
			
			serviceAddress = modeling.createServiceAddressOsh(virtualServer,
											snmpRowElement.ipserver_address,
											snmpRowElement.ipport_number,
											CNT_PROTOCOL_MAP[snmpRowElement.ipport_type])
			serviceAddress.setContainer(virtualServer)
			self.OSHVResult.add(serviceAddress)

			# KB specific: fix of port translations
			self.resourcePoolsToServiceAddress[snmpRowElement.cnt_name] = serviceAddress

			for i in range(int(snmpRowElement.ip_range)):
				#TODO: Add all IPs from range
				pass
def StepMain(Framework):
    logger.debug('Start dependency mapping')
    # get result from workflow state
    workflowState = Framework.getWorkflowState()
    searchResult = workflowState.getProperty(DependenciesDiscoveryConsts.DEPENDENCIES_DISCOVERY_RESULT)
    oshv = ObjectStateHolderVector()
    dependencyCount = 0
    if searchResult:
        providerServiceOsh = None
        providerDeployable = searchResult.getProviderDeployable()
        if providerDeployable:
            providerServiceOsh = providerDeployable.getDeployable()
        if providerServiceOsh:
            logger.debug('The search result does not contain a provider object, generate one from destination data instead')
            triggerId = Framework.getCurrentDestination().getId()
            providerType = Framework.getDestinationAttribute('PROVIDERTYPE')
            providerServiceOsh = ObjectStateHolder(providerType, CmdbObjectID.Factory.restoreObjectID(triggerId))
        moreProviderOshs = createOtherProviderOshsIfNeed(Framework)
        for index in range(0, searchResult.size()):
            deployable = searchResult.get(index)
            deployableOsh = deployable.getDeployable()
            if providerServiceOsh.compareTo(deployableOsh):
                dependencyNames = []
                references = []
                for dependency in deployable.getDependencies():
                    dependencyName = dependency.getDependencyName()
                    variables = dependency.getExportVariables()
                    logger.debug('%s export variables found by dependency %s' % (variables.size(), dependencyName))
                    dependencyNames.append(dependencyName)
                    for var in variables:
                        varName = var.getName()
                        values = var.getValues()
                        logger.debug('Variable %s:%s' % (varName, values))
                        if varName.lower() == REFERENCES:
                            references += list(values)
                reference = references and ','.join(references)
                logger.debug('Found %s link from %s(%s) to %s(%s) by dependency [%s] with reference %s' % (
                    CONSUMER_PROVIDER_LINK_TYPE, deployableOsh.getObjectClass(),
                    deployableOsh.getCmdbId(),
                    providerServiceOsh.getObjectClass(),
                    providerServiceOsh.getCmdbId(),
                    '/'.join(dependencyNames),
                    reference))
                consumerProviderLink = modeling.createLinkOSH(CONSUMER_PROVIDER_LINK_TYPE, deployableOsh, providerServiceOsh)
                if reference:
                    consumerProviderLink.setAttribute(REFERENCES, reference)
                oshv.add(consumerProviderLink)
                dependencyCount += 1
                for otherProviderOsh in moreProviderOshs:
                    oshv.add(modeling.createLinkOSH(CONSUMER_PROVIDER_LINK_TYPE, deployableOsh, otherProviderOsh))
            else:
                logger.debug('Ignore self link found on %s(%s)' % (deployableOsh.getObjectClass(), deployableOsh.getCmdbId()))

    logger.debug('%s consumer-provider link(s) found' % dependencyCount)
    if dependencyCount:
        Framework.sendObjects(oshv)
        Framework.flushObjects()
        logger.debug("Finished sending results")
Пример #18
0
    def buildTopology(self):
        '''
        Construct as400 node topology
        @types AS400Client -> ObjectStateHolderVector
        '''
        myvec = ObjectStateHolderVector()
        ip_address = self.__client.getIpAddress()
        # create as400 agent OSH

        interfaceList = self.__interfacesInfo
        as400HostOsh = None
        if interfaceList and len(interfaceList) > 0:
            # Create as400 CIT       
            try: 
                # Get the host_key - lowest mac address of the valid interface list
                as400HostOsh = modeling.createCompleteHostOSHByInterfaceList('as400_node', interfaceList, 'OS400', self.__sysInfo.hostName)
                as400HostOsh.setAttribute('host_model', self.__sysInfo.hostModel)
                as400HostOsh.setAttribute('host_serialnumber', self.__sysInfo.hostSerialNum)
                as400HostOsh.setAttribute('host_osversion', self.__sysInfo.hostOSVersion)
                as400HostOsh.setAttribute('host_vendor', 'IBM')
                myvec.add(as400HostOsh)
                
                as400Osh = self.__createAS400AgentOSH(ip_address)
                as400Osh.setAttribute('credentials_id', self.__client.getCredentialId())
                as400Osh.setContainer(as400HostOsh)
                myvec.add(as400Osh)

            except:
                logger.warn('Could not find a valid MAC addresses for key on ip : ', self.__client.getIpAddress())
       
        # add all interfaces to the host
        if as400HostOsh is not None:
            for interface in interfaceList:
                interfaceOsh = modeling.createInterfaceOSH(interface.macAddress, as400HostOsh, interface.description, interface.interfaceIndex, interface.type, interface.adminStatus, interface.adminStatus, interface.speed, interface.name, interface.alias, interface.className)
                ips = interface.ips
                masks = interface.masks
                if interfaceOsh:
                    myvec.add(interfaceOsh)
                    if ips and masks:
                        for i in xrange(len(ips)):
                            ipAddress = ips[i]
                            ipMask = masks[i]

                            ipProp = modeling.getIpAddressPropertyValue(ipAddress, ipMask, interface.dhcpEnabled, interface.description)
                            ipOSH = modeling.createIpOSH(ipAddress, ipMask, ipProp)
                            myvec.add(ipOSH)
                            
                            myvec.add(modeling.createLinkOSH('containment', as400HostOsh, ipOSH))
                            netOSH = modeling.createNetworkOSH(ipAddress, ipMask)   
                            myvec.add(netOSH)
                            
                            myvec.add(modeling.createLinkOSH('member', netOSH, as400HostOsh))
                            myvec.add(modeling.createLinkOSH('member', netOSH, ipOSH))
                            myvec.add(modeling.createLinkOSH('containment', interfaceOsh, ipOSH))
        else:
            logger.warn('Parent host wasn\'t created. No interfaces will be reported.')
        return myvec
Пример #19
0
    def report(self, vector, hostOsh=None, ipOsh=None):
        if self.osh is not None:
            vector.add(self.osh)

            if hostOsh is not None:
                vector.add(modeling.createLinkOSH("member", self.osh, hostOsh))

            if ipOsh is not None:
                vector.add(modeling.createLinkOSH("member", self.osh, ipOsh))
Пример #20
0
    def report(self, vector, hostOsh=None, interfaceOsh=None):
        if self.osh is not None:
            vector.add(self.osh)

            if hostOsh is not None:
                vector.add(modeling.createLinkOSH("containment", hostOsh, self.osh))

            if interfaceOsh is not None:
                vector.add(modeling.createLinkOSH("containment", interfaceOsh, self.osh))
Пример #21
0
    def report(self, cloud):
        vector = ObjectStateHolderVector()
        
        vcloudDirectorOsh = self.reportVcloudDirector(cloud, vector)
        
        vcloudRootOsh = None
        systemOrganizationOsh = None
        if cloud.systemOrganization is not None:
            
            if cloud.companyName:
                vcloudRootOsh = self.reportVcloudRoot(cloud, vector)
                self.reportVcloudUri(cloud, vcloudRootOsh, vector)
            
            systemOrganizationOsh = self.reportSystemOrganization(cloud.systemOrganization, vcloudRootOsh, vector)

            manageLink = modeling.createLinkOSH('manage', vcloudDirectorOsh, systemOrganizationOsh)
            vector.add(manageLink)

            for providerVdc in cloud.providerVdcByName.values():
                self.reportProviderVdc(providerVdc, systemOrganizationOsh, vector)

        for organization in cloud.organizationsByName.values():
            organizationOsh = self.reportOrganization(organization, vcloudRootOsh, vector)
            
            manageLink = modeling.createLinkOSH('manage', vcloudDirectorOsh, organizationOsh)
            vector.add(manageLink)

            for vdc in organization.vdcByName.values():
                vdcOsh = self.reportVdc(vdc, organizationOsh, cloud, vector)
                
                for vapp in vdc.vappsByName.values():
                    vappOsh = self.reportVapp(vapp, organizationOsh, vector)
                    
                    
                    for vm in vapp.vmsByName.values():
                        self.reportVm(vm, vappOsh, vector)
            
            for catalog in organization.catalogsByName.values():
                catalogOsh = self.reportCatalog(catalog, organizationOsh, vector)
                
                for media in catalog.mediaByName.values():
                    mediaOsh = self.reportMedia(media, catalogOsh, vector)
                    
                    if media._parentVdcReference is not None:
                        mediaParentVdc = organization._vdcByHref.get(media._parentVdcReference.getHref())
                        if mediaParentVdc is not None:
                            vdcOsh = mediaParentVdc.getOsh()
                            if vdcOsh is not None:
                                usageLink = modeling.createLinkOSH('usage', mediaOsh, vdcOsh)
                                vector.add(usageLink)
                    
                for vappTemplate in catalog.vappTemplatesByName.values():
                    self.reportVappTemplate(vappTemplate, catalogOsh, vector)
        
        return vector
Пример #22
0
 def build(self):
     domainName = DomainScopeManager.getDomainByIp(self.vServer.ip)
     name = '%s:%s %s' % (self.vServer.ip, self.vServer.port, domainName)
     vServerOsh = modeling.createCompleteHostOSH('cluster_resource_group', name, None, self.vServer.name)
     ipOSH = modeling.createIpOSH(self.vServer.ip)
     linkIpOSH = modeling.createLinkOSH('contained', vServerOsh, ipOSH)
     ownership_link = modeling.createLinkOSH('ownership', self.netscaler_software_osh, vServerOsh)
     vipServiceOsh = modeling.createServiceAddressOsh(vServerOsh, self.vServer.ip, self.vServer.port,
                                                      modeling.SERVICEADDRESS_TYPE_TCP, self.vServer.server_type)
     self.osh = vServerOsh
     return self.newVector(vServerOsh, ipOSH, ownership_link, linkIpOSH, vipServiceOsh)
Пример #23
0
def reportLayer2Connection(localInterfaceOsh, remoteInterfaceOsh, l2id):
        vector = ObjectStateHolderVector()

        layer2Osh = ObjectStateHolder('layer2_connection')
        layer2Osh.setAttribute('layer2_connection_id', l2id)
        vector.add(layer2Osh)
        linkOsh = modeling.createLinkOSH('member', layer2Osh, localInterfaceOsh)
        vector.add(linkOsh)
        linkOsh = modeling.createLinkOSH('member', layer2Osh, remoteInterfaceOsh)
        vector.add(linkOsh)
        return vector
Пример #24
0
 def createClientServerDependentLink(self,OSHVResult, clientHostOsh, serverHostOSH, serverPort, portName):
     ucmdbVersion = modeling.CmdbClassModel().version()
     if ucmdbVersion >= 9:
         nodeDependencyLink = modeling.createLinkOSH('node_dependency',clientHostOsh, serverHostOSH)
         nodeDependencyLink.setAttribute('dependency_name', serverPort)
         nodeDependencyLink.setAttribute('dependency_source', portName)
         OSHVResult.add(nodeDependencyLink)
     else:
         dependencyLink = modeling.createLinkOSH('dependency', clientHostOsh, serverHostOSH)
         dependencyLink.setAttribute('dependency_name', serverPort)
         dependencyLink.setAttribute('dependency_source', portName)
         OSHVResult.add(dependencyLink)
def DiscoveryMain(Framework):
	OSHVResult = ObjectStateHolderVector()	
	exchangeServerId = Framework.getDestinationAttribute('id')
	exchangeServerOsh = ms_exchange_utils.restoreExchangeServerOSH(exchangeServerId)
	
	try:
		shellClient = Framework.createClient()
		client = PowerShellClient(shellClient, Framework)
		try:
			ExchangeServer = client.executeScenario("Exchange_Server_2007_Discovery.ps1")
			
			exchangeSystemName = extractOrganizationNameFromDn(ExchangeServer.ExchangeLegacyDN)
			exchangeSystemOsh = ObjectStateHolder('exchangesystem')
			exchangeSystemOsh.setAttribute('data_name', exchangeSystemName)
			modeling.setAppSystemVendor(exchangeSystemOsh)
			OSHVResult.add(exchangeSystemOsh)
			OSHVResult.add(modeling.createLinkOSH('member', exchangeSystemOsh, exchangeServerOsh))
			adminGroupName = extractAdminGrouptFromDn(ExchangeServer.ExchangeLegacyDN)
			if adminGroupName and exchangeSystemOsh:
				adminGroupOsh = ObjectStateHolder('exchange_administrative_group')
				adminGroupOsh.setAttribute('data_name' , adminGroupName)
				adminGroupOsh.setContainer(exchangeSystemOsh)
				OSHVResult.add(adminGroupOsh)
				OSHVResult.add(modeling.createLinkOSH('member', adminGroupOsh, exchangeServerOsh))

			createServerRoles(exchangeServerOsh, ExchangeServer.ServerRole, OSHVResult)
			dagList = []
			clusteredMailBox = None
			try:
				dagList = ExchangeServer.dagList
				if not dagList:
					raise ValueError('Failed getting DAG information')
			except:
				logger.debugException('')
			else:
				OSHVResult.addAll(TopologyBuilder(None, None, None, None).buildDagRelatedTopology(exchangeServerOsh, dagList))
				
			try:
				clusteredMailBox = ExchangeServer.clusteredMailBox
				if not clusteredMailBox:
					raise ValueError('Failed getting Clustered Mailbox')
			except:
				logger.debugException('')
			else:
				setattr(clusteredMailBox, "exchOrgName", exchangeSystemName)
				OSHVResult.addAll(TopologyBuilder(None, None, None, None).buildClusteredMailBoxRelatedTopology(exchangeServerOsh, clusteredMailBox))
			OSHVResult.add(exchangeServerOsh)
		finally:
			client.close()
	except Exception, ex:
		logger.debugException('')
		strException = str(ex.getMessage())
		errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework)
Пример #26
0
    def build(self):
        #@return: oshv
        OSHVResult = ObjectStateHolderVector()
        exchageOsh = self.buildExchangeServerOsh(self.exchangeServer,
                            self.hostOsh, self.ipAddress, self.credentialsId)

        if self.exchangeServer.organization:
            exchOrgOsh = self.buildExchangeOrganization(self.exchangeServer.organization)
            OSHVResult.add(exchOrgOsh)
            OSHVResult.add(modeling.createLinkOSH('member', exchOrgOsh, exchageOsh))
            if self.exchangeServer.organizationalUnit:
                adminGrOsh = self.buildExchAdminGrOsh(exchOrgOsh, self.exchangeServer.organizationalUnit)
                OSHVResult.add(adminGrOsh)
                OSHVResult.add(modeling.createLinkOSH('member', adminGrOsh, exchageOsh))

        if self.exchangeServer.dagList:
            OSHVResult.addAll(self.buildDagRelatedTopology(exchageOsh, self.exchangeServer.dagList))

        if self.exchangeServer.clusteredMailBox:
            self.exchangeServer.clusteredMailBox.exchOrgName = self.exchangeServer.clusteredMailBox.exchOrgName or self.exchangeServer.organization
            OSHVResult.addAll(self.buildClusteredMailBoxRelatedTopology(exchageOsh, self.exchangeServer.clusteredMailBox))

        if self.exchangeServer.mdbList:
            for mdb in self.exchangeServer.mdbList:
                containerOsh = None
                if mdb.relateTo == RELATE_TO_DAG:
                    if self.exchangeServer.dagList:
                        for dag in self.exchangeServer.dagList:
                            if dag.dagName == mdb.containerName:
                                exchOrgOsh = self.buildExchangeOrganization(dag.exchOrgName)
                                containerOsh = self.buildDag(exchOrgOsh, dag)
                if containerOsh:
                    mdbOsh = self.buildMailboxDatabase(mdb, containerOsh)
                    if mdbOsh:
                        OSHVResult.add(containerOsh)
                        OSHVResult.add(mdbOsh)
                        if mdb.servers:
                            for server in mdb.servers:
                                if server.ips:
                                    hostOsh = modeling.createHostOSH(str(server.ips[0]))
                                    exchangeServerOsh = modeling.createExchangeServer(hostOsh)
                                    linkOsh = modeling.createLinkOSH('ownership', exchangeServerOsh, mdbOsh)
                                    OSHVResult.add(exchangeServerOsh)
                                    OSHVResult.add(linkOsh)
                                    OSHVResult.add(hostOsh)
                                    if server.name == mdb.runningServer:
                                        linkOsh = modeling.createLinkOSH('run', exchangeServerOsh, mdbOsh)
                                        OSHVResult.add(linkOsh)
        OSHVResult.add(exchageOsh)
        OSHVResult.addAll(self.buildServerRoles(exchageOsh, self.exchangeServer))
        OSHVResult.add(self.hostOsh)
        return OSHVResult
Пример #27
0
def reportStorageSystem(hostDo, fsm_osh):
    vector = ObjectStateHolderVector()
    storage_osh = buildStorageSystem(hostDo)
    link_osh = modeling.createLinkOSH('manage', fsm_osh, storage_osh)
    vector.add(link_osh)
    if hostDo.ipList:
        for ip in hostDo.ipList:
            ip_osh = modeling.createIpOSH(ip)
            link_osh = modeling.createLinkOSH('containment', storage_osh, ip_osh)
            vector.add(ip_osh)
            vector.add(link_osh)
    vector.add(storage_osh)
    return vector, storage_osh
Пример #28
0
 def buildStorageArrays(self):
     for storage in self.storageArrays.values():
         storageArrayOSHV = ObjectStateHolderVector()
         oshDict = storage.build()
         for name in oshDict.keys():
             arrayOsh = storage.oshs[name]
             ip = storage.ips[name]
             if ip and netutils.isValidIp(ip):
                 ipOsh = modeling.createIpOSH(storage.ips[name])
                 containmentOsh = modeling.createLinkOSH('containment', arrayOsh, ipOsh)
                 storageArrayOSHV.add(ipOsh)
                 storageArrayOSHV.add(containmentOsh)
             storageArrayOSHV.add(arrayOsh)
         hbaIdToOsh = {}
         for hba in storage.hbas.values():
             hbaOsh = hba.build()
             if storage.isClustered:
                 for name in storage.names:
                     if hba.name.startswith(name):
                         hbaOsh.setContainer(oshDict[name])
             else:
                 hbaOsh.setContainer(oshDict[oshDict.keys()[0]])
             hbaIdToOsh[hba.hbaId] = hbaOsh
             self.addWwnOsh(hba.wwn, hbaOsh)
             storageArrayOSHV.add(hbaOsh)
         for port in storage.ports.values():
             portOsh = port.build()
             if storage.isClustered:
                 for name in storage.names:
                     if port.name.startswith(name):
                         portOsh.setContainer(oshDict[name])
             else:
                 portOsh.setContainer(oshDict[oshDict.keys()[0]])
             if port.nodeId and port.nodeId in hbaIdToOsh.keys():
                 containmentLinkOsh = modeling.createLinkOSH('containment', hbaIdToOsh[port.nodeId], portOsh)
                 storageArrayOSHV.add(containmentLinkOsh)
             self.portIdToOsh[port.portId] = portOsh
             self.addWwnOsh(port.wwn, portOsh)
             storageArrayOSHV.add(portOsh)
         for volume in storage.volumes.values():
             volumeOsh = volume.build()
             if storage.isClustered:
                 for name in storage.names:
                     if volume.name.startswith(name):
                         volumeOsh.setContainer(oshDict[name])
             else:
                 volumeOsh.setContainer(oshDict[oshDict.keys()[0]])
             self.volumeIdToOsh[volume.volumeId] = volumeOsh
             storageArrayOSHV.add(volumeOsh)
         self.framework.sendObjects(storageArrayOSHV)
         self.framework.flushObjects()
Пример #29
0
def reportTopology(switchOsh, interfaces_dict, vlans, remote_peers_map, ports_map):
    
    vector = ObjectStateHolderVector()
    vector.add(switchOsh)
    
    interfaceNameToInterfaceOshMap = {} 
    
    for interfaceDo in interfaces_dict.values():
        interfaceDo.build()
        interfaceOsh = interfaceDo.getOsh()
        interfaceOsh.setContainer(switchOsh)
        vector.add(interfaceOsh)
        interfaceNameToInterfaceOshMap[interfaceDo.getName()] = interfaceOsh
    
    portNameToPortOshMap = {}
    if ports_map:
        for (port_name, port) in ports_map.items():
            portOsh = buidlPort(port, switchOsh)
            interfaceOsh = interfaceNameToInterfaceOshMap.get(sanitizePort(port_name))
            if not (portOsh and interfaceOsh):
                continue
            vector.add(portOsh)
            linkOsh = modeling.createLinkOSH('realization', portOsh, interfaceOsh)
            vector.add(linkOsh)
            portNameToPortOshMap[port_name] = portOsh
        
    if remote_peers_map:
        for (interface_name, remote_peers) in remote_peers_map.items():
            localInterfaceOsh = interfaceNameToInterfaceOshMap.get(interface_name)
            if not localInterfaceOsh:
                continue
            for remote_peer in remote_peers:
                vector.addAll(reportRemotePeer(remote_peer, localInterfaceOsh, interface_name))
    
    if vlans:
        for vlan in vlans:
            vlanOsh = buildVlan(vlan, switchOsh)
            if not (vlan and vlanOsh):
                continue
            
            for port_name in vlan.ports:
                portOsh = portNameToPortOshMap.get(port_name)
                if not portOsh:
                    continue
                portOsh.setStringAttribute('port_vlan', str(vlan.id))
                linkOsh = modeling.createLinkOSH('membership', vlanOsh, portOsh)
                vector.add(vlanOsh)
                vector.add(linkOsh)
                
            
    return vector
Пример #30
0
 def buildDagRelatedTopology(self, exchangeServerOsh, dagList):
     OSHVResult = ObjectStateHolderVector()
     for dag in dagList:
         exchOrgOsh = self.buildExchangeOrganization(dag.exchOrgName)
         if exchOrgOsh:
             exchAdminGrOsh = self.buildExchAdminGrOsh(exchOrgOsh, dag.exchAdminGrName)
             OSHVResult.add(modeling.createLinkOSH('membership', exchAdminGrOsh, exchangeServerOsh))
             dagOsh = self.buildDag(exchOrgOsh, dag)
             if dagOsh:
                 OSHVResult.add(modeling.createLinkOSH('membership', dagOsh, exchangeServerOsh))
                 OSHVResult.add(exchOrgOsh)
                 OSHVResult.add(exchAdminGrOsh)
                 OSHVResult.add(dagOsh)
     return OSHVResult
Пример #31
0
 def reportAvailabilityZoneInRegion(self, region, zone):
     r'''@types: aws.Regtion, aws.AvailabilityZone -> ObjectStateHolderVector
     @raise ValueError: Region is not specified or not built
     @raise ValueError: Zone is not specified
     '''
     if not (region and region.getOsh()):
         raise ValueError("Region is not specified or not built")
     if not zone:
         raise ValueError("Zone is not specified")
     vector = self._createOshVector()
     regionOsh = region.getOsh()
     vector.add(regionOsh)
     vector.add(zone.build(self.__builder))
     vector.add(
         modeling.createLinkOSH('containment', regionOsh, zone.getOsh()))
     return vector
Пример #32
0
 def reportStoreDependencyOnDatasource(self, container, store, datasource):
     r''' Reports linkage between JMS Store and any type of datasource,
     like JDBC store and database datasource.
     @note: Store will be built if it wasn't previously
     @types: entity.HasOsh, jms.Store, entity.HasOsh -> ObjectStateHolderVector
     @param container: JMS Store container in case if store is not built
     '''
     if not store:
         raise ValueError("Store is not specified")
     if not (datasource and datasource.getOsh()):
         raise ValueError("Datasource is not specified or not built")
     vector = ObjectStateHolderVector()
     storeOsh = store.getOsh() or store.build(self.builder())
     vector.add(
         modeling.createLinkOSH('depend', storeOsh, datasource.getOsh()))
     return vector
Пример #33
0
 def reportJmsServer(self, domain, deploymentScope, server):
     r'''@types: jee.Domain, entity.HasOsh, jms.Server -> ObjectStateHolderVector
     @raise ValueError: JMS Server is not specified
     @raise ValueError: JMS Server container is not specified or not built
     '''
     container = domain
     if not server:
         raise ValueError("JMS Server is not specified")
     vector = ObjectStateHolderVector()
     if not server.getOsh():
         vector.addAll(self._reportJmsServer(container, server))
     if deploymentScope and deploymentScope.getOsh():
         vector.add(
             modeling.createLinkOSH('deployed', deploymentScope.getOsh(),
                                    server.getOsh()))
     return vector
Пример #34
0
 def report_client_server(self,
                          client_process_osh,
                          server_ips_osh,
                          server_port_name,
                          server_port,
                          protocol_type=modeling.TCP_PROTOCOL):
     protocol = protocol_type == modeling.TCP_PROTOCOL and 'TCP' or 'UDP'
     cs_link = modeling.createLinkOSH('client_server', client_process_osh,
                                      server_ips_osh)
     cs_link.setStringAttribute('clientserver_protocol', protocol)
     cs_link.setStringAttribute('data_name', server_port_name)
     if server_port and server_port.isdigit():
         cs_link.setLongAttribute('clientserver_destport', int(server_port))
     else:
         logger.debug('Server port is not a numeric: %s' % server_port)
     return cs_link
Пример #35
0
 def getBackup(self, databases, dbList, hostId):
     oshv = ObjectStateHolderVector()
     backupMap = self.getDBBackups(databases, dbList)
     backupFilesMap = self.getBackupFiles(databases, dbList, hostId, oshv)
     #create the use link
     logger.debug("get backup files")
     for key in backupMap.keySet():
         backup = backupMap.get(key)
         backupFile = backupFilesMap.get(key)
         if backup is not None and backupFile is not None:
             oshv.add(backup)
             oshv.add(backupFile)
             link = modeling.createLinkOSH("use", backup, backupFile)
             oshv.add(link)
         logger.debug("got backup files: ", oshv.size())
     return oshv
Пример #36
0
    def reportTopology(self, app_pools_list, web_sites_list, parentOsh, iis_version=None, webservice_ext_filter=[]):
        """

        :param web_sites_list: List of WebSites which was discovered
        :type web_sites_list: list[iis.Site]
        :param parentOsh: parent OSH for each website
        :type parentOsh: ObjectStateHolder
        :return: list[ObjectStateHolder]
        :rtype: list[ObjectStateHolder]
        """
        result = []
        apppool_map = self.reportAppPools(app_pools_list, parentOsh)
        sites_map = self.reportWebSites(web_sites_list, parentOsh, iis_version)
        result.extend(sites_map.values())
        result.extend(apppool_map.values())

        # report VirtualDir and WebDirs(WebApplication)
        for site in web_sites_list:
            web_site_osh = sites_map.get(site.name)
            if not site.is_ftp():
                # report root web dir
                root_web_dir = iis.WebApplication("Root", "/", site.path, site.config_files)
                root_osh = self._builder.buildApplication(root_web_dir)
                root_osh.setContainer(web_site_osh)
                result.append(root_osh)
                if apppool_map:
                    app_pool_osh = apppool_map.get(site.app_pool.name)
                    if app_pool_osh:
                        result.append(modeling.createLinkOSH("deployed", root_osh, app_pool_osh))

                # report config files
                result.extend(self.reportConfigFiles(site.config_files, root_osh))

                # report virtual dirs
                report_virtual_dirs = partial(self.reportVirtualDir, parent_osh=root_osh)
                result.extend(iflatten(ifilter(None, imap(report_virtual_dirs, site.virtual_dirs))))

                # report Webdirs = WebApplications
                report_web_application = partial(self.reportWebDir, parent_osh=root_osh, app_pools_map=apppool_map, webservice_ext_filter=webservice_ext_filter)
                result.extend(iflatten(ifilter(None, imap(report_web_application, site.web_applications))))

            bindings = flatten(
                ifilter(None, imap(lambda binding: binding[1].lower() in ['http', 'https', 'ftp'] and binding[2],
                                   site.bindings)))
            result.extend(self.reportBindings(bindings, web_site_osh, parentOsh))

        return result
Пример #37
0
def getGroupComponents(client, mapGroupNameToOSH, ip, OSHVResult, enterprise, siteOSH):
	compsListing = client.executeCmd('list comps')#@@CMD_PERMISION siebel protocol execution
	compsTbl = siebel_common.makeTable(compsListing)
	# sample output
	# SV_NAME  CC_ALIAS   CC_NAME             CT_ALIAS  CG_ALIAS  CC_RUNMODE  CP_DISP_RUN_STATE  CP_NUM_RUN_  CP_MAX_TASK  CP_ACTV_MTS  CP_MAX_MTS_  CP_START_TIME        CP_END_TIME  CP_STATUS  CC_INCARN_NO  CC_DESC_TEXT
	# -------  ---------  ------------------  --------  --------  ----------  -----------------  -----------  -----------  -----------  -----------  -------------------  -----------  ---------  ------------  ------------
	# sblapp2  AsgnSrvr   Assignment Manager            AsgnMgmt  Batch       Online             0            20           1            1            2004-08-01 03:29:42
	# sblapp2  AsgnBatch  Batch Assignment              AsgnMgmt  Batch       Online             0            20                                     2004-08-01 03:29:42
	#
	# 2 rows returned.

	cCount = 0
	#compsOSHV = ObjectStateHolderVector()

	for compEntry in compsTbl:
		try:
			compObj = compEntry[0]
			compDataRow = compEntry[1]
			attrNum = len(compObj)
			appOSH = None
			if attrNum > 3:
				compName = compObj[2]
				endIndex = compName.find(' Object Manager')
				if endIndex > 0:
					appName = compName[0:endIndex]
					appOSH = ObjectStateHolder('siebel_application')
					appOSH.setAttribute('data_name', appName)
					appOSH.setContainer(siteOSH)
					OSHVResult.add(appOSH)
			if attrNum > 4:
				# get Name or Alias
				cgName = compObj[4]
				groupOSH = mapGroupNameToOSH.get(cgName)
				if groupOSH != None:
					(compOSH, paramsFileOSH) = makeComponent(client, compObj, compDataRow, ip, enterprise)
					compOSH.setContainer(groupOSH)
					OSHVResult.add(compOSH)
					OSHVResult.add(paramsFileOSH)
					cCount += 1
					if appOSH != None and compOSH != None:
						OSHVResult.add(modeling.createLinkOSH('contains',appOSH, compOSH))
				else:
					logger.warn('Group is not found for component [', cgName, ']')
		except:
			logger.warnException('failed making component:', compDataRow)

	logger.debug('parsed ', str(cCount), ' components')
Пример #38
0
    def report(self, regionOsh):
        vector = ObjectStateHolderVector()
        hostOsh = ObjectStateHolder('host_node')
        hostOsh.setAttribute("name", self.name)

        hypervisorOsh = ObjectStateHolder('virtualization_layer')
        if self.type:
            hypervisorOsh.setStringAttribute('name', self.type)
        hypervisorOsh.setStringAttribute('discovered_product_name', 'openstack_hypervisor')
        hypervisorOsh.setAttribute('hypervisor_name', self.name)
        hypervisorOsh.setContainer(hostOsh)

        vector.add(hostOsh)
        vector.add(hypervisorOsh)
        vector.add(modeling.createLinkOSH("membership", regionOsh, hostOsh))

        return hypervisorOsh, vector
Пример #39
0
 def _reportDbToSharePointLinks(self, result, sharepointOsh):
     """
     Generates links between sharepoint software element and databases.
     Reports ipserver_address, use, clientserver
     ObjectStateHolderVector, OSH->None
     """
     reportedDatabaseLinks = []
     for dbConnection in self._databaseConnections:
         if dbConnection.name in reportedDatabaseLinks:
             continue
         dbOsh = self._dbNameToDbOsh[dbConnection.name]
         dbUrlOsh = modeling.createUrlOsh(dbOsh, 'sql://'+dbConnection.name)
         result.add(dbUrlOsh)
         link = modeling.createLinkOSH('client_server', sharepointOsh, dbUrlOsh)
         link.setAttribute('clientserver_protocol', 'SQL')
         result.add(link)
         reportedDatabaseLinks.append(dbConnection.name)
Пример #40
0
    def addResultsToVector(self, resultsVector):

        if self.resultVector:
            resultsVector.addAll(self.resultVector)
        # when the destination IP is virtual, and it exists in NATIpAddress.xml
        # Continue to create the shell object other than ignore it
        if self.hostDo.ipIsVirtual:
            if self.hostDo.ipIsNATed:
                vIPOSH = modeling.createIpOSH(self.destinationIp)
                vIPOSH.setBoolAttribute('isvirtual', 1)
                resultsVector.add(vIPOSH)
                resultsVector.add(
                    modeling.createLinkOSH('contained', self.hostOsh, vIPOSH))
            else:
                return
        self.ntcmdObj.setContainer(self.hostOsh)
        resultsVector.add(self.ntcmdObj)
Пример #41
0
def osh_createASPOsh(lparOsh, ASPList, DiskList):

    spDict = {}
    str_name = 'name'
    str_storagepool_poolid = 'storagepool_poolid'
    str_storagepool_mbavailable = 'storagepool_mbavailable'
    str_storagepool_mbtotal = 'storagepool_mbtotal'
    str_storagepool_capacitynum = 'storagepool_capacitynum'
    str_serial_number = 'serial_number'
    str_logicalvolume_fstype = 'logicalvolume_fstype'
    str_logicalvolume_id = 'logicalvolume_id'
    str_logicalvolume_free = 'logicalvolume_free'
    str_logicalvolume_size = 'logicalvolume_size'
    _vector = ObjectStateHolderVector()
    if isNotNull(ASPList):
        for asp in ASPList:
            if isNotNull(asp[0]):
                aspname = ('ASP' + asp[0])
                spOsh = ObjectStateHolder('storagepool')
                spOsh.setAttribute(str_name, aspname)
                spOsh.setIntegerAttribute(str_storagepool_poolid, int(asp[0]))
                spOsh.setDoubleAttribute(str_storagepool_mbavailable, asp[3])
                spOsh.setDoubleAttribute(str_storagepool_mbtotal, asp[2])
                spOsh.setIntegerAttribute(str_storagepool_capacitynum, asp[1])
                spOsh.setContainer(lparOsh)
                spDict[asp[0]] = spOsh
                _vector.add(spOsh)
    if isNotNull(DiskList):
        for disk in DiskList:
            if isNotNull(disk[0]):
                aspid = disk[0]
                diskOsh = ObjectStateHolder('logical_volume')
                diskOsh.setAttribute(str_name, disk[4])
                diskOsh.setAttribute(str_serial_number, disk[3])
                diskOsh.setAttribute(str_logicalvolume_fstype, disk[1])
                diskOsh.setIntegerAttribute(str_logicalvolume_id, int(disk[5]))
                diskOsh.setDoubleAttribute(str_logicalvolume_free, disk[7])
                diskOsh.setDoubleAttribute(str_logicalvolume_size, disk[6])
                diskOsh.setContainer(lparOsh)
                _vector.add(diskOsh)
                if spDict.has_key(aspid):
                    memberOsh = modeling.createLinkOSH('membership',
                                                       spDict[aspid], diskOsh)
                    _vector.add(memberOsh)
    return _vector
Пример #42
0
 def reportNode(self, node, resultsVector):
     nodeOsh = self._nodeBuilder.build(node)
     resultsVector.add(nodeOsh)
     node.setOsh(AutoStartReporter.NODE_KEY_HOST, nodeOsh)
     
     for nic in node.nicsByName.values():
         if nic and nic.ip:
             try:
                 ipOsh = modeling.createIpOSH(nic.ip)
                 resultsVector.add(ipOsh)
                 
                 containmentLink = modeling.createLinkOSH('containment', nodeOsh, ipOsh)
                 resultsVector.add(containmentLink)
                 
             except ValueError:
                 logger.warn("Invalid IP during reporting is ignored")
     
     return nodeOsh
Пример #43
0
 def populateResult(self, oshv, hostName, userName, dbOSH, clientsCount):
     if (hostName) and (userName):
         #create the remote host
         remoteHost = Util.getHost(hostName)
         if not remoteHost:
             logger.debug('RemoteHost osh is None, hostName:%s' % hostName)
             return
         oshv.add(remoteHost)
         #create the remote process
         program = modeling.createProcessOSH(userName, remoteHost)
         oshv.add(program)
         if dbOSH:
             #create the dblink
             dbLink = modeling.createLinkOSH('dbclient', dbOSH, program)
             dbLink.setIntegerAttribute('dbclient_connectioncount',clientsCount)
             oshv.add(dbLink)
         else:
             logger.debug('Database osh is None')
Пример #44
0
 def discoverPlanJobs(self,oshv,sqlServerId,plans,jobById):
     itr = plans.entrySet().iterator()
     while(itr.hasNext()):
         entry = itr.next()
         name = entry.getKey()
         plan = entry.getValue()
         query = Util.replace(self.jobsOfPlanQuery, name)
         try:
             rs = self.connection.getTable(query)
             while(rs.next()):
                 jobId = rs.getString('job_id')
                 job = jobById.get(jobId)
                 if(job is not None):
                     oshv.add(modeling.createLinkOSH('dblink',plan,job))
             rs.close()
         except:
             logger.debugException("couldn't get jobs for plan:", name)
     return
Пример #45
0
def osh_createIBMframeOsh(lparOsh, cecTable):
    str_name = 'name'
    str_discovered_model = 'discovered_model'
    str_serial_number = 'serial_number'
    isComplete = 1
    _vector = ObjectStateHolderVector()
    cecOsh = ObjectStateHolder('ibm_pseries_frame')  # iSeries CEC
    cecOsh.setAttribute(str_name, 'CEC' + cecTable[0][2])
    cecOsh.setBoolAttribute('host_iscomplete', isComplete)
    cecOsh.setAttribute(str_discovered_model, cecTable[0][1])  # CPC SI
    cecOsh.setAttribute('host_key', cecTable[0][2])
    cecOsh.setAttribute(str_serial_number, cecTable[0][2])
    str_membership = 'membership'
    membershipOsh = modeling.createLinkOSH(str_membership, cecOsh, lparOsh)
    _vector.add(cecOsh)
    _vector.add(lparOsh)
    _vector.add(membershipOsh)
    return _vector
Пример #46
0
    def reportIpString(self, ipAddress, device, vector, ipMask=None):
        ''' string, Device, OSHV, string? -> OSH? '''
        deviceOsh = device and device.getOsh() or None
        if ipAddress and deviceOsh:
            ipOsh = None
            try:
                ipOsh = modeling.createIpOSH(ipAddress, ipMask)
            except ValueError, ex:
                logger.warn(str(ex))

            if ipOsh:
                vector.add(ipOsh)

                containmentLink = modeling.createLinkOSH(
                    'containment', deviceOsh, ipOsh)
                vector.add(containmentLink)

                return ipOsh
Пример #47
0
 def reportHostWithIps(self, *ips):
     r''' Report complete host with containment links to IPs
     If None among IPs it will be skipped but wrong IP will cause exception
     @types: ip_addr._BaseIP -> tuple[ObjectStateHolder, ObjectStateHolderVector]
     @raise ValueError: Host key is not specified
     @raise ValueError: IPs are not specified
     '''
     ips = filter(None, ips)
     if not ips:
         raise ValueError("IPs are not specified")
     ips = map(ip_addr.IPAddress, ips)
     vector = ObjectStateHolderVector()
     hostOsh = self._getBuilder().buildCompleteHost(str(ips[0]))
     vector.add(hostOsh)
     for ipOsh in map(modeling.createIpOSH, ips):
         vector.add(modeling.createLinkOSH('containment', hostOsh, ipOsh))
         vector.add(ipOsh)
     return hostOsh, vector
def modelApplicationPool(context):
    processes = context.application.getProcessesByName('w3wp.exe')
    iisOSHV = ObjectStateHolderVector()
    applicationOsh = context.application.getOsh()
    for process in processes:
        procCmdLine = process.commandLine
        if procCmdLine:
            poolName = re.match(r".*w3wp.*\-ap\s*\"(.*?)\".*", procCmdLine)
            if poolName:
                iisAppPoolOSH = ObjectStateHolder('iisapppool')
                iisAppPoolOSH.setAttribute('data_name',
                                           poolName.group(1).strip())
                iisAppPoolOSH.setContainer(applicationOsh)
                iisOSHV.add(iisAppPoolOSH)
                linkOSH = createLinkOSH('depend', iisAppPoolOSH,
                                        process.getOsh())
                iisOSHV.add(linkOSH)
    return iisOSHV
Пример #49
0
def createCPLink(clientId,
                 clientClass,
                 serverId,
                 serverClass,
                 scpId,
                 reference=None):
    OSHVResult = ObjectStateHolderVector()
    clientOsh = ObjectStateHolder(
        clientClass, CmdbObjectID.Factory.restoreObjectID(clientId))
    serverOsh = ObjectStateHolder(
        serverClass, CmdbObjectID.Factory.restoreObjectID(serverId))
    OSHVResult.addAll(createCPLinkByOsh(clientOsh, serverOsh, scpId,
                                        reference))
    if clientClass == 'business_application':
        containmentLink = modeling.createLinkOSH('containment', clientOsh,
                                                 serverOsh)
        OSHVResult.add(containmentLink)
    return OSHVResult
Пример #50
0
    def discoverFarmMembers(self, farmNameToFarm):
        queryBuilder = SnmpQueryBuilder(CISCO_ACE_OID_TABLE_SERVER)
        queryBuilder.addQueryElement(1, 'farmName')
        queryBuilder.addQueryElement(2, 'ipAddress')
        queryBuilder.addQueryElement(3, 'port')
        farmMembers = self.snmpAgent.getSnmpData(queryBuilder)

        for farmMember in farmMembers:
            farmMemberOsh = modeling.createHostOSH(farmMember.ipAddress,
                                                   'host')
            serviceAddressOsh = modeling.createServiceAddressOsh(
                farmMemberOsh, farmMember.ipAddress, farmMember.port,
                modeling.SERVICEADDRESS_TYPE_TCP)
            self.OSHVResult.add(farmMemberOsh)
            self.OSHVResult.add(serviceAddressOsh)
            farmOsh = farmNameToFarm[farmMember.farmName]
            self.OSHVResult.add(
                modeling.createLinkOSH('member', farmOsh, serviceAddressOsh))
Пример #51
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    dbFileId = Framework.getDestinationAttribute('dbFileId')
    dbFilePath = Framework.getDestinationAttribute('dbFilePath')
    fsIds = Framework.getTriggerCIDataAsList('fsId') 
    mountPoints = Framework.getTriggerCIDataAsList('mountPoints')
    logger.debug(mountPoints)
    logger.debug(dbFilePath)
    (index, mountPoint) = getMountPoint(dbFilePath, mountPoints)
    if mountPoint:
        fsOsh = modeling.createOshByCmdbId('file_system', fsIds[index])
        dbDatafileOsh = modeling.createOshByCmdbId('dbdatafile', dbFileId)
        linkOsh = modeling.createLinkOSH('usage', dbDatafileOsh, fsOsh)
        OSHVResult.add(fsOsh)
        OSHVResult.add(dbDatafileOsh)
        OSHVResult.add(linkOsh)
        
    return OSHVResult
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()

    ## Write implementation to return new result CIs here...
    clientId = Framework.getDestinationAttribute('CLIENT_ID')
    clientClass = Framework.getDestinationAttribute('CLIENT_CLASS')
    serverIds = Framework.getTriggerCIDataAsList('SERVER_ID')
    serverClasses = Framework.getTriggerCIDataAsList('SERVER_CLASS')
    scpId = Framework.getDestinationAttribute('id')
    serverIdsHaveLink = Framework.getTriggerCIDataAsList('SERVER_ID_HAVE_LINK')
    serverIdsShouldHaveLink = Framework.getTriggerCIDataAsList('SERVER_ID_SHOULD_HAVE_LINK')
    serverClassesHaveLink = Framework.getTriggerCIDataAsList('SERVER_CLASS_HAVE_LINK')

    clientOsh = ObjectStateHolder(clientClass, clientId)
    OSHVResult.add(clientOsh)
    if Framework.getDestinationAttribute('CLIENT_APPLICATION_ID'):
        buildClientOsh(Framework, clientOsh)

    index = -1
    processed = set()
    reference = buildReferenceString(Framework)
    for serverId in serverIds:
        index += 1
        if serverId:
            if serverId in processed:
                logger.debug('Ignore duplication link for id:', serverId)
                continue
            processed.add(serverId)
            if serverId == clientId:
                logger.debug('Ignore self link from id:', serverId)
                continue
            logger.debug("creating cp-link for ci:", serverId)
            serverClass = serverClasses[index] or 'running_software'
            serverOsh = ObjectStateHolder(serverClass, serverId)
            OSHVResult.add(serverOsh)
            OSHVResult.addAll(scp.createCPLinkByOsh(clientOsh, serverOsh, scpId, reference))
            if clientClass == 'business_application':
                containmentLink = modeling.createLinkOSH('containment', clientOsh, serverOsh)
                OSHVResult.add(containmentLink)

    logger.debug("check if there is cp link need to be deleted")

    scp.deleteDependencies(Framework, clientOsh, serverIdsHaveLink, serverIdsShouldHaveLink, serverClassesHaveLink)
    return OSHVResult
Пример #53
0
    def __reportOracleRac(self, platform, datasource, rac):
        r'@types: db_platform.Oracle, jdbc.Datasource, db.OracleRac -> ObjectStateHolderVector'
        logger.info("Report Oracle RAC %s" % rac)
        # Resolve addresses for all server instances in the RAC
        resolvedServers = []
        for server in rac.getServers():
            if not netutils.isValidIp(server.address):
                try:
                    ips = self.__dnsResolver.resolveIpsByHostname(
                        server.address)
                    server.address = ips[0]
                    resolvedServers.append(server)
                except (Exception, JException):
                    logger.warnException("Failed to resolve IP for the %s" %
                                         server)
            else:
                resolvedServers.append(server)
        # After attempt to resolve addresses of RAC instances we will use only
        # with resolved address
        resolvedServers = filter(db.DatabaseServer.getPort, resolvedServers)
        if not resolvedServers:
            raise ValueError("None of RAC instances were resolved")
        # Prepare builders and reporters for RAC and db servers
        databaseBuilder = db_builder.getBuilderByPlatform(platform)
        databaseServerReporter = db.TopologyReporter(databaseBuilder)
        racReporter = db.OracleRacTopologyReporter(
            db_builder.OracleRacBuilder())

        vector = ObjectStateHolderVector()
        # Report RAC
        racOsh = racReporter.reportRac(rac)
        vector.add(racOsh)
        for server in resolvedServers:
            # Report each resolved server
            vector.addAll(
                databaseServerReporter.reportDatabaseServerFromAddress(server))
            # report link between RAC and server
            vector.add(racReporter.linkRacWithDbServer(racOsh,
                                                       server.getOsh()))
        # Report dependency link between datasource and RAC
        vector.add(
            modeling.createLinkOSH('depend', datasource.getOsh(), racOsh))
        return vector
Пример #54
0
 def process(self, context):
     webseal_instance_osh = context.application.applicationOsh
     command_line = self._main_process.commandLine
     m = re.search('.*-config.+webseald-(\w+)', command_line)
     if m:
         logger.debug('Found instance name %s for Webseal Instance' % m.group(1))
         webseal_instance_osh.setStringAttribute('name', m.group(1))
         
     config_path = self._parseConfigPath(command_line)
     if not config_path:
         logger.warn('Failed to get more info')
     
     shell = context.client
     file_content = self._fetchConfigFileContent(shell, config_path)
     
     if not file_content:
         return
     
     master_host = self._parseMasterHostData(file_content)
     if not master_host:
         return
     
     ip = None
     
     if ip_addr.isValidIpAddressNotZero(master_host):
         ip = master_host
     else:
         try:
             resolver = dns_resolver.create(shell)
             ips = resolver.resolve_ips(master_host)
             ip = ips and ips[0]
         except:
             logger.debugException('Failed to resolve host name %s' % master_host)
     
     if ip:
         host_osh = modeling.createHostOSH(str(ip))
         if host_osh:
             policy_osh = self.buildPolicyServer(host_osh)
             link_osh = modeling.createLinkOSH('usage', webseal_instance_osh, policy_osh)
             vector = context.resultsVector
             vector.add(host_osh)
             vector.add(policy_osh)
             vector.add(link_osh)
Пример #55
0
 def _reportVirtualSwitchBackingInterface(self, switch, domain, vector):
     if not switch.backingInterfaceName:
         return
     
     hostOsh = domain.getOsh(LdomTopologyReporter._KEY_HOST)
     switchOsh = switch.getOsh(LdomTopologyReporter._KEY_SWITCH)
     if hostOsh is None or switchOsh is None:
         return
     
     backingInterfaceOsh = self._virtualSwitchBackingInterfaceBuilder.build(switch)
     if backingInterfaceOsh is None: 
         return
     
     backingInterfaceOsh.setContainer(hostOsh)
     vector.add(backingInterfaceOsh)
     switch.setOsh(LdomTopologyReporter._KEY_SWITCH_BACKING_NIC, backingInterfaceOsh)
     
     usageLink = modeling.createLinkOSH('usage', switchOsh, backingInterfaceOsh)
     vector.add(usageLink)
Пример #56
0
    def discoverPlanDbs(self,oshv,plans,dbs):
        itr = plans.entrySet().iterator()
        while(itr.hasNext()):
            entry = itr.next()
            name = entry.getKey()
            plan = entry.getValue()
            try:
                query = Util.replace(Queries.GET_DATABASE_OF_PLAN,name)
                rs = self.connection.getTable(query)
                while(rs.next()):
                    dbName = rs.getString("database_name")
                    db = dbs.get(dbName)
                    if(db is not None):
                        oshv.add(modeling.createLinkOSH('dblink',plan,db))
                rs.close()
            except:
                logger.debug("couldn't get jobs for plan:", name)

        return
    def report(self, webSphereConfig, resultVector, webServerOsh):
        self._resolveHostNameToIp(webSphereConfig)

        for route in webSphereConfig.routes:
            clusterName = route.clusterName
            cluster = webSphereConfig.clustersByName.get(clusterName)
            if not cluster:
                continue

            uriGroupName = route.uriGroupName
            uriGroup = webSphereConfig.uriGroupsByName.get(uriGroupName)

            for server in cluster.serversByName.values():
                for transport in server.transports:
                    if transport.hostIp and transport.port:

                        self._reportDependentWebSphere(server, transport,
                                                       webServerOsh,
                                                       resultVector)

                        if uriGroup is not None:
                            for uri in uriGroup.uris:

                                normalizedUri = self._getNormalizedUri(
                                    uri.name)
                                if not normalizedUri: continue

                                httpContextOsh = self._createHttpContext(
                                    normalizedUri, transport, server.name,
                                    webServerOsh)
                                if httpContextOsh is not None:
                                    contextConfigOsh = modeling.createConfigurationDocumentOSH(
                                        'httpcontext.txt', '',
                                        self._getContextContent(
                                            normalizedUri, transport),
                                        httpContextOsh)
                                    contextConfigLinkOsh = modeling.createLinkOSH(
                                        'usage', httpContextOsh,
                                        contextConfigOsh)
                                    resultVector.add(contextConfigOsh)
                                    resultVector.add(contextConfigLinkOsh)
                                    resultVector.add(httpContextOsh)
Пример #58
0
 def _reportBackingDeviceForVolume(self, volume, domain, vector):
     hostOsh = domain.getOsh(LdomTopologyReporter._KEY_HOST)
     if hostOsh is None:
         return
     
     volumeOsh = volume.getOsh(LdomTopologyReporter._KEY_VIRTUAL_VOLUME)
     if volumeOsh is None:
         return
     
     try:
         backingVolumeOsh = self._virtualVolumeBackingDeviceBuilder.build(volume)
         backingVolumeOsh.setContainer(hostOsh)
         vector.add(backingVolumeOsh)
         volume.setOsh(LdomTopologyReporter._KEY_VIRTUAL_VOLUME_BACKING, backingVolumeOsh)
         
         realizationLink = modeling.createLinkOSH('realization', volumeOsh, backingVolumeOsh)
         vector.add(realizationLink)
         
     except ValueError, ex:
         logger.warn(str(ex))
Пример #59
0
def start_srvrmgr_discovery(client, ip, port, credentialsId, Framework,
                            OSHVResult):
    try:
        logger.debug('connected to gateway')
        username = client.getUserName()
        enterprise = client.getEnterprise()
        srvrmgrPath = client.getServerManagerPath()
        siebelGatewayOSH = makeSiebelgatewayOSH(client, username, enterprise,
                                                srvrmgrPath, credentialsId, ip,
                                                port, Framework)
        siebelsiteOSH = makesiebelsiteOSH(enterprise, credentialsId, ip)
        enterpriseLink = modeling.createLinkOSH('member', siebelsiteOSH,
                                                siebelGatewayOSH)
        OSHVResult.add(siebelGatewayOSH)
        OSHVResult.add(siebelsiteOSH)
        OSHVResult.add(enterpriseLink)
    except Exception, ex:
        strException = str(ex.getMessage())
        errormessages.resolveAndReport(strException, PROTOCOL_NAME, Framework)
        logger.debugException('')
Пример #60
0
 def attachToUsers(self, db, users, oshv, dbName=None):
     if dbName:
         query = Util.replaceAll(Queries.DATABASE_USERS_DBNAME, dbName)
     else:
         query = Queries.DATABASE_USERS
     rs = None
     try:
         rs = self.connection.getTable(query)
         while (rs.next()):
             name = rs.getString('name')
             user = users.get(name)
             if (user is not None):
                 owner = modeling.createLinkOSH('owner', user, db)
                 oshv.add(owner)
         rs.close()
     except:
         if rs:
             rs.close()
         logger.debug("Failed to get database user:", dbName)
         return