分布式监控系统开发【day37】:监控客户端开发（五）

一、目录结构

二、模块方法调用关系总图

三、入口文件main

1、解决了说明问题

1、客户端就干了一件事情，干什么事情
　　收集数据汇报给服务端？
　　但是我这个客户端是插件形式
2、首先必须要传一个参数，start干了 什么事情？
　　启动了一个程序，先去服务器端拿去配置信息，
　　拿到配置信息，根据不同的服务的执行间隔去执行监控
3、这个是个死循环，永远执行，服务器断了，客户端也就断了，等服务器重启启动起来，客户端就好了

2、实现代码

from core import client

class command_handler(object):

    def __init__(self, sys_args):
        self.sys_args = sys_args
        if len(self.sys_args)<2:
            self.help_msg()

        self.command_allowcator()


    def command_allowcator(self):
        '''分捡用户输入的不同指令'''
        print(self.sys_args[1])

        if hasattr(self,self.sys_args[1]):
            func= getattr(self,self.sys_args[1])
            return func()
        else:
            print("command does not exist!")
            self.help_msg()

    def help_msg(self):
        valid_commands = '''
        start       start monitor client
        stop        stop monitor client

        '''
        exit(valid_commands)


    def start(self):
        print("going to start the monitor client")
        #exit_flag = False

        Client = client.ClientHandle()
        Client.forever_run()

    def stop(self):
        print("stopping the monitor client")

四、配置中心settings

1、解决了什么问题？

1、启动了之后，本地什么都没有，去服务器端要监控的配置项，拿着自己的客户端ID，去服务端，说我是谁我的id是什么，你把让我监控的配置信息给我
2、如果你要想获取监控配置信息，就用'api/client/config','get'这个url的get方法
3、如果你要想汇报数据，就找'api/client/service/report/','post' 用post方法
4、我写到配置文件里的好处是什么？
我避免写到代码里写死了就不好了，
5、我连接服务器30秒没通就超时了 ，
6、每300秒去客户端加载一次监控配置，为什么这么干？

1. 　　因为你的客户端一启动加载完一次配置，加载完了你就运行了，那我服务端有没有可能更改？
2. 　　我给这个机器又加一个指标，这样客户端就加载不上，也就是说我加一个监控指标，也就是5分钟生效

2、实现代码

configs ={
    'HostID': 1,
    "Server": "192.168.16.56",
    "ServerPort": 8000,
    "urls":{

        'get_configs' :['api/client/config','get'],  #acquire all the services will be monitored
        'service_report': ['api/client/service/report/','post'],

    },
    'RequestTimeout':30,
    'ConfigUpdateInterval': 300, #5 mins as default

}

五、请求监控配置汇报数据

1、解决了什么问题

1、要要每5分钟去客户端那一次最新的监控数据，你要知道上一次是什么时候拿的?你的记下来吧
2、知道为什么开始是0了？
　　1、每次和上一次拿去的时间做一个对比
　　2、当前时间-减去这个时间大于这个时间，你默认是0的话，肯定会大于这个时间
　　3、然后我就去获取最新的监控配置信息

3、把ip地址和 url全部拼接起来，判断你的请求类型

　　1、主流的Python服务器是python2
　　2、百度现在就是不让你爬数据，我换一个知乎就好了
　　　　1、是不是一堆数据，至少让你爬取主页
　　　　2、就是客户端给你返回的数据

4、因为我一会我要给服务端端汇报数据
5、post是不是有参数，先把你的参数进行一个extra_data，刚才请求是url现在带着的数据
6、是谁调用的 def url_request它呀？
　　为什么要调用呀 ？我是要加载配置文件 def load_latest_configs，我就调用elf.url_request(request_type,url)就拿到了最新的数据，它是一个json格式的
7、也就是第一次，取回来这个字典就是一个空的，
　　把最后的时间更新成当前时间，不改下一次循环有直接去拿了

2、实现代码

import time
from conf import settings
import urllib
import urllib2
import json
import threading
from plugins import plugin_api

class ClientHandle(object):
    def __init__(self):
        self.monitored_services = {}

    def load_latest_configs(self):
        '''
        load the latest monitor configs from monitor server
        :return:
        '''
        request_type = settings.configs['urls']['get_configs'][1]
        url = "%s/%s" %(settings.configs['urls']['get_configs'][0], settings.configs['HostID'])
        latest_configs = self.url_request(request_type,url)
        latest_configs = json.loads(latest_configs)
        self.monitored_services.update(latest_configs)

