예제 #1
0
 def parseNetworkingInformation(self, buffer):
     """
     This function performs parsing of the 'lshmc -n' command output
     @param buffer: string buffer of the command output 
     @return: host and ip information
     @rtype: instance of HostDo object
     """
     host = ibm_hmc_lib.Host()
     if buffer:
         propertiesDict = self.buildPropertiesDict(buffer)
         host.hostname = propertiesDict.get('hostname')
         host.domainName = propertiesDict.get('domain')
         for (key, value) in propertiesDict.items():
             if key.startswith('ipv4addr_eth'):
                 if value and netutils.isValidIp(value) and not netutils.isLocalIp(value):
                     ip = ibm_hmc_lib.Ip(value, propertiesDict.get(key.replace('addr', 'netmask')))
                     host.ipList.append(ip)
         
         if not host.ipList: #another version of HMC outputs, for the minor HMC version change
             ipStr = propertiesDict.get('ipaddr')
             netMaskStr = propertiesDict.get('networkmask')
             if ipStr and netMaskStr:
                 ipList = ipStr.split(',')
                 netMaskList = netMaskStr.split(',')
                 for i in range(len(ipList)):
                     ipAddr = ipList[i].strip()
                     netMask = netMaskList[i].strip()
                     if ipAddr and netutils.isValidIp(ipAddr) and not netutils.isLocalIp(ipAddr):
                         ip = ibm_hmc_lib.Ip(ipAddr, netMask)
                         host.ipList.append(ip)
                         
         if not host.ipList:
             raise ValueError("Failed parsing HMC host IP addresses from  %s " % buffer)
     return host
예제 #2
0
def _resolve(hostname):
    '@types: str -> str?'
    if netutils.isValidIp(hostname):
        return hostname
    ip = netutils.getHostAddress(hostname)
    if ip and not netutils.isLocalIp(ip):
        return ip
예제 #3
0
 def fixLocalIp(self, ip):
     '''
     @deprecated: not used, doesn't work with ipv6
     '''
     if netutils.isLocalIp(ip) or (not re.match('\d+\.\d+\.\d+\.\d+', ip)):
         ip = self.client.getIpAddress()
     return ip
예제 #4
0
def getUrl(WSDLUrl, containerOSH):

    res = ObjectStateHolderVector()
    urlIP = None
    try:
        url = URL(WSDLUrl)
        hostName = url.getHost()
        urlIP = netutils.getHostAddress(hostName, None)

        if (not netutils.isValidIp(urlIP)) or netutils.isLocalIp(urlIP):
            urlIP = None
    except:
        urlIP = None
    
    urlOSH = modeling.createUrlOsh(containerOSH, WSDLUrl, 'wsdl')

    urlIpOSH = None
    if urlIP != None:
        try:
            urlIpOSH = modeling.createIpOSH(urlIP)
        except:
            urlIpOSH = None

    res.add(urlOSH)

    if urlIpOSH:
        res.add(urlIpOSH)
        urlToIpOSH = modeling.createLinkOSH('depend', urlOSH, urlIpOSH)
        res.add(urlToIpOSH)

    return res
예제 #5
0
 def __init__(self, props, nlbClusterOsh, hostOSH, framework):
     if not nlbClusterOsh:
         raise Exception(
             'NLB cluster discovery misconfigured; NLB node have to be linked to existing cluster'
         )
     self.nlbClusterOsh = nlbClusterOsh
     self.hostOSH = hostOSH
     self.priority = props['HostPriority']
     self.modeOnStart = props['ClusterModeOnStart']
     if props['DedicatedIPAddresses/']:
         self.ip = props['DedicatedIPAddresses/'].split('/')[0]
         netMask = props['DedicatedIPAddresses/'].split('/')[1]
     else:
         self.ip = props['DedicatedIPAddress']
         netMask = props['DedicatedNetworkMask']
     self.dedicatedIpOSH = None
     #check the IP
     #very unreal situation but we have to handle it
     if not netutils.isValidIp(self.ip) or netutils.isLocalIp(self.ip):
         msg = 'Dedicated IP of cluster node is local or invalid: ' + str(
             self.ip)
         logger.warn(msg)
         framework.reportWarning(
             'Dedicated IP of cluster node is local or invalid')
     else:
         self.dedicatedIpOSH = modeling.createIpOSH(self.ip, netMask)
예제 #6
0
 def fixLocalIp(self, ip):
     '''
     @deprecated: not used, doesn't work with ipv6
     '''
     if netutils.isLocalIp(ip) or (not re.match('\d+\.\d+\.\d+\.\d+', ip)):
         ip = self.client.getIpAddress()
     return ip
def DiscoveryMain(Framework):
	OSHVResult = ObjectStateHolderVector()
	
	urlString = Framework.getParameter(PARAM_URL)
	
	reportPoweredOffVms = 0
	reportPoweredOffVmsValue = Framework.getParameter(PARAM_REPORT_POWERED_OFF_VMS)
	if reportPoweredOffVmsValue and reportPoweredOffVmsValue.lower() =='true':
		reportPoweredOffVms = 1

	
	ipAddress = None
	try:
		urlObject = URL(urlString)
		hostname = urlObject.getHost()
		
		if not hostname:
			logger.debug("Hostname is not defined in URL '%s'" % urlString)
			raise MalformedURLException()
		
		ipAddress = vcloud_discover.getIpFromUrlObject(urlObject)
		if not ipAddress or not netutils.isValidIp(ipAddress) or netutils.isLocalIp(ipAddress):
			msg = "Failed to resolve the IP address of server from specified URL"
			errormessages.resolveAndReport(msg, vcloud_discover.VcloudProtocol.DISPLAY, Framework)
			return OSHVResult
		
	except MalformedURLException:
		msg = "Specified URL '%s' is malformed" % urlString
		errormessages.resolveAndReport(msg, vcloud_discover.VcloudProtocol.DISPLAY, Framework)
	except:
		msg = logger.prepareJythonStackTrace("")
		errormessages.resolveAndReport(msg, vcloud_discover.VcloudProtocol.DISPLAY, Framework)
	else:
		
		#configure how connections should be discovered/established
		connectionDiscoverer = vcloud_discover.ConnectionDiscoverer(Framework)
		urlGenerator = vcloud_discover.ConstantUrlGenerator(urlString)
		connectionDiscoverer.setUrlGenerator(urlGenerator)
		connectionDiscoverer.addIp(ipAddress)
		
		#configure how established/failed connection should be used
		connectionHandler = vcloud_discover.BaseDiscoveryConnectionHandler(Framework)
		topologyDiscoverer = vcloud_discover.createVcloudDiscoverer(Framework)
		topologyReporter = vcloud_report.createVcloudReporter(Framework, None, reportPoweredOffVms)
		connectionHandler.setDiscoverer(topologyDiscoverer)
		connectionHandler.setReporter(topologyReporter)
		
		connectionDiscoverer.setConnectionHandler(connectionHandler)
		
		connectionDiscoverer.initConnectionConfigurations()
		
		connectionDiscoverer.discover(firstSuccessful=0)
		
		if not connectionHandler.connected:
			for errorMsg in connectionHandler.connectionErrors:
				Framework.reportError(errorMsg)
			for warningMsg in connectionHandler.connectionWarnings:
				Framework.reportWarning(warningMsg)

	return OSHVResult
예제 #8
0
def getVirtualMachinesByEsx(client, esxInstance):
    '''
    CimClient -> list(VmComputerSystem)
    '''
    vmInstances = cim_discover.getAssociatorsWithTypeEnforcement(
        client, esxInstance.getObjectPath(), "VMWARE_HostedDependency",
        "VMWARE_VMComputerSystem")

    vmList = []
    for vmInstance in vmInstances:
        vm = VmComputerSystem()
        vm.setObjectPath(vmInstance.getObjectPath())
        vm.name = cim_discover.cleanString(
            _getCimInstanceProperty(vmInstance, "Name"))
        elementName = _getCimInstanceProperty(vmInstance, "ElementName")
        elementName = cim_discover.cleanString(elementName)
        # html unescape : & -> &
        elementName = cim_discover.htmlUnescape(elementName)
        # url unescape: %25 -> %
        # vmware escapes 3 characters, both slashes and %
        elementName = urllib.unquote(elementName)
        vm.elementName = elementName

        description = _getCimInstanceProperty(vmInstance, "Description")
        description = cim_discover.cleanString(description)
        vm.description = cim_discover.htmlUnescape(description)

        identifyingDescriptions = _getCimInstanceProperty(
            vmInstance, 'IdentifyingDescriptions')
        identifyingDescriptions = map(cim_discover.cleanString,
                                      identifyingDescriptions)

        otherIdentifyingInfo = _getCimInstanceProperty(vmInstance,
                                                       'OtherIdentifyingInfo')
        otherIdentifyingInfo = map(cim_discover.cleanString,
                                   otherIdentifyingInfo)

        customProperties = _dictionaryFromCrossCollections(
            identifyingDescriptions, otherIdentifyingInfo)

        vm.biosUuid = customProperties.get("BIOS UUID")
        vm.hostName = customProperties.get("Hostname")

        primaryIpAddress = customProperties.get("Primary IP Address")
        if netutils.isValidIp(
                primaryIpAddress) and not netutils.isLocalIp(primaryIpAddress):
            vm.primaryIpAddress = primaryIpAddress

        operationalStatusArray = _getCimInstanceProperty(
            vmInstance, 'OperationalStatus')
        if operationalStatusArray is not None:
            for statusValue in operationalStatusArray:
                if statusValue is not None:
                    statusValueInt = cim_discover.getIntFromCimInt(statusValue)
                    vm.operationalStatus.add(statusValueInt)

        vmList.append(vm)

    return vmList
 def _parceLsofOutput(self, output):
     results = []
     if output:
         matcher = re.compile('TCP\s+([\d\.]+)\:(\d+)\s+\(LISTEN')
         for block in re.split('\n', output):
             match = matcher.search(block)
             if match and netutils.isValidIp(match.group(1)) and not netutils.isLocalIp(match.group(1)):
                 results.append(netutils.createTcpEndpoint(match.group(1), match.group(2)))
     return results
예제 #10
0
 def parseNetworkingInformation(self, output):
     host = ibm_hmc_lib.Host()
     if output:
         potential_ips = re.findall('e[nt]+\s+([\da-fA-F:]+)\s+([\da-fA-F:]+)', output)
         for (ipAddr, mask) in potential_ips:
             if ipAddr and netutils.isValidIp(ipAddr) and not netutils.isLocalIp(ipAddr):
                 ip = ibm_hmc_lib.Ip(ipAddr, mask)
                 host.ipList.append(ip)
     return host
예제 #11
0
def createURLOSHV(urlString, framework = None):
    OSHVResult = ObjectStateHolderVector()    
    
    #urlOSH2 = modeling.createOshByCmdbIdString('uri_endpoint', urlId)       
    logger.debug("Starting URL discovery on '%s'" % urlString)
    #urlString = urlString[1:len(urlString)-1]
    if not urlString:
        return OSHVResult
    
    try:
    
        urlString = str(urlString).replace("\\", "//")
        
        urlObject = URL(urlString)
        hostname = urlObject.getHost()
    
        if not hostname:
            raise MalformedURLException("Hostname is not defined in URL '%s'" % urlString)
    
        urlObjectResolver = URLObjectResolver(urlObject)
        protocol = urlObjectResolver.getProtocolFromUrlObject()
        
        if not protocol:
            raise Exception("Failed to resolve the http/https protocol from specified URL")
    
        port = urlObjectResolver.getPortFromUrlObject()
        
        if not port:
            raise Exception("Failed to resolve the port number from specified URL")
    
        # get topology
        # create business element CI and attach the url as configuration document CI to it 
    
        ips = urlObjectResolver.getIpFromUrlObject()
        
        for ipAddress in ips:
            logger.debug('%s: Reporting ip address: %s' % (urlString, ipAddress))
            if not ipAddress or not netutils.isValidIp(ipAddress) or netutils.isLocalIp(ipAddress):
                raise Exception("Failed to resolve the IP address of server from specified URL")
    
            
            hostOSH, ipOSH, OSHVResult2 = createIPEndpointOSHV(framework, ipAddress, port, protocol, hostname)     
            OSHVResult.addAll(OSHVResult2)
            # create UriEndpoint and relations between business element and UriEndpoint
            urlOSH = modeling.createUrlOsh(hostOSH, urlString, None)
            #urlOSH.setCmdbObjectId(urlOSH2.getCmdbObjectId())            
            OSHVResult.add(urlOSH)
            OSHVResult.add(modeling.createLinkOSH('dependency', urlOSH, ipOSH)) 
           
                        
            #create Web Server
    except:
        logger.warnException("Error creating URL OSH for %s" % urlString)


    return OSHVResult
