首页 > 代码库 > 自动化监控系统(四) 客户端设计

自动化监控系统(四) 客户端设计

一个程序的目录结构:

bin:可执行文件

conf:配置文件

core:逻辑关系

plugins:各种插件

var:日志

 

客户端:

1、设置一个程序入口,运行该文件A就能启动客户端。

2、给A传位置参数(start 或 stop),通过获取位置参数名称,使用反射来调用相应方法,做到启动或者停止client。

3、启动客户端后,通过发起HTTP请求,获取service下发的任务(监控哪些服务:CPU、memory、network。。。。。。)

发送请求中,应该有client相关配置信息:主机Id、主机IP地址、主机端口、url配置、请求超时时间和更新监控配置时间。

暂时这些,后面再添加

 client端通过特定url,发送http请求,然后server端返回相应的信息,告诉client需要监控什么服务

在服务端也需要添加相应的url和view,返回客户端的请求信息。

view

技术分享
from django.shortcuts import render

# Create your views here.

from django.views.generic import View
from django.http import HttpResponse
import json

from .serializer import ClientHandler


class client_config_view(View):

    #返回客户端需要监控信息
    def get(self,request,client_id):
        #获取client信息
        # client_configs = ClientHandler(client_id).fetch_configs()
        client_obj = ClientHandler(client_id)
        client_config = client_obj.fetch_configs()
        print("客户端ID",client_id)
        if client_config:
            return HttpResponse(json.dumps(client_config),content_type="application/json")
View Code

serializer

技术分享
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = "BIGNI"
__date__ = "2017/4/29 16:34"
import traceback

from django.views.generic import View

from .models import Host


class ClientHandler(View):
    #初始化
    def __init__(self,client_id):
        self.client_id = client_id
        #client配置
        self.client_configs = {
            "services":{}
        }


    def fetch_configs(self):

        try:

            host_obj_id = Host.objects.get(id=self.client_id)
            print(">>>>>>>>>",host_obj_id)
            #获取模板list
            template_list = list(host_obj_id.templates.select_related())
            print(">>>>",template_list)
            #获取主机组obj

            host_group_obj = host_obj_id.host_groups.select_related()
            #把主机组下的目标添加进来
            template_list.extend([template for template in host_group_obj])
            print("--->",template_list)
            #获取服务列表
            for template in template_list:
                for service in template.services.select_related():
                    print(service)
                    #获取插件名和间隔时间
                    self.client_configs[services][service.name] = [service.plugin_name,service.interval]

        except:
            traceback.print_exc()
        return self.client_configs

# test = ClientHandler(1)
# print(test,test.fetch_configs())
View Code

 测试下:

技术分享

调用特定url,server端可以返回需要监控的信息。

 接下来继续client端的开发:

1、通过运行monitor_client启动客户端,执行main_command方法。

技术分享

2、main_command方法自带start和stop两个方法

技术分享
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
__author__ = "BIGNI"
__date__ = "2017/4/15 23:48"

from .client import ClientHandlers

class main_command(object):
    #初始化
    def __init__(self,sys_argv):
        self.sys_argv = sys_argv
        if len(sys_argv) < 2 :
            exit("请输入start或stop")
        else:
            self.entry_command()

    #根据命令调用方法
    def entry_command(self):
        print("##############################################")
        if hasattr(self.sys_argv[1]):
            func = getattr(self,self.sys_argv[1])
            return func()
        else:
            print("请输入正确的命令")


    def start(self):
        client = ClientHandlers()
        client.forever_run()

    def stop(self):
        pass
main_command

3、start方法会创建ClientHandlers对象,接着调用里面的forever_run方法,获取server端返回的信息,并根据插件名给各个服务进行监控

技术分享
#!/usr/bin/env python3
# _*_ coding:utf-8 _*_
__author__ = "BIGNI"
__date__ = "2017/4/29 11:42"
import time,threading,json

import requests

from conf import settings
from plugins import plugin_api