六、监控计数器设计

1、我拿到的字典长什么样

{"services": {"LinuxNetwork": ["LinuxNetworkPlugin ", 60], 
"LinuxCPU": ["LinuxCpuPlugin", 60], 
"Mysql": ["MysqlPlugin", 60],
 " Linuxload": ["LinuxloadPlugin", 30],
 "LinuxMemory": ["LinuxMemoryPlugin", 90]}}

2、需求讨论

1、服务那么多，这个间隔个60 那个90怎样处理？

2、你启动一个for循环，你怎么知道cpu或者内存需要监控？
　　1、你这个计数器怎么维护，这样可复杂了
　　2、你维护一个全局的计数器，这样很复杂
3、我能不能给每个服务启动一个计数器
　　上一次执行的时间我知道，我每次循环对每个服务进行循环如果大于就出发记录

3、实现代码

for service_name,val in self.monitored_services['services'].items():
    if len(val) == 2:# means it's the first time to monitor
        self.monitored_services['services'][service_name].append(0)
    monitor_interval = val[1]
    last_invoke_time = val[2]
    if time.time() - last_invoke_time > monitor_interval: #needs to run the plugin
        print(last_invoke_time,time.time())
        self.monitored_services['services'][service_name][2]= time.time()
        #start a new thread to call each monitor plugin
        t = threading.Thread(target=self.invoke_plugin,args=(service_name,val))
        t.start()
        print("Going to monitor [%s]" % service_name)

    else:
        print("Going to monitor [%s] in [%s] secs" % (service_name,
                                                                       monitor_interval - (time.time()-last_invoke_time)))

time.sleep(1)

七、forever_run函数

1、解决了什么问题

1、如果之前没有执行过，第一次执行，为什么初始化执行为0了
　　为了第一次肯定触发监控
2、你怎样去判断要不要触发这次监控呢？
　　1、监控间隔
　　2、最后调用时间，就是我刚才添加进去的0
　　3、当前时间-上一次服务监控时间如果大于5分钟就需触发监控，如果小于5分钟就不需要出发

3、是不是要去调用插件吧！，我现在通过反射调用插件

4、如果这个插件需要执行2分钟，那么调这个服务你是不是要等它两分钟，但是其他的服务间隔30秒，你卡了2分钟
　　也就是说这一次的执行不能影响其他的服务
　　每监控一个服务就启用一个线程并发
5、我为什么要判断多少个服务？
　　你的意思10个服务启动10个线程，启动起来就不宕了
6、我为什么要启用10个线程，因为我的监控间隔还没有到
　　所以我就到监控的时间到了再启动这个线程

2、实现代码

 def forever_run(self):
   '''
   start the client program forever
   :return:
   '''
   exit_flag = False
   config_last_update_time = 0

   while not exit_flag:
         if time.time() - config_last_update_time > settings.configs['ConfigUpdateInterval']:
             self.load_latest_configs() #获取最新的监控配置信息
             print("Loaded latest config:", self.monitored_services)
             config_last_update_time = time.time()
         #start to monitor services

         for service_name,val in self.monitored_services['services'].items():
             if len(val) == 2:# means it's the first time to monitor
                 self.monitored_services['services'][service_name].append(0)
                 #为什么是0， 因为为了保证第一次肯定触发监控这个服务
             monitor_interval = val[1]
             last_invoke_time = val[2] #0
             if time.time() - last_invoke_time > monitor_interval: #needs to run the plugin
                 print(last_invoke_time,time.time())
                 self.monitored_services['services'][service_name][2]= time.time() #更新此服务最后一次监控的时间
                 #start a new thread to call each monitor plugin
                 t = threading.Thread(target=self.invoke_plugin,args=(service_name,val))
                 t.start()
                 print("Going to monitor [%s]" % service_name)

             else:
                 print("Going to monitor [%s] in [%s] secs" % (service_name,
                                                                                monitor_interval - (time.time()-last_invoke_time)))

         time.sleep(1)

八、插件API

1、解决了什么问题？