예제 #12
0
def parseNslookupOutput(nslookupOutput, hostname):
    if re.search(r"Non-existent host", nslookupOutput): return None
    pattern = "Name:[^\n]+\s*\nAddress:\s*(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"
    matcher = re.search(pattern, nslookupOutput, re.I)
    if matcher:
        resolvedIp = matcher.group(1)
        if resolvedIp is not None:
            resolvedIp = resolvedIp.strip()
            if netutils.isValidIp(resolvedIp) and not netutils.isLocalIp(resolvedIp):
                return resolvedIp
    def _resolveHostNameWithCaching(self, hostName):
        # TODO: use external resolver
        ip = None
        if self.__resolveCache.has_key(hostName):
            ip = self.__resolveCache.get(hostName)
        else:
            ip = netutils.getHostAddress(hostName)
            self.__resolveCache[hostName] = ip

        if ip and netutils.isValidIp(ip) and not netutils.isLocalIp(ip):
            return ip
    def _resolveHostNameWithCaching(self, hostName):
        # TODO: use external resolver
        ip = None
        if self.__resolveCache.has_key(hostName):
            ip = self.__resolveCache.get(hostName)
        else:
            ip = netutils.getHostAddress(hostName)
            self.__resolveCache[hostName] = ip

        if ip and netutils.isValidIp(ip) and not netutils.isLocalIp(ip):
            return ip
예제 #15
0
 def parseNetworkingInformation(self, output):
     host = ibm_hmc_lib.Host()
     if output:
         potential_ips = re.findall(
             'e[nt]+\s+([\da-fA-F:]+)\s+([\da-fA-F:]+)', output)
         for (ipAddr, mask) in potential_ips:
             if ipAddr and netutils.isValidIp(
                     ipAddr) and not netutils.isLocalIp(ipAddr):
                 ip = ibm_hmc_lib.Ip(ipAddr, mask)
                 host.ipList.append(ip)
     return host
예제 #16
0
    def parseNetworkingInformation(self, buffer):
        """
        This function performs parsing of the 'lshmc -n' command output
        @param buffer: string buffer of the command output 
        @return: host and ip information
        @rtype: instance of HostDo object
        """
        host = ibm_hmc_lib.Host()
        if buffer:
            propertiesDict = self.buildPropertiesDict(buffer)
            host.hostname = propertiesDict.get('hostname')
            host.domainName = propertiesDict.get('domain')
            for (key, value) in propertiesDict.items():
                if key.startswith('ipv4addr_eth'):
                    if value and netutils.isValidIp(
                            value) and not netutils.isLocalIp(value):
                        ip = ibm_hmc_lib.Ip(
                            value,
                            propertiesDict.get(key.replace('addr', 'netmask')))
                        host.ipList.append(ip)

            if not host.ipList:  #another version of HMC outputs, for the minor HMC version change
                ipStr = propertiesDict.get('ipaddr')
                netMaskStr = propertiesDict.get('networkmask')
                if ipStr and netMaskStr:
                    ipList = ipStr.split(',')
                    netMaskList = netMaskStr.split(',')
                    for i in range(len(ipList)):
                        ipAddr = ipList[i].strip()
                        netMask = netMaskList[i].strip()
                        if ipAddr and netutils.isValidIp(
                                ipAddr) and not netutils.isLocalIp(ipAddr):
                            ip = ibm_hmc_lib.Ip(ipAddr, netMask)
                            host.ipList.append(ip)

            if not host.ipList:
                raise ValueError(
                    "Failed parsing HMC host IP addresses from  %s " % buffer)
        return host
예제 #17
0
 def _parceLsofOutput(self, output):
     results = []
     if output:
         matcher = re.compile('TCP\s+([\d\.]+)\:(\d+)\s+\(LISTEN')
         for block in re.split('\n', output):
             match = matcher.search(block)
             if match and netutils.isValidIp(
                     match.group(1)) and not netutils.isLocalIp(
                         match.group(1)):
                 results.append(
                     netutils.createTcpEndpoint(match.group(1),
                                                match.group(2)))
     return results
 def discoverIpAddressFromLogFile(self, filePath):
     '''
         Discovers assigned ip and subnets from log file
         @param filePath: string - path to log file
         @returns: list of strings - list of ips
     '''
     result = []
     ipStrList = self._getEntriesFromLogFile(filePath, 'Adding IP', 'Adding\s+IP\s+address\s([\d\.]+)')
     if ipStrList:
         for ipStr in ipStrList:
             if ipStr and netutils.isValidIp(ipStr) and not netutils.isLocalIp(ipStr):
                 dnsName = netutils.resolveFQDN(self._shell, ipStr)
                 result.append(Ip(ipStr, dnsName))
     return result
예제 #19
0
def getVirtualMachinesByEsx(client, esxInstance):
    '''
    CimClient -> list(VmComputerSystem)
    '''
    vmInstances = cim_discover.getAssociatorsWithTypeEnforcement(client, esxInstance.getObjectPath(), "VMWARE_HostedDependency", "VMWARE_VMComputerSystem")
    
    vmList = []
    for vmInstance in vmInstances:
        vm = VmComputerSystem()
        vm.setObjectPath(vmInstance.getObjectPath())
        vm.name = cim_discover.cleanString(_getCimInstanceProperty(vmInstance, "Name"))
        elementName = _getCimInstanceProperty(vmInstance, "ElementName")
        elementName = cim_discover.cleanString(elementName)
        # html unescape : & -> &
        elementName = cim_discover.htmlUnescape(elementName)
        # url unescape: %25 -> %
        # vmware escapes 3 characters, both slashes and %
        elementName = urllib.unquote(elementName)
        vm.elementName = elementName
        
        description = _getCimInstanceProperty(vmInstance, "Description")
        description = cim_discover.cleanString(description)
        vm.description = cim_discover.htmlUnescape(description)
        
        identifyingDescriptions = _getCimInstanceProperty(vmInstance, 'IdentifyingDescriptions')
        identifyingDescriptions = map(cim_discover.cleanString, identifyingDescriptions)
        
        otherIdentifyingInfo = _getCimInstanceProperty(vmInstance, 'OtherIdentifyingInfo')
        otherIdentifyingInfo = map(cim_discover.cleanString, otherIdentifyingInfo)
        
        customProperties = _dictionaryFromCrossCollections(identifyingDescriptions, otherIdentifyingInfo)
        
        vm.biosUuid = customProperties.get("BIOS UUID")
        vm.hostName = customProperties.get("Hostname")
        
        primaryIpAddress = customProperties.get("Primary IP Address")
        if netutils.isValidIp(primaryIpAddress) and not netutils.isLocalIp(primaryIpAddress):
            vm.primaryIpAddress = primaryIpAddress
        
        operationalStatusArray = _getCimInstanceProperty(vmInstance, 'OperationalStatus')
        if operationalStatusArray is not None:
            for statusValue in operationalStatusArray:
                if statusValue is not None:
                    statusValueInt = cim_discover.getIntFromCimInt(statusValue)
                    vm.operationalStatus.add(statusValueInt)
        
        vmList.append(vm)
    
    return vmList
예제 #20
0
def getIpFromUrlString(urlString):
    try:
        urlObject = URL(urlString)
        hostname = urlObject.getHost()
        if not hostname:
            logger.debug("Hostname is not defined in URL '%s'" % urlString)
            raise MalformedURLException()
        
        ipAddress = getIpFromUrlObject(urlObject)
        if not ipAddress or not netutils.isValidIp(ipAddress) or netutils.isLocalIp(ipAddress):
            raise ValueError("Failed determining the IP address of server")
        
        return ipAddress
    except:
        logger.warnException("Invalid URL")
 def _parsePFilesOutput(self, output):
     results = []
     if output:
         matcher = re.compile('localaddr/port\s+=\s+([\w\.]+)\s*/\s*(\d+).*listening')
         for block in re.split('S_ISSOCK', output):
             match = matcher.search(block)
             ip = None
             if match:
                 if not netutils.isValidIp(match.group(1)):
                     ip = netutils.resolveIP(self._shell, match.group(1))
                 else:
                     ip = match.group(1)
                 if not netutils.isLocalIp(ip):
                     results.append(netutils.createTcpEndpoint(ip, match.group(2)))
     return results
예제 #22
0
    def __init__(self, props, config, hostOSH, framework, connectedIp):
        self.nlbClusterOSH = None
        self.hostOSH = hostOSH
        self.props = props
        self.config = config

        self.ip = props['ClusterIPAddress']
        if connectedIp == self.ip:
            raise ConnectedToClusterIpException()
        netMask = props['ClusterNetworkMask']
        #check the IP; if cluster IP is invalid no cluster will be reported
        if not netutils.isValidIp(self.ip) or netutils.isLocalIp(self.ip):
            msg = 'Cluster IP is local or invalid: %s' % str(self.ip)
            raise InvalidIpException(self.ip)

        self.clusterIpOSH = modeling.createIpOSH(self.ip, netMask)
예제 #23
0
 def discoverIpAddressFromLogFile(self, filePath):
     '''
         Discovers assigned ip and subnets from log file
         @param filePath: string - path to log file
         @returns: list of strings - list of ips
     '''
     result = []
     ipStrList = self._getEntriesFromLogFile(
         filePath, 'Adding IP', 'Adding\s+IP\s+address\s([\d\.]+)')
     if ipStrList:
         for ipStr in ipStrList:
             if ipStr and netutils.isValidIp(
                     ipStr) and not netutils.isLocalIp(ipStr):
                 dnsName = netutils.resolveFQDN(self._shell, ipStr)
                 result.append(Ip(ipStr, dnsName))
     return result
예제 #24
0
파일: db.py 프로젝트: ddonnelly19/dd-git
    def reportDatabaseServerFromAddress(self, dbServer):
        r""" Reports database server (running application) and related topology
        where container is built from server address as incomplete host by IP address

        @types: db.DatabaseServer -> ObjectStateHolderVector
        @raise ValueError: Address for the specified server is not valid or is local
        @raise ValueError: Server to report is not specified
        """
        if not dbServer:
            raise ValueError("Server to report is not specified")
        address = dbServer.address
        if not (address and netutils.isValidIp(address) and not netutils.isLocalIp(address)):
            msg = "Address for the specified server is not valid or is local"
            raise ValueError(msg)
        hostOsh = modeling.createHostOSH(dbServer.address)
        return self.reportServerAndDatabases(dbServer, hostOsh)
예제 #25
0
    def __init__(self, props, config, hostOSH, framework, connectedIp):
        self.nlbClusterOSH = None
        self.hostOSH = hostOSH
        self.props = props
        self.config = config

        self.ip = props['ClusterIPAddress']
        if connectedIp == self.ip:
            raise ConnectedToClusterIpException()
        netMask = props['ClusterNetworkMask']
        #check the IP; if cluster IP is invalid no cluster will be reported
        if not netutils.isValidIp(self.ip) or netutils.isLocalIp(self.ip):
            msg = 'Cluster IP is local or invalid: %s' % str(self.ip)
            raise InvalidIpException(self.ip)

        self.clusterIpOSH = modeling.createIpOSH(self.ip, netMask)
예제 #26
0
 def _parsePFilesOutput(self, output):
     results = []
     if output:
         matcher = re.compile(
             'localaddr/port\s+=\s+([\w\.]+)\s*/\s*(\d+).*listening')
         for block in re.split('S_ISSOCK', output):
             match = matcher.search(block)
             ip = None
             if match:
                 if not netutils.isValidIp(match.group(1)):
                     ip = netutils.resolveIP(self._shell, match.group(1))
                 else:
                     ip = match.group(1)
                 if not netutils.isLocalIp(ip):
                     results.append(
                         netutils.createTcpEndpoint(ip, match.group(2)))
     return results
예제 #27
0
 def resolveIpsByHostname(self, hostname):
     ''' Process cases with loopback address (local IP)
     - when hostname is 'localhost' destination Ip address will be returned
     - resolved local IP address will be replaced by destination IP
     @types: str -> list[str]
     @raise ResolveException: Failed to resolve IP
     '''
     if hostname == 'localhost':
         return [self.__destinationIpAddress]
     ips = self.__dnsResolver.resolveIpsByHostname(hostname)
     isNotLocalIp = lambda ip: not netutils.isLocalIp(ip)
     nonLocalIps = filter(isNotLocalIp, ips)
     if len(nonLocalIps) < len(ips):
         # seems like we have local IPs
         nonLocalIps.append(self.__destinationIpAddress)
         ips = nonLocalIps
     return ips
예제 #28
0
 def resolveIpsByHostname(self, hostname):
     ''' Process cases with loopback address (local IP)
     - when hostname is 'localhost' destination Ip address will be returned
     - resolved local IP address will be replaced by destination IP
     @types: str -> list[str]
     @raise ResolveException: Failed to resolve IP
     '''
     if hostname == 'localhost':
         return [self.__destinationIpAddress]
     ips = self.__dnsResolver.resolveIpsByHostname(hostname)
     isNotLocalIp = lambda ip: not netutils.isLocalIp(ip)
     nonLocalIps = filter(isNotLocalIp, ips)
     if len(nonLocalIps) < len(ips):
         # seems like we have local IPs
         nonLocalIps.append(self.__destinationIpAddress)
         ips = nonLocalIps
     return ips
