Esempio n. 1
0
    def testGetManufacturerAndModel(self):
        r = getManufacturerAndModel("Unknown CPU Type")
        self.assertEquals(r.args[0], "Unknown CPU Type")
        self.assertEquals(r.args[1], "Unknown")

        r = getManufacturerAndModel("Intel CPU")
        self.assertEquals(r.args[0], "Intel CPU")
        self.assertEquals(r.args[1], "Intel")

        r = getManufacturerAndModel("Xeon")
        self.assertEquals(r.args[0], "Xeon")
        self.assertEquals(r.args[1], "Intel")

        r = getManufacturerAndModel("Opteron Quad-Core")
        self.assertEquals(r.args[0], "Opteron Quad-Core")
        self.assertEquals(r.args[1], "AMD")
Esempio n. 2
0
    def process(self, device, results, log):
        """collect snmp information from this device"""
        log.info('processing %s for device %s', self.name(), device.id)
        getdata, tabledata = results
        cputable = tabledata.get("cpuTable")
        cachetable = tabledata.get("cacheTable")
        if not cputable: return
        rm = self.relMap()
        cpumap = {}
        for cpu in cputable.values():
            del cpu['null']
            om = self.objectMap(cpu)
            om.setProductKey = getManufacturerAndModel(om.setProductKey)
            idx = getattr(om, 'socket', om._cpuidx)
            om.id = self.prepId("%s_%s" % (om.setProductKey,idx))
            cpumap[cpu['_cpuidx']] = om
            rm.append(om)

        if not cachetable: return rm
        for cache in cachetable.values():
            cpu = cpumap.get(cache['cpuidx'], None)
            if cpu is None: continue
            if cache['level'] == 1: 
                cpu.cacheSizeL1 = cache.get('size',0)
            elif cache['level'] == 2:
                cpu.cacheSizeL2 = cache.get('size',0)
        return rm
    def process(self, device, results, log):
        log.info(
            "Modeler %s processing data for device %s",
            self.name(), device.id)

        for cache in results.get('Win32_CacheMemory', []):
            if cache.DeviceID == 'Cache Memory 0':
                l1_cache_size = int_or_none(cache.InstalledSize)
                break
        else:
            l1_cache_size = None

        rm = self.relMap()
        for processor in results.get('Win32_Processor', []):
            product_key = getManufacturerAndModel(
                ', '.join((processor.Name, processor.Version)))

            socket_match = re.search(r'(\d+)', processor.SocketDesignation)
            if socket_match:
                socket = int_or_none(socket_match.group(1))
            else:
                socket = None

            # Not available in Windows 2003 or XP.
            cores = int_or_none(getattr(processor, 'NumberOfCores', None))
            threads = int_or_none(getattr(processor, 'NumberOfLogicalProcessors', None))
            l3_cache_size = int_or_none(getattr(processor, 'L3CacheSize', None))
            l3_cache_speed = int_or_none(getattr(processor, 'L3CacheSpeed', None))

            current_voltage = int_or_none(processor.CurrentVoltage)
            if current_voltage:
                current_voltage = current_voltage * 100

            rm.append(self.objectMap({
                'id': self.prepId(processor.DeviceID),
                'title': processor.Name,
                'description': processor.Description,
                'perfmonInstance': self.getPerfmonInstance(processor, log),
                'setProductKey': product_key,
                'socket': socket,
                'cores': cores,
                'threads': threads,
                'clockspeed': int_or_none(processor.CurrentClockSpeed),
                'extspeed': int_or_none(processor.ExtClock),
                'voltage': current_voltage,
                'cacheSizeL1': l1_cache_size,
                'cacheSizeL2': int_or_none(processor.L2CacheSize),
                'cacheSpeedL2': int_or_none(processor.L2CacheSpeed),
                'cacheSizeL3': l3_cache_size,
                'cacheSpeedL3': l3_cache_speed,
                }))

        return rm