1、commands这个命令在插件3里面已经没有了
2、只要不为0，就代表没出错，我就认为拿到值存成一个字典，你只要确认插件拿到的数据是一个字典就没问题
3、不等于0就是一个无效数据

4、我这里这么多这样的脚本，我怎么能让我刚才的线程怎么去调用的我脚本呢？

1、通过反射去调用，我前端给我返回了插件名
2、前端的插件名和脚本名不是一一对应的，他俩肯定不一样
3、我这里做了一个中间层plugin_api文件里一一对应
4、这样相当于我插件的名字，

2、实现代码

1、cpu.py

import commands

def monitor(frist_invoke=1):
    #shell_command = 'sar 1 3| grep "^Average:"'
    shell_command = 'sar 1 3| grep "^平均时间:"'
    status,result = commands.getstatusoutput(shell_command)
    if status != 0:
        value_dic = {'status': status}
    else:
        value_dic = {}
        print('---res:',result)
        user,nice,system,iowait,steal,idle = result.split()[2:]
        value_dic= {
            'user': user,
            'nice': nice,
            'system': system,
            'idle': idle,
            'status': status
        }
    return value_dic

if __name__ == '__main__':
    print monitor()

2、plugin_api.py

from linux import sysinfo,cpu_mac,cpu,memory,network,host_alive


def LinuxCpuPlugin():
    return cpu.monitor()

def host_alive_check():
    return host_alive.monitor()

def GetMacCPU():
    #return cpu.monitor()
    return cpu_mac.monitor()

def LinuxNetworkPlugin():
    return network.monitor()

def LinuxMemoryPlugin():
    return memory.monitor()

九、invoke_plugin调用函数

1、解决了什么问题

1、是怎么调用的呢？
2、拿到这插件名，去调用这个脚本，
3、里面有好多函数，通过反射有没有这个函数
4、然后汇报我的数据有一个新的url
5、我就把数据这个字典写好，我告诉服务器端，我是回报的那个监控的监控项
6、我为了减少汇报次数，我一次可以提交多个服务的监控项
　　不能，因为每个服务的监控间隔都不一样 zabbix都不是一次汇报是单独汇报
　　拿到请求方法，数据，汇报到后端，你的把这个编写成它支持的格式，

2、实现代码

 def invoke_plugin(self,service_name,val):
        '''
        invoke the monitor plugin here, and send the data to monitor server after plugin returned status data each time
        :param val: [pulgin_name,monitor_interval,last_run_time]
        :return:
        '''
        plugin_name = val[0]
        if hasattr(plugin_api,plugin_name):
            func = getattr(plugin_api,plugin_name)
            plugin_callback = func()
            #print("--monitor result:",plugin_callback)

            report_data = {
                'client_id':settings.configs['HostID'],
                'service_name':service_name,
                'data':json.dumps(plugin_callback)
            }

            request_action = settings.configs['urls']['service_report'][1]
            request_url = settings.configs['urls']['service_report'][0]

            #report_data = json.dumps(report_data)
            print('---report data:',report_data)
            self.url_request(request_action,request_url,params=report_data)
        else:
            print("\033[31;1mCannot find service [%s]'s plugin name [%s] in plugin_api\033[0m"% (service_name,plugin_name ))
        print('--plugin:',val)

九、URL处理函数

1、解决了什么问题

1、extra_data是额外的数据，字典不能直接发，要变成url，走到这里，这个线程是退出了
2、但是主线程还在走，刚才有一部我没讲

self.monitored_services['services'][service_name][2]= time.time()

3、我刚才在监控间隔里加一个0，
　　更新此服务最后一次监控的时间

4、我现在传进来的服务名和监控间隔，这个服务已经监控完了，也 拿到数据了，我现在要干嘛？
　　是不不是要汇报给服务器端

2、实现代码

