cmdb项目-2

1.命令插件异常处理 + 日志采集

　　1)为了更清楚发送客户端收集信息的状态，优化返回api的数据，变为字典存储 {状态错误信息数据} ，因为每个插件的每种系统下都要这个返回值我们将他单独做成类

　　/lib/BaseReponse.py

class BaseReponese:

    def __init__(self):

        self.status = True

        self.error = None

        self.data = None

    @property

    def dict(self):

        return self.__dict__

　　2)在执行命令的时候，debug模式下有打开文件的操作，打开文件可能出现目录不存在而导致程序终止，且这个错误信息仅能在服务端看到，这是不合理的所以同时引用日志

　　/lib/log.py 日志做一个单例对象到处使用导入使用即可

import logging

from conf import settings

class Logger:

    def __init__(self, file_name, log_name):

        file_handler = logging.FileHandler(file_name, encoding='utf-8')

        fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s")

        file_handler.setFormatter(fmt)

        self.logger = logging.Logger(log_name)

        self.logger.addHandler(file_handler)

    def info(self, msg):

        return self.logger.info(msg)

    def error(self, msg):

        return self.logger.error(msg)

logger = Logger(settings.LOGGER_PATH, settings.LOGGER_NAME)

　　所有的插件的linux'与win模式下都肯能出现这个问题，所以所有的都要加错误处理 + 客户端日志

　　　　traceback可以直接捕获发生异常的文件，以及哪行出错

import traceback
from lib.BaseReponse import BaseResponese  
  def linux or win(self, handler, hostname=None):

        response = BaseReponese()

        try:

            if self.debug:

                with open(os.path.join(self.base_dir, 'files1', 'memory.out')) as f:

                    ret = f.read()

            else:

                ret = handler.cmd('lsblk', hostname)

            response.data = self.parse(ret)

        except Exception as e:

            logger.error(e)

            response.error = traceback.format_exc()

            response.status = False

        return response.dict

2.完善资产采集插件

　　增加cpu采集 ,主板信息采集 ,基本信息采集

##settings.py
PLUGINS_DICT = {

    'disk': 'src.plugins.disk.Disk',

    'memory': 'src.plugins.memory.Memory',

    'nic': 'src.plugins.nic.NIC',

    'basic': 'src.plugins.basic.Basic',

    'cpu': 'src.plugins.cpu.Cpu',

    'board': 'src.plugins.main_board.MainBoard',

}

　　cpu命令插件代码

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import os

import traceback

from .base import BasePlugin

from lib.BaseReponse import BaseReponese

from lib.log import logger

from conf.settings import BASE_DIR

class Cpu(BasePlugin):

    def win(self, handler, hostname=None):

        raise NotImplementedError('win must be implemented ')

    def linux(self, handler, hostname=None):

        response = BaseReponese()

        try:

            if self.debug:

                output = open(os.path.join(BASE_DIR, 'files', 'cpuinfo.out'), 'r').read()

            else:

                shell_command = "cat /proc/cpuinfo"

                output = handler.cmd(shell_command, hostname)

            response.data = self.parse(output)

        except Exception as e:

            msg = traceback.format_exc()

            response.status = False

            response.error = msg

            logger.error(msg)

        return response.dict

    @staticmethod

    def parse(content):

        """

        解析shell命令返回结果

        :param content: shell 命令结果

        :return:解析后的结果

        """

        response = {'cpu_count': 0, 'cpu_physical_count': 0, 'cpu_model': ''}

        cpu_physical_set = set()

        content = content.strip()

        for item in content.split('\n\n'):

            for row_line in item.split('\n'):

                key, value = row_line.split(':')

                key = key.strip()

                if key == 'processor':

                    response['cpu_count'] += 1

                elif key == 'physical id':

                    cpu_physical_set.add(value)

                elif key == 'model name':

                    if not response['cpu_model']:

                        response['cpu_model'] = value

        response['cpu_physical_count'] = len(cpu_physical_set)

        return response

　　basic命令插件代码

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import traceback

from .base import BasePlugin

from lib.response import BaseReponese

from lib.log import logger