예제 #29
0
 def parseNetworkingInformation(self, buffer):
     """
     This function performs parsing of the 'lshmc -n' command output for HMC 3.7 version
     @param buffer: string buffer of the command output 
     @return: host and ip information
     @rtype: instance of HostDo object
     """
     host = ibm_hmc_lib.Host()
     if buffer:
         propertiesDict = self.buildPropertiesDict(buffer, '\n', ':')
         host.hostname = propertiesDict.get('Host Name')
         host.domainName = propertiesDict.get('Domain Name')
         for (key, value) in propertiesDict.items():
             if re.match('TCP/IP Interface \d+ Address', key):
                 if value and netutils.isValidIp(value) and not netutils.isLocalIp(value):
                     ip = ibm_hmc_lib.Ip(value, propertiesDict.get(key.replace('Address', 'Network Mask')))
                     host.ipList.append(ip)
     return host
예제 #30
0
 def _findHostKeyAndIps(self):
     if self.networkConnectionSection is not None:
         macs = []
         connections = self.networkConnectionSection.getNetworkConnection()
         for connection in connections:
             isConnected = connection.isIsConnected()
             if isConnected:
                 rawMac = connection.getMACAddress()
                 if netutils.isValidMac(rawMac):
                     mac = netutils.parseMac(rawMac)
                     macs.append(mac)
                 
                 ip = connection.getIpAddress()
                 if ip is not None and netutils.isValidIp(ip) and not netutils.isLocalIp(ip):
                     self._ips.append(ip)
         
         self._validMacs = macs
         macs.sort()
         if macs:
             self._hostKey = macs[0]
예제 #31
0
    def _findHostKeyAndIps(self):
        if self.networkConnectionSection is not None:
            macs = []
            connections = self.networkConnectionSection.getNetworkConnection()
            for connection in connections:
                isConnected = connection.isIsConnected()
                if isConnected:
                    rawMac = connection.getMACAddress()
                    if netutils.isValidMac(rawMac):
                        mac = netutils.parseMac(rawMac)
                        macs.append(mac)

                    ip = connection.getIpAddress()
                    if ip is not None and netutils.isValidIp(
                            ip) and not netutils.isLocalIp(ip):
                        self._ips.append(ip)

            self._validMacs = macs
            macs.sort()
            if macs:
                self._hostKey = macs[0]
예제 #32
0
 def __init__(self, props, nlbClusterOsh, hostOSH, framework):
     if not nlbClusterOsh:
         raise Exception('NLB cluster discovery misconfigured; NLB node have to be linked to existing cluster')
     self.nlbClusterOsh = nlbClusterOsh
     self.hostOSH = hostOSH
     self.priority = props['HostPriority']
     self.modeOnStart = props['ClusterModeOnStart']
     if props['DedicatedIPAddresses/']:
         self.ip = props['DedicatedIPAddresses/'].split('/')[0]
         netMask = props['DedicatedIPAddresses/'].split('/')[1]
     else:
         self.ip = props['DedicatedIPAddress']
         netMask = props['DedicatedNetworkMask']
     self.dedicatedIpOSH = None
     #check the IP
     #very unreal situation but we have to handle it
     if not netutils.isValidIp(self.ip) or netutils.isLocalIp(self.ip):
         msg = 'Dedicated IP of cluster node is local or invalid: ' + str(self.ip)
         logger.warn(msg)
         framework.reportWarning('Dedicated IP of cluster node is local or invalid')
     else:
         self.dedicatedIpOSH = modeling.createIpOSH(self.ip, netMask)
예제 #33
0
 def parseNetworkingInformation(self, buffer):
     """
     This function performs parsing of the 'lshmc -n' command output for HMC 3.7 version
     @param buffer: string buffer of the command output 
     @return: host and ip information
     @rtype: instance of HostDo object
     """
     host = ibm_hmc_lib.Host()
     if buffer:
         propertiesDict = self.buildPropertiesDict(buffer, '\n', ':')
         host.hostname = propertiesDict.get('Host Name')
         host.domainName = propertiesDict.get('Domain Name')
         for (key, value) in propertiesDict.items():
             if re.match('TCP/IP Interface \d+ Address', key):
                 if value and netutils.isValidIp(
                         value) and not netutils.isLocalIp(value):
                     ip = ibm_hmc_lib.Ip(
                         value,
                         propertiesDict.get(
                             key.replace('Address', 'Network Mask')))
                     host.ipList.append(ip)
     return host
예제 #34
0
    def parseNetworking(self, output):
        """
        This function performs parsing of the 'lsnetcfg -n' command output
        @param output: string buffer of the command output 
        @return: host and ip information
        @rtype: instance of HostDo object
        """
        hostDo = ibm_fsm.Host()
        m = re.search('hostname:\s+([\w\-\.]+)', output)
        hostDo.hostname = m and m.group(1)
        
        m = re.search('domain:\s+([\w\-\.]+)', output)
        hostDo.domain_name = m and m.group(1)
        
        m = re.search('gateway:\s+([\w\-\.]+)', output)
        hostDo.gateway = m and m.group(1)
        
        m = re.search('nameserver:\s+"*([\w\-\.]+)"*', output)
        hostDo.dns_servers = m and m.group(1).split(',')
        
        m = re.search('ipaddr:\s+"*([\d\-\.\,]+)"*', output)
        ips = m and m.group(1).split(',')
        
        m = re.search('networkmask:\s+"*([\d\-\.\,]+)"*', output)
        masks = m and m.group(1).split(',')
        
        for i in xrange(len(ips)):        
            if ips[i] and netutils.isValidIp(ips[i]) and not netutils.isLocalIp(ips[i]):
                ip = ibm_fsm.Ip(ips[i], masks[i])
                hostDo.ipList.append(ip)

        if not ips:
            logger.warn('Failed to get IP of the FSM')
 
            
        hostDo.networking = self.parseInterfaces(output)
        return hostDo
예제 #35
0
    def parseNetworking(self, output):
        """
        This function performs parsing of the 'lsnetcfg -n' command output
        @param output: string buffer of the command output 
        @return: host and ip information
        @rtype: instance of HostDo object
        """
        hostDo = ibm_fsm.Host()
        m = re.search('hostname:\s+([\w\-\.]+)', output)
        hostDo.hostname = m and m.group(1)

        m = re.search('domain:\s+([\w\-\.]+)', output)
        hostDo.domain_name = m and m.group(1)

        m = re.search('gateway:\s+([\w\-\.]+)', output)
        hostDo.gateway = m and m.group(1)

        m = re.search('nameserver:\s+"*([\w\-\.]+)"*', output)
        hostDo.dns_servers = m and m.group(1).split(',')

        m = re.search('ipaddr:\s+"*([\d\-\.\,]+)"*', output)
        ips = m and m.group(1).split(',')

        m = re.search('networkmask:\s+"*([\d\-\.\,]+)"*', output)
        masks = m and m.group(1).split(',')

        for i in xrange(len(ips)):
            if ips[i] and netutils.isValidIp(
                    ips[i]) and not netutils.isLocalIp(ips[i]):
                ip = ibm_fsm.Ip(ips[i], masks[i])
                hostDo.ipList.append(ip)

        if not ips:
            logger.warn('Failed to get IP of the FSM')

        hostDo.networking = self.parseInterfaces(output)
        return hostDo
예제 #36
0
    def __discoverInterfacesInfo(self):
        ips = {}
        masks = {}
        interfacesDict = {}
        interfacesList = []

        # Separate out the entries from the network information class entries
        for entry in self.__ipInfo:
            interfaceDescr = entry.interfaceDescr
            interfacesDict[interfaceDescr] = entry.interfaceName
            ip = entry.ip
            mask = entry.mask
            if netutils.isValidIp(ip) and not netutils.isLocalIp(ip):
                inIPs = ips.get(interfaceDescr, [])
                if not inIPs:
                    ips[interfaceDescr] = inIPs
                inIPs.append(ip)
                
                inMasks = masks.get(interfaceDescr, [])
                if not inMasks:
                    masks[interfaceDescr] = inMasks 
                inMasks.append(mask)

        maclist = self.__getMACsData()
        if maclist == None:
            logger.warn('Invalid MAC info, skipping.')
        else:
            for interfaceDesc in maclist.keys():
                mac = maclist.get(interfaceDesc)
                if netutils.isValidMac(mac):
                    logger.debug("Interface: %s, MAC: %s" % (interfaceDesc, mac))
                    mac = netutils.parseMac(mac)
                    interface = NetworkInterface(interfaceDesc, mac, ips.get(interfaceDesc), masks.get(interfaceDesc), -1, 0)
                    interface.name = interfacesDict.get(interfaceDescr) or None;
                    interfacesList.append(interface)
        return interfacesList
예제 #37
0
def hostnamelookup(shell, namesToResolve,  Framework):
    filename = '/etc/hosts'
    cmdResult = None
    nodeDictionary = {}
    try:
        #rawCmdResult = simulatecmd('c:/etchosts.txt')
        rawCmdResult = shell.safecat(filename)
        cmdResult = rawCmdResult.strip()
    except:
        msg = "Failed reading /etc/host file."
        errobj = errorobject.createError(errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg)
        logger.reportWarningObject(errobj)
        logger.debug(msg)
        return nodeDictionary
    keywords = ['Permission\s*Denied', 'Cannot Open']
    for keyword in keywords:
        if re.search(keyword,cmdResult,re.I):
            msg = "Permission failure."
            errobj = errorobject.createError(errorcodes.PERMISSION_DENIED, None, msg)
            logger.reportErrorObject(errobj)
            logger.debug(msg)
            return nodeDictionary
    if (re.search('\r\n', cmdResult)):
        cmdResult = cmdResult.split('\r\n')
    elif (re.search('\n', cmdResult)):
        cmdResult = cmdResult.split('\n')

    ## Only parse the node names at first, for resolution before
    ## trying to map the actual interface content
    for line in cmdResult:
        try:
            line = line.strip()
            ## Parse out headers and blank lines
            if not line or re.match('#', line):
                continue
            Address = None
            ## Remove trailing comments
            if (re.search('#', line)):
                tmp = line.split('#', 1)
                line = tmp[0]
            tmp = line.split()

            # IP Address will be the first entry
            # Names will follow corresponding to the  IP.
            # We will validate the IP then search for the name to match
            # If we find it then we will add it into our node dictionary
            # Alphanumeric representation of the host:
            #    hostname, FQDN, alias....
            # Most objects will only have two names
            # The order (of FQDN, short name, aliases) is not
            #necessarily standard across platforms/versions
            if len(tmp) > 1:
                Address = tmp[0]
                tmp = tmp[1:]
            if not Address or not netutils.isValidIp(Address) or netutils.isLocalIp(Address):
                continue
            for entry in tmp:
                if entry in namesToResolve:
                    logger.debug ('Name to resolve  ',entry,' Address = ', Address)
                    if nodeDictionary.has_key(entry):
                        logger.debug(concatenate('   From /etc/host output:  Node ', entry, ' already has an address; ignoring ' , Address))
                    else:
                        nodeDictionary[entry] = Address
                        logger.debug(concatenate('   From /etc/host output:  Adding ', entry, ' to the list with address: ', Address))
        except:
            msg = "Failed to parse etc/host file."
            errobj = errorobject.createError(errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg)
            logger.reportWarningObject(errobj)
            logger.debug(msg)

    return nodeDictionary
예제 #38
0
def hostnamelookup(shell, namesToResolve, Framework):
    filename = '/etc/hosts'
    cmdResult = None
    nodeDictionary = {}
    try:
        #rawCmdResult = simulatecmd('c:/etchosts.txt')
        rawCmdResult = shell.safecat(filename)
        cmdResult = rawCmdResult.strip()
    except:
        msg = "Failed reading /etc/host file."
        errobj = errorobject.createError(
            errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg)
        logger.reportWarningObject(errobj)
        logger.debug(msg)
        return nodeDictionary
    keywords = ['Permission\s*Denied', 'Cannot Open']
    for keyword in keywords:
        if re.search(keyword, cmdResult, re.I):
            msg = "Permission failure."
            errobj = errorobject.createError(errorcodes.PERMISSION_DENIED,
                                             None, msg)
            logger.reportErrorObject(errobj)
            logger.debug(msg)
            return nodeDictionary
    if (re.search('\r\n', cmdResult)):
        cmdResult = cmdResult.split('\r\n')
    elif (re.search('\n', cmdResult)):
        cmdResult = cmdResult.split('\n')

    ## Only parse the node names at first, for resolution before
    ## trying to map the actual interface content
    for line in cmdResult:
        try:
            line = line.strip()
            ## Parse out headers and blank lines
            if not line or re.match('#', line):
                continue
            Address = None
            ## Remove trailing comments
            if (re.search('#', line)):
                tmp = line.split('#', 1)
                line = tmp[0]
            tmp = line.split()

            # IP Address will be the first entry
            # Names will follow corresponding to the  IP.
            # We will validate the IP then search for the name to match
            # If we find it then we will add it into our node dictionary
            # Alphanumeric representation of the host:
            #    hostname, FQDN, alias....
            # Most objects will only have two names
            # The order (of FQDN, short name, aliases) is not
            #necessarily standard across platforms/versions
            if len(tmp) > 1:
                Address = tmp[0]
                tmp = tmp[1:]
            if not Address or not netutils.isValidIp(
                    Address) or netutils.isLocalIp(Address):
                continue
            for entry in tmp:
                if entry in namesToResolve:
                    logger.debug('Name to resolve  ', entry, ' Address = ',
                                 Address)
                    if nodeDictionary.has_key(entry):
                        logger.debug(
                            concatenate('   From /etc/host output:  Node ',
                                        entry,
                                        ' already has an address; ignoring ',
                                        Address))
                    else:
                        nodeDictionary[entry] = Address
                        logger.debug(
                            concatenate('   From /etc/host output:  Adding ',
                                        entry, ' to the list with address: ',
                                        Address))
        except:
            msg = "Failed to parse etc/host file."
            errobj = errorobject.createError(
                errorcodes.COMMAND_OUTPUT_VERIFICATION_FAILED, None, msg)
            logger.reportWarningObject(errobj)
            logger.debug(msg)

    return nodeDictionary
