杀毒

开发平台：
Visual C++

Scheduler.py：源码内容
							#-----------------------------------------------------------------------------
# Name:        Scheduler.py
# Product:     ClamWin Free Antivirus
#
# Author:      alch [alch at users dot sourceforge dot net]
#
# Created:     2004/19/03
# Copyright:   Copyright alch (c) 2004
# Licence:     
#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
# 
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
# 
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software
#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#-----------------------------------------------------------------------------
#!/usr/bin/env python
import os, tempfile
import sched, time, locale
import types
import threading
class Scheduler(threading.Thread):
    # empty tuple for status_filenames parameter will reuslt in no checking
    # for missed schedules
    def __init__(self, frequency, startTime, weekDay, action, argument=(), 
            status_filenames=(), loopDelay = 0.5):           
        threading.Thread.__init__(self)    	    
        self._filenames = status_filenames
        self._delay = 0.5
        self._loopDelay = loopDelay
        self._cancelling = False
        self._frequency = frequency                    
        self._weekDay = weekDay
        self._startTime = startTime                             
                
        self._action = action
        self._argument = argument
        self._lastRun = self._ReadLastRun()                
            
        self._sched = sched.scheduler(time.time, self._DelayFunc)        
        self._missedSchedule = False
        self._id = self._sched.enterabs(self._CalcNextRun(), 0, self._RunTask, ())
        
    def reset(self, frequency, startTime, weekDay, action, argument=(), loopDelay = 0.2):
        self._delay = 1.0
        self._loopDelay = loopDelay
        self._cancelling = False
        self._frequency = frequency                    
        self._weekDay = weekDay
        self._startTime = startTime                             
                
        self._action = action
        self._argument = argument
        self._lastRun = self._ReadLastRun()
        self._missedSchedule = False
        
        # stop current thread
        self.stop()
        threading.Thread.__init__(self)    	    
        
        
        # ensure it stopped
        i = 0        
        while self.isAlive() and i < 50:
            time.sleep(0.1)
            i+=1
            
        # recreate scheduled event                                                
        self._id = self._sched.enterabs(self._CalcNextRun(), 0, self._RunTask, ())
                
        
    def _ReadLastRun(self):        
        # 0 signifies an error  	
        t = 0
        # read when the task was run last        
        for filename in self._filenames:
            try:
                f = file(os.path.join(tempfile.gettempdir(), filename), 'r')
                t = f.read()
                f.close()            
            except:
                t = 0
                continue
            # check that we have a float
            if not isinstance(t, types.FloatType):
                t = 0
                continue
            if time.time() < float(t):                
                # got time in future, ignore it
                t = 0
                continue    
            else:
                break
                
        return float(t)        
            
    def _WriteLastRun(self):
        # save time when the task was run for future
        for filename in self._filenames:
            try:                        
                f = file(os.path.join(tempfile.gettempdir(), filename), 'w')
                f.write(str(self._lastRun))
                f.close()                       
            except IOError:            
                pass
            
    def _AdjustDST(self, t):
        # deal with daylight savings, if we're on the edge        
        dstDiff = time.localtime().tm_isdst - time.localtime(t).tm_isdst
        t += dstDiff * 3600.00
        return t
    # returns time in seconds (as in time.time())
    # when next scheduled run occurs
    def _CalcNextRun(self):
        # calculate when the next task should run
        # depending on last run time, update frequency,
        # task start time and day of the week
        
        # set C locale, otherwise python and wxpython complain
        locale.setlocale(locale.LC_ALL, 'C')            
        # get current time, skip milliseconds
        t = time.time()
        if self._frequency == 'Hourly':                        
            try:
                # use only MM:SS part of starttime                            
                schedTime = time.mktime(time.strptime(time.strftime('%d-%m-%Y %H:') + self._startTime.split(':', 1)[1],'%d-%m-%Y %H:%M:%S'))                                
            except ValueError, e:            
                print "couldn't parse time, self._startTime = %s.n Error: %s" % (self._startTime, str(e))
                self._missedSchedule = True
                schedTime = t + 120
            addTime = 3600.0            
        elif self._frequency in ('Weekly', 'Once'):        
            try:
                lt = time.localtime(t)
                # use  weekday and HH:MM:SS part of starttime
                schedTime = time.mktime(time.strptime(str(lt.tm_yday - lt.tm_wday + self._weekDay) + 
                            time.strftime(' %Y ', lt) + self._startTime, '%j %Y %H:%M:%S')) 
            except ValueError, e:
                print "couldn't parse time, self._startTime = %s. self._weekDay = %in Error: %s" % (self._startTime, self._weekDay, str(e))
                self._missedSchedule = True
                schedTime = t + 120
            addTime = 3600.0*24*7                    
        else: #'Daily' or 'Workdays' is default                    
            try:
                # use HH:MM:SS part of starttime
                schedTime = time.mktime(time.strptime(time.strftime('%d-%m-%Y ') + self._startTime,'%d-%m-%Y %H:%M:%S'))                                
            except ValueError, e:                
                self._missedSchedule = True
                schedTime = t + 120
                print "couldn't parse time, self._startTime = %s.n Error: %s" % (self._startTime, str(e))
            addTime = 3600.0*24
            
        
        # go to next time interval if it is out
        tmp = schedTime
        while self._AdjustDST(schedTime) < t:            
            schedTime += addTime                 
        
        # move out of the weekend for workdays            
        if self._frequency == 'Workdays':                        
            while time.localtime(self._AdjustDST(schedTime)).tm_wday in (5,6):
                schedTime += addTime  
            if tmp < schedTime:             
                addTime = schedTime - tmp
                
        #don't return for missed schedule if frequency is workdays and it is weekend now
        if self._frequency != 'Workdays' or time.localtime(t).tm_wday not in (5,6):        	
            # check if we missed the scheduled run
            # and return now (+ 2 minutes) instead            
            if  self._lastRun != 0 and self._AdjustDST(schedTime) - addTime > self._lastRun:
                t = t + 120
                print 'Schedule missed, returning: %s' % time.asctime(time.localtime(t))
                try:
		              print 'LastRun: %s' % time.asctime(time.localtime(self._lastRun))
                except:
		              pass
                self._missedSchedule = True
                return t
                
        schedTime = self._AdjustDST(schedTime)
        print 'Scheduling task for: %s' % time.asctime(time.localtime(schedTime))        
        return schedTime + self._delay
                                  
    def _RunTask(self):
        # get current time        
        if self._cancelling:            
            return 
        # set C locale, otherwise python and wxpython complain
        locale.setlocale(locale.LC_ALL, 'C')
                                           
        t = time.time()
                                
        # execute the action
        print 'running task on: %s. Frequency is: %sn' % (time.strftime('%d-%m-%y %H:%M:%S', time.localtime(t)), self._frequency)
        void = self._action(*self._argument)
        self._lastRun = t
        self._WriteLastRun()
        
        # schedule next action        
        if self._frequency != 'Once' and not self._missedSchedule:                        
            self._id = self._sched.enterabs(self._CalcNextRun(), 0, self._RunTask, ())               
        
    def _DelayFunc(self, delay):
        start = time.time()
        while not self._cancelling and int(time.time() - start) < int(delay):
            time.sleep(self._loopDelay)                                    
                        
    def run(self):
        self._sched.run()
        print 'Scheduler terminated'
        
    def stop(self):
        try:
           self._sched.cancel(self._id)        
        except:
           pass        
        self._cancelling = True                                        
if __name__ == '__main__':
    import sys
    def action():
        print 'execute'
        
    s = Scheduler('Workdays', '20:20:00', 5, action)
    s.start()
    while sys.stdin.read(1) != 'c':
        time.sleep(0)
    s.stop()    
    s.join(1)
    print 'completed'
    
        
        

						