class Basic(BasePlugin):

    def os_platform(self, handler, hostname):

        """

        获取系统平台

        :return:

        """

        output = handler.cmd('uname', hostname)

        return output.strip()

    def os_version(self, handler, hostname):

        """

        获取系统版本

        :return:

        """

        output = handler.cmd('cat /etc/issue', hostname)

        result = output.strip().split('\n')[0]

        return result

    def os_hostname(self, handler, hostname):

        """

        获取主机名

        :return:

        """

        output = handler.cmd('hostname', hostname)

        return output.strip()

    def win(self, handler, hostname=None):

        raise NotImplementedError('win must be implemented ')

    def linux(self, handler, hostname=None):

        response = BaseReponese()

        try:

            if self.debug:

                ret = {

                    'os_platform': 'linux',

                    'os_version': '6.5',

                    'hostname': 'c2.com'

                }

            else:

                ret = {

                    'os_platform': self.os_platform(handler, hostname),

                    'os_version': self.os_version(handler, hostname),

                    'hostname': self.os_hostname(handler, hostname),

                }

            response.data = ret

        except Exception as e:

            msg = traceback.format_exc()

            response.status = False

            response.error = msg

            logger.error(msg)

        return response.dict

　　board命令插件代码

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import os

import traceback

from .base import BasePlugin

from lib.BaseReponse import BaseReponese

from lib.log import logger

from conf.settings import BASE_DIR

class MainBoard(BasePlugin):

    def win(self, handler, hostname=None):

        raise NotImplementedError('win must be implemented ')

    def linux(self, handler, hostname=None):

        response = BaseReponese()

        try:

            if self.debug:

                output = open(os.path.join(BASE_DIR, 'files', 'board.out'), 'r').read()

            else:

                shell_command = "sudo dmidecode -t1"

                output = handler.cmd(shell_command, hostname)

            response.data = self.parse(output)

        except Exception as e:

            msg = traceback.format_exc()

            response.status = False

            response.error = msg

            logger.error(msg)

        return response.dict

    def parse(self, content):

        result = {}

        key_map = {

            'Manufacturer': 'manufacturer',

            'Product Name': 'model',

            'Serial Number': 'sn',

        }

        for item in content.split('\n'):

            row_data = item.strip().split(':')

            if len(row_data) == 2:

                if row_data[0] in key_map:

                    result[key_map[row_data[0]]] = row_data[1].strip() if row_data[1] else row_data[1]

        return result

3.完善资产上报

　　1)需要考虑的问题 : 资产上报如何确定该这是对应的资源 ? 本次提交数据是新增还是修改呢 ?

　　　　主机唯一标识使用主机名 ,主机名存在系统的一个文件A中 ,每次提交数据的时候客户端比对一下就能完美解决唯一标识的问题 (唯一标识仅agent模式需要 ,ssh的模式中都是从api获取主机列表)

　　　　客户端提交数据的操作 ,我们可以在上报的字典中加一个状态

　　　　　　情况1:如果没有文件A ,新增主机

　　　　　　情况2:如果有文件A 且文件中记录主机名与提交主机名一致 ,唯一标识未被修改修改数据

　　　　　　情况3:如果有文件A 且文件中记录主机名与提交主机名不一致 ,唯一标识被修改的修改数据

　　　　服务端收到字典

　　　　　　针对情况1:新增记录到数据库

　　　　　　针对情况2:根据主机名找到资源更新该资源信息

　　　　　　针对情况3:根据文件A中的主机名找到字段更新信息 ,将返回唯一标识返回给客户端 ,客户端改动文件A

　　2)客户端情况进行代码实现

　　　　考虑三种情况 + 保存唯一标识文件(文件位置由配置定义)

from src.engine.base import BaseHandler

from ..plugins import get_server_info

import requests

import json

import os

from conf import settings

class AgentHandler(BaseHandler):

    """定义cmd窗口 ,操控资产采集 + 上报"""

    def cmd(self, command, hostname=None):

        import subprocess

        return subprocess.getoutput(command)

    def handler(self):

        info = get_server_info(self)

        # 新增

        if not os.path.exists(settings.CERT_PATH):

            info['type'] = 'create'

        else:

            with open(settings.CERT_PATH, 'r', encoding='utf-8') as f1:

                cert_hostname = f1.read()

                hostname = info['basic']['data']['hostname']

                # 修改

                if cert_hostname == hostname:

                    info['type'] = 'update'

                # 主机名被修改

                else:

                    info['type'] = 'host_change'

                    info['cert_hostname'] = cert_hostname

        r1 = requests.post(

            url='http://127.0.0.1:8000/api/asset/',

            data=json.dumps(info).encode('gbk'),

            headers={

                'content-type': 'application/json'

            }

        )

        response_data = r1.json()

        with open(settings.CERT_PATH,'w',encoding='utf-8') as f1:

            f1.write(response_data['hostname'])