class ClientHandlers(object):

    def __init__(self):
        #初始化监控服务
        self.monitor_services = {}

    def load_lastest_config(self):
        """
        加载最新的配置信息
        :return:
        """
        #request请求方式
        request_type = settings.configs["urls"]["get_configs"][1]
        #拼接url
        request_url = "%s/%s" % (settings.configs[urls][get_configs][0], settings.configs[HostID])
        lastest_config = self.url_request(request_type,request_url)
        #把最小配置更新到监控服务字典中
        self.monitor_services.update(lastest_config)


    def forever_run(self):
        #启动客户端
        exit_flag = False
        #第一次启动时初始化最新配置时间
        config_lastest_update_time = 0
        while not exit_flag:

            if time.time() - config_lastest_update_time > settings.configs[ConfigUpdateInterval]:
                self.load_lastest_config()
                print("Lastest_config:",self.monitor_services)
                config_lastest_update_time = time.time()

            """
            Lastest_config: {‘services‘: {‘LinuxCPU‘: [‘get_linux_cpu‘, 15], ‘LinuxMemory‘: [‘get_memory_info‘, 60],
            ‘LinuxNetwork‘: [‘GetNetworkStatus‘, 60]}}

            """
            for service_name,val in self.monitor_services[services].items():
                if len(val) ==2:
                    # 第一次启动插件时,初始化当前时间,给每个服务维护一个计时器
                    self.monitor_services[services][service_name].append(0)
                #获取监控间隔和最新插件时间
                monitor_interval = val[1]
                last_invoke_time = val[2]
                if time.time() - last_invoke_time > monitor_interval:
                    print("--->",last_invoke_time,"--->",time.time())
                    #重置计时器时间
                    self.monitor_services[services][service_name][2] = time.time()
                    t = threading.Thread(target=self.invoke_plugin,args=(service_name,val))
                    t.start()
                    print("启动监控的服务: [{ServiceName}]".format(ServiceName=service_name))

                else:
                    #需要等待监控间隔时间
                    print("监控的服务: {ServiceName} 距离下次启动时间:{interval} secs".format(ServiceName=service_name,
                                                                  interval=monitor_interval - (time.time() - last_invoke_time)))
                    time.sleep(5)

        time.sleep(1)


    #运行插件
    def invoke_plugin(self,service_name,val):
        #{"services": {"LinuxNetwork": ["n/a", 60,0], "LinuxMemory": ["n/a", 60,0], "LinuxCPU": ["n/a", 60,0]}}
        #获取插件名
        plugin_name = val[0]
        if hasattr(plugin_api,plugin_name):
            func = getattr(plugin_api,plugin_name)
            plugin_callback = func()
            print("####################################################")
            print(plugin_callback)
            print("####################################################")

            report_data = {
                client_id:settings.configs[HostID],
                service_name:service_name,
                data:plugin_callback
            }
            #请求方式get or post
            request_action = settings.configs[urls][service_report][1]
            #请求路径
            request_url = settings.configs[urls][service_report][0]

            #report_data = http://www.mamicode.com/json.dumps(report_data)
            # print(‘---report data(发送的数据):‘,report_data)
            #调用url_request方法,以post方式发送request
            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)


    def url_request(self,action,request_url,**extra_data):

        abs_url = "http://{ip_addr}:{port}/{url}".format(ip_addr=settings.configs["Server"],
                                                         port=settings.configs["ServerPort"],
                                                         url=request_url)
        print("\033[31;1m{abs_url}\033[0m".format(abs_url=abs_url),type(extra_data),extra_data)
        if action in (get,"GET"):
            print(abs_url,extra_data)
            try:
                r = requests.get(abs_url,timeout=settings.configs[RequestTimeout])
                r_data = r.json()
                return r_data

            except requests.RequestException as E :
                exit("\033[31;1m%s\033[0m" % E)

        elif action in (post,POST):
            try:
                #把数据转换成json再通过post发送
                # data = http://www.mamicode.com/json.dumps(extra_data[‘params‘])
                req = requests.post(url=abs_url,data=http://www.mamicode.com/extra_data["params"])

                res_data = req.json()
                # res_data = http://www.mamicode.com/req.text
                print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
                print("\033[31;1m[%s]:[%s]\033[0m response:\n%s,%s" % (action, abs_url, res_data,data))
                print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
                return res_data

            except Exception as e:
                print(------exec, e)
                exit("\033[31;1m%s\033[0m" % e)
client

 

PS:客户端在接收到服务端返回的配置信息,并不能识别具体要监控的服务,比如server端告诉client端需要监控CPU各项参数等,所以两端要能约定好,比如server端返回CPU、Memory和Network这三个字符串,就表示要监控这三种服务,三个字符串在这里就是插件名。插件统一放在plugins目录下。

 不同服务监控的时间可以通过server端返回的监控间隔来判断

 技术分享

 每次监控服务就生成一个新的线程,然后就让线程返回数据给服务端,不需要再做处理。

技术分享

 

 对于server端和client端的数据交互,推荐使用requests模块,可以自动处理数据的编码、json、发送超时等问题。

 

 

 

 

 

 问题1:在models里的manytomany字段不会存储在数据表中,多对多的在xadmin里要按ctrl选中才行,不然通过select_relate获取到的是空的queryset,

技术分享

问题2:我调用model的serializer没放在app的默认views文件里,进行debug调试时,serializer也需要打上断点。

问题3:我在client通过post方式发送数据给server端,debug调试时发现没取到值,查了资料,原来requests库有三种post发送数据方式,我使用的是json方式(发送前先用json.dumps处理下),改成用form方式(实际就是不需要json,requests会自动转换)

技术分享技术分享

 

技术分享
 

自动化监控系统(四) 客户端设计