[python-win32] NTService detecting if the Windows System is Idle

[Hughes, Chad O]

I think this example is what you want to do. It is not a service, but
you can turn it into one.

import win32pdh
from time import sleep
import threading

pdhQuery = win32pdh.OpenQuery(None, 0)

class PDH_COUNTER_PATH_ELEMENTS(list):
  def __init__(self, l = None):
    if not l:
      l = ['127.0.0.1',None,None,None,-1,None]
    list.__init__(self,l)
    self.__machineName = self[0]
    self.__objectName = self[1]
    self.__instanceName = self[2]
    self.__parantInstance = self[3]
    self.__instanceIndex = self[4]
    self.__counterName = self[5]
  def __setMachineName(self,value):
    self.__machineName = value
    self[0] = value
  def __setObjectName(self,value):
    self.__objectName = value
    self[1] = value
  def __setInstanceName(self,value):
    self.__instanceName = value
    self[2] = value
  def __setParentInstance(self,value):
    self.__parentInstance = value
    self[3] = value
  def __setInstanceIndex(self,value):
    self.__instanceIndex = value
    self[4] = value
  def __setCounterName(self,value):
    self.__counterName = value
    self[5] = value
  def __getMachineName(self):
    return self.__machineName
  def __getObjectName(self):
    return self.__objectName
  def __getInstanceName(self):
    return self.__instanceName
  def __getParentInstance(self):
    return self.__parentInstance
  def __getInstanceIndex(self):
    return self.__instanceIndex
  def __getCounterName(self):
    return self.__counterName
  machineName = property(__getMachineName, __setMachineName)
  objectName = property(__getObjectName, __setObjectName)
  instanceName = property(__getInstanceName, __setInstanceName)
  instanceIndex = property(__getInstanceIndex, __setInstanceIndex)
  parentInstanceIndex = property(__getParentInstance,
__setParentInstance)
  counterName = property(__getCounterName, __setCounterName)
  def makeCopy(self):
    return PDH_COUNTER_PATH_ELEMENTS(self)
  def __repr__(self):
    return 'machineName = %s\nobjectName = %s\nInstanceName =
%s\nparentInstance = %s\ninstanceIndex = %s\ncounterName =
%s'%tuple(self) 

class WorkerThread(threading.Thread):
  def __init__(self):
    threading.Thread.__init__(self, target = self.__runLoop)
    self.__pauseEvent = threading.Event()
    #when wait is called after clear the thread will pause until set  
    self.__pauseEvent.clear()
    self.__stayAlive = True
  def stop(self):
    self.__stayAlive = False
    #loop until runLoop is exited
    while self.isAlive():
      self.__pauseEvent.set()
  def pause(self):
    self.__pauseEvent.clear()
  def resume(self):
    self.__pauseEvent.set()
  def __runLoop(self):
    while self.__stayAlive:
      self.__pauseEvent.wait()
      #do what ever you want to do while the CPU is idle
      #example print that cpu is idle
      print 'The CPU is idle'
      

#make paths
cpe = PDH_COUNTER_PATH_ELEMENTS((
  '127.0.0.1',
  "Processor",
  '_Total', 
  None,
  -1,
  "% Idle Time"
))
#you can replace _Total with a CPU id.
#For example: replace it with 0 for the first CPU
#Look up Perfmon for more details 

procPath = win32pdh.MakeCounterPath(cpe)
procCounter = win32pdh.AddCounter(pdhQuery, procPath, 0)

#For Windows to get a good statistic you must collect once first.
#That way Windows can form a delta on the CPU usage.
win32pdh.CollectQueryData(pdhQuery)
sleep(.1)

#Lets say that the CPU is idle if it has 60% or more idle time. 
threshold = 90

worker = WorkerThread()
worker.start()
while 1:
  #type CTRL-C to stop
  try:
    #Collect the percient idle time
    win32pdh.CollectQueryData(pdhQuery) 
    format = win32pdh.PDH_FMT_LONG | win32pdh.PDH_FMT_NOSCALE
    idleTime = win32pdh.GetFormattedCounterValue(procCounter, format)[1]
    print idleTime 
    if idleTime >= threshold:
      worker.resume()
    else:
      worker.pause()
    sleep(.1)
  except:
    print 'Stopping thread'
    worker.stop()
    worker.join()
    raise


 
Chad

-----Original Message-----
From: Animesh Bansriyar [mailto:animesh at neolinuxsolutions.com] 
Sent: Friday, June 10, 2005 12:19 PM
To: Hughes, Chad O
Subject: RE: [python-win32] NTService detecting if the Windows System is
Idle



Chad,

Thanks for the reply. What I mean here is something like say, "Google
Desktop Search". The Indexer for Google Desktop Search doesn't run until
the system is "IDLE". I am not too sure what the word IDLE means. 

On Fri, 2005-06-10 at 21:51, Hughes, Chad O wrote:
> Are you saying that you want to launch a program that waits until the 
> CPU's idle time is at a given threshold and once the threshold is met 
> the program does something until the threshold is no longer met after 
> wich your app waits for the threshold again?
> 

In my case the application uses both more memory and more CPU, hence if
the application runs throughout, the systems become slow to use. So as
you sugessted, we could have a threshold like say, the NTService runs
when the System utilizes less than 5% of the RAM and 5% of CPU. Could
you help in this regard. Does it make sense?

Thanks in Advance,
Animesh