Python win32pdh.AddCounter方法代碼示例

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def GetPerformanceAttributes(object, counter, instance=None,
                                 inum=-1, format=None, machine=None):
        # NOTE: Many counters require 2 samples to give accurate results,
        # including "% Processor Time" (as by definition, at any instant, a
        # thread's CPU usage is either 0 or 100).  To read counters like this,
        # you should copy this function, but keep the counter open, and call
        # CollectQueryData() each time you need to know.
        # See http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp (dead link)
        # My older explanation for this was that the "AddCounter" process forced
        # the CPU to 100%, but the above makes more sense :)
        import win32pdh
        if format is None:
            format = win32pdh.PDH_FMT_LONG
        path = win32pdh.MakeCounterPath( (machine, object, instance, None, inum, counter))
        hq = win32pdh.OpenQuery()
        try:
            hc = win32pdh.AddCounter(hq, path)
            try:
                win32pdh.CollectQueryData(hq)
                type, val = win32pdh.GetFormattedCounterValue(hc, format)
                return val
            finally:
                win32pdh.RemoveCounter(hc)
        finally:
            win32pdh.CloseQuery(hq) 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def GetPerformanceAttributes(object, counter, instance=None,
                                 inum=-1, format=None, machine=None):
        # NOTE: Many counters require 2 samples to give accurate results,
        # including "% Processor Time" (as by definition, at any instant, a
        # thread's CPU usage is either 0 or 100).  To read counters like this,
        # you should copy this function, but keep the counter open, and call
        # CollectQueryData() each time you need to know.
        # See http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp
        # My older explanation for this was that the "AddCounter" process forced
        # the CPU to 100%, but the above makes more sense :)
        import win32pdh
        if format is None:
            format = win32pdh.PDH_FMT_LONG
        path = win32pdh.MakeCounterPath( (machine, object, instance, None, inum, counter))
        hq = win32pdh.OpenQuery()
        try:
            hc = win32pdh.AddCounter(hq, path)
            try:
                win32pdh.CollectQueryData(hq)
                type, val = win32pdh.GetFormattedCounterValue(hc, format)
                return val
            finally:
                win32pdh.RemoveCounter(hc)
        finally:
            win32pdh.CloseQuery(hq) 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def open(self,*args,**namedargs):
		'''
		Explicitly open a query:
		When you are needing to make multiple calls to the same query,
		it is most efficient to open the query, run all of the calls,
		then close the query, instead of having the collectdata method
		automatically open and close the query each time it runs.
		There are currently no arguments to open.
		'''
		# do all the normal opening stuff, self._base is now the query object
		BaseQuery.open(*(self,)+args, **namedargs)
		# should rewrite getinstpaths to take a single tuple
		paths = []
		for tup in self.volatilecounters:
			paths[len(paths):] = self.getinstpaths(*tup)
		for path in paths:
			try:
				self.counters.append(win32pdh.AddCounter(self._base, path))
				self.curpaths.append(path) # if we fail on the line above, this path won't be in the table or the counters
			except win32api.error:
				pass # again, what to do with a malformed path??? 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def GetPerformanceAttributes(object, counter, instance = None, inum=-1,
                             format = win32pdh.PDH_FMT_LONG, machine=None):
    # NOTE: Many counters require 2 samples to give accurate results,
    # including "% Processor Time" (as by definition, at any instant, a
    # thread's CPU usage is either 0 or 100).  To read counters like this,
    # you should copy this function, but keep the counter open, and call
    # CollectQueryData() each time you need to know.
    # See http://support.microsoft.com/default.aspx?scid=kb;EN-US;q262938
    # and http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp
    # My older explanation for this was that the "AddCounter" process forced
    # the CPU to 100%, but the above makes more sense :)
    path = win32pdh.MakeCounterPath( (machine,object,instance, None, inum,counter) )
    hq = win32pdh.OpenQuery()
    try:
        hc = win32pdh.AddCounter(hq, path)
        try:
            win32pdh.CollectQueryData(hq)
            type, val = win32pdh.GetFormattedCounterValue(hc, format)
            return val
        finally:
            win32pdh.RemoveCounter(hc)
    finally:
        win32pdh.CloseQuery(hq) 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def GetPerformanceAttributes(object, counter, instance = None,
                                 inum=-1, format = None, machine=None):
        # NOTE: Many counters require 2 samples to give accurate results,
        # including "% Processor Time" (as by definition, at any instant, a
        # thread's CPU usage is either 0 or 100).  To read counters like this,
        # you should copy this function, but keep the counter open, and call
        # CollectQueryData() each time you need to know.
        # See http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp
        # My older explanation for this was that the "AddCounter" process forced
        # the CPU to 100%, but the above makes more sense :)
        import win32pdh
        if format is None: format = win32pdh.PDH_FMT_LONG
        path = win32pdh.MakeCounterPath( (machine, object, instance, None, inum, counter) )
        hq = win32pdh.OpenQuery()
        try:
            hc = win32pdh.AddCounter(hq, path)
            try:
                win32pdh.CollectQueryData(hq)
                type, val = win32pdh.GetFormattedCounterValue(hc, format)
                return val
            finally:
                win32pdh.RemoveCounter(hc)
        finally:
            win32pdh.CloseQuery(hq) 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def _setup_query(self, which):
        inum = -1
        instance = None
        machine = None
        object = "Processor(%s)" % which
        counter = "% Processor Time"
        path = win32pdh.MakeCounterPath( (machine, object, instance,
                                          None, inum, counter) )
        hq = win32pdh.OpenQuery()
        self.hqs.append(hq)
        try:
            hc = win32pdh.AddCounter(hq, path)
            self.hcs.append(hc)
        except:
            self.close()
            raise 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def ShowAllProcesses():
    object = find_pdh_counter_localized_name("Process")
    items, instances = win32pdh.EnumObjectItems(None,None,object,
                                                win32pdh.PERF_DETAIL_WIZARD)
    # Need to track multiple instances of the same name.
    instance_dict = {}
    for instance in instances:
        try:
            instance_dict[instance] = instance_dict[instance] + 1
        except KeyError:
            instance_dict[instance] = 0

    # Bit of a hack to get useful info.
    items = [find_pdh_counter_localized_name("ID Process")] + items[:5]
    print "Process Name", ",".join(items)
    for instance, max_instances in instance_dict.iteritems():
        for inum in xrange(max_instances+1):
            hq = win32pdh.OpenQuery()
            hcs = []
            for item in items:
                path = win32pdh.MakeCounterPath( (None,object,instance,
                                                  None, inum, item) )
                hcs.append(win32pdh.AddCounter(hq, path))
            win32pdh.CollectQueryData(hq)
            # as per http://support.microsoft.com/default.aspx?scid=kb;EN-US;q262938, some "%" based
            # counters need two collections
            time.sleep(0.01)
            win32pdh.CollectQueryData(hq)
            print "%-15s\t" % (instance[:15]),
            for hc in hcs:
                type, val = win32pdh.GetFormattedCounterValue(hc, win32pdh.PDH_FMT_LONG)
                print "%5d" % (val),
                win32pdh.RemoveCounter(hc)
            print
            win32pdh.CloseQuery(hq)