Esempio n. 4
0
    def process(self, device, results, log):
        """collect snmp information from this device"""
        log.info('processing %s (Cache) for device %s', self.name(), device.id)
        L1Cache = None
        for cache in results["Win32_CacheMemory"]:
            if cache.deviceid == 'Cache Memory 0':  # This is the L1 Cache
                L1Cache = int(cache.installedsize)
                break
            else:
                continue

        log.info('processing %s (CPU) for device %s', self.name(), device.id)
        maps = []
        rm = self.relMap()
        for cpu in results["Win32_Processor"]:
            if cpu.deviceid is not None:
                om = self.objectMap()
                om.id = prepId(cpu.deviceid)
                om.setProductKey = getManufacturerAndModel(cpu.manufacturer +
                                                           " " +
                                                           cpu.description)
                om.socket = cpu.socketdesignation
                if isinstance(om.socket, basestring):
                    integerMatch = FIND_INTEGER(om.socket)
                    if integerMatch:
                        om.socket = int(integerMatch.group(0))
                om.clockspeed = cpu.currentclockspeed
                om.extspeed = cpu.extclock
                om.voltage = int(cpu.currentvoltage) * 100
                if L1Cache:
                    om.cacheSizeL1 = L1Cache

                # the l2cachesize attribute isn't correct on multicore CPUs
                # when running in VMware
                try:
                    om.cacheSizeL2 = int(cpu.l2cachesize)
                except (TypeError, ValueError):
                    om.cacheSizeL2 = 0

                om.perfmonInstance = self.getPerfmonInstance(cpu, log)
                rm.append(om)

        maps.append(rm)
        return maps
    def process(self, device, results, log):
        """collect snmp information from this device"""
        log.info('processing %s (Cache) for device %s', self.name(), device.id)
        L1Cache = None
        for cache in results["Win32_CacheMemory"]:
            if cache.deviceid == 'Cache Memory 0': # This is the L1 Cache
                L1Cache = int(cache.installedsize)
                break
            else:
                continue
            
        log.info('processing %s (CPU) for device %s', self.name(), device.id)
        maps = []
        rm = self.relMap()
        for cpu in results["Win32_Processor"]:
            if cpu.deviceid is not None:
                om = self.objectMap()
                om.id = prepId(cpu.deviceid)
                om.setProductKey = getManufacturerAndModel(
                    cpu.manufacturer + " " + cpu.description)
                om.socket = cpu.socketdesignation
                if isinstance(om.socket, basestring):
                    integerMatch = FIND_INTEGER(om.socket)
                    if integerMatch:
                        om.socket = int(integerMatch.group(0))
                om.clockspeed = cpu.currentclockspeed
                om.extspeed = cpu.extclock
                om.voltage = int(cpu.currentvoltage) * 100
                if L1Cache:
                    om.cacheSizeL1 = L1Cache
                    
                # the l2cachesize attribute isn't correct on multicore CPUs
                # when running in VMware
                try:
                    om.cacheSizeL2 = int(cpu.l2cachesize)
                except (TypeError, ValueError):
                    om.cacheSizeL2 = 0

                om.perfmonInstance = self.getPerfmonInstance(cpu, log)
                rm.append(om)
            
        maps.append(rm)
        return maps
Esempio n. 6
0
    def process(self, device, results, log):
        """collect snmp information from this device"""
        log.info('processing %s for device %s', self.name(), device.id)
        getdata, tabledata = results
        cputable = tabledata.get("cpuTable")
        cachetable = tabledata.get("cacheTable")
        if not cputable: return
        rm = self.relMap()
        cpumap = {}
        for cpu in cputable.values():
            om = self.objectMap(cpu)
            if not getattr(om, '_manuf', False):
                continue
            try:
                cpufam = self.cpufamily[cpu['_familyidx'] - 1]
            except IndexError:
                cpufam = ""
            if not cpufam.startswith(om._manuf):
                cpufam = om._manuf + " " + cpufam
            om.setProductKey = getManufacturerAndModel(cpufam + " " +
                                                       om._version)
            om.title = "%s_%s" % (om._manuf, om.socket)
            om.id = self.prepId(om.title)
            cpumap[om.socket] = om
            rm.append(om)

        for cache in cachetable.values():
            cpu = cpumap.get(cache.get('cpusock', None), None)
            if cpu is None: continue
            try:
                level = self.cacheLevel[cache['level'] - 1]
            except IndexError:
                level = None
            if level == "L1":
                cpu.cacheSizeL1 = cache['size']
            elif level == "L2":
                cpu.cacheSizeL2 = cache['size']
        return rm
Esempio n. 7
0
    def process(self, device, results, log):
        log.info("Modeler %s processing data for device %s", self.name(),
                 device.id)

        for cache in results.get('Win32_CacheMemory', []):
            if cache.DeviceID == 'Cache Memory 0':
                l1_cache_size = int_or_none(cache.InstalledSize)
                break
        else:
            l1_cache_size = None

        rm = self.relMap()
        for processor in results.get('Win32_Processor', []):
            product_key = getManufacturerAndModel(', '.join(
                (processor.Name, processor.Version)))

            if processor.SocketDesignation:
                socket_match = re.search(r'(\d+)', processor.SocketDesignation)
                if socket_match:
                    socket = int_or_none(socket_match.group(1))
                else:
                    socket = None

            # Not available in Windows 2003 or XP.
            cores = int_or_none(getattr(processor, 'NumberOfCores', None))
            threads = int_or_none(
                getattr(processor, 'NumberOfLogicalProcessors', None))
            l3_cache_size = int_or_none(getattr(processor, 'L3CacheSize',
                                                None))
            l3_cache_speed = int_or_none(
                getattr(processor, 'L3CacheSpeed', None))

            current_voltage = int_or_none(processor.CurrentVoltage)
            if current_voltage:
                current_voltage = current_voltage * 100

            rm.append(
                self.objectMap({
                    'id':
                    self.prepId(processor.DeviceID),
                    'title':
                    processor.Name,
                    'description':
                    processor.Description,
                    'perfmonInstance':
                    self.getPerfmonInstance(processor, log),
                    'setProductKey':
                    product_key,
                    'socket':
                    socket,
                    'cores':
                    cores,
                    'threads':
                    threads,
                    'clockspeed':
                    int_or_none(processor.CurrentClockSpeed),
                    'extspeed':
                    int_or_none(processor.ExtClock),
                    'voltage':
                    current_voltage,
                    'cacheSizeL1':
                    check_value(l1_cache_size),
                    'cacheSizeL2':
                    check_value(int_or_none(processor.L2CacheSize)),
                    'cacheSpeedL2':
                    check_value(int_or_none(processor.L2CacheSpeed)),
                    'cacheSizeL3':
                    check_value(l3_cache_size),
                    'cacheSpeedL3':
                    check_value(l3_cache_speed),
                }))

        return rm