예제 #39
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()

    DISCOVERED_IP = Framework.getDestinationAttribute('ip_address')
    DISCOVERED_IP_ID = Framework.getDestinationAttribute('ip_id')
    #    ip = modeling.createOshByCmdbIdString('ip_address', DISCOVERED_IP_ID)
    ucmdbVersion = modeling.CmdbClassModel().version()
    if ucmdbVersion >= 9:
        ipClass = 'ip_address'
    else:
        ipClass = 'ip'

    protocols = Framework.getAvailableProtocols(
        DISCOVERED_IP, ClientsConsts.SNMP_PROTOCOL_NAME)

    if protocols.__len__() == 0:
        errStr = 'No credentials defined for the triggered ip'
        logger.debug(errStr)
        Framework.reportWarning(errStr)
    else:
        for protocol in protocols:
            sysplexNameList = None
            lparIpList = None

            snmpOSH = modeling.createSnmpOSH(DISCOVERED_IP, None)

            client = None
            try:
                client = Framework.createClient(protocol)
                logger.debug('got snmp agent for: ', DISCOVERED_IP)
                isMultiOid = client.supportMultiOid()

                sysplexNameList = client.executeQuery(
                    '1.3.6.1.4.1.2.6.19.2.2.2.41,1.3.6.1.4.1.2.6.19.2.2.2.41,string,1.3.6.1.4.1.2.6.19.2.2.2.40,string'
                )  #@@CMD_PERMISION snmp protocol execution
                sysplexNameList = sysplexNameList.asTable()

                lparIpList = client.executeQuery(
                    '1.3.6.1.2.1.4.20.1.1,1.3.6.1.2.1.4.20.1.2,string'
                )  #@@CMD_PERMISION snmp protocol execution
                lparIpList = lparIpList.asTable()

                mainframeMacList = client.executeQuery(
                    '1.3.6.1.2.1.2.2.1.6,1.3.6.1.2.1.2.2.1.7,hexa'
                )  #@@CMD_PERMISION snmp protocol execution
                mainframeMacList = mainframeMacList.asTable()
                snmpOSH.setAttribute('application_port', client.getPort())

                snmpOSH.setAttribute('application_timeout',
                                     client.getTimeout())
                snmpOSH.setAttribute('snmp_port', client.getPort())
                snmpOSH.setAttribute('credentials_id',
                                     client.getCredentialId())
                snmpOSH.setAttribute('snmp_retry', client.getRetries())
                snmpOSH.setAttribute('snmp_timeout', client.getTimeout())
                if isMultiOid == 1:
                    snmpOSH.setBoolAttribute('snmp_supportmultioid', 1)
                else:
                    snmpOSH.setBoolAttribute('snmp_supportmultioid', 0)
            except:
                logger.debugException('Unexpected SNMP_AGENT Exception:')
                continue

            if client != None:
                client.close()

            mainframeKey = getMainframeKey(mainframeMacList)
            if mainframeKey:
                mainframeOSH = modeling.createCompleteHostOSH(
                    'mainframe', mainframeKey, machineName=mainframeKey)
                modeling.setHostOsFamily(mainframeOSH, 'mainframe')
                OSHVResult.add(mainframeOSH)

                for currSysplex in sysplexNameList:
                    if logger.isDebugEnabled():
                        logger.debug('SYSPLEX : ', currSysplex[1])
                        logger.debug('LPAR : ', currSysplex[2])
                        logger.debug('MainframeKEY : ', mainframeKey)

                    lparKey = mainframeKey + ':' + currSysplex[2]
                    lparOSH = modeling.createCompleteHostOSH(
                        'lpar', lparKey, machineName=currSysplex[2])
                    OSHVResult.add(lparOSH)

                    snmpOSH.setContainer(lparOSH)
                    OSHVResult.add(snmpOSH)

                    # Create contained link between discovered IP and lpar
                    OSHVResult.add(
                        modeling.createLinkOSH(
                            'contained', lparOSH,
                            modeling.createOshByCmdbIdString(
                                ipClass, DISCOVERED_IP_ID)))

                    # Create member link between lpar and Mainframe
                    OSHVResult.add(
                        modeling.createLinkOSH('member', mainframeOSH,
                                               lparOSH))

                    # Create sysplex
                    sysplexOSH = ObjectStateHolder('sysplex')
                    sysplexOSH.setAttribute('data_name', currSysplex[1])
                    OSHVResult.add(sysplexOSH)

                    # Create member link between lpar and sysplex
                    OSHVResult.add(
                        modeling.createLinkOSH('member', sysplexOSH, lparOSH))

                    # Create member link between mainframe and sysplex
                    OSHVResult.add(
                        modeling.createLinkOSH('member', mainframeOSH,
                                               sysplexOSH))

                    # connect all ips to lpar
                    for currLparIp in lparIpList:
                        if netutils.isLocalIp(currLparIp[1]):
                            continue

                        currIpOSH = modeling.createIpOSH(currLparIp[1])
                        OSHVResult.add(currIpOSH)
                        OSHVResult.add(
                            modeling.createLinkOSH('contained', lparOSH,
                                                   currIpOSH))
                break
            else:
                logger.debug("Failed to get Mainframe key.")
        else:
            errormessages.resolveAndReport(
                "Could not perform snmp connection to %s" % DISCOVERED_IP,
                ClientsConsts.SNMP_PROTOCOL_NAME, Framework)

    return OSHVResult
예제 #40
0
def createURLOSHV(urlString, framework=None):
    OSHVResult = ObjectStateHolderVector()

    #urlOSH2 = modeling.createOshByCmdbIdString('uri_endpoint', urlId)
    logger.debug("Starting URL discovery on '%s'" % urlString)
    #urlString = urlString[1:len(urlString)-1]
    if not urlString:
        return OSHVResult

    try:

        urlString = str(urlString).replace("\\", "//")

        urlObject = URL(urlString)
        hostname = urlObject.getHost()

        if not hostname:
            raise MalformedURLException("Hostname is not defined in URL '%s'" %
                                        urlString)

        urlObjectResolver = URLObjectResolver(urlObject)
        protocol = urlObjectResolver.getProtocolFromUrlObject()

        if not protocol:
            raise Exception(
                "Failed to resolve the http/https protocol from specified URL")

        port = urlObjectResolver.getPortFromUrlObject()

        if not port:
            raise Exception(
                "Failed to resolve the port number from specified URL")

        # get topology
        # create business element CI and attach the url as configuration document CI to it

        ips = urlObjectResolver.getIpFromUrlObject()

        for ipAddress in ips:
            logger.debug('%s: Reporting ip address: %s' %
                         (urlString, ipAddress))
            if not ipAddress or not netutils.isValidIp(
                    ipAddress) or netutils.isLocalIp(ipAddress):
                raise Exception(
                    "Failed to resolve the IP address of server from specified URL"
                )

            hostOSH, ipOSH, OSHVResult2 = createIPEndpointOSHV(
                framework, ipAddress, port, protocol, hostname)
            OSHVResult.addAll(OSHVResult2)
            # create UriEndpoint and relations between business element and UriEndpoint
            urlOSH = modeling.createUrlOsh(hostOSH, urlString, None)
            #urlOSH.setCmdbObjectId(urlOSH2.getCmdbObjectId())
            OSHVResult.add(urlOSH)
            OSHVResult.add(modeling.createLinkOSH('dependency', urlOSH, ipOSH))

            #create Web Server
    except:
        logger.warnException("Error creating URL OSH for %s" % urlString)

    return OSHVResult
예제 #41
0
def DiscoveryMain(Framework):

    OSHVResult = ObjectStateHolderVector()
    ms_domain_name = Framework.getDestinationAttribute('ms_domain_name')
    if not ms_domain_name:
        ms_domain_name = 'NULL'

    try:
        netUtil = MsNetworkUtil()
        hostsOutput = netUtil.doNetServerEnum('NULL', SV_TYPE_SERVER,
                                              ms_domain_name)
        if hostsOutput != None:
            discoverUnknownIPs = 1
            try:
                strDiscoverUnknownIPs = Framework.getParameter(
                    'discoverUnknownIPs')
                discoverUnknownIPs = Boolean.parseBoolean(
                    strDiscoverUnknownIPs)
            except:
                pass

            oshMsDomain = ObjectStateHolder('msdomain')
            oshMsDomain.setStringAttribute('data_name', ms_domain_name)
            alreadyDiscoveredIps = HashMap()
            for hostInfo in hostsOutput:
                hostType = Long(hostInfo[1]).longValue()
                hostName = (str(hostInfo[0])).lower()
                try:
                    ip = InetAddress.getByName(hostInfo[0]).getHostAddress()
                    if netutils.isLocalIp(ip):
                        continue
                    cachedHostName = alreadyDiscoveredIps.get(ip)
                    if cachedHostName != None:
                        logger.debug(
                            'IP ', ip,
                            ' already reported for host ' + cachedHostName,
                            ' current host ', hostName, ' - skipping')
                        continue
                    else:
                        logger.debug('Discovered IP ' + ip + ' for host ' +
                                     hostName)
                        alreadyDiscoveredIps.put(ip, hostName)
                    ipDomain = DomainScopeManager.getDomainByIp(ip)
                    if not discoverUnknownIPs and ipDomain == 'unknown':
                        logger.debug(
                            'ip: ' + ip +
                            ' is out of probe range and will be excluded')
                        continue
                    if SV_TYPE_CLUSTER_NT & hostType:
                        logger.debug(
                            'Not reporting the entry %s because it is a Cluster'
                            % hostName)
                        continue
                    hostOsType = 'nt'
                    if SV_TYPE_SERVER_UNIX & hostType:
                        hostOsType = 'unix'
                    oshHost = modeling.createHostOSH(ip, hostOsType)
                    oshHost.setStringAttribute("host_hostname", hostName)
                    OSHVResult.add(oshHost)

                    link = modeling.createLinkOSH('member', oshMsDomain,
                                                  oshHost)
                    OSHVResult.add(link)
                    ipOSH = modeling.createIpOSH(ip)
                    OSHVResult.add(ipOSH)
                    contained = modeling.createLinkOSH('contained', oshHost,
                                                       ipOSH)
                    OSHVResult.add(contained)
                except:
                    errorMsg = str(sys.exc_info()[1]).strip()
                    logger.warn('Failed to resolve host ', hostInfo[0], ' : ',
                                errorMsg)
        else:
            message = 'Failed to discover hosts on MS Domain'
            logger.warn(message)
            logger.reportWarning(message)
    except:
        errorMsg = str(sys.exc_info()[1]).strip()
        logger.errorException('Failed to discovery MS Domains')
        errorMessage = errormessages.makeErrorMessage(
            "msdomain", errorMsg,
            errormessages.ERROR_FAILED_DISCOVERING_MSDOMAIN_HOSTS)
        errobj = errorobject.createError(
            errorcodes.FAILED_DISCOVERIING_MSDOMAIN_HOST,
            ["msdomain", errorMsg], errorMessage)
        logger.reportErrorObject(errobj)
    return OSHVResult
예제 #42
0
 def __init__(self, dnsResolver, destinationIpAddress):
     r'@types: netutils.BaseDnsResolver, str'
     assert (dnsResolver and destinationIpAddress
             and not netutils.isLocalIp(destinationIpAddress))
     self.__dnsResolver = dnsResolver
     self.__destinationIpAddress = destinationIpAddress