　　3)api服务端根据三种情况 ,使用django提供数据增删改查

　　　　建立models表结构 ,数据迁移

　　　　　　外键遵循多对一 :IDC对于Server来说是一 ,那么Server设置外键字段 ,Server对于内存网卡来说是一 ....

from django.db import models

# 业务线

class BusinessUnit(models.Model):

"""

    业务名

"""

# 机房信息

class IDC(models.Model):

"""

    机房名    楼层

"""

# 服务器信息

class Server(models.Model):

"""

    服务器状态   IDC外键   机柜号   机柜序号    业务线外键   

    主机名   系统   系统版本    SN    厂商    型号   CPU个数   CPU物理个数   CPU型号

    最后一次更新日期时间   创建时间

"""

# 硬盘信息

class Disk(models.Model):

"""

    硬盘所在槽位    硬盘型号    硬盘容量   硬盘类型    服务器外键

"""

# 网卡信息

class NIC(models.Model):

"""

    网卡名    网卡mac地址    网卡的掩码   网卡的ip    启用状态    服务器外键

"""

# 内存信息

class Memory(models.Model):

"""

    内存所在槽位   内存型号   内存容量   内存厂商    SN   内存读写速率   服务器外键

"""

# 变更审计

class AssetRecord(models.Model):

"""

    审计内容    服务器外键    创建时间

"""

# 错误日志

class ErrorLog(models.Model):

"""

    日志内容   日志标题   创建时间   服务器外键信息

"""

　　4)API处理3种情况的方式

　　　　create完全新增 ,update与host_change两种情况是重合的 ,host_change需要先变更一下主机名而已 ,修改部分的重复代码放入service.py

　　　　service.py

from api import models

def process_basic(info, server_list):

    server_info = {}

    server_info.update(info['basic']['data'])

    server_info.update(info['cpu']['data'])

    server_info.update(info['board']['data'])

    # 将新字典内容打散用于更新数据库数据

    server_list.update(**server_info)

def process_disk(info, server):

    disk_info = info['disk']['data']

    disk_query = models.Disk.objects.filter(server=server)

    disk_info_set = set(disk_info)  # 针对字典的key,也就是slot

    disk_query_set = {str(i.slot) for i in disk_query}  # 针对对象的slot属性

    add_slot_set = disk_info_set - disk_query_set  # 差集(新增硬盘槽位)

    del_slot_set = disk_query_set - disk_info_set  # 差集(移除的硬盘槽位)

    update_slot_set = disk_info_set & disk_query_set  # 交集(槽位硬盘更新)

    # add_slot_set

    disk_list = []

    for slot in add_slot_set:

        disk_info[slot]['server'] = server

        disk_list.append(**disk_list[slot])

    if disk_list:

        models.Disk.objects.bulk_create(disk_list)

    # del_slot_set(拿出所有被删除的对象列表)

    if del_slot_set:

        models.Disk.objects.filter(server=server, slot__in=del_slot_set).delete()

    # update_slot_set

    if update_slot_set:

        for slot in update_slot_set:

            models.Disk.objects.filter(server=server, slot=slot).update(**disk_info[slot])

def process_memory(info,server):

    memory_info = info['memory']['data']

    memory_query = models.Memory.objects.filter(server=server)

    memory_info_set = set(memory_info)  # 针对字典的key,也就是slot

    memory_query_set = {str(i.slot) for i in memory_query}  # 针对对象的slot属性

    add_slot_set = memory_info_set - memory_query_set  # 差集(新增内存槽位)

    del_slot_set = memory_query_set - memory_info_set  # 差集(移除的内存槽位)

    update_slot_set = memory_info_set & memory_query_set  # 交集(槽位内存更新)

    # add_slot_set

    memory_list = []

    for slot in add_slot_set:

        memory_info[slot]['server'] = server

        memory_list.append(**memory_list[slot])

    if memory_list:

        models.Memory.objects.bulk_create(memory_list)

    # del_slot_set(拿出所有被删除的对象列表)

    if del_slot_set:

        models.Memory.objects.filter(server=server, slot__in=del_slot_set).delete()

    # update_slot_set

    if update_slot_set:

        for slot in update_slot_set:

            models.Memory.objects.filter(server=server, slot=slot).update(**memory_info[slot])

