Horland-运维监控系统

用python开发的小型的运维监控系统，使用了twisted框架 更详细的信息见： blog.csdn.net/smallfish1983

#!/usr/bin/env python
#coding:utf-8
__author__ = ‘dwj‘

from twisted.protocols import basic
from twisted.internet import  protocol defer task
import Get_basic_info_2 as Huoqu
import guardian as shouhu
import time
from twisted.application import service internet


class Monitor_Protocol（basic.LineReceiver）:
    #自定义客户端和服务端的连接协议，从basic的line继承

    def __init__（self）:
        #没想好要初始化点什么
        pass

    @staticmethod
    def huoqu_shuju（）:
        #定义一个函数获取本机的一些状态
        now = str（time.strftime（‘%Y-%m-%d %H:%M:%S‘））
        
        def add_tag（source tag1 tag2 = ‘none‘）:
        #定义格式化字符串函数
            return ‘:::‘.join（[now tag1 tag2 source]）
            #使用：：：分隔时间、简单信息、详细信息、原始信息
        
        tcp = add_tag（Huoqu.net_tcp（） ‘tcp‘）
        cpu = add_tag（Huoqu.cpu（） ‘cpu‘ ‘cpu_detail‘）
        mem = add_tag（Huoqu.mem（） ‘mem‘ ‘mem_detail‘）
        disk = add_tag（Huoqu.disk_usage（） ‘disk‘ ‘disk_detail‘）
        net = add_tag（Huoqu.net_rate（） ‘net‘ ‘net_detail‘）
        process = add_tag（shouhu.check_alive（） ‘process_down‘ ‘process_alived‘）
        result = （tcp cpu mem disk net process ） 
        d = defer.Deferred（）
        #使用defered返回结果
        d.callback（result）
        return d

    def xunhuan（self list）:
    #定义循环发送函数
        for i in list:
            self.sendLine（i）

    def fasong（self）:
    #定义程序运行顺序，取得信息后用callback交给发送函数发送
        self.huoqu_shuju（）.addCallback（self.xunhuan）

    def loop（self）:
    #使用twist内置的循环函数定义几秒监控数据传送到服务端
        l = task.LoopingCall（self.fasong）
        l.start（1）

    def connectionMade（self）:
    #覆盖协议的connectmade函数，定义于服务端的连接建立后开始循环
        print ‘Connected!......ok!‘
        self.loop（）

    def lineReceived（self line）:
    #必须覆盖接受函数，否则twist会报not importent错误！
        pass


class Moinitor_client_factory（protocol.ReconnectingClientFactory）:
    
    def __init__（self service）:
    #还没想要要写什么
        self.service = service
    protocol = Monitor_Protocol


class Client_Service（service.Service）:

    def __init__（self）:
        pass

    def startService（self）:
        service.Service.startService（self）


#配置文件开始
port = 10000
host = ‘127.0.0.1‘

#守护进程
top_service = service.MultiService（）                   #定义服务容器

client_service = Client_Service（）                      #实例化服务类
client_service.setServiceParent（top_service）           #把自己定义的服务丢到服务容器中

factory = Moinitor_client_factory（client_service）      #定义服务工厂化

tcp_service = internet.TCPClient（host port factory）  #定义tcp连接的服务
tcp_service.setServiceParent（top_service）              #把tcp服务丢到服务容器中去

application = service.Application（‘Fish_Service‘）      #定义应用名字
top_service.setServiceParent（application）              #把服务容器丢到应用中去

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     目录           0  2014-07-08 07:20  dwj\
     目录           0  2014-07-09 01:24  dwj\.idea\
     目录           0  2014-07-09 01:03  dwj\.svn\
     目录           0  2014-07-08 09:06  dwj\Client\
     文件        2164  2014-07-07 01:05  dwj\Client\Get_basic_info_2.py
     文件          56  2014-07-08 05:59  dwj\Client\__init__.py
     文件        3220  2014-07-08 06:44  dwj\Client\client.py
     文件        2623  2014-07-07 01:05  dwj\Client\guardian.py
     目录           0  2014-07-09 01:03  dwj\Server\
     文件          56  2014-07-07 01:05  dwj\Server\__init__.py
     文件        2943  2014-07-09 14:28  dwj\Server\main.py
     目录           0  2014-07-08 06:00  dwj\Server\twisted\
     目录           0  2014-07-09 01:03  dwj\codebak\
     目录           0  2014-07-09 01:03  dwj\test\
     目录           0  2014-07-08 06:00  dwj\twisted\