def url_request(self,action,url,**extra_data):
     '''
     cope with monitor server by url
     :param action: "get" or "post"
     :param url: witch url you want to request from the monitor server
     :param extra_data: extra parameters needed to be submited
     :return:
     '''
     abs_url = "http://%s:%s/%s" % (settings.configs['Server'],
                                    settings.configs["ServerPort"],
                                    url)
     if action in  ('get','GET'):
         print(abs_url,extra_data)
         try:
             req = urllib2.Request(abs_url)
             req_data = urllib2.urlopen(req,timeout=settings.configs['RequestTimeout'])
             callback = req_data.read()
             #print "-->server response:",callback
             return callback
         except urllib2.URLError as e:
             exit("\033[31;1m%s\033[0m"%e)

     elif action in ('post','POST'):
         #print(abs_url,extra_data['params'])
         try:
             data_encode = urllib.urlencode(extra_data['params'])
             req = urllib2.Request(url=abs_url,data=data_encode)
             res_data = urllib2.urlopen(req,timeout=settings.configs['RequestTimeout'])
             callback = res_data.read()
             callback = json.loads(callback)
             print "\033[31;1m[%s]:[%s]\033[0m response:\n%s" %(action,abs_url,callback)
             return callback
         except Exception as e:
             print('---exec',e)
             exit("\033[31;1m%s\033[0m"%e)

十、其他完整代码

1、bin

CrazyClient.py

import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)

from core import main

if __name__ == "__main__":
    client = main.command_handler(sys.argv)

2、plugins

1、linux

1、host_alive.py

import subprocess

def monitor(frist_invoke=1):
    value_dic = {}
    shell_command = 'uptime'
    result = subprocess.Popen(shell_command,shell=True,stdout=subprocess.PIPE).stdout.read()

    #user,nice,system,iowait,steal,idle = result.split()[2:]
    value_dic= {
        'uptime': result,

        'status': 0
    }
    return value_dic


print monitor()

2、load.py

import commands


def monitor():
    shell_command = 'uptime'

    status,result = commands.getstatusoutput(shell_command)
    if status != 0: #cmd exec error
        value_dic = {'status':status}
    else:
        value_dic = {}
        uptime = result.split(',')[:1][0]
        print(result)
        #load1,load5,load15 = result.split('load averages:')[1].split(',')
        load1,load5,load15 = result.split('load averages:')[1].split()
        value_dic= {
            #'uptime': uptime,
            'load1': load1,
            'load5': load5,
            'load15': load15,
            'status': status
        }
    return value_dic



print(monitor())

3、memory.py

#!/usr/bin/env python
#coding:utf-8


import commands


def monitor(frist_invoke=1):
    monitor_dic = {
        'SwapUsage': 'percentage',
        'MemUsage'  : 'percentage',
    }
    shell_command ="grep 'MemTotal\|MemFree\|Buffers\|^Cached\|SwapTotal\|SwapFree' /proc/meminfo"

    status,result = commands.getstatusoutput(shell_command)
    if status != 0: #cmd exec error
        value_dic = {'status':status}
    else:
        value_dic = {'status':status}
        for i in result.split('kB\n'):
            key= i.split()[0].strip(':') # factor name
            value = i.split()[1]   # factor value
            value_dic[ key] =  value

        if monitor_dic['SwapUsage'] == 'percentage':
            value_dic['SwapUsage_p'] = str(100 - int(value_dic['SwapFree']) * 100 / int(value_dic['SwapTotal']))
        #real SwapUsage value
        value_dic['SwapUsage'] = int(value_dic['SwapTotal']) - int(value_dic['SwapFree'])

        MemUsage = int(value_dic['MemTotal']) - (int(value_dic['MemFree']) + int(value_dic['Buffers'])  + int(value_dic['Cached']))
        if monitor_dic['MemUsage'] == 'percentage':
            value_dic['MemUsage_p'] = str(int(MemUsage) * 100 / int(value_dic['MemTotal']))
        #real MemUsage value
        value_dic['MemUsage'] = MemUsage
    return value_dic

if __name__ == '__main__':
    print monitor()

5、network.py

import subprocess

def monitor(frist_invoke=1):
    shell_command = 'sar -n DEV 1 5 |grep -v IFACE |grep Average'
    result = subprocess.Popen(shell_command,shell=True,stdout=subprocess.PIPE).stdout.readlines()
    #print(result)
    value_dic = {'status':0, 'data':{}}
    for line in result:
        line = line.split()
        nic_name,t_in,t_out = line[1],line[4],line[5]
        value_dic['data'][nic_name] = {"t_in":line[4], "t_out":line[5]}
    #print(value_dic)
    return value_dic

4、sysinfo.py

import os,sys,subprocess
import commands
import re