def process_nic(info,server):

    nic_info = info['nic']['data']

    nic_query = models.NIC.objects.filter(server=server)

    nic_info_set = set(nic_info)

    nic_query_set = {str(i.name) for i in nic_query}

    create_name_set = nic_info_set - nic_query_set

    del_name_set = nic_query_set - nic_info_set

    update_name_set = nic_info_set & nic_query_set

    if create_name_set:

        nic_list = []

        for name in create_name_set:

            nic_info[name]['server'] = server

            nic_info[name]['name'] = name

            nic_list.append(models.NIC(**nic_info[name]))

            models.NIC.objects.bulk_create(nic_list)

    if del_name_set:

        models.NIC.objects.filter(server=server, name__in=del_name_set).delete()

    if update_name_set:

        for name in update_name_set:

            models.NIC.objects.filter(server=server, name=name).update(**nic_info[name])

　　　　view.py

　　　　　　数据打散时注意一下model的字段名要与info中的key一致

　　　　　　在对硬盘网卡内存等一种多资源的操作 ,需要先判断新增多少 ,删除多少 ,变更多少三种情况再具体操作

from django.shortcuts import render, HttpResponse

from rest_framework.views import APIView

from rest_framework.response import Response

from api import models

from api import service

class Asset(APIView):

    def get(self, request):

        server_info = ['master1', 'master2']

        return Response(server_info)

    def post(self, request):

        info = request.data

        hostname = info['basic']['data']['hostname']

        ret = {'status': True, 'hostname': hostname}

        action_type = info.get('type')

        print(action_type)

        # 完全新增主机

        if action_type == 'create':

            # 1.新增主机记录 将info中有关Server表字段的字典数据拿出来放入server_info中

            server_info = {}

            server_info.update(info['basic']['data'])

            server_info.update(info['cpu']['data'])

            server_info.update(info['board']['data'])

            # 创建Server记录 ,保存在数据库 ,并拿到该对象 ,其他外键与之关联

            server = models.Server.objects.create(**server_info)

            # 2.新增该主机的硬盘信息

            disk_list = []

            for i in info['disk']['data'].values():

                i['server'] = server

                disk_list.append(models.Disk(**i))

            models.Disk.objects.bulk_create(disk_list)

            # 3.新增该主机内存信息

            memory_list = []

            for i in info['memory']['data'].values():

                i['server'] = server

                memory_list.append(models.Memory(**i))

            models.Memory.objects.bulk_create(memory_list)

            # 4.新增该主机的网卡信息

            nic_list = []

            for n, m in info['nic']['data'].items():

                m['server'] = server

                m['name'] = n

                nic_list.append(models.NIC(**m))

            models.NIC.objects.bulk_create(nic_list)

        # 唯一标识不变,更新数据

        elif action_type == 'update':

            # 取出旧的信息

            server_list = models.Server.objects.filter(hostname=hostname)

            server = server_list.first()

            ##1. 修改主机信息

            service.process_basic(info, server_list)

            ##2. 修改硬盘信息

            service.process_disk(info, server)

            ##3. 内存信息变更

            service.process_memory(info, server)

            ##4. 网卡信息变更

            service.process_nic(info, server)

        # 唯一标识变更的情况下 ,更新数据

        elif action_type == 'host_change':

            print('host_change')

            cert = info.get('cert_hostname')

            server = models.Server.objects.filter(hostname=cert).first()

            server.hostname = info['basic']['data']['hostname']

            server.save()

            server_list = models.Server.objects.filter(hostname=server.hostname)

            ##1 修改主机信息

            service.process_basic(info,server_list)

            ##2 修改硬盘信息

            service.process_disk(info,server)

            ##3 修改内存信息

            service.process_memory(info,server)

            ##4 修改网卡信息

            service.process_nic(info,server)

        return Response(ret)

4.api的验证

　　客户端必须拥有key才能去调用服务端api ,两端存储同一个key值不在网络中传输

　　原理: 客户端发送 MD5=md5(client的key+A时间) + A时间

　　　　服务端接收 MD5 + A时间

　　　　服务端使用 md5(server的key+A时间) 是否等于客户端传来的MD5 ,由此判断两边存储的key值是否相等

　　合理使用: 客户端的post请求带上MD5与时间的参数 ,服务端所有api都要使用到这个校验 ,重写dispatch方法来完成

　　客户端代码

　　　　/lib/api_auth.py 所有的engine都要使用所以放入lib中

import hashlib

from conf import settings

def MD5_key(ctime):

    key = '{}|{}'.format(settings.AUTH_KEY, ctime)

    md5 = hashlib.md5()

    md5.update(key.encode('utf-8'))

    return md5.hexdigest()