예제 #43
0
def doQueryMainframeTCP(client, OSHVResult, Framework):
    ip_address = client.getIpAddress()
    hostOSH = modeling.createHostOSH(client.getIpAddress())
    modeling.setHostOsFamily(hostOSH, 'mainframe')
    ################     Query and data    ################################
    resultSetList = client.executeQuery(
        '1.3.6.1.4.1.2.6.19.2.2.7.1.1.37,1.3.6.1.4.1.2.6.19.2.2.7.1.1.38,string'
    )  #@@CMD_PERMISION snmp protocol execution
    resultSetList = resultSetList.asTable()

    tcpUtil = tcpdbutils.TcpDbUtils(Framework)

    regExp = '(\d+\.\d+\.\d+\.\d+)\.(\d+)\.(\d+\.\d+\.\d+\.\d+)\.(\d+)'
    for resultSet in resultSetList:
        try:
            currRowData = string.strip(resultSet[0])
            processName = string.strip(resultSet[1])

            processOSH = modeling.createProcessOSH(processName, hostOSH)
            OSHVResult.add(processOSH)

            resArray = re.search(regExp, currRowData)
            if resArray:
                ip1 = resArray.group(1)
                port1 = resArray.group(2)
                ip2 = resArray.group(3)
                port2 = resArray.group(4)
                processName = resultSet[1]

                # Create

                # Discard invalid lines (No port#)
                if port1 == '0':
                    continue

                # Loop back and listen
                if netutils.isLocalIp(ip1):
                    prot = 6  #tcp protocol
                    tcpUtil.addPortToProcess(ip_address, int(port1), -1, 1,
                                             prot)
                    continue

                tcpUtil.addTcpConnection(ip1, int(port1), ip2, int(port2))
                tcpUtil.addTcpConnection(ip2, int(port2), ip1, int(port1))

#				print '--------------------------------'
#				print 'ip1 :' , ip1
#				print 'port1 :' , port1
#				print 'ip2 :' , ip2
#				print 'port2 :' , port2
#				print 'processName :' , processName
#				print '--------------------------------'

        except:
            logger.warnException('Failed ip: %s' % (ip_address))
        try:
            tcpUtil.flushPortToProcesses()
        except:
            pass
        try:
            tcpUtil.flushTcpConnection()
        except:
            pass
        tcpUtil.close()
    logger.debug('Finished to process results')
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()

    urlString = Framework.getParameter(PARAM_URL)

    reportPoweredOffVms = 0
    reportPoweredOffVmsValue = Framework.getParameter(
        PARAM_REPORT_POWERED_OFF_VMS)
    if reportPoweredOffVmsValue and reportPoweredOffVmsValue.lower() == 'true':
        reportPoweredOffVms = 1

    ipAddress = None
    try:
        urlObject = URL(urlString)
        hostname = urlObject.getHost()

        if not hostname:
            logger.debug("Hostname is not defined in URL '%s'" % urlString)
            raise MalformedURLException()

        ipAddress = vcloud_discover.getIpFromUrlObject(urlObject)
        if not ipAddress or not netutils.isValidIp(
                ipAddress) or netutils.isLocalIp(ipAddress):
            msg = "Failed to resolve the IP address of server from specified URL"
            errormessages.resolveAndReport(
                msg, vcloud_discover.VcloudProtocol.DISPLAY, Framework)
            return OSHVResult

    except MalformedURLException:
        msg = "Specified URL '%s' is malformed" % urlString
        errormessages.resolveAndReport(msg,
                                       vcloud_discover.VcloudProtocol.DISPLAY,
                                       Framework)
    except:
        msg = logger.prepareJythonStackTrace("")
        errormessages.resolveAndReport(msg,
                                       vcloud_discover.VcloudProtocol.DISPLAY,
                                       Framework)
    else:

        #configure how connections should be discovered/established
        connectionDiscoverer = vcloud_discover.ConnectionDiscoverer(Framework)
        urlGenerator = vcloud_discover.ConstantUrlGenerator(urlString)
        connectionDiscoverer.setUrlGenerator(urlGenerator)
        connectionDiscoverer.addIp(ipAddress)

        #configure how established/failed connection should be used
        connectionHandler = vcloud_discover.BaseDiscoveryConnectionHandler(
            Framework)
        topologyDiscoverer = vcloud_discover.createVcloudDiscoverer(Framework)
        topologyReporter = vcloud_report.createVcloudReporter(
            Framework, None, reportPoweredOffVms)
        connectionHandler.setDiscoverer(topologyDiscoverer)
        connectionHandler.setReporter(topologyReporter)

        connectionDiscoverer.setConnectionHandler(connectionHandler)

        connectionDiscoverer.initConnectionConfigurations()

        connectionDiscoverer.discover(firstSuccessful=0)

        if not connectionHandler.connected:
            for errorMsg in connectionHandler.connectionErrors:
                Framework.reportError(errorMsg)
            for warningMsg in connectionHandler.connectionWarnings:
                Framework.reportWarning(warningMsg)

    return OSHVResult
예제 #45
0
def doUddiExplore(uddiAgent, registryOSH, OSHVResult):
    table = uddiAgent.doTableCommand("")
    Empty = ''

    rows = table.getRowCount()
    logger.debug('XXXXXXXXXXXXXXX  There are Business entity:', rows)

    for row in range(rows):
        properties = table.getCell(row, 0)
        #businessEntity
        entityName = properties.getProperty(UDDIUtil.BUSINESS_ENTITY_NAME,
                                            Empty)
        entityDescription = properties.getProperty(
            UDDIUtil.BUSINESS_ENTITY_DESC, Empty)

        bsOSH = ObjectStateHolder('organization')
        bsOSH.setAttribute('name', entityName)
        bsOSH.setAttribute('description', entityDescription)
        bsOSH.setAttribute('organization_type', 'department')

        logger.debug('XXXXXXXXXXXXXXX add Business entity:', entityName)
        contacts = properties.get(UDDIUtil.BUSINESS_ENTITY_CONTACTS)
        contactinfo = []
        if contacts != None:
            itc = contacts.iterator()
            while itc.hasNext():
                contact = itc.next()
                contactName = contact.getProperty(UDDIUtil.CONTACT_NAME, Empty)
                contactPhon = contact.getProperty(UDDIUtil.CONTACT_PHONE,
                                                  Empty)
                contactEmail = contact.getProperty(UDDIUtil.CONTACT_EMAIL,
                                                   Empty)
                contactUse = contact.getProperty(UDDIUtil.CONTACT_USE_TYPE,
                                                 Empty)
                contactinfo.append("[")
                contactinfo.append(contactName)
                contactinfo.append(" Phone:")
                contactinfo.append(contactPhon)
                contactinfo.append(" Email:")
                contactinfo.append(contactEmail)
                contactinfo.append(" Use type:")
                contactinfo.append(contactUse)
                contactinfo.append("] ")
            contactInfoData = ''.join(contactinfo)
            bsOSH.setAttribute('contact_info', contactInfoData)

        OSHVResult.add(bsOSH)
        link2Reg = modeling.createLinkOSH('containment', registryOSH, bsOSH)
        OSHVResult.add(link2Reg)

        services = properties.get(UDDIUtil.BUSINESS_ENTITY_SERVICES)
        if services != None:
            logger.debug('XXXXXXXXXXXXXXX services:', services.size())
            its = services.iterator()
            while its.hasNext():
                service = its.next()
                name = service.getProperty(UDDIUtil.NAME, Empty)
                description = service.getProperty(UDDIUtil.DESCRIPTION, Empty)
                key = service.getProperty(UDDIUtil.KEY, Empty)
                wsdlUrl = service.getProperty(UDDIUtil.WSDL_URL, Empty)
                url = service.getProperty(UDDIUtil.URL, Empty)
                namespace = service.getProperty(UDDIUtil.TARGET_NAME_SPACE,
                                                Empty)

                if not wsdlUrl and url:
                    wsdlUrl = url

                urlIP = None
                try:
                    url = URL(wsdlUrl)
                except:
                    logger.warn("Incorrect URL \"%s\" found. Skipped." %
                                wsdlUrl)
                    continue

                try:
                    hostName = url.getHost()
                    urlIP = netutils.getHostAddress(hostName, None)
                    if (not netutils.isValidIp(urlIP)
                        ) or netutils.isLocalIp(urlIP):
                        urlIP = None
                except:
                    urlIP = None

                urlOSH = modeling.createUrlOsh(registryOSH, wsdlUrl, 'wsdl')
                urlIpOSH = None
                if urlIP != None:
                    try:
                        urlIpOSH = modeling.createIpOSH(urlIP)
                    except:
                        urlIpOSH = None

                OSHVResult.add(urlOSH)
                if urlIpOSH:
                    OSHVResult.add(urlIpOSH)
                    urlToIpOSH = modeling.createLinkOSH(
                        'dependency', urlOSH, urlIpOSH)
                    OSHVResult.add(urlToIpOSH)

                wsOSH = ObjectStateHolder('webservice')
                wsOSH.setAttribute('name', namespace)
                wsOSH.setAttribute('description', description)
                wsOSH.setAttribute('service_name', name)
                wsOSH.setAttribute('wsdl_url', wsdlUrl)
                OSHVResult.add(wsOSH)

                urlToWsOSH = modeling.createLinkOSH('dependency', wsOSH,
                                                    urlOSH)
                OSHVResult.add(urlToWsOSH)

                logger.debug('Service Name: ', name)
                logger.debug('Service Key: ', key)
                logger.debug('Service Description: ', description)
                logger.debug('WSDL url: ', wsdlUrl)
                logger.debug('Service url: ', url)

                dependOSH = modeling.createLinkOSH('dependency', wsOSH,
                                                   registryOSH)
                link2bus = modeling.createLinkOSH('dependency', wsOSH, bsOSH)
                OSHVResult.add(dependOSH)
                OSHVResult.add(link2bus)
                logger.debug('add containment link to Registry ', name)
예제 #46
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    businessElementId = Framework.getDestinationAttribute('id') 
    urlString = Framework.getDestinationAttribute('url')
    jobId = Framework.getDiscoveryJobId()
    dnsServers = Framework.getParameter('dnsServers') or None
    localShell = None

    if dnsServers:
        dnsServers = [dnsServer for dnsServer in dnsServers.split(',') if dnsServer and dnsServer.strip()] or None
    if dnsServers:
        logger.debug('Using dns servers: ', dnsServers)
        localShell = shellutils.ShellUtils(Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME))

    if not urlString:
        msg = "There is no specified URL in the input BusinessElement CI"
        errormessages.resolveAndReport(msg, jobId, Framework)
        return OSHVResult

    try:
        urlString = urlString[1:len(urlString)-1]

        if netutils.isValidIp(urlString):
            createHostOSHwithIP(OSHVResult, urlString)
            return OSHVResult

        urlObject = URL(urlString)
        hostname = urlObject.getHost()

        if not hostname:
            logger.debug("Hostname is not defined in URL '%s'" % urlString)
            raise MalformedURLException()

        urlObjectResolver = URLObjectResolver(urlObject)
        protocol = urlObjectResolver.getProtocolFromUrlObject()
        if not protocol:
            msg = "Failed to resolve the http/https protocol from specified URL"
            errormessages.resolveAndReport(msg, jobId, Framework)
            return OSHVResult

        port = urlObjectResolver.getPortFromUrlObject()
        if not port:
            msg = "Failed to resolve the port number from specified URL"
            errormessages.resolveAndReport(msg, jobId, Framework)
            return OSHVResult


        # get topology
        # create business element CI and attach the url as configuration document CI to it
        bizOSH = modeling.createOshByCmdbIdString('business_element', businessElementId)
        urlConfigOSH = modeling.createConfigurationDocumentOSH('url.txt', '', urlString, bizOSH)
        linkBizUrlConifg = modeling.createLinkOSH('composition', bizOSH, urlConfigOSH)
        OSHVResult.add(bizOSH)
        OSHVResult.add(urlConfigOSH)
        OSHVResult.add(linkBizUrlConifg)

        hostDNSName = None
        if not netutils.isValidIp(hostname):
            # Treat the host name as its DNS name if it is not a valid ip address
            hostDNSName = hostname

        ipAddresses = []
        if dnsServers:
            ipAddresses = urlObjectResolver.getIpFromUrlObjectWithDnsList(dnsServers, localShell)
        else:
            ipAddresses = urlObjectResolver.getIpFromUrlObject()
        for ipAddress in ipAddresses:
            logger.debug('Reporting ip address: ', ipAddresses)
            if not ipAddress or not netutils.isValidIp(ipAddress) or netutils.isLocalIp(ipAddress):
                msg = "Failed to resolve the IP address of server from specified URL"
                errormessages.resolveAndReport(msg, jobId, Framework)
                return OSHVResult

            hostOSH, ipOSH = createHostOSHwithIP(OSHVResult, ipAddress)
            if hostDNSName:
                ipOSH.setAttribute('authoritative_dns_name', hostDNSName)

            # create UriEndpoint and relations between business element and UriEndpoint
            urlOSH = modeling.createServiceURLAddressOsh(hostOSH, urlString)
            linkBizUrl = modeling.createLinkOSH('usage', bizOSH, urlOSH)
            OSHVResult.add(urlOSH)
            OSHVResult.add(linkBizUrl)

            # create ipServiceEndpoint and relations between UriEndpoint and ipServiceEndpoint
            ipPort = modeling.createServiceAddressOsh(hostOSH, ipAddress, port, modeling.SERVICEADDRESS_TYPE_TCP)
            linkUrlIP = modeling.createLinkOSH('dependency', urlOSH, ipOSH)
            OSHVResult.add(ipPort)
            OSHVResult.add(linkUrlIP)

    except MalformedURLException:
        msg = "Specified URL '%s' is malformed" % urlString
        errormessages.resolveAndReport(msg, jobId, Framework)
    except:
        msg = logger.prepareJythonStackTrace("")
        errormessages.resolveAndReport(msg, jobId, Framework)

    return OSHVResult