def collect():
    filter_keys = ['Manufacturer','Serial Number','Product Name','UUID','Wake-up Type']
    raw_data = {}

    for key in filter_keys:
        try:
            #cmd_res = subprocess.check_output("sudo dmidecode -t system|grep '%s'" %key,shell=True)
            cmd_res = commands.getoutput("sudo dmidecode -t system|grep '%s'" %key)
            cmd_res = cmd_res.strip()

            res_to_list = cmd_res.split(':')
            if len(res_to_list)> 1:#the second one is wanted string
                raw_data[key] = res_to_list[1].strip()
            else:

                raw_data[key] = -1
        except Exception,e:
            print e
            raw_data[key] = -2 #means cmd went wrong

    data = {"asset_type":'server'}
    data['manufactory'] = raw_data['Manufacturer']
    data['sn'] = raw_data['Serial Number']
    data['model'] = raw_data['Product Name']
    data['uuid'] = raw_data['UUID']
    data['wake_up_type'] = raw_data['Wake-up Type']

    data.update(cpuinfo())
    data.update(osinfo())
    data.update(raminfo())
    data.update(nicinfo())
    data.update(diskinfo())
    return data


def diskinfo():
    obj = DiskPlugin()
    return obj.linux()

def nicinfo():
    #tmp_f = file('/tmp/bonding_nic').read()
    #raw_data= subprocess.check_output("ifconfig -a",shell=True)
    raw_data = commands.getoutput("ifconfig -a")

    raw_data= raw_data.split("\n")

    nic_dic = {}
    next_ip_line = False
    last_mac_addr = None
    for line in raw_data:
        if next_ip_line:
            #print last_mac_addr
            #print line #, last_mac_addr.strip()
            next_ip_line = False
            nic_name = last_mac_addr.split()[0]
            mac_addr = last_mac_addr.split("HWaddr")[1].strip()
            raw_ip_addr = line.split("inet addr:")
            raw_bcast = line.split("Bcast:")
            raw_netmask = line.split("Mask:")
            if len(raw_ip_addr) > 1: #has addr
                ip_addr = raw_ip_addr[1].split()[0]
                network = raw_bcast[1].split()[0]
                netmask =raw_netmask[1].split()[0]
                #print(ip_addr,network,netmask)
            else:
                ip_addr = None
                network = None
                netmask = None
            if mac_addr not in nic_dic:
                nic_dic[mac_addr] = {'name': nic_name,
                                     'macaddress': mac_addr,
                                     'netmask': netmask,
                                     'network': network,
                                     'bonding': 0,
                                     'model': 'unknown',
                                     'ipaddress': ip_addr,
                                     }
            else: #mac already exist , must be boding address
                if '%s_bonding_addr' %(mac_addr) not in nic_dic:
                    random_mac_addr = '%s_bonding_addr' %(mac_addr)
                else:
                    random_mac_addr = '%s_bonding_addr2' %(mac_addr)

                nic_dic[random_mac_addr] = {'name': nic_name,
                                     'macaddress':random_mac_addr,
                                     'netmask': netmask,
                                     'network': network,
                                     'bonding': 1,
                                     'model': 'unknown',
                                     'ipaddress': ip_addr,
                                     }

        if "HWaddr" in line:
            #print line
            next_ip_line = True
            last_mac_addr = line


    nic_list= []
    for k,v in nic_dic.items():
        nic_list.append(v)

    return {'nic':nic_list}