# NOTE: This BrowseCallback doesn't seem to work on Vista for markh.
# XXX - look at why!? 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def getcpuload():
        cpupath = win32pdh.MakeCounterPath((None, 'Processor', '_Total', None, -1, '% Processor Time'))
        query = win32pdh.OpenQuery(None, 0)
        counter = win32pdh.AddCounter(query, cpupath, 0)
        win32pdh.CollectQueryData(query)
        time.sleep(0.1)
        win32pdh.CollectQueryData(query)
        status, value = win32pdh.GetFormattedCounterValue(counter, win32pdh.PDH_FMT_LONG)
        return float(value) / 100.0 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def FindChildrenOf(self, parentid):

        childPids = []

        object = "Process"
        items, instances = win32pdh.EnumObjectItems(None, None, object, win32pdh.PERF_DETAIL_WIZARD)

        instance_dict = {}
        for instance in instances:
            if instance in instance_dict:
                instance_dict[instance] += 1
            else:
                instance_dict[instance] = 0

        for instance, max_instances in instance_dict.items():
            for inum in range(max_instances + 1):
                hq = win32pdh.OpenQuery()
                try:
                    hcs = []

                    path = win32pdh.MakeCounterPath((None, object, instance, None, inum, "ID Process"))
                    hcs.append(win32pdh.AddCounter(hq, path))

                    path = win32pdh.MakeCounterPath((None, object, instance, None, inum, "Creating Process ID"))
                    hcs.append(win32pdh.AddCounter(hq, path))

                    try:
                        # If the process goes away unexpectedly this call will fail
                        win32pdh.CollectQueryData(hq)

                        type, pid = win32pdh.GetFormattedCounterValue(hcs[0], win32pdh.PDH_FMT_LONG)
                        type, ppid = win32pdh.GetFormattedCounterValue(hcs[1], win32pdh.PDH_FMT_LONG)

                        if int(ppid) == parentid:
                            childPids.append(int(pid))
                    except:
                        pass

                finally:
                    win32pdh.CloseQuery(hq)

        return childPids 

