转载请注明出处：http://blog.csdn.net/dysj4099

   上文提到如何使用Python通过WMI获取Windows系统信息，而本文将演示如何通过Windows服务框架包装监控数据轮询及数据发布任务。在《利用Linux守护进程机制完成一个简单系统监控demo》这篇博文中，我提到希望目标监控agent满足易用性、扩展性、稳定性以及可控性四大特点，其中稳定性是重中之重，它保证agent能够在不过多占用系统资源的情况下忠实可靠地完成轮询任务。在Linux系统中我们用一个Python实现的守护进程框架实现了这个目标，而至于Windows平台，由于进程管理方式的差异，我们不能沿用Linux的方法，但Windows的服务框架为我们提供了一种更方便的方法来实现这个目标，下面是具体的使用方法。

#coding:utf-8
# PollManager.py
import win32serviceutil
import win32service
import win32event
import win32evtlogutil
import time
import json
import urllib2
import traceback
from WinPollster import WinPollster

def wr_data(url, obj):
    '''Write data/parameter through HttpServer.'''
    data = json.dumps(obj)
    res = None
    try:
        req = urllib2.Request(url, data, {'Content-Type': 'application/json'})
        res = urllib2.urlopen(req, timeout=5)
        return res.read()
    except Exception, err:
        return False
    finally:
        if res:
            res.close()

class PollManager(win32serviceutil.ServiceFramework):
    _svc_name_ = "agent_poll_manager"
    _svc_display_name_ = "agent_poll_manager"
    _wp = None
    _wr_url = None
    _poll_intvl = None

    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
        self._wr_url = 'http://127.0.0.1:8655/'
        self._wp = WinPollster()
        self._poll_intvl = 20
        print 'Service start.'
        
    def SvcDoRun(self):
        import servicemanager
        servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,servicemanager.PYS_SERVICE_STARTED,(self._svc_name_, ''))

        self.timeout=100
        while True:
            rc=win32event.WaitForSingleObject(self.hWaitStop,self.timeout)
            
            if rc == win32event.WAIT_OBJECT_0:
                break
            else:
                wr_obj = self._wp.combine()
                if wr_obj:
                    # Write to Http Server
                    wr_data('%s%s' %(self._wr_url, 'setdata'), wr_obj)
                    # Append to file
                    f=open('c:\\time.txt','a')
                    f.write('%s %s'%(str(wr_obj), '\n'))
                    f.close()
                time.sleep(self._poll_intvl)
        return


    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        win32event.SetEvent(self.hWaitStop)
        print 'Service stop'
        return

if __name__=='__main__':
    win32serviceutil.HandleCommandLine(PollManager)

win32serviceutil.ServiceFramework 是封装得很好的Windows服务框架， PollManager 类通过继承它并重写 SvcDoRun 和 SvcStop 方法就能获得Windows服务的功能，其中需要做的事情在 SvcDoRun 中定义。在这个例子中，我将轮询任务封装在While True循环中，每个20秒获取一次系统信息，数据封装成JSON格式后追加写入c:\data_sample.txt文件中。代码中 wr_data 函数的作用我会在下面提到。

使用方法非常简单，在Windows shell下:

# 安装服务
python PollManager.py install

# 启动服务
python PollManager.py start

# 停止服务
python PollManager.py stop

就可以完成对服务的启动，是不是很简单？并且你能够通过Windows服务管理器查看并管理这个服务，设定工作模式、恢复策略以及查看日志等。通过这个服务框架，能够比较轻松的管理自定义的服务。需要注意的一点是，必须在Administrator账户下才能使用此服务框架，否则会报 拒绝访问 的错误。

当轮询任务每隔20秒一次忠实的执行同时，除了写入文件中，我们还需要一个对外提供数据的接口，在这个例子中，我将同样使用Windows服务框架包装一个Http Server，功能很简单，就是提供数据的写入及读出功能。而PollManager通过调用wr_data函数将数据写入由Http Server维护的缓冲区中。

# HttpServer.py
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SocketServer import ThreadingMixIn
import threading
import json
from datetime import datetime
import time
import subprocess
import sys

# Look up the full hostname using gethostbuaddr() is too slow.
import BaseHTTPServer
def not_insance_address_string(self):
    host, port = self.client_address[:2]
    # Just only return host.
    return '%s (no getfqdn)' % host
BaseHTTPServer.BaseHTTPRequestHandler.address_string = not_insance_address_string