def raminfo():
    #raw_data = subprocess.check_output(["sudo", "dmidecode" ,"-t", "17"])
    raw_data = commands.getoutput("sudo dmidecode -t 17")
    raw_list = raw_data.split("\n")
    raw_ram_list = []
    item_list = []
    for line in raw_list:

        if line.startswith("Memory Device"):
            raw_ram_list.append(item_list)
            item_list =[]
        else:
            item_list.append(line.strip())

    ram_list = []
    for item in raw_ram_list:
        item_ram_size = 0
        ram_item_to_dic = {}
        for i in item:
            #print i
            data = i.split(":")
            if len(data) ==2:
                key,v = data

                if key == 'Size':
                    #print key ,v
                    if  v.strip() != "No Module Installed":
                        ram_item_to_dic['capacity'] =  v.split()[0].strip() #e.g split "1024 MB"
                        item_ram_size = int(v.split()[0])
                        #print item_ram_size
                    else:
                        ram_item_to_dic['capacity'] =  0

                if key == 'Type':
                    ram_item_to_dic['model'] =  v.strip()
                if key == 'Manufacturer':
                    ram_item_to_dic['manufactory'] =  v.strip()
                if key == 'Serial Number':
                    ram_item_to_dic['sn'] =  v.strip()
                if key == 'Asset Tag':
                    ram_item_to_dic['asset_tag'] =  v.strip()
                if key == 'Locator':
                    ram_item_to_dic['slot'] =  v.strip()

                #if i.startswith("")
        if item_ram_size == 0:  # empty slot , need to report this
            pass
        else:
            ram_list.append(ram_item_to_dic)

    #get total size(mb) of ram as well
    #raw_total_size = subprocess.check_output(" cat /proc/meminfo|grep MemTotal ",shell=True).split(":")
    raw_total_size = commands.getoutput("cat /proc/meminfo|grep MemTotal ").split(":")
    ram_data = {'ram':ram_list}
    if len(raw_total_size) == 2:#correct

        total_mb_size = int(raw_total_size[1].split()[0]) / 1024
        ram_data['ram_size'] =  total_mb_size
        #print(ram_data)

    return ram_data
def osinfo():
    #distributor = subprocess.check_output(" lsb_release -a|grep 'Distributor ID'",shell=True).split(":")
    distributor = commands.getoutput(" lsb_release -a|grep 'Distributor ID'").split(":")
    #release  = subprocess.check_output(" lsb_release -a|grep Description",shell=True).split(":")
    release  = commands.getoutput(" lsb_release -a|grep Description").split(":")
    data_dic ={
        "os_distribution": distributor[1].strip() if len(distributor)>1 else None,
        "os_release":release[1].strip() if len(release)>1 else None,
        "os_type": "linux",
    }
    #print(data_dic)
    return data_dic
def cpuinfo():
    base_cmd = 'cat /proc/cpuinfo'

    raw_data = {
        'cpu_model' : "%s |grep 'model name' |head -1 " % base_cmd,
        'cpu_count' :  "%s |grep  'processor'|wc -l " % base_cmd,
        'cpu_core_count' : "%s |grep 'cpu cores' |awk -F: '{SUM +=$2} END {print SUM}'" % base_cmd,
    }

    for k,cmd in raw_data.items():
        try:
            #cmd_res = subprocess.check_output(cmd,shell=True)
            cmd_res = commands.getoutput(cmd)
            raw_data[k] = cmd_res.strip()

        #except Exception,e:
        except ValueError,e:
            print e

    data = {
        "cpu_count" : raw_data["cpu_count"],
        "cpu_core_count": raw_data["cpu_core_count"]
        }
    cpu_model = raw_data["cpu_model"].split(":")
    if len(cpu_model) >1:
        data["cpu_model"] = cpu_model[1].strip()
    else:
        data["cpu_model"] = -1


    return data




class DiskPlugin(object):

    def linux(self):
        result = {'physical_disk_driver':[]}

        try:
            script_path = os.path.dirname(os.path.abspath(__file__))
            shell_command = "sudo %s/MegaCli  -PDList -aALL" % script_path
            output = commands.getstatusoutput(shell_command)
            result['physical_disk_driver'] = self.parse(output[1])
        except Exception,e:
            result['error'] = e
        return result

    def parse(self,content):
        '''
        解析shell命令返回结果
        :param content: shell 命令结果
        :return:解析后的结果
        '''
        response = []
        result = []
        for row_line in content.split("\n\n\n\n"):
            result.append(row_line)
        for item in result:
            temp_dict = {}
            for row in item.split('\n'):
                if not row.strip():
                    continue
                if len(row.split(':')) != 2:
                    continue
                key,value = row.split(':')
                name =self.mega_patter_match(key);
                if name:
                    if key == 'Raw Size':
                        raw_size = re.search('(\d+\.\d+)',value.strip())
                        if raw_size:

                            temp_dict[name] = raw_size.group()
                        else:
                            raw_size = '0'
                    else:
                        temp_dict[name] = value.strip()

            if temp_dict:
                response.append(temp_dict)
        return response

    def mega_patter_match(self,needle):
        grep_pattern = {'Slot':'slot', 'Raw Size':'capacity', 'Inquiry':'model', 'PD Type':'iface_type'}
        for key,value in grep_pattern.items():
            if needle.startswith(key):
                return value
        return False