예제 #47
0
def doSnmp(client, isClient, snmpOSH, ip_address, ip_domain, Framework, host_cmdbid, host_key, host_macs):
    '''SnmpClient, osh, str, str, Framework, str, str, list(str) -> ObjectStateHolderVector
    @deprecated
    '''
    networkList = []
    vector = ObjectStateHolderVector()
    ucmdb_version = modeling.CmdbClassModel().version()
    # system table
    snmpQuery = '1.3.6.1.2.1.1.1,1.3.6.1.2.1.1.2,string,1.3.6.1.2.1.1.2,string,1.3.6.1.2.1.1.5,string'
    table = client.executeQuery(snmpQuery)#@@CMD_PERMISION snmp protocol execution

    sysname = None
    oid = None
    description = None
    try:
        if table.next():
            description = table.getString(2)
            oid = table.getString(3)
            sysname = table.getString(4)
    except:
        logger.debugException('')

    node_description = description or ''

    sysObjId = oid
    className, vendorName, hostOsName, hostModel, serialNumberOid, serialNumberSNMPMethod = getNodeDetails(description, oid)
    logger.debug("Node details:%s, %s, %s, %s, %s, %s"%(className, vendorName, hostOsName, hostModel, serialNumberOid, serialNumberSNMPMethod))
    if className == 'netprinter':
        sysname = getNetPrinterName(client) or sysname
    hostVersion, hostRelease = getOsVersionAndBuild(hostOsName, description)

# since sysUpTime returns a time since the snmp was re-initialized, this
# time doesn't provide us correct answer, therefore this code is disabled
#    snmpQuery = '1.3.6.1.2.1.1.3,1.3.6.1.2.1.1.4,string'
#    upTime = client.executeQuery(snmpQuery)

    if oid != None:
        snmpOSH.setAttribute('snmp_oid', oid)
    if((sysname != None) and (sysname != '') and (sysname != 'unknown')):
        snmpOSH.setAttribute('snmp_sysname', sysname)
    if description != None:
        snmpOSH.setAttribute('snmp_description', description)

    logger.debug('ip_address: ', ip_address, ', sysname: ' , sysname, ', className: ', className, ', oid: ', oid, ', description: ', description)

    #dicovery arp cache available
    arp_available = SNMP_Networking_Utils.isArpCacheAvailable(client)
    snmpOSH.setBoolAttribute('arp_cache_available', arp_available)

    # indx, description & mac

    interfaceList = []
    interfaceDictionary = {}

    ifList = SNMP_Networking_Utils.discoverInterfaceData(client, None)

    for nic in ifList:
        if nic.ifType and int(nic.ifType) == 24:
            continue

        macAddress = str(nic.ifMac).upper()
        if nic.ifIndex != None and nic.ifIndex != '':
            inrfcindex = nic.ifIndex
        description = _stripVirtualMiniportInfo(nic.ifDescr)

        if interfaceDictionary.has_key(inrfcindex):
            logger.debug('this mac was already reported, skip it ... : inrfcindex: ', inrfcindex, ', descrition: ', description, ', macAddress: ', macAddress)
            continue

        logger.debug('inrfcindex: ', inrfcindex, ', description: ', description, ', macAddress: ', macAddress)

        interfaceDictionary[inrfcindex] = macAddress
        networkinterface = modeling.NetworkInterface(description, macAddress, None, None, inrfcindex)
        networkinterface.type = nic.ifType
        networkinterface.adminStatus = nic.ifAdminStatus
        networkinterface.operStatus = nic.ifOperStatus
        networkinterface.speed = nic.ifSpeed
        networkinterface.name = nic.ifName
        networkinterface.alias = nic.ifAlias
        if not networkinterface.name:
            m = re.match('(lan[\d\:\.]+)', description)
            if m:
                networkinterface.name = m.group(1)
                networkinterface.description = None
        interfaceList.append(networkinterface)

    # create the host and all the objects
    if len(interfaceList) > 0:
        macToInterfaceListMap = {}
        for interface in interfaceList:
            macToInterfaceListMap.setdefault(interface.macAddress, []).append(interface)

        for ifaceList in macToInterfaceListMap.values():
            if ifaceList and len(ifaceList) < 2:
                continue
            try:
                iface = reduce(lambda x,y: x.interfaceIndex > y.interfaceIndex and x or y, ifaceList)
                iface.role = 'aggregate_interface'
            except:
                logger.debugException('')
        hostOSH = None

        try:
            # Get the host_key - lowest mac address of the valid interface list
            hostOSH = modeling.createCompleteHostOSHByInterfaceList(className, interfaceList, None, None, None, host_cmdbid, host_key, host_macs, ucmdb_version)
            if (className in netDeviceClasses) and (sysname != None) and (sysname != '') and ((host_cmdbid in ['NA','',None]) or (host_key and (host_key.lower() == sysname.lower()))):
                # JEO @ Fidelity: use SNMP system name for host key of network devices unless its null
                hostOSH.setAttribute('host_key', sysname)

        except:
            logger.debug('Could not find a valid MAC address for key on ip : ', ip_address)
            if (className in netDeviceClasses) and (sysname != None) and (sysname != '') and (host_cmdbid in ['NA','',None]):
                logger.debug('Network device, hostkey is sysname...')
                hostOSH = modeling.createCompleteHostOSH(className, sysname)
            else:
                logger.debug('Creating incomplete host...')
                hostOSH = modeling.createHostOSH(ip_address, className)

        logger.debug('Created [' + className + '] strong key=[' + hostOSH.getAttributeValue('host_key') + ']')

        if((sysname != None) and (sysname != '') and (sysname != 'unknown')):
            hostOSH.setAttribute('snmp_sys_name', sysname)
            # set hostname to SNMP system name less domain suffix which is typical of other data sources
            hostname = sysname.split('.')[0].lower()
            hostOSH.setAttribute('name', hostname)
            logger.debug("hostname=" + hostname)

        defaultGateway = getDefaultGateway(client)
        modeling.setHostDefaultGateway(hostOSH, defaultGateway)
        modeling.setHostOsFamily(hostOSH, None, className)
        if sysObjId and sysObjId.startswith('.') != -1:
            sysObjId = "." + sysObjId
        modeling.setSNMPSysObjectId(hostOSH, sysObjId)

        if((hostOsName != None) and (hostOsName != '') and (hostOsName != 'unknown')):
            modeling.setHostOsName(hostOSH, hostOsName)
        if((vendorName != None) and (vendorName != '') and (vendorName != 'unknown')):
            hostOSH.setAttribute('discovered_os_vendor', vendorName)
        if((hostModel != None) and (hostModel != '') and (hostModel != 'unknown')):
            hostOSH.setAttribute('discovered_model', hostModel)
        if hostRelease is not None:
            hostOSH.setAttribute('host_osrelease', hostRelease)
        if hostVersion is not None:
            hostOSH.setAttribute('discovered_os_version', hostVersion)

# since sysUpTime returns a time since the snmp was re-initialized, this
# time doesn't provide us correct answer, therefore this code is disabled
#        if upTime:
#            today = Calendar.getInstance().getTime()
#            setLastBootDate(hostOSH, upTime, today, Framework)

        vector.add(modeling.finalizeHostOsh(hostOSH))
        snmpOSH.setContainer(hostOSH)
        if className == 'mainframe':
            modeling.setHostOsFamily(hostOSH, 'mainframe')

        interfaceOshToIndex = {}
        roleManager = networking_win.InterfaceRoleManager()
        try:
            reportInterfaceName = Boolean.parseBoolean(Framework.getParameter('reportInterfaceName'))
        except:
            logger.warn('Failed to parse reportInterfaceName parameter falue. Not a Boolean type.')
            reportInterfaceName = True
        for nic in interfaceList:
            if netutils.isValidMac(nic.macAddress):
                nic.osh = modeling.createInterfaceOSH(nic.macAddress, hostOSH, nic.description,
                            nic.interfaceIndex, nic.type, nic.adminStatus, nic.operStatus,
                            nic.speed, nic.name, nic.alias, reportInterfaceName)
                roleManager.assignInterfaceRole(nic)
                interfaceOshToIndex[nic.interfaceIndex] = nic.osh
                vector.add(nic.osh)
            else:
                logger.debug('MAC %s is invalid (name: %s, description: %s, index: %s)' %
                             (nic.macAddress, nic.name, nic.description, nic.interfaceIndex))

        # create the ip's
        logger.debug("create the ip's")
        snmpQuery = '1.3.6.1.2.1.4.20.1.1, 1.3.6.1.2.1.4.20.1.2, string'
        table = client.executeQuery(snmpQuery)#@@CMD_PERMISION snmp protocol execution
        ips = table.asTable()
        snmpQuery = '1.3.6.1.2.1.4.20.1.2, 1.3.6.1.2.1.4.20.1.3, string'
        table = client.executeQuery(snmpQuery)#@@CMD_PERMISION snmp protocol execution
        ifindexes = table.asTable()
        snmpQuery = '1.3.6.1.2.1.4.20.1.3, 1.3.6.1.2.1.4.20.1.4, string'
        table = client.executeQuery(snmpQuery)#@@CMD_PERMISION snmp protocol execution
        ipmasks = table.asTable()
        try:
            rfcIpV6Query = '1.3.6.1.2.1.55.1.8.1.1,1.3.6.1.2.1.55.1.8.1.5, string'
            rfcIpV6Result = client.executeQuery(rfcIpV6Query)#@@CMD_PERMISION snmp protocol execution
            results = rfcIpV6Result.asTable()
        except:
            logger.warn('Failed to get or process IPv6 MIB results.')

        #try to collect IPv6 addresses from IPv6 address table and connect them to corresponding interface
        logger.debug("Begin to discovery IPv6 related info")
        try:
            ipv6Map = {}
            ipv6AddressTable = SNMP_Networking_Utils.discoverIPv6AddressTable(client)
            if ipv6AddressTable:
                for row in ipv6AddressTable:
                    if row.ipv6AddrStatus != '1':# 1 means valid ip address in arp cache
                        continue
                    ifIndex, ipAddress = _parseIPv6FromIndex(row.ipv6AddrAddress)
                    if ifIndex and ipAddress:
                        try:
                            formatedIP = getValidIP(ipAddress)
                            if formatedIP:
                                ipv6Map[ifIndex] = formatedIP
                        except:
                            pass
            mixedIPAddressTable = SNMP_Networking_Utils.discoverMixedIPAddressTable(client)
            if mixedIPAddressTable:
                for row in mixedIPAddressTable:
                    if row.ipAddressStatus != '1' or row.ipAddressRowStatus != '1':# 1 means valid ip address in arp cache
                        continue
                    ifIndex = row.ipAddressIfIndex
                    ipAddress = _parseMixedIPFromIndex(row.ipAddressAddr)
                    if ifIndex and ipAddress:
                        try:
                            formatedIP = getValidIP(ipAddress)
                            if formatedIP and formatedIP.version == 6:
                                ipv6Map[ifIndex] = formatedIP
                        except:
                            pass

            if ipv6Map and interfaceOshToIndex:
                for ifIndex in ipv6Map.keys():
                    ipv6 = ipv6Map[ifIndex]
                    logger.debug("Discovered IPv6:", ipv6)
                    ipOSH = modeling.createIpOSH(ipv6)
                    vector.add(ipOSH)
                    interfaceOsh = interfaceOshToIndex.get(str(ifIndex))
                    if not interfaceOsh and isClient:
                        logger.info('client ip is not associated with an interface')
                        msg = "Can not find the related interface for client IP: %s" % ip_address
                        logger.reportWarningObject(errormessages.resolveError(msg, 'SNMP'))
                        continue
                    if interfaceOsh:
                        parent = modeling.createLinkOSH('containment', interfaceOsh, ipOSH)
                        vector.add(parent)
                        interfaceMacAddress = interfaceOsh.getAttributeValue('mac_address')
                        if (isClient == TRUE):
                            ipOSH.setAttribute('arp_mac', interfaceMacAddress)
                            if (
                            ipv6 == ip_addr_util.IPAddress(ip_address)):#compare ipv6 by the formatting to avoid same IPv6 with different format
                                snmpOSH.setAttribute('arp_mac', interfaceMacAddress)

                    isCompleteAttribute = hostOSH.getAttribute('host_iscomplete')
                    if isCompleteAttribute is not None and isCompleteAttribute.getBooleanValue() == 1:
                        contained = modeling.createLinkOSH('contained', hostOSH, ipOSH)
                        vector.add(contained)
        except:
            logger.debug(str(sys.exc_info()))

        index = 0
        if len(ips) > 0 and len(ifindexes) > 0:
            for ip in ips:
                try:
                    ip_addr = ip[1]
                    #logger.debug('candidate ip_addr: ', ip_addr)
                    ifIndex = ifindexes[index][1]
                    mask = ipmasks[index][1]
                    index += 1

                    interfaceOsh = interfaceOshToIndex.get(ifIndex)

                    ''' this commented out block should be removed
                    # no such thing as netmask IPs, there are broadcast IPs which have .255 in them
                    # but we would definitely want to discover and nic which was asssigned
                    # such an address -
                    #if(ip_addr.find('255.') == 0 ):
                        #exclude netmask ip
                        #continue
                    '''

                    if netutils.isValidIp(ip_addr) and (not netutils.isLocalIp(ip_addr)):
                        '''
                        netutils.isLocalIp is not finding all local addresses
                        127.0.0.0 through 127.255.255.255 are local
                        additional if clause can be removed when this is fixed
                        see http://www.tcpipguide.com/free/t_IPReservedPrivateandLoopbackAddresses.htm
                        '''
                        # ip is valid and not local (i.e. 0.0.0.0, 127.0.0.1)
                        ipOSH = modeling.createIpOSH(ip_addr, mask)
                    else:
                        # loopbacks are standard; don't complain about them in the logs
                        continue
                    logger.debug('ip_addr: ', ip_addr, ', mask: ', mask)

                    netOSH = modeling.createNetworkOSH(ip_addr, mask)

                    strNetAddr = str(netOSH.getAttribute('network_netaddr'))
                    strNetMask = str(netOSH.getAttribute('network_netMask'))
                    currNet = strNetAddr + strNetMask

                    broadcastIp = netOSH.getAttributeValue('network_broadcastaddress')
                    if ip_address == broadcastIp:
                        raise BroadcastIpDiscoveryException()
                    if not interfaceOsh and isClient:
                        logger.info('client ip is not associated with an interface')
                        msg = "Can not find the related interface for client IP: " + ip_addr
                        logger.reportWarningObject(errormessages.resolveError(msg, 'SNMP'))
                        continue
                    if interfaceOsh:
                        parent = modeling.createLinkOSH('containment', interfaceOsh, ipOSH)
                        vector.add(parent)
                        interfaceMacAddress = interfaceOsh.getAttributeValue('mac_address')
                        if (isClient == TRUE):
                            ipOSH.setAttribute('arp_mac', interfaceMacAddress)
                            if (ip_addr == ip_address):
                                snmpOSH.setAttribute('arp_mac', interfaceMacAddress)

                    member1 = modeling.createLinkOSH('member', netOSH, ipOSH)
                    member2 = modeling.createLinkOSH('member', netOSH, hostOSH)

                    if currNet in networkList:
                        pass
                    else:
                        networkList.append(currNet)
                        vector.add(netOSH)
                        vector.add(member2)

                    vector.add(ipOSH)
                    vector.add(member1)

                    # link IPs to host only in case host is complete
                    # otherwise reconciliation may fail
                    isCompleteAttribute = hostOSH.getAttribute('host_iscomplete')
                    if isCompleteAttribute is not None and isCompleteAttribute.getBooleanValue() == 1:
                        contained = modeling.createLinkOSH('contained', hostOSH, ipOSH)
                        vector.add(contained)

                    if interfaceOsh:
                        parent = modeling.createLinkOSH('containment', interfaceOsh, ipOSH)
                        vector.add(parent)
                except BroadcastIpDiscoveryException, ex:
                    raise ex
                except:
                    pass