　　　　/engine/agent.py　　engine中使用的方式

　　　　　　其中params可以让url上带参数 ,服务端通过request.GET.get('key')获取

        ctime = time.time()

        r1 = requests.post(

            url='http://127.0.0.1:8000/api/asset/',

            data=json.dumps(info).encode('gbk'),

            params={'key': MD5_key(ctime), 'ctime': ctime},

            headers={

                'content-type': 'application/json'

            }

        )

　　服务端代码

　　　　views.py

　　　　　　1.定义一个类 ,重写dispatch方法进行校验 ,让所有api都继承这个类

　　　　　　2.校验中考虑超时问题拒绝 ,重复伪造的url拒绝 ,md5值无法对应的拒绝

　　　　　　3.如果失败直接返回json ,如果成功就走父类的dispatch ,执行api流程

def MD5_key(ctime):

    key = '{}|{}'.format(settings.AUTH_KEY, ctime)

    md5 = hashlib.md5()

    md5.update(key.encode('utf-8'))

    return md5.hexdigest()

already_key = {}

class AuthView(APIView):

    def dispatch(self, request, *args, **kwargs):

        ret = {'status': True, 'msg': 'ok'}

        key = request.GET.get('key')

        ctime = request.GET.get('ctime')

        now = time.time()

        if now - float(ctime) > 3:

            ret['status'] = False

            ret['msg'] = '请求超时'

            return JsonResponse(ret)

        if key in already_key:

            ret['status'] = False

            ret['msg'] = 'url已使用'

            return JsonResponse(ret)

        if key != MD5_key(ctime):

            ret['status'] = False

            ret['msg'] = '验证失败'

        already_key[key] = None

        if ret['status']:

            return super().dispatch(request, *args, **kwargs)

        else:

            return JsonResponse(ret)

5.数据传输加密

　　提高安全性 ,客户端服务端传输的数据使用非对称加密

　　1)生成秘钥对

　　　　生成最多加密1024位 ,那就是128个字节 ,其中有11个是加密自己用 ,所以每次能加密最大长度为117

import rsa

import base64

####生成一组秘钥对####

pub_key_obj, priv_key_obj = rsa.newkeys(1024)  # 最大加密value的字节数是  1024/8 - 11(自己用) = 117(可用加密字节)

# 将公私钥的str类型拿出

pub_key_str = pub_key_obj.save_pkcs1()

priv_key_str = priv_key_obj.save_pkcs1()

# 再将str的类型用base64编码

pub_key_code = base64.standard_b64encode(pub_key_str)

priv_key_code = base64.standard_b64encode(priv_key_str)

print(pub_key_code)

print(priv_key_code)

　　2)客户端加密

　　　　使用配置好的公钥 ,对数据进行分段加密再拼接在一起 ,发送到服务端

　　　　数据编码加密格式化顺序 : 加密(编码(json(原始数据)))

　　　　lib/encrypt.py 将加密函数单独放入公共功能文件夹

import base64

import rsa

from conf import settings

def encrypt(bytes_value):

    values_list = []

    key_str = base64.standard_b64decode(settings.PUB_KEY)

    pk = rsa.PublicKey.load_pkcs1(key_str)

    length = len(bytes_value)

    for i in range(0, length, 117):

        val = rsa.encrypt(bytes_value[i: i + 117], pk)

        values_list.append(val)

    val = b''.join(values_list)

    return val

　　　　所有的engine中的handler方法数据上报都加密

r1 = requests.post(

...

    data=encrypt(json.dumps(info).encode('utf-8')),

...

    }

)

　　3)服务端解密

　　　　当post请求中数据过长 ,request的数据放在body中

　　　　数据编码解密格式化顺序 : json(解码(解密(原始数据) ))

　　　　utils.py/decrypt.py　将数据解码文件函数放入工具文件夹

import base64

import rsa

from django.conf import settings

def decrypt(value):

    values_list = []

    key_str = base64.standard_b64decode(settings.PRI_KEY)

    pk = rsa.PrivateKey.load_pkcs1(key_str)

    length = len(value)

    for i in range(0, length, 128):

        val = rsa.decrypt(value[i:i + 128], pk)

        values_list.append(val)

    val = b''.join(values_list)

    return val

　　　　视图函数中接收的info数据进行解密

    def post(self, request):

        info = json.loads(decrypt(request.body).decode('utf-8'))

巴特西

cmdb项目-2

最新文章

热门文章