if __name__=="__main__":
    print DiskPlugin().linux()

2、windows

sysinfo.py

import platform
import win32com
import wmi
import os


def collect():
    data = {
        'os_type': platform.system(),
        'os_release':"%s %s  %s "%( platform.release() ,platform.architecture()[0],platform.version()),
        'os_distribution': 'Microsoft',
        'asset_type':'server'
    }
    #data.update(cpuinfo())
    win32obj = Win32Info()
    data.update(win32obj.get_cpu_info())
    data.update(win32obj.get_ram_info())
    data.update(win32obj.get_server_info())
    data.update(win32obj.get_disk_info())
    data.update(win32obj.get_nic_info())

    #for k,v in data.items():
    #    print k,v
    return data
class Win32Info(object):
    def __init__(self):
        self.wmi_obj = wmi.WMI()
        self.wmi_service_obj = win32com.client.Dispatch("WbemScripting.SWbemLocator")
        self.wmi_service_connector =self.wmi_service_obj.ConnectServer(".","root\cimv2")

    def get_cpu_info(self):
        data = {}
        cpu_lists = self.wmi_obj.Win32_Processor()
        cpu_core_count = 0

        for cpu in cpu_lists:
            cpu_core_count += cpu.NumberOfCores
            cpu_model = cpu.Name
        data["cpu_count"] = len(cpu_lists)
        data["cpu_model"] = cpu_model
        data["cpu_core_count"] =cpu_core_count
        return data

    def get_ram_info(self):
        data = []
        ram_collections = self.wmi_service_connector.ExecQuery("Select * from Win32_PhysicalMemory")
        for item in ram_collections:
            item_data = {}
            #print item
            mb = int(1024 * 1024)
            ram_size = int(item.Capacity) / mb
            item_data = {
                "slot":item.DeviceLocator.strip(),
                "capacity":ram_size,
                "model":item.Caption,
                "manufactory":item.Manufacturer,
                "sn":item.SerialNumber,
            }
            data.append(item_data)
        #for i in data:
        #    print i
        return {"ram":data}
    def get_server_info(self):
        computer_info =  self.wmi_obj.Win32_ComputerSystem()[0]
        system_info =  self.wmi_obj.Win32_OperatingSystem()[0]
        data = {}
        data['manufactory'] = computer_info.Manufacturer
        data['model'] = computer_info.Model
        data['wake_up_type'] = computer_info.WakeUpType
        data['sn'] = system_info.SerialNumber
        #print data
        return data

    def get_disk_info(self):
        data = []
        for disk in self.wmi_obj.Win32_DiskDrive():
            #print  disk.Model,disk.Size,disk.DeviceID,disk.Name,disk.Index,disk.SerialNumber,disk.SystemName,disk.Description
            item_data = {}
            iface_choices = ["SAS","SCSI","SATA","SSD"]
            for iface in iface_choices:
                if iface in disk.Model:
                    item_data['iface_type']  = iface
                    break
            else:
                item_data['iface_type']  = 'unknown'
            item_data['slot']  = disk.Index
            item_data['sn']  = disk.SerialNumber
            item_data['model']  = disk.Model
            item_data['manufactory']  = disk.Manufacturer
            item_data['capacity']  = int(disk.Size ) / (1024*1024*1024)
            data.append(item_data)
        return {'physical_disk_driver':data}
    def get_nic_info(self):
        data = []
        for nic in self.wmi_obj.Win32_NetworkAdapterConfiguration():
            if nic.MACAddress is not None:
                item_data = {}
                item_data['macaddress'] = nic.MACAddress
                item_data['model'] = nic.Caption
                item_data['name'] = nic.Index
                if nic.IPAddress  is not None:
                    item_data['ipaddress'] = nic.IPAddress[0]
                    item_data['netmask'] = nic.IPSubnet
                else:
                    item_data['ipaddress'] = ''
                    item_data['netmask'] = ''
                bonding = 0
                #print nic.MACAddress ,nic.IPAddress,nic.ServiceName,nic.Caption,nic.IPSubnet
                #print item_data
                data.append(item_data)
        return {'nic':data}
if __name__=="__main__":
    collect()

十一、测试截图

图一

图二