class Handler(BaseHTTPRequestHandler):
    content = {'data':'test'}
    intvl = 10
    
    # timestamp of get from host
    ts_get = ''

    def do_GET(self):
        if self.path == '/getdata':
            self.send_response(200)
            self.send_header("Content-type", "text/json")
            Handler.ts_get = time.asctime(time.localtime())
            t_content = datetime.strptime(Handler.content['timestamp'], "%a %b %d %H:%M:%S %Y")
            t_last_get = datetime.strptime(Handler.ts_get, "%a %b %d %H:%M:%S %Y")
            if (t_last_get - t_content).seconds < 60:
                Handler.content['status'] = 'NORMAL'
            else:
                Handler.content['status'] = 'POLLING_TIMEOUT'
                Handler.content['data'] = {}
            obj_str = json.dumps(Handler.content)
            self.send_header("Content-Length", str(len(obj_str)))
            self.end_headers()
            self.wfile.write(obj_str.encode())
            self.wfile.write('\n')
        else:
            self.send_response(404)
            self.end_headers()

    def do_POST(self):
        if self.path == '/setdata':
            length = self.headers['content-length']
            data = self.rfile.read(int(length))
            Handler.content = eval(data.decode())
            self.send_response(200)
            self.end_headers()
            self.wfile.write(str(Handler.content))
            self.wfile.write('\n')
        else:
            self.send_response(404)
            self.end_headers()

class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    """Handle requests in a separate thread."""

    # Rewrite for service stop
    def serve_forever(self):
        self.stop_serving = False
        while not self.stop_serving:
            self.handle_request()

    # Rewrite for service stop
    def stop (self):
        self.stop_serving = True
        self.socket.close()

if __name__ == '__main__':
    server = None
    try:
        server = ThreadedHTTPServer(('0.0.0.0', 8655), Handler)
        print 'Starting server, use <Ctrl-C> to stop'
        server.serve_forever()
    except:
        if server:
            server.socket.close()

在上面的代码中，通过继承 BaseHTTPRequestHandler 和 ThreadingMixIn 类包装了一个基于多线程的Http Server，它响应 setdata 和 getdata 两种操作， PollManager 负责在轮询获取数据之后将数据存入 Handler 的 content 中作为缓冲，而外界可以通过 getdata 获取到缓冲区中的数据，并且当 PollManager 超过60秒没有写入新的数据时将数据缓冲区清空并设置超时标记。

下面，尝试用windows服务框架封装这个Http Server：

#coding:utf-8
# HttpServerManager.py
import win32serviceutil
import win32service
import win32event
import win32evtlogutil
import time
import traceback
from HttpServer import Handler
from HttpServer import ThreadedHTTPServer

class HttpServerManager(win32serviceutil.ServiceFramework):
    _svc_name_ = "agent_http_server"
    _svc_display_name_ = "agent_http_server"
    _http_server = None

    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
        self._http_server = ThreadedHTTPServer(('0.0.0.0', 8655), Handler)
        print 'Service start.'
        
    def SvcDoRun(self):
        import servicemanager
        servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,servicemanager.PYS_SERVICE_STARTED,(self._svc_name_, ''))
        self._http_server.serve_forever()
        return

    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        self._http_server.stop()
        win32event.SetEvent(self.hWaitStop)
        print 'Service stop'
        return

if __name__=='__main__':
    win32serviceutil.HandleCommandLine(HttpServerManager)

这里有一点需要注意，在HttpServer.py中 ThreadedHTTPServer 的 server_forever 方法负责启动Http Server，它将 handle_request 方法封装到While True循环中，这样如果直接执行 python HttpServer.py ，命令行会一直等待，并且打印接收到的http请求。但是这样一来当它被封装到 win32serviceutil.ServiceFramework 之中后，就无法通过 SvcStop 方法停止服务了，原因是无法获取服务停止的信号。所以解决方法是重写 server_forever 和 stop 方法，用布尔变量来控制循环的启停。这样一来，就能通过Windows服务框架进行统一的控制了。

# 安装服务
python HttpServerManager.py install

# 启动服务
python HttpServerManager.py start

# 停止服务
python HttpServerManager.py stop

这样，当启动PollManager和HttpServerManager两个服务之后，polling task将20秒一次获取监控信息并通过setdata设置到Http Server中，而外界能够通过getdata方法进行获取，除此之外可以添加身份验证、监控参数设置等其他扩展功能。下图为agent的组织结构图：

总结：

   本文通过两个例子演示了如何用Windows服务框架封装一个任务，本例所示的监控agent通过PollManager完成对系统信息的获取，同时通过HttpServerManager完成对数据的发布，两个服务运行相对独立不存在任务的相互阻塞问题，并且windows服务框架能够提供比较好的服务管理、故障恢复以及错误排查功能。

相关代码下载 Github