예제 #48
0
 def isLocal(self):
     if isinstance(self.ip, type("")) or isinstance(self.ip, type(u"")):
         return netutils.isLocalIp(self.ip)
     else:
         return self.ip.is_loopback or self.ip.is_unspecified
예제 #49
0
def DiscoveryMain(Framework):
    """
    Retrieving a list of LDAP ports we strive to connect to domain controller in
    member role first. So we have to choose the lowest port number in the list.
    """
    protocolName = "LDAP"

    OSHVResult = ObjectStateHolderVector()

    baseDn = Framework.getParameter('baseDN') or None
    if baseDn == 'NA':
        baseDn = None
    ipAddress = Framework.getDestinationAttribute('ip_address')
    credentialsId = Framework.getDestinationAttribute('credentials_id')
    applicationPort = Framework.getDestinationAttribute("application_port")
    serviceAddressPort = Framework.getDestinationAttribute('port')

    if not applicationPort or applicationPort == 'NA':
        applicationPort = serviceAddressPort

    # build environment and connect
    envBuilder = active_directory_utils.LdapEnvironmentBuilder(applicationPort)
    client = Framework.createClient(credentialsId, envBuilder.build())

    discoverer = oracle_ldap_discoverer.OracleLdapDiscoverer(client, baseDn)

    try:
        probe_client  = Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME)
        probe_shell = shellutils.ShellFactory().createShell(probe_client)

        resolver = netutils.FallbackResolver([netutils.JavaDnsResolver(), netutils.DnsResolverByShell(probe_shell)])

        # discover
        servers = discoverer.discover()

        # report
        endpoint_builder = netutils.ServiceEndpointBuilder()
        endpoint_reporter = netutils.EndpointReporter(endpoint_builder)

        oracle_builder = db_builder.Oracle()
        reporter = db.OracleTopologyReporter(oracle_builder, endpoint_reporter)

        for dbServer in servers:
            if dbServer:
                try:
                    address = dbServer.address
                    if not ip_addr.isValidIpAddress(address):
                        ips = resolver.resolveIpsByHostname(address)
                        if ips and len(ips) > 0:
                            dbServer.address = str(ip_addr.IPAddress(ips[0]))
                    # get Host OSH
                    if not (dbServer.address
                            and netutils.isValidIp(address)
                            and not netutils.isLocalIp(address)):
                        raise ValueError("Address for the specified server is not valid or is local")
                    hostOsh = modeling.createHostOSH(dbServer.address)

                    # report database
                    OSHVResult.addAll(reporter.reportServerAndDatabases(dbServer, hostOsh))

                    # report TNS Listener
                    listener = db.OracleListener(dbServer.address, dbServer.getPort())
                    OSHVResult.addAll(reporter.reportTnsListener(listener, hostOsh))

                    # report Oracle Service Names
                    if dbServer.getServiceNames():
                        OSHVResult.addAll(reporter.reportServiceNameTopology(dbServer.getServiceNames(), listener.getOsh(), dbServer.getOsh()))

                except netutils.ResolveException:
                    logger.error("Cannot resolve " + dbServer.address + ". Skip")
    except oracle_ldap_discoverer.OracleContextDiscoveryException, ex:
        msg = str(ex)
        logger.debugException(msg)
        logger.error(msg)
예제 #50
0
def makeAppServer(client, username, enterprise, serverObj, serverDataRow, siteOSH, Framework, OSHVResult):
	# init return value

	logger.debug('server:', string.join(serverObj), ' dataRow:', serverDataRow)
	datalist = serverObj
	sblsvrName = datalist[0]
	logger.debug('sblsvrName:', sblsvrName)
	hostName = datalist[1]
	installDir = datalist[2]
	sblmgrPID = datalist[3]
	serverID = datalist[9]
	# if no PID, server is not running. send an event on it
	# the message of the event will be everything that follows
	# the PID field
	if string.strip(sblmgrPID) == '':
		logger.debug('problem server:', serverDataRow)
		runningServer = 0
		logger.debug('app server', sblsvrName, ' is not Running')
	else:
		runningServer = 1
		# called status, but actually version details
		status = datalist[8]
		logger.debug('status:', status)
		versionTokens = status.split()
		version = versionTokens[0]
		build = versionTokens[1]
		lang = versionTokens[2]

	# host
	logger.debug('building host:', hostName)
	try:
		ip = netutils.getHostAddress(hostName)
		logger.debug('found ip:', ip, ' for hostName:', hostName)
		if ip == None:
			return None
		if netutils.isLocalIp(ip):
			logger.debug('got loopback ip, probably error.')
			return None
		appServerHostOSH = modeling.createHostOSH(ip)
	except:
		logger.errorException('failed to convert host name:', hostName, ' to IP')
		return None

	# siebel application server
	appServerOSH = modeling.createApplicationOSH('siebel_app_server', sblsvrName, appServerHostOSH, 'Enterprise App', 'oracle_corp')
	appServerOSH.setAttribute('application_ip', ip)
	appServerOSH.setAttribute('application_username', username)
	appServerOSH.setAttribute('install_dir', installDir)
	appServerOSH.setAttribute('svr_id',serverID)

	modeling.setAppServerType(appServerOSH)

	#9.0 workaround
	versionAsDouble = logger.Version().getVersion(Framework)
	if versionAsDouble >= 9:
		appServerOSH.removeAttribute('data_name')
		appServerOSH.setAttribute('name', sblsvrName)
		modeling.setApplicationProductName(appServerOSH, 'Siebel Server')

	OSHVResult.add(appServerHostOSH)
	OSHVResult.add(appServerOSH)

	if runningServer:
		appServerOSH.setAttribute('version', version)
		appServerOSH.setAttribute('application_version', version)
		appServerOSH.setAttribute('build', build)
		appServerOSH.setAttribute('lang', lang)

		# NOTE: setting the current app server so that all info will be only
		# for it
		prompt = client.executeCmd(string.join(['set server ', sblsvrName]), 5000)#@@CMD_PERMISION siebel protocol execution
		logger.debug(prompt)

		# get component groups (and components for each group) for this server
		# NOTE: as far as we know there can't be components that are not under a group
		# if such a situation can exist we won't find such 'leaf' components
		# with the current code

		#
		#
		makeComponentGroups(client, appServerOSH, ip, OSHVResult, enterprise, siteOSH)

		if version[0] == '7' or version[0] == '8':
			# get DB (Data Source) Attributes
			# table[0][0][1] means:
			# [0] - first row (should be only one, we are inside a server context)
			# [0] - first column: the parsed fields (second column is original row for error purposes)
			# [1] - second value in the parsed fields
			try:
				svrdsconnstrTblTxt = client.executeCmd('list parameter DSConnectString for named subsystem ServerDataSrc')#@@CMD_PERMISION siebel protocol execution
				svrdsconnstrTbl = siebel_common.makeTable(svrdsconnstrTblTxt)
				svrdsconnstr = string.upper(svrdsconnstrTbl[0][0][1])
				logger.debug('svrdsconnstr:', svrdsconnstr)
				appServerOSH.setAttribute('srv_ds_conn_str', svrdsconnstr)
			except:
				error_message = 'failed to get DSConnectString (to set attribute srv_ds_conn_str) on server'
				logger.debug(error_message)
				Framework.reportWarning(error_message)
			try:
				svrdstypeTblTxt = client.executeCmd('list parameters DSSQLStyle for named subsystem ServerDataSrc')#@@CMD_PERMISION siebel protocol execution
				svrdstypeTbl = siebel_common.makeTable(svrdstypeTblTxt)
				if svrdstypeTbl:
					svrdstype = svrdstypeTbl[0][0][1]
				else:
					svrdstypeTblTxt = client.executeCmd('list parameters DSDLLName for named subsystem ServerDataSrc')#@@CMD_PERMISION siebel protocol execution
					svrdstypeTbl = siebel_common.makeTable(svrdstypeTblTxt)
					svrdstype = DLL_TO_SQL_TYPE_MAP[svrdstypeTbl[0][0][1]]

				logger.debug('svrdstype:', svrdstype)
				appServerOSH.setAttribute('svr_ds_type', svrdstype)
			except:
				error_message = 'failed to get DSSQLStyle (to set attribute svr_ds_type) on server'
				logger.debugException(error_message)
				Framework.reportWarning(error_message)


			serverType = getSiebelServerType(client)
			if serverType:
				appServerOSH.setStringAttribute('data_description', serverType)
			else:
				logger.warn("Cannot determine the type of server '%s', no required components were found" % sblsvrName)

		if version[0] == '6':
			# in Siebel 2000 (tested with 6.3), we can't obtain some of the parameters using command line API
			# get missing attributes from configuration file
			logger.info('Datasource parameters are not supported in version ', version)
			logger.info('Please run SIEBEL_DIS_APP_SERVER_CONFIG pattern to get server datasource attributes')

		try:
			odbcDSNTblTxt = client.executeCmd('list param connect')#@@CMD_PERMISION siebel protocol execution
			odbcDSNTbl = siebel_common.makeTable(odbcDSNTblTxt)
			odbcDSN = odbcDSNTbl[0][0][1]
			logger.debug('odbcDSN:', odbcDSN)
			appServerOSH.setAttribute('odbc_dsn', odbcDSN)
		except:
			error_message = 'failed to get ODBC DSN (connect param (to set attribute odbc_dsn) on server'
			logger.debug(error_message)
			Framework.reportWarning(error_message)

		# NOTE: unsetting the current app server
		prompt = client.executeCmd('unset server', 3000)#@@CMD_PERMISION siebel protocol execution
		logger.debug(prompt)

	return appServerOSH
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()

    DISCOVERED_IP = Framework.getDestinationAttribute('ip_address')
    DISCOVERED_IP_ID = Framework.getDestinationAttribute('ip_id')    