# 需要導入模塊: import win32pdh [as 別名]
# 或者: from win32pdh import AddCounter [as 別名]
def collect_counters(self):
        counters, instances = win32pdh.EnumObjectItems(
            None, self._machine_name, self._class_name, win32pdh.PERF_DETAIL_WIZARD
        )
        if self._instance_name is None and len(instances) > 0:
            all_instances = set()
            for inst in instances:
                path = self._make_counter_path(self._machine_name, self._counter_name, inst, counters)
                if not path:
                    continue
                all_instances.add(inst)

                try:
                    if inst not in self.counterdict:
                        self.logger.debug('Adding instance `%s`', inst)
                        self.counterdict[inst] = win32pdh.AddCounter(self.hq, path)
                except:  # noqa: E722
                    self.logger.fatal(
                        "Failed to create counter.  No instances of %s\\%s" % (self._class_name, self._counter_name)
                    )

            expired_instances = set(self.counterdict) - all_instances
            for inst in expired_instances:
                self.logger.debug('Removing expired instance `%s`', inst)
                del self.counterdict[inst]
        else:
            if self._instance_name is not None:
                # check to see that it's valid
                if len(instances) <= 0:
                    self.logger.error(
                        "%s doesn't seem to be a multi-instance counter, but asked for specific instance %s",
                        self._class_name,
                        self._instance_name,
                    )
                    raise AttributeError("%s is not a multi-instance counter" % self._class_name)
                if self._instance_name not in instances:
                    self.logger.error("%s is not a counter instance in %s", self._instance_name, self._class_name)
                    raise AttributeError("%s is not an instance of %s" % (self._instance_name, self._class_name))

            path = self._make_counter_path(self._machine_name, self._counter_name, self._instance_name, counters)
            if not path:
                self.logger.warning("Empty path returned")
            elif win32pdh.ValidatePath(path) != 0:
                # Multi-instance counter with no instances presently
                pass
            else:
                try:
                    if SINGLE_INSTANCE_KEY not in self.counterdict:
                        self.logger.debug('Adding single instance for path `%s`', path)
                        self.counterdict[SINGLE_INSTANCE_KEY] = win32pdh.AddCounter(self.hq, path)
                except:  # noqa: E722
                    self.logger.fatal(
                        "Failed to create counter.  No instances of %s\\%s" % (self._class_name, self._counter_name)
                    )
                    raise
                self._is_single_instance = True