#    ip = modeling.createOshByCmdbIdString('ip_address', DISCOVERED_IP_ID)
    ucmdbVersion = modeling.CmdbClassModel().version()
    if ucmdbVersion >= 9:
        ipClass = 'ip_address'
    else:
        ipClass = 'ip'

    protocols = Framework.getAvailableProtocols(DISCOVERED_IP, ClientsConsts.SNMP_PROTOCOL_NAME)

    if protocols.__len__() == 0:
        errStr = 'No credentials defined for the triggered ip'
        logger.debug(errStr)
        Framework.reportWarning(errStr)
    else:
        for protocol in protocols:
            sysplexNameList = None
            lparIpList = None
            
            snmpOSH = modeling.createSnmpOSH(DISCOVERED_IP, None)

            client = None
            try:
                client = Framework.createClient(protocol)
                logger.debug('got snmp agent for: ', DISCOVERED_IP)
                isMultiOid = client.supportMultiOid()
                
                sysplexNameList = client.executeQuery( '1.3.6.1.4.1.2.6.19.2.2.2.41,1.3.6.1.4.1.2.6.19.2.2.2.41,string,1.3.6.1.4.1.2.6.19.2.2.2.40,string' )#@@CMD_PERMISION snmp protocol execution
                sysplexNameList = sysplexNameList.asTable()

                lparIpList = client.executeQuery( '1.3.6.1.2.1.4.20.1.1,1.3.6.1.2.1.4.20.1.2,string' )#@@CMD_PERMISION snmp protocol execution
                lparIpList = lparIpList.asTable()

                mainframeMacList = client.executeQuery( '1.3.6.1.2.1.2.2.1.6,1.3.6.1.2.1.2.2.1.7,hexa' )#@@CMD_PERMISION snmp protocol execution
                mainframeMacList = mainframeMacList.asTable()
                snmpOSH.setAttribute('application_port', client.getPort())
                
                snmpOSH.setAttribute('application_timeout', client.getTimeout())
                snmpOSH.setAttribute('snmp_port', client.getPort())
                snmpOSH.setAttribute('credentials_id', client.getCredentialId())
                snmpOSH.setAttribute('snmp_retry', client.getRetries())
                snmpOSH.setAttribute('snmp_timeout', client.getTimeout())
                if isMultiOid == 1:
                    snmpOSH.setBoolAttribute('snmp_supportmultioid', 1)
                else:
                    snmpOSH.setBoolAttribute('snmp_supportmultioid', 0)
            except:
                logger.debugException('Unexpected SNMP_AGENT Exception:')
                continue

            if client != None:
                client.close()

            mainframeKey = getMainframeKey(mainframeMacList)
            if mainframeKey:
                mainframeOSH = modeling.createCompleteHostOSH('mainframe', mainframeKey, machineName = mainframeKey)
                modeling.setHostOsFamily(mainframeOSH, 'mainframe')
                OSHVResult.add(mainframeOSH)

                for currSysplex in sysplexNameList:
                    if logger.isDebugEnabled():
                        logger.debug( 'SYSPLEX : ', currSysplex[1] )
                        logger.debug( 'LPAR : ', currSysplex[2] )
                        logger.debug( 'MainframeKEY : ', mainframeKey )

                    lparKey = mainframeKey + ':' + currSysplex[2]
                    lparOSH = modeling.createCompleteHostOSH('lpar', lparKey, machineName = currSysplex[2])
                    OSHVResult.add(lparOSH)
                    
                    snmpOSH.setContainer(lparOSH)
                    OSHVResult.add(snmpOSH)

                    # Create contained link between discovered IP and lpar
                    OSHVResult.add(modeling.createLinkOSH('contained', lparOSH, modeling.createOshByCmdbIdString(ipClass, DISCOVERED_IP_ID)))

                    # Create member link between lpar and Mainframe
                    OSHVResult.add(modeling.createLinkOSH('member', mainframeOSH, lparOSH))

                    # Create sysplex
                    sysplexOSH = ObjectStateHolder('sysplex')
                    sysplexOSH.setAttribute('data_name', currSysplex[1])
                    OSHVResult.add(sysplexOSH)

                    # Create member link between lpar and sysplex
                    OSHVResult.add(modeling.createLinkOSH('member', sysplexOSH, lparOSH))

                    # Create member link between mainframe and sysplex
                    OSHVResult.add(modeling.createLinkOSH('member', mainframeOSH, sysplexOSH))

                    # connect all ips to lpar
                    for currLparIp in lparIpList:
                        if netutils.isLocalIp(currLparIp[1]):
                            continue

                        currIpOSH = modeling.createIpOSH(currLparIp[1])
                        OSHVResult.add(currIpOSH)
                        OSHVResult.add(modeling.createLinkOSH('contained', lparOSH, currIpOSH))
                break
            else:
                logger.debug("Failed to get Mainframe key.")
        else:
            errormessages.resolveAndReport("Could not perform snmp connection to %s" % DISCOVERED_IP, ClientsConsts.SNMP_PROTOCOL_NAME, Framework)

    return OSHVResult
예제 #52
0
def DiscoveryMain(Framework):
    OSHVResult = ObjectStateHolderVector()
    businessElementId = Framework.getDestinationAttribute('id')
    urlString = Framework.getDestinationAttribute('url')
    jobId = Framework.getDiscoveryJobId()
    dnsServers = Framework.getParameter('dnsServers') or None
    localShell = None

    if dnsServers:
        dnsServers = [
            dnsServer for dnsServer in dnsServers.split(',')
            if dnsServer and dnsServer.strip()
        ] or None
    if dnsServers:
        logger.debug('Using dns servers: ', dnsServers)
        localShell = shellutils.ShellUtils(
            Framework.createClient(ClientsConsts.LOCAL_SHELL_PROTOCOL_NAME))

    if not urlString:
        msg = "There is no specified URL in the input BusinessElement CI"
        errormessages.resolveAndReport(msg, jobId, Framework)
        return OSHVResult

    try:
        urlString = urlString[1:len(urlString) - 1]

        if netutils.isValidIp(urlString):
            createHostOSHwithIP(OSHVResult, urlString)
            return OSHVResult

        urlObject = URL(urlString)
        hostname = urlObject.getHost()

        if not hostname:
            logger.debug("Hostname is not defined in URL '%s'" % urlString)
            raise MalformedURLException()

        urlObjectResolver = URLObjectResolver(urlObject)
        protocol = urlObjectResolver.getProtocolFromUrlObject()
        if not protocol:
            msg = "Failed to resolve the http/https protocol from specified URL"
            errormessages.resolveAndReport(msg, jobId, Framework)
            return OSHVResult

        port = urlObjectResolver.getPortFromUrlObject()
        if not port:
            msg = "Failed to resolve the port number from specified URL"
            errormessages.resolveAndReport(msg, jobId, Framework)
            return OSHVResult

        # get topology
        # create business element CI and attach the url as configuration document CI to it
        bizOSH = modeling.createOshByCmdbIdString('business_element',
                                                  businessElementId)
        urlConfigOSH = modeling.createConfigurationDocumentOSH(
            'url.txt', '', urlString, bizOSH)
        linkBizUrlConifg = modeling.createLinkOSH('composition', bizOSH,
                                                  urlConfigOSH)
        OSHVResult.add(bizOSH)
        OSHVResult.add(urlConfigOSH)
        OSHVResult.add(linkBizUrlConifg)

        hostDNSName = None
        if not netutils.isValidIp(hostname):
            # Treat the host name as its DNS name if it is not a valid ip address
            hostDNSName = hostname

        ipAddresses = []
        if dnsServers:
            ipAddresses = urlObjectResolver.getIpFromUrlObjectWithDnsList(
                dnsServers, localShell)
        else:
            ipAddresses = urlObjectResolver.getIpFromUrlObject()
        for ipAddress in ipAddresses:
            logger.debug('Reporting ip address: ', ipAddresses)
            if not ipAddress or not netutils.isValidIp(
                    ipAddress) or netutils.isLocalIp(ipAddress):
                msg = "Failed to resolve the IP address of server from specified URL"
                errormessages.resolveAndReport(msg, jobId, Framework)
                return OSHVResult

            hostOSH, ipOSH = createHostOSHwithIP(OSHVResult, ipAddress)
            if hostDNSName:
                ipOSH.setAttribute('authoritative_dns_name', hostDNSName)

            # create UriEndpoint and relations between business element and UriEndpoint
            urlOSH = modeling.createServiceURLAddressOsh(hostOSH, urlString)
            linkBizUrl = modeling.createLinkOSH('usage', bizOSH, urlOSH)
            OSHVResult.add(urlOSH)
            OSHVResult.add(linkBizUrl)

            # create ipServiceEndpoint and relations between UriEndpoint and ipServiceEndpoint
            ipPort = modeling.createServiceAddressOsh(
                hostOSH, ipAddress, port, modeling.SERVICEADDRESS_TYPE_TCP)
            linkUrlIP = modeling.createLinkOSH('dependency', urlOSH, ipOSH)
            OSHVResult.add(ipPort)
            OSHVResult.add(linkUrlIP)

    except MalformedURLException:
        msg = "Specified URL '%s' is malformed" % urlString
        errormessages.resolveAndReport(msg, jobId, Framework)
    except:
        msg = logger.prepareJythonStackTrace("")
        errormessages.resolveAndReport(msg, jobId, Framework)

    return OSHVResult
예제 #53
0
def DiscoveryMain(Framework):

    OSHVResult = ObjectStateHolderVector()
    ms_domain_name = Framework.getDestinationAttribute('ms_domain_name')
    if not ms_domain_name:
        ms_domain_name = 'NULL'

    try:
        netUtil = MsNetworkUtil()
        hostsOutput = netUtil.doNetServerEnum('NULL',SV_TYPE_SERVER, ms_domain_name)
        if hostsOutput != None:
            discoverUnknownIPs = 1
            try:
                strDiscoverUnknownIPs = Framework.getParameter('discoverUnknownIPs');
                discoverUnknownIPs = Boolean.parseBoolean(strDiscoverUnknownIPs);
            except:
                pass

            oshMsDomain = ObjectStateHolder('msdomain')
            oshMsDomain.setStringAttribute('data_name', ms_domain_name)
            alreadyDiscoveredIps = HashMap()
            for hostInfo in hostsOutput:
                hostType = Long(hostInfo[1]).longValue()
                hostName = (str(hostInfo[0])).lower()
                try:
                    ip = InetAddress.getByName(hostInfo[0]).getHostAddress()
                    if netutils.isLocalIp(ip):
                        continue
                    cachedHostName = alreadyDiscoveredIps.get(ip)
                    if cachedHostName != None:
                        logger.debug('IP ', ip, ' already reported for host ' + cachedHostName, ' current host ', hostName, ' - skipping')
                        continue
                    else:
                        logger.debug('Discovered IP ' + ip + ' for host ' + hostName)
                        alreadyDiscoveredIps.put(ip, hostName)
                    ipDomain  = DomainScopeManager.getDomainByIp(ip)
                    if not discoverUnknownIPs and ipDomain == 'unknown':
                        logger.debug('ip: ' + ip + ' is out of probe range and will be excluded')
                        continue
                    if SV_TYPE_CLUSTER_NT & hostType:
                        logger.debug('Not reporting the entry %s because it is a Cluster' % hostName)
                        continue
                    hostOsType = 'nt'
                    if SV_TYPE_SERVER_UNIX & hostType:
                        hostOsType = 'unix'
                    oshHost = modeling.createHostOSH(ip, hostOsType)
                    oshHost.setStringAttribute("host_hostname", hostName)
                    OSHVResult.add(oshHost)

                    link = modeling.createLinkOSH('member', oshMsDomain, oshHost)
                    OSHVResult.add(link)
                    ipOSH = modeling.createIpOSH(ip)
                    OSHVResult.add(ipOSH)
                    contained = modeling.createLinkOSH('contained', oshHost, ipOSH)
                    OSHVResult.add(contained)
                except:
                    errorMsg = str(sys.exc_info()[1]).strip()
                    logger.warn('Failed to resolve host ', hostInfo[0], ' : ', errorMsg)
        else:
            message = 'Failed to discover hosts on MS Domain'
            logger.warn(message)
            logger.reportWarning(message)
    except:
        errorMsg = str(sys.exc_info()[1]).strip()
        logger.errorException('Failed to discovery MS Domains')
        errorMessage = errormessages.makeErrorMessage("msdomain", errorMsg, errormessages.ERROR_FAILED_DISCOVERING_MSDOMAIN_HOSTS)
        errobj = errorobject.createError(errorcodes.FAILED_DISCOVERIING_MSDOMAIN_HOST, ["msdomain", errorMsg], errorMessage)
        logger.reportErrorObject(errobj)
    return OSHVResult