发表于 | 分类于

最近关注了几个公众号，想收藏有价值的内容。不过文章较多，不停的下滑操作去找文章是一件折磨人的事，试过几次后，面对众多的资源望洋兴叹。

有什么好的方法呢？有人推荐连接手机用fiddler抓包，被坑了2个小时😡，此路不通或者说麻烦。

一个比较好的方法是找到微信公众号平台内部的API，比如“python技术”的的文章这里都有，哈哈：

为了获取文章列表，我特意注册了一个微信公众号。

注册好了，咱们直奔主题，说下操作过程。

进入公众号点击<草稿箱>，再点击右侧<图文模板> ![](http://www.justdopython.com/assets/images/2022/11/scrapywechatmp/2.png) 选择<新建图文模板> ![](http://www.justdopython.com/assets/images/2022/11/scrapywechatmp/3.png) 进入到编辑界面，点<超链接>,选<选择其他公众号>，输入你要爬的公众号名称。 ![](http://www.justdopython.com/assets/images/2022/11/scrapywechatmp/4.png) ![](http://www.justdopython.com/assets/images/2022/11/scrapywechatmp/5.png) 以python技术为例： ![](http://www.justdopython.com/assets/images/2022/11/scrapywechatmp/6.png) 按F12或通过鼠标右键检查，点《Network》后选择《XHR》一般最后一个即是当前页面内容所在，这里看到url和标题分别位于《link》和《title》标签下，如果network没东西刷新试一下

下图最后一个箭头的title标签，可以看到我昨天发表的“用LOL英雄点缀你的博客”

到这里我们已经成功了一半，接下来我们获取用到的《user-agent》《URL》《cooike》《tooken》和《fakeid》,点击Headers

  • cooike帮我们绕过登录过程
  • fakeid是目标公众号的唯一标识符
  • user-agent可以模拟浏览器请求 至此信息获取部分完成，下面开始开始代码部分。

注意： 下面“完整脚本”中的fakeid、token、type等的值在url中可以看到 也可以直接访问这个url，一个JSON格式的数据：

完整脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# -*- coding: utf-8 -*-
import requests
import time

headers = {
    "cookie": "appmsglist_action_3889613222=card; ua_id=Q1Dfu2THA6T9Qr1HAAAAAN_KYa5xTwNmiuqj1Mkl6PY=; wxuin=18828715020059xid=a5c7612f529374b74deb4178e7ff4ca7",
    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36"
}
url = 'https://mp.weixin.qq.com/cgi-bin/appmsg'
fad = 'MjM5ODM3MTUwMA=='                     #爬不同公众号只需要更改 fakeid

def page(num=1):                             #要请求的文章页数
    title = []
    link = []
    for i in range(num):         
        data = {
            'action': 'list_ex',
            'begin': i*5,       #页数
            'count': '5',
            'fakeid': fad,
            'type': '9',
            'query':'' ,
            'token': '1753262244',
            'lang': 'zh_CN',
            'f': 'json',
            'ajax': '1',
        }
        r = requests.get(url,headers = headers,params=data)
        dic = r.json()            
        for i in dic['app_msg_list']:     #遍历dic['app_msg_list']中所有内容
            title.append(i['title'])      #取 key键 为‘title’的 value值
            link.append(i['link'])        #去 key键 为‘link’的 value值
    return title,link

if __name__ == '__main__':
    (tle,lik) = page(5)
    for x,y in zip(tle,lik):
        print(x,y)

成功获取5页url和标题，可以看到我发表过的几篇文章😀，以后查公众号文章就方便了，bingo！

阅读全文 »

发表于 | 分类于

不知道大家的windows桌面用的哪个壁纸？

早上来上班，打开电脑，被漂亮的桌面壁纸所吸引，年底将近，这又是哪个地方的节日？

才晓得，原来这是泰国第二大城市清迈的“天灯节”，把🏮送上天空是对神灵的尊敬，代表着摆脱厄运，祈求好运

灯笼通常是由宣纸制成，把点燃的蜡烛固定在中心。火能产生足够的热量使灯笼变得很轻，可以飘向天空。

有些人认为，如果你的灯笼在蜡烛燃尽之前消失在夜空中，那么你将在新的一年里获得好运。

一张小小的桌面壁纸，也可能给你带来惊喜和感动

就像我们囿于办公室或许未能远行，但心底从未停止过对远方的探索，除了诗和远方，还有柴米油盐，甚至还有python帮你做点事。

这么多好看的Bing壁纸怎么手到擒来呢？提供2个方法让你壁纸不愁，赏心悦目

python批量下载

该方法基于一个 Bing 壁纸 API。

用浏览器访问 https://bingw.jasonzeng.dev，你可以看到一张高清图片。

我们可以用 Python 来调用它，然后批量保存下来，比如说下载最近 100 天的图片：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import requests
from pathlib import Path

def save_pic(path:Path):
    for i in range(100):
        url = f"http://bingw.jasonzeng.dev?resolution=UHD&index={i}"
        with requests.get(url) as r:
            with open(path/f"{i}.jpg","wb") as w:
                w.write(r.content)


if __name__ == "__main__":
    saved_path = Path("./bing_pic")
    saved_path.mkdir(parents = True, exist_ok = True)
    save_pic(saved_path)

执行上面的代码，就可以在目标路径看到下载的高清图片：

接口介绍

1、传入 resolution 参数可以指定壁纸图像的分辨率。默认为1920x1080，可选值如下：

  • UHD
  • 1920x1200
  • 1920x1080
  • 1366x768
  • 1280x768
  • 1024x768
  • 800x600
  • 800x480
  • 768x1280
  • 720x1280
  • 640x480
  • 480x800
  • 400x240
  • 320x240
  • 240x320 UHD 就是高清，图片比较大。

2、传入 index 可以获取哪天的图片，0 表示今天，1 表示昨天，以此类推，index=random 表示随机一天。

3、传入 date 可以获取从某某一天到今天的图片，比如 data=20210401。

4、传入 w 和 h 可以指定图片的宽度和高度。

5、传入 qlt 可以指定图片的质量，取值范围是 0 到 100

方法二：安装bing-wallpaper

浏览器访问

1
https://www.microsoft.com/zh-hk/bing/bing-wallpaper

下载 bing-wallpaper 后，每日都能以全新背景图片来令桌面焕发活力

阅读全文 »

发表于 | 分类于

Python 已经得到了全球程序员的喜爱，连续多期稳坐编程语言排行榜第一把交椅。但是还是遭到一些人的诟病，原因之一就是认为它运行缓慢。

于是，大家都在想尽各种办法来提高 Python 代码的运行速度，大多数体现在写代码的习惯优化以及代码优化上。但是平时写代码注意太多这些方面可能会有糟糕的体验，甚至会不利于我们的工作效率。

要是有一款能够自动优化我们代码的神器该有多好啊！

今天就给大家带来这样的一款神器——taichi！

taichi 是何方神圣

Taichi 起步于 MIT 的计算机科学与人工智能实验室（CSAIL），设计初衷是便利计算机图形学研究人员的日常工作，帮助他们快速实现适用于 GPU 的视觉计算和物理模拟算法。

说人话就是 Taichi 是一个基于 Python 的领域特定语言，专为高性能能并行计算设计。

本来是服务于学术界的一款 DSL ，但是我们也可以拿来用在我们这些凡夫俗子的代码中（虽然有点大材小用）！

安装

Taichi 是一个 PyPI 包，所以使用 pip 命令即可安装：

pip install taichi

注意 taichi 安装的先决条件是：

  • Python: 3.7/3.8/3.9/3.10 (64-bit)
  • OS: Windows, OS X, and Linux (64-bit)

在使用命令安装的时候，如果遇到错误，可以使用管理员模式命令行进行安装。

一个小栗子

我们先来用一个小栗子，感受一下它的鬼斧神工！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import time
 
def is_prime(n):
    result = True
    for k in range(2, int(n**0.5) + 1):
        if n % k == 0:
            result = False
            break
    return result

def count_primes(n: int) -> int:
    count = 0
    for k in range(2, n):
        if is_prime(k):
            count += 1
    
    return count

t0 = time.time()
print(count_primes(100000))
t1 = time.time()

print(t1-t0)

这个是我们以前经常用来做例子的统计质数个数。求100000以内速度比较快，但是到了1000000，运行时间就明显慢了下来，竟然需要3.38秒。

Python 的大型 for 循环或嵌套 for 循环总是导致运行时性能不佳。

我们只需导入 Taichi 或切换到 Taichi 的 GPU 后端，就能看到整体性能的大幅提升：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import time
import taichi as ti

ti.init()

@ti.func
def is_prime(n):
    result = True
    for k in range(2, int(n**0.5) + 1):
        if n % k == 0:
            result = False
            break
    return result

@ti.kernel
def count_primes(n: int) -> int:
    count = 0
    for k in range(2, n):
        if is_prime(k):
            count += 1
    
    return count

t0 = time.time()
print(count_primes(1000000))
t1 = time.time()

print(t1-t0)

在这里，我们只需要引入 taichi 库，然后加两个注解，速度直接飙到了0.1秒，速度提升了30多倍。如果我们把数字再扩大，速度提升会更明显！

没有使用之前，统计10000000以内质数使用 90 秒，使用之后，并且更改为 GPU 运行，使用 0.1秒。

我们还可以将 Taichi 的后端从 CPU 更改为 GPU 运行：

1
ti.init(arch=ti.gpu)

用 Taichi 进行物理模拟

上面的动图很好地模拟了一块布料落到一个球体上。 动图中的布料建模使用了弹簧质点系统，其中包含 10,000 多个质点和大约 100,000个弹簧。 模拟如此大规模的物理系统并实时渲染绝不是一项容易的任务。

Taichi 让物理模拟程序变得更易读和直观，同时仍然达到与 C++ 或 CUDA 相当的性能。 只需拥有基本 Python 编程技能，就可以使用 Taichi 用更少的代码编写高性能并行程序，从而关注较高层次的算法本身，把诸如性能优化的任务交由 Taichi 处理。

我们直接上源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
import taichi as ti
ti.init(arch=ti.vulkan)  # Alternatively, ti.init(arch=ti.cpu)

n = 128
quad_size = 1.0 / n
dt = 4e-2 / n
substeps = int(1 / 60 // dt)

gravity = ti.Vector([0, -9.8, 0])
spring_Y = 3e4
dashpot_damping = 1e4
drag_damping = 1

ball_radius = 0.3
ball_center = ti.Vector.field(3, dtype=float, shape=(1, ))
ball_center[0] = [0, 0, 0]

x = ti.Vector.field(3, dtype=float, shape=(n, n))
v = ti.Vector.field(3, dtype=float, shape=(n, n))

num_triangles = (n - 1) * (n - 1) * 2
indices = ti.field(int, shape=num_triangles * 3)
vertices = ti.Vector.field(3, dtype=float, shape=n * n)
colors = ti.Vector.field(3, dtype=float, shape=n * n)

bending_springs = False

@ti.kernel
def initialize_mass_points():
    random_offset = ti.Vector([ti.random() - 0.5, ti.random() - 0.5]) * 0.1

    for i, j in x:
        x[i, j] = [
            i * quad_size - 0.5 + random_offset[0], 0.6,
            j * quad_size - 0.5 + random_offset[1]
        ]
        v[i, j] = [0, 0, 0]


@ti.kernel
def initialize_mesh_indices():
    for i, j in ti.ndrange(n - 1, n - 1):
        quad_id = (i * (n - 1)) + j
        # 1st triangle of the square
        indices[quad_id * 6 + 0] = i * n + j
        indices[quad_id * 6 + 1] = (i + 1) * n + j
        indices[quad_id * 6 + 2] = i * n + (j + 1)
        # 2nd triangle of the square
        indices[quad_id * 6 + 3] = (i + 1) * n + j + 1
        indices[quad_id * 6 + 4] = i * n + (j + 1)
        indices[quad_id * 6 + 5] = (i + 1) * n + j

    for i, j in ti.ndrange(n, n):
        if (i // 4 + j // 4) % 2 == 0:
            colors[i * n + j] = (0.22, 0.72, 0.52)
        else:
            colors[i * n + j] = (1, 0.334, 0.52)

initialize_mesh_indices()

spring_offsets = []
if bending_springs:
    for i in range(-1, 2):
        for j in range(-1, 2):
            if (i, j) != (0, 0):
                spring_offsets.append(ti.Vector([i, j]))

else:
    for i in range(-2, 3):
        for j in range(-2, 3):
            if (i, j) != (0, 0) and abs(i) + abs(j) <= 2:
                spring_offsets.append(ti.Vector([i, j]))

@ti.kernel
def substep():
    for i in ti.grouped(x):
        v[i] += gravity * dt

    for i in ti.grouped(x):
        force = ti.Vector([0.0, 0.0, 0.0])
        for spring_offset in ti.static(spring_offsets):
            j = i + spring_offset
            if 0 <= j[0] < n and 0 <= j[1] < n:
                x_ij = x[i] - x[j]
                v_ij = v[i] - v[j]
                d = x_ij.normalized()
                current_dist = x_ij.norm()
                original_dist = quad_size * float(i - j).norm()
                # Spring force
                force += -spring_Y * d * (current_dist / original_dist - 1)
                # Dashpot damping
                force += -v_ij.dot(d) * d * dashpot_damping * quad_size

        v[i] += force * dt

    for i in ti.grouped(x):
        v[i] *= ti.exp(-drag_damping * dt)
        offset_to_center = x[i] - ball_center[0]
        if offset_to_center.norm() <= ball_radius:
            # Velocity projection
            normal = offset_to_center.normalized()
            v[i] -= min(v[i].dot(normal), 0) * normal
        x[i] += dt * v[i]

@ti.kernel
def update_vertices():
    for i, j in ti.ndrange(n, n):
        vertices[i * n + j] = x[i, j]

window = ti.ui.Window("Taichi Cloth Simulation on GGUI", (1024, 1024),
                      vsync=True)
canvas = window.get_canvas()
canvas.set_background_color((1, 1, 1))
scene = ti.ui.Scene()
camera = ti.ui.make_camera()

current_t = 0.0
initialize_mass_points()

while window.running:
    if current_t > 1.5:
        # Reset
        initialize_mass_points()
        current_t = 0

    for i in range(substeps):
        substep()
        current_t += dt
    update_vertices()

    camera.position(0.0, 0.0, 3)
    camera.lookat(0.0, 0.0, 0)
    scene.set_camera(camera)

    scene.point_light(pos=(0, 1, 2), color=(1, 1, 1))
    scene.ambient_light((0.5, 0.5, 0.5))
    scene.mesh(vertices,
               indices=indices,
               per_vertex_color=colors,
               two_sided=True)

    # Draw a smaller ball to avoid visual penetration
    scene.particles(ball_center, radius=ball_radius * 0.95, color=(0.5, 0.42, 0.8))
    canvas.scene(scene)
    window.show()

感兴趣的可以具体看看代码的实现过程，如果不加 taichi 库，这段代码运行起来会有点吃力，但是上了 taichi 之后，运行效果是如此丝滑！

总结

大家看这个 taichi 是不是会联想到“太极”二字？

没错，这个库是中国人发明的，它就是毕业于清华大学，后来去麻省理工学院进修的胡渊鸣！

他是太极图形创始人，北京太琦图形科技有限公司联合创始人、CEO。总之，他是个天才，让国人也在世界编程舞台上绽放异彩！

阅读全文 »

发表于 | 分类于

上回我们活捉一只叫“轩逸”的动力蜘蛛，因为它动力拉垮，实在太慢了

这次让它变身给大家跳个舞，看下边的舞蹈，最拉跨的“动力”，这两个字给力吧！

词云来自轩逸车友圈的真实数据，爬取过程可以参考用python来吐槽，真是太会玩啦

gif不够清晰流畅，所以把更清晰的视频文件上传了，http://ssw.fit/file/

前言

利用you-get下载一个B站上跳舞的小姐姐视频，利用懂车帝爬取的“轩逸最不满意”来制作一个漂亮小姐姐词云跳舞视频，一起来看看吧。

1.下载视频

安装 you-get 库

1
pip install you-get -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

利用 you-get 下载 B 站视频到本地

1
you-get https://www.bilibili.com/video/BV1rD4y1Q7jc?from=search&seid=10634574434789745619

2.词云文本

脚本要用到的2个文件：

1
2
轩逸最不满意.txt
stopwords.txt

已上传 http://ssw.fit/file/

3.从视频中提取图片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import cv2

# ============================ 视频处理 分割成一帧帧图片 =======================================
cap = cv2.VideoCapture(r"不要心动❤️我要开始表白了【欣小萌】 (P1. 横屏版).mp4")
num = 1
while True:
    # 逐帧读取视频  按顺序保存到本地文件夹
    ret, frame = cap.read()
    if ret:
        if 88 <= num < 888:
            cv2.imwrite(f"./pictures/img_{num}.jpg", frame)   # 保存一帧帧的图片
            print(f'========== 已成功保存第{num}张图片 ==========')
        num += 1
    else:
        break
cap.release()   # 释放资源

结果如下：

4.利用百度AI进行人像分割

准备工作

百度智能云网址

1
https://console.bce.baidu.com/

Python SDK参考文档

安装人体分析 Python SDK

1
pip install baidu-aip

1.领取免费资源

登录进去后，搜索“人体分析” 进入“人体分析”的页面后，领取免费资源 没领取的话，后面脚本的“人像分割”部分会报错，因为使用百度api需要用到这些资源。默认1万次，我已经用了1000多次

2.创建应用

创建一个人像分割的应用，记住你的AppID、API Key、Secret Key，后面会用到。 查看人像分割的 Python SDK 文档，熟悉它的基本使用。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# -*- coding: UTF-8 -*-

import cv2
import base64
import numpy as np
import os
from aip import AipBodyAnalysis
import time
import random

# 利用百度AI的人像分割服务 转化为二值图  有小姐姐身影的蒙版
# 百度云中已创建应用的  APP_ID API_KEY SECRET_KEY
APP_ID = '……'
API_KEY = '……'
SECRET_KEY = '……'

client = AipBodyAnalysis(APP_ID, API_KEY, SECRET_KEY)
# 保存图像分割后的路径
path = './mask_img/'

# os.listdir  列出保存到图片名称
img_files = os.listdir('./pictures')
print(img_files)
for num in range(88, len(img_files) + 1):
    # 按顺序构造出图片路径
    img = f'./pictures/img_{num}.jpg'
    img1 = cv2.imread(img)
    height, width, _ = img1.shape
    # print(height, width)
    # 二进制方式读取图片
    with open(img, 'rb') as fp:
        img_info = fp.read()

    # 设置只返回前景   也就是分割出来的人像
    seg_res = client.bodySeg(img_info)
    print(111,seg_res)
    labelmap = base64.b64decode(seg_res['labelmap'])
    nparr = np.frombuffer(labelmap, np.uint8)
    labelimg = cv2.imdecode(nparr, 1)
    labelimg = cv2.resize(labelimg, (width, height), interpolation=cv2.INTER_NEAREST)
    new_img = np.where(labelimg == 1, 255, labelimg)
    mask_name = path + 'mask_{}.png'.format(num)
    # 保存分割出来的人像
    cv2.imwrite(mask_name, new_img)
    print(f'======== 第{num}张图像分割完成 ========')
    time.sleep(random.randint(1,2))

结果如下：

5.小姐姐跳舞词云生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# -*- coding: UTF-8 -*-
from wordcloud import WordCloud
import collections
import jieba
import re
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np


# 读取数据
with open('轩逸最不满意.txt',encoding='utf8') as f:
    data = f.read()

# 文本预处理  去除一些无用的字符   只提取出中文出来
new_data = re.findall('[\u4e00-\u9fa5]+', data, re.S)
new_data = "/".join(new_data)

# 文本分词
seg_list_exact = jieba.cut(new_data, cut_all=True)

result_list = []
with open('stopwords.txt', encoding='utf-8') as f:
    con = f.read().split('\n')
    stop_words = set()
    for i in con:
        stop_words.add(i)

for word in seg_list_exact:
    # 设置停用词并去除单个词
    if word not in stop_words and len(word) > 1:
        result_list.append(word)

# 筛选后统计词频
word_counts = collections.Counter(result_list)
path = './wordcloud/'

for num in range(88, 888):
    img = f'./mask_img/mask_{num}.png'
    # 获取蒙版图片
    mask_ = 255 - np.array(Image.open(img))
    # 绘制词云
    plt.figure(figsize=(8, 5), dpi=200)
    my_cloud = WordCloud(
        background_color='black',  # 设置背景颜色  默认是black
        mask=mask_,      # 自定义蒙版
        mode='RGBA',
        max_words=500,
        font_path='C:/Windows/Fonts/simhei.TTF',   # 设置字体  显示中文
    ).generate_from_frequencies(word_counts)

    # 显示生成的词云图片
    plt.imshow(my_cloud)
    # 显示设置词云图中无坐标轴
    plt.axis('off')
    word_cloud_name = path + 'wordcloud_{}.png'.format(num)
    my_cloud.to_file(word_cloud_name)    # 保存词云图片
    plt.close()
    print(f'======== 第{num}张词云图生成 ========')

结果如下：

6.合成跳舞视频

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding: UTF-8 -*-
import cv2
import os

# 输出视频的保存路径
video_dir = '轩逸最不满意.mp4'
# 帧率
fps = 30
# 图片尺寸
img_size = (1920, 1080)

fourcc = cv2.VideoWriter_fourcc('M', 'P', '4', 'V')  # opencv3.0 mp4会有警告但可以播放
videoWriter = cv2.VideoWriter(video_dir, fourcc, fps, img_size)
img_files = os.listdir('./wordcloud')

for i in range(88, 801):
    img_path = './wordcloud/' + 'wordcloud_{}.png'.format(i)
    frame = cv2.imread(img_path)
    frame = cv2.resize(frame, img_size)   # 生成视频   图片尺寸和设定尺寸相同
    videoWriter.write(frame)      # 写进视频里
    print(f'======== 按照视频顺序第{i}张图片合进视频 ========')

videoWriter.release()   # 释放资源

本文参考 利用Python做一个漂亮小姐姐词云跳舞视频

阅读全文 »

发表于 | 分类于

Img

公司主营短信，工作中数据库查询占了很大比例。

我们的操作是，通过navicat连接十多台机器的库，然后连接数据库-输入sql-修改查询条件（如一长串的日期）进行各种查询，

遇上高峰期，客服频频转发问题给我们，例如查下客户为什么没收到短信啦，查询发送记录啦，某个短信通道的发送量，签名统计等等 Img 最让我郁闷的地方，每次手机号、日期、短信通道等条件挨个修改一遍，键盘敲得噼里啪啦，鼠标点的不亦乐乎，别人还以为你有多忙，结果一顿操作猛于虎就查了条数据 Img

都说打工人苦打工人累 Img

我们就不要把工作耗费在这无意义的机械重复中了，是的，即使快一点也好 Img

思路

我想到总结常用的sql，写入配置文件 Img 通过网页点击执行这些语句。

在前端，好不容易靠试错发现，可以通过JavaScript的splice函数来对接红框内的查询条件： Img

利用splice实现搜索条件动态添加，这个用法是我蒙的，不知道专业的前端MM怎么做的。

上述内容就是我最初的想法。

虽然研发已经给客服MM做了查询后台，不过不适合我们这种“查询工程师”。

手工DIY一个？ Img

想法挺好，怎么实现呢。

这个不急，骑着毛驴看唱本——走着瞧

摸到一条鱼

日月轮转，上班闲敲棋子，忙改文字，敲敲打打的，在没有其它技术人员支持的情况下，前后端居然调通了。

忽然间，大部分的查询工作，我都可以通过自己的笔记本轻描淡写的“指点江山”了: Img

不管多少个数据库，多少条语句，我都可以写到配置文件中。

前端呢，可以用element-ui的“Cascader 级联选择器”分门别类来添加要执行的sql Img

下图红框内就是“Cascader 级联选择器”效果，选中后会动态出现相关的搜索选项： Img

我们看下展示效果： Img

大体情况就是这样。

怎么实现的，主要介绍2点：

  • 如何连接不同的数据库
  • 如何添加一条sql查询

    文末上传了所有源码到gitee，有兴趣的同学可以看看

如何连接不同的数据库

1. 怎么在前端看到数据库

如图，怎么让数据库信息在下拉框中显示呢？ Img 首先，每个数据库取个英文名字，写在配置文件里，通过configparser模块读取 Img

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from rest_framework.views import APIView
import configparser

def read_cfg(name):
    cfg = configparser.RawConfigParser()
    cfg.read(settings.CONFIG_PATH, encoding='utf-8')
    return cfg.items(name)

class get_dbs(APIView):
    def get(self, request, *args, **kwargs):
        dbs = read_cfg('db')
        dbs_list = []
        d = {}
        for k,v in dbs:
            d['label'] = k
            d['value'] = v
            dbs_list.append(d)
            d = {}
        return JsonResponse({'code': 1, 'data': dbs_list})

然后配置前端，一打开页面就获取数据库信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
export default {
  created() {
    this.get_dbs()
  },
}

async get_dbs() {
    //this.$http.get('dbs')，dbs为获取数据库信息的接口地址
    const { data: res } = await this.$http.get('dbs')
    if (res.code !== 1) {
    return this.$message.error('获取dbs失败')
    }
    this.operateFormLabel[0].children = res.data
},

2. 让django处理前端传来的数据库信息

公司数据库为oracle，并且经过堡垒机，所以用到cx_Oracle和sshtunnel模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from cx_Oracle import Connection
from sshtunnel import SSHTunnelForwarder
from rest_framework.views import APIView

class get_messages(APIView):
    def post(self, request, *args, **kwargs):
        data = json.loads(request.body.decode('utf-8'))
        db = data['db']
        #根据下拉框中选择的数据库名字，配置要连接的数据库
        if not db:
            return JsonResponse({'code':0,'msg':"请选择数据库"})
        if db == 'lt1':
            conn = ('192.168.2.1','ms','sgate;Normal;sms')
        elif db == 'lt2':
            conn = ('192.168.2.6','ms2','sgate;Normal;sms2')
        
        #sshtunnel建立客户端与堡垒机的隧道
        with SSHTunnelForwarder(
                ('堡垒机地址', port),
                ssh_username="ssw",
                ssh_password="1223456",
                remote_bind_address=(conn, 1521)) as server:
            conn = (conn[1], '123456', '127.0.0.1:%d/%s' % (server.local_bind_port,conn[2]))
            xconn = Connection(*conn)
            cursor = xconn.cursor()  # 新建游标
            cursor.execute(sql)  # 执行sql语句
            ret = cursor.fetchall()
            cursor.close()
            xconn.close()

这样就可以在页面下拉框中，自由的进行数据库的连接啦。接下来就是如何添加sql了，请看下面的例子。

如何添加一条sql查询

前端操作

1. 怎么在前端看到它

如图，怎么让这条sql在前端显示呢？ Img 只需一步， 在messages.vue中添加级联菜单的一级菜单巡检和二级菜单服务器即可

1
2
3
4
5
6
7
8
9
10
11
12
      casecadeFormLabel: [
        {
          model: 'weekly_check',
          label: '巡检',
          children: [
            {
              label: '服务器',
              value: 'inspect'
            },
          ]
        }
      ],

只是显示还不够，每条语句要显示的字段不一样，我们需要单独定义它们 Img

2. 单独定义要显示的表头字段

如上所述，在messages.vue中添加inspect的表头字段，并且设置this.tableLabel = this.inspectLabel。为每条sql语句设置不同的表头字段，赋值给this.tableLabel，这样可以让不同的sql显示不同的字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
      inspectLabel: [
        { prop: 'ip', label: '服务器', width: 120},
        { prop: 'cpu', label: 'CPU占用率', width: 70},
        { prop: 'mem', label: '内存占用率', width: 70},
        { prop: 'disk', label: '磁盘使用情况', width: 230 },
        { prop: 'vda1', label: '/dev/vda1使用率', width: 100},
        { prop: 'vdb1', label: '/dev/vdb1使用率', width: 100},
        { prop: 'network', label: '网络连接', width: 60},
        { prop: 'service', label: '服务检查', width: 165 },  
        { prop: 'url', label: '站点检查', width: 165 },       
        { prop: 'create_time', label: '日期', width: 70}      
      ], 

      ...中间略
      else if (this.operateForm.sql === 'inspect') {
        this.tableLabel = this.inspectLabel
      }
3. 动态添加搜索条件

如图，框内的3个搜索条件是通过JavaScript的splice函数生成的。通过它，我们可以为每条语句定义不同的搜索条件。 Img 在commonForm.vue中编辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 如果点击的的sql是“inspect”，就在页面上添加3个搜索条件，分别是网络连接、服务检查、时间范围
export default {
  data() {
    return {
      network: {
        model: 'network',
        label: '网络连接'
      },
      service: {
        model: 'service',
        label: '服务检查'
      },
      timerange: {
        model: 'timerange',
        label: '时段',
        type: 'date'
      },
    }
  }，

    methods: {
    handleChange() {

        if (this.selectedKeys === 'inspect') {
            this.formLabel.splice(1, 1, this.network)
            this.formLabel.splice(2, 1, this.service)
            this.formLabel.splice(3, 1, this.timerange)
        }
    }
    }
}

接下来是后端操作

后端操作

1. 读取sql

首先，sql取名为“inspect”。 config.cfg-[sql] 填写要执行的sql语句 Img

old_views.py-read_cfg函数，get_sql函数 读取config.cfg中的sql语句，比如读到名为“inspect”的语句，返回的结果是这样的 [‘select project,ip,cpu,mem,disk,vda1,vdb1,network,service,url,create_time\nfrom weekly_check\nwhere create_time BETWEEN {1} AND {2}’]

1
2
3
4
5
6
7
8
9
10
11
12
import configparser
def read_cfg(name):
    cfg = configparser.RawConfigParser()
    cfg.read(settings.CONFIG_PATH, encoding='utf-8')
    return cfg.items(name)

#读取config.cfg中的sql语句，比如读到名为“inspect”的语句，返回的结果是这样的
#['select project,ip,cpu,mem,disk,vda1,vdb1,network,service,url,create_time\nfrom weekly_check\nwhere create_time BETWEEN {1} AND {2}']
def get_sql(sqlname):
    data = read_cfg('sql')
    sql = [item[1] for item in data if sqlname == item[0]]
    return sql[0]
2. 对页面提交过来的sql语句进行处理

然后，对页面提交过来的sql语句进行处理： 如修改日期，修改where条件，加上搜索条件等

old_views.py-get_messages()

1
2
3
4
5
6
7
8
9
10
11
12
13
if sqlname in ('inspect'):
    inputLabel = []
    field = []
    condition = []
    field_dict = {'network': network, 'service': service}
    for key, value in field_dict.items():
        print('len(value)',len(value))
        field.append(key)
        condition.append("{0} like '%{1}%' and".format(key, value))
    if sqlname == 'inspect':
        print('get_sql(sqlname)',get_sql(sqlname).format(','.join(field), start, end))
        print('condition',condition)
        sql = get_sql(sqlname).format(','.join(field), start, end).replace('where','where {0}').format(' '.join(condition))
3. 数据转成字典

(('农林牧渔', '172.16.1.6', '2.05', '24.59', '/dev/vda1 used: 7.9G nouse: 30G', '19.75', '74.11', '异常', 'Bootlog: OK'),)

这是从数据库返回的数据，类型为元组，需要转成字典并给value加上key，方便前端识别。如{‘项目名称’: ‘农林牧渔’, ‘ip’: ‘172.16.1.6’}

old_views.py-foo函数，bar函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#把参数转成字典
def foo(**kwargs):
    #对字典中的datetime时间格式数据转为字符串
    if isinstance(kwargs['create_time'],datetime.datetime):
        kwargs['create_time'] = kwargs['create_time'].strftime(('%Y-%m-%d %X'))
    return kwargs

#field是选取哪些字段的数据返回给前端
def bar(ret,sqlname,field=None,user_id=None):
    for item in ret:
        if sqlname == 'inspect':
            obj = foo(project=item[0], ip=item[1], cpu=item[2],mem=item[3],disk=item[4],
                      vda1=item[5],
                      vdb1=item[6],
                      network=item[7],
                      service=item[8],
                      url=item[9],
                      create_time=item[10])
        yield obj

上一步bar()函数主要作用是把从数据库查到的数据转成字典，并给value加上一个key，大概过程：

1
2
3
4
5
6
7
8
9
10
11
import datetime
ret = (('农林牧渔', '172.16.1.6', '2.05', '24.59', '/dev/vda1 used: 7.9G nouse: 30G', '19.75', '74.11', '异常', 'Bootlog: OK', '', datetime.datetime(2022, 8, 19, 16, 17, 12)),)
obj = {}
field = ['network', 'service']
for item in ret:
    for i, v in enumerate(field):
        obj[v] = item[i]

print(obj)
输出为：
{'network': '农林牧渔', 'service': '172.16.1.6'}

到这里，一条sql查询就添加完了。

源码下载和安装

vue

1
2
3
4
git clone https://gitee.com/sswfit/vue-morning-shift.git
cd vue-morning-shift
npm install --registry=https://registry.npm.taobao.org
npm run serve

django

1
2
3
4
git clone https://gitee.com/sswfit/morning_shift.git
cd morning_shift
pip install -r requirements.txt
python manage.py runserver localhost:8887
阅读全文 »

发表于 | 分类于

最近好多人都在吐槽打工人好难，最近尤其难！

谁说不是呢？

以前大家自己买热水壶烧水泡茶喝，几排工位共用一个，方便快捷。最近公司发通知说会有用电危险不让用了，发现使用直接没收。现在只能去公共区域接热水。工作这么忙，跑那么远去实在是懒得动！

公司是担心大家泡茶喝耽误工作吗？

打工已是如此的艰难，有些事情就不要拆穿！

在这难熬的日子里，给大家搜集几个有用的脚本，希望给大家带来一点乐趣，或者给大家的工作生活提升效率。

自动生成素描草图

在注册一些网站时，经常发愁头像怎么选？放真人照上去怕吓跑别人，放风景图片自己又不喜欢。

是时候用素描草图了，妈妈再也不用担心我的头像吓跑人了！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import cv2
  img = cv2.imread("elon.jpg")

  ## Image to Gray Image
  gray_image = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

  ## Gray Image to Inverted Gray Image
  inverted_gray_image = 255-gray_image

  ## Blurring The Inverted Gray Image
  blurred_inverted_gray_image = cv2.GaussianBlur(inverted_gray_image, (19,19),0)

  ## Inverting the blurred image
  inverted_blurred_image = 255-blurred_inverted_gray_image

  ### Preparing Photo sketching
  sketck = cv2.divide(gray_image, inverted_blurred_image,scale= 256.0)

  cv2.imshow("Original Image",img)
  cv2.imshow("Pencil Sketch", sketck)
  cv2.waitKey(0)

运行效果如下：

自动发邮件

有时候我们工作中需要给领导或者客户发邮件，这可是一门技术活。如果很快发过去，要么是效率高，要么是工作不饱和。所以我们可能需要定时发邮件，比如凌晨一点。

这里以QQ邮箱为例，简单演示怎么自动发邮件。

在运行脚本之前，需要先在邮箱中设置开启 smtp 服务。

设置完成后，会生成一个授权码，这个授权码在下面的程序中会用到。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import smtplib 
from email.message import EmailMessage
import pandas as pd

def send_email(remail, rsubject, rcontent):
    email = EmailMessage()      
    # 发件人邮箱                    
    email['from'] = '发件人邮箱'    
    # 收件人邮箱        
    email['to'] = remail            
    # 主题               
    email['subject'] = rsubject   
    # 内容                  
    email.set_content(rcontent)                     
    with smtplib.SMTP(host='smtp.qq.com',port=25)as smtp:     
        smtp.ehlo()                                 
        smtp.starttls()       
        # 授权码登录                     
        smtp.login("发件人邮箱","授权码") 
        smtp.send_message(email)                    
        print("email send to ",remail)              

if __name__ == '__main__':
    send_email('目标邮箱','test','test')

解压文件

解压文件的软件多如牛毛，但是如果一次性需求比较旺盛，需要批量解压的时候，就可以考虑用 python 实现了。 python 解压文件就几行代码：

1
2
3
4
from zipfile import ZipFile

unzip = ZipFile("file.zip", "r")
unzip.extractall("outputdir")

写个代码读取某个目录下的压缩文件，然后应用这两行就可以了。

PDF 加解密

对于一些重要 PDF 文件，我们可以对其设置密码，只有拿到文件和密码才可以查看内容。PDF 软件可以帮助我们做这个事情，但是如果有好多份文件呢？

使用Python的pikepdf模块，即可对文件进行加密，写一个循环就能进行批量加密文档。

1
2
3
4
5
import pikepdf

pdf = pikepdf.open("test.pdf")
pdf.save('encrypt.pdf', encryption=pikepdf.Encryption(owner="your_password", user="your_password", R=4))
pdf.close()

总结

今天的内容就介绍到这里，赶紧收藏和点赞吧！

阅读全文 »

发表于 | 分类于

上班摸鱼看了2个星期车评，还是一头雾水，选合资还是国产？发动机cvt好还是双离合好？艾瑞泽5 GT动力足，但腰线和前脸让人吐槽，真的可靠吗。国产选长安逸动还是吉利帝豪？标志408出来了，还有艾瑞泽8很漂亮。看会视频吧，同质化严重，讲来将去就是车内车外介绍一遍。

热门视频下通常有几百条评论，我一般会翻看一遍，七个八个视频就是几千条评论，信息芜杂，没个定准，所以干脆不看了！我决定从评分入手，爬下懂车帝看到底有多少个汽车品牌。长安、吉利、奇瑞它们有多少车型，高分段的车型多不，每家热销的车子分数排在哪个段位。所以用scrapy爬了3655条数据。

正好前段时间在python技术分享过一篇《不止高效，原来pandas表格可以更美的！》，https://mp.weixin.qq.com/s/KpKF6tvdcfG7d6rf8Xbv2w ，结合里面介绍过的排序分组配色，对我们的数据进行分析。通过这些数据，可以看出厂商的产品布局和销售优势。

比如马路上很多别克牌子，我又对它没啥印象，除了知道威朗在紧凑型轿车中排名靠前，还有其它热销车型吗？所以特意看了下别克的数据：

好家伙，居然有排名第一的！ 再比如韩国车企在中国没落了，落寞成什么样子呢，

可以看到，现代和起亚在小型轿车和中型MPV是有销量的，悦纳曾经也是月销过万的主流合资轿车，这里它虽然位于小型桥车销量NO.10，但8月仅销售303辆。 确实有点惨淡啊，除了伊兰特，8月销量超过1千辆的只有一个库斯途，其它最多的的月销也只有1到3百辆，它们曾经非常受欢迎，不过随着汽车行业的更新换代，逐渐淡出了消费者们的视野。

评分最高的车型

再举个🌰，我想知道486个品牌中，每个品牌评分最高的车型

486个品牌的车型评分，已上传，http://ssw.fit/file/ 。由于部分品牌没有车型，如“众泰”没一款车型，所以爬的时候不会把这种写入csv文件中。一共3655条数据，也就是3655个车型。

对car.csv进行处理：

1
2
3
4
5
6
7
8
9
10
import pandas as pd
df2 = pd.read_csv("D:/桌面/car.csv",encoding='gb18030')
#取出评分大于0的（也就是去掉懂车帝上显示“暂无评分”的）
x = df2.groupby('评分').filter(lambda x:x['评分'].mean() > 0)

#取各组品牌中评分最高的
t = x.sort_values('评分',ascending=False).groupby('品牌', as_index=False).first()

t.sort_values('评分',ascending=False,inplace=True)
t.to_csv('评分榜.csv', index = True)

输出如下：

可以看到，所有品牌中，评分最高的车型是劳斯莱斯的“幻影”，4.74分，这个分数很高了。要知道国产长安最高3.88（长安UNI-K），吉利最高3.9（星越L），日产最高也没超过4分。

说明几个地方

下面开始整活。先说明几个地方：

  • 因为品牌较多，对应不同的url，可以利用multiprocessing.dummy多线程加快速度（这是个好工具，咱们的另一篇文章《3个python小工具，Linux服务器性能直线飞起！！！》，https://mp.weixin.qq.com/s/x4jZN4TisfTzdzVGSwZlWg 也用到过它）

  • 使用的爬虫框架是scrapy，它结构清晰，使用起来方便，比所有内容写到一个文件里好些。

  • 有些页面是动态加载的，需要使用selenium模拟页面向下滚动加载，把滚动条拉到最下面。

  • 大概运行过程是这样的：

好了，先从观察页面开始。

猜了个猜

观察它的url。首先来个十八连猜，猜下它尾部的18个“x”分别代表什么意思？

1
https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x

我先猜一个，倒数第3个x代表汽车品牌，不信吗，修改数字的话，第二个红框会出现不同的品牌：

所以url的倒数第三位，数字3代表奔驰，2为奥迪，4是宝马。其它你可以试一下，能搜索到结果的数字大概在600以内。我猜汽车品牌数也在600内吧。当然不能这么一个个猜， 还是赶紧干正事，找出每个品牌对应的数字，这样才好向相关品牌的页面发送请求。

找了个找

一共有6个属性为layout_label__1qfS8的span标签，我们要找的是第6个，即找到“已知条件”这个span标签。

这个时候下面脚本中的条件condition[5]才成立，BeautifulSoup才找得到：

1
2
3
4
5
6
7
soup = BeautifulSoup(rep.text,'html.parser')
condition = soup.find_all('span', class_='layout_label__1qfS8')
# 当num大于500时，有可能没这个品牌，condition[5]会报错
try:
    condition[5].next_sibling.a.text
except Exception as e:
    pass

因为数字大于500时，很可能没这个品牌，页面上不会出现“已知条件”，而是提示“0车系符合条件”

上面的next_sibling属性用来查询兄弟节点，也就是“已选条件”那个span的下一个span；next_sibling.a.text，下一个span的a标签里的文字就是品牌的名字

找出品牌对应的id

BeautifulSoup找到数据后，因为品牌对应的url较多，使用multiprocessing.dummy多线程加快速度。另外，数字大于500时，很可能找不到品牌，所以循环1000以内的数字基本能覆盖到所有品牌

1
2
pool = ThreadPool(10)
pool.map(get_brand_id,[i for i in range(1,1000)])

综上，获取品牌对应id的完整脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# -*- coding: utf-8 -*-
import json,re,requests,ssl
from bs4 import BeautifulSoup
from multiprocessing.dummy import Pool as ThreadPool

num_list = []
brand_dict = {}
def get_brand_id(num):

    x = 'https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-%s-x-x' % num
    rep = requests.get(x,timeout=10)
    soup = BeautifulSoup(rep.text,'html.parser')
    condition = soup.find_all('span', class_='layout_label__1qfS8')
    # 当num大于500时，有可能没这个品牌，condition[5]会报错
    try:
        s = condition[5].next_sibling.a.text
        print('s111', s)
    except Exception as e:
        pass

    for span in condition:
        if span.string == '已选条件':
            print('ok')
            brand_dict[s] = num
            num_list.append(num)
            
pool = ThreadPool(10)
pool.map(get_brand_id,[i for i in range(1,1000)])
print(num_list)
print(brand_dict)

输出结果如下，总共486个汽车品牌：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{
前面略...
 '雪佛兰': 6,
 '雪铁龙': 21,
 '零跑汽车': 207,
 '雷丁': 282,
 '雷克萨斯': 22,
 '雷诺': 46,
 '雷诺三星': 301,
 '雷达汽车': 514,
 '霍顿': 278,
 '领克': 174,
 '领志': 309,
 '领途汽车': 247,
 '飞凡汽车': 401,
 '飞碟汽车': 404,
 '首望': 340,
 '马自达': 15,
 '驭胜': 167,
 '骐铃汽车': 104,
 '高合': 249,
 '魏牌': 66,
 '黄海': 132,
 '龙程汽车': 415
 }

品牌对应的url如下，我们可以挑选自己感兴趣的品牌url发送请求：

1
2
3
4
5
6
7
[
 前面略...
 'https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-101-x-x',
 'https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-76-x-x',
 'https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-1-x-x',
 'https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-126-x-x',
]

下面会用scrapy爬虫框架对这些url发起请求，数据写入csv

scrapy设置

整个目录结构如下：

  1. 创建scrapy项目 
    1
    2
    3
    4
    5
    #创建scrapy项目
scrapy startproject dcd
cd dcd
#生成一个爬虫
scrapy genspider car "https://www.dongchedi.com/"
  2. 修改settings.py 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    # 是否遵守协议,设置false
ROBOTSTXT_OBEY = False
#设置请求头
DEFAULT_REQUEST_HEADERS = {
 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
 'Accept-Language': 'en',
 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0'
}
#下载中间件
DOWNLOADER_MIDDLEWARES = {
'dcd.chrom_middlewares.DcdDownloaderMiddleware': 543,
}
ITEM_PIPELINES = {
'dcd.pipelines.DcdPipeline': 300,
}
  3. 新建一个chrom_middlewares.py文件

第2步DOWNLOADER_MIDDLEWARES设置的下载中间件，我们自己编写： chrom_middlewares.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import time
from selenium import webdriver
from scrapy.http.response.html import HtmlResponse

class DcdDownloaderMiddleware(object):

    def __init__(self):
        # selenium加载浏览器
        options = webdriver.ChromeOptions()
        options.add_argument('--no-sandbox')
        options.add_argument('--disable-gpu')
        options.add_argument('--ignore-certificate-errors')
        options.add_argument('--ignore-ssl-errors')

        self.driver = webdriver.Chrome(executable_path=r"C:\drf2\drf2\chromedriver.exe",options=options)
        self.driver.maximize_window()

    #重写process_request方法
    def process_request(self, request, spider):
        print('request.url',request.url)
        self.driver.get(request.url)
        js = 'return document.body.scrollHeight;'
        height = 0
        #selenium模拟页面向下滚动加载全部页面
        if request.url != 'https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-x':
            while True:
                new_height = self.driver.execute_script(js)
                if new_height > height:
                    self.driver.execute_script('window.scrollTo(0, document.body.scrollHeight)')
                    height = new_height
                    time.sleep(1)
                else:
                    print("滚动条已经处于页面最下方!")
                    break
        source = self.driver.page_source
        # 创建一个response对象,把页面信息都封装在reponse对象中
        response = HtmlResponse(url=self.driver.current_url,body=source,request = request,encoding="utf-8")
        return response

对process_request说明一点：

如果车型多，需要滚动鼠标分一次或多次才能加载完毕，这个时候需要selenium模拟页面向下滚动加载全部车型，否则取到的车型是不全的。

1
2
3
4
5
6
7
8
9
while True:
    new_height = self.driver.execute_script(js)
    if new_height > height:
        self.driver.execute_script('window.scrollTo(0, document.body.scrollHeight)')
        height = new_height
        time.sleep(1)
    else:
        print("滚动条已经处于页面最下方!")
        break

  1. item.py ```py import scrapy

class DcdItem(scrapy.Item): #品牌 brand = scrapy.Field() #车型 name = scrapy.Field() #评分 score = scrapy.Field() #特点 title = scrapy.Field()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
这几个字段的意思用箭头标明了：

![](http://www.justdopython.com/assets/images/2022/09/scrapydcd/12.png)

5. `car.py`
```py
import scrapy
from lxml import etree
from dcd.items import DcdItem
import os,csv

if os.path.exists('D:/桌面/car.csv'):
    print('delete?')
    os.remove('D:/桌面/car.csv')
f = open('D:/桌面/car.csv', 'a+', newline='', encoding='gb18030')
f_csv = csv.writer(f)
f_csv.writerow(['品牌','车型', '评分', '特点'])
class RainSpider(scrapy.Spider):
    name = 'car'
    allowed_domains = ['https://www.dongchedi.com/']
    start_urls = ['https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-11-x-x','https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-13-x-x']

    def parse(self, response):
        print('html111')
        html =etree.HTML(response.text)

        item = DcdItem()
        brand = html.xpath('//*[@id="__next"]/div[1]/div[2]/div/div[4]/span[2]/div/div/a/text()')[0]
        lis = html.xpath('//*[@id="__next"]/div[1]/div[2]/div/ul/li[position()>= 1]')
        print('111 lis',lis)
        for li in lis:
            name = li.xpath('./div/a[1]/text()')[0]
            try:
                #有评分
                score = li.xpath('./div/a[2]/text()')[0].split('分')[0]
            except Exception as e:
                #无评分
                score = 0
            try:
                #有标题
                title = li.xpath('./div/span/text()')[0]
                # print('title111',title)
            except Exception as e:
                #无标题
                title = '无'
            print(name,score,title)
            f_csv.writerow([brand,name,score,title])

        item['name'] = name
        item['score'] = score
        item['title'] = title
        yield item

下面对car.py的2个地方进行说明

5.1 获取品牌

1
brand = html.xpath('//*[@id="__next"]/div[1]/div[2]/div/div[4]/span[2]/div/div/a/text()')[0]

xpath路径，在edge浏览器中可以通过右键“检查”找到元素，再右键选择“复制”->”复制 Xpath”

按crtl+F键可以粘贴刚才复制的xpath，按回车键，页面上会突出显示对应的元素。

5.2 获取所有的li标签，代表一辆辆汽车信息

然后循坏这些li标签，获取到车型、评分、左上角的蓝色说明文字，写入csv文件

1
lis = html.xpath('//*[@id="__next"]/div[1]/div[2]/div/ul/li[position()>= 1]')

  1. 新增一个启动爬虫的文件start.py 
    1
    2
    from scrapy.cmdline import execute
execute('scrapy crawl car'.split(' '))

    文件位置：

在pycharm中右击即可运行爬虫：

排序分组配色

参考上文提到的《不止高效，原来pandas表格可以更美的！》

假如你想了解长安吉利奇瑞这3个品牌，那么在car.py中填写对应的url

1
2
#url中的73代表吉利，18是奇瑞，35是长安，对这3个品牌发起请求
start_urls = ['https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-73-x-x','https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-18-x-x','https://www.dongchedi.com/auto/library/x-x-x-x-x-x-x-x-x-x-x-x-x-x-x-35-x-x']

这样car.csv中就只有这3个品牌的数据了，方便我们配色和对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import pandas as pd
from datetime import datetime,timedelta
df2 = pd.read_csv("D:/桌面/car.csv",encoding='gb18030')

#取出评分大于0的（也就是去掉懂车帝上显示“暂无评分”的）
x = df2.groupby('评分').filter(lambda x:x['评分'].mean() > 0)
x.sort_values('评分',ascending=True,inplace=True)
new = x.groupby(['品牌','评分','车型','特点'],as_index=False)
new3 = new.all()

#给每种品牌加上颜色
#评分大于3.8的，用黄色标注
new3.style.highlight_between(left='吉利汽车',right='吉利汽车',subset=['品牌'],props='background:#ffa5a5')\
.highlight_between(left='奇瑞',right='奇瑞',subset=['品牌'],props='background:#a1eafb')\
.highlight_between(left='长安',right='长安',subset=['品牌'],props='background:#71c9ce')\
.highlight_between(left=3.8,right=5,subset=['评分'],props='background:#f9ed69')

输出结果如下：

从数据可以看出，国内一线品牌产品线丰富，吉利在小型SUV、紧凑型轿车、紧凑型SUV都有热销产品，奇瑞仅瑞虎3x和瑞虎5x位于销量榜前10（怎么没有出口汽车？），看来理工男从产品受欢迎程度上来说离一线品牌还有差距

可以根据自己的喜好，给想看的品牌配上它们的logo色，看看它们的数据是否有惊喜

代码下载地址

已上传到 linux服务器上，http://ssw.fit/file/

总结

爬完了

阅读全文 »

发表于 | 分类于

新人入职，我们经常需要登记他的ip和MAC地址，为什么呢？ 因为行政MM经常来找我“打印机又出问题了”，作为一个桌面维护工程师，我知道打印机的ip是固定的，但员工修改自己的跟它一样引起冲突。这样的话，一不小心涉及到网络安全了，emm..

影响网络安全的因素很多，IP地址盗用或地址欺骗就是其中一个常见的因素。为了防止内部人员进行非法IP盗用（例如盗用权限更高人员的IP地址）， 可以在交换机的每个端口上做IP地址的限定，如果有人修改了自己的IP地址，那么他的网络就不通了。他就会来找我“怎么我上不了网？”，好好的上不了网，可能你干了啥坏事。

作为一个网络管理人员，如果对MAC地址和IP进行绑定，就会创建一个十分有利的环境，可以大大减小安全隐患。

同时，这些信息可以和姓名一起，在入职的时候统一登记，绑定mac的同时顺便给他分配邮箱。不少公司分配邮箱的任务是行政MM做的，我们帮她做了，可以减少她们的日常工作，从而建立起良好的关系。

听起来非常不错，那怎么实行呢？且听下回分解

思路

  1. 我们需要的信息有ip、MAC、姓名（用于生成公司邮箱）

这些内容可以通过django网页获取，谁访问就会显示谁的IP地址，用户只需输入姓名。跟行政商量，让它作为入职的一个流程，登记这些信息。

  1. 查看录入情况

为方便查看，需要准备一个后台页面。员工提交一条数据，后台就能看到新用户。 以新员工邢道荣为例，看看他的录入， 整个流程是这样的：

具体操作

MAC地址怎么获取？

linux执行arping命令，会返回对方的MAC。

我们需要找一台内网linux机器，用paramiko模块登录上去，让它替我们arping员工网页提交过来的ip

1
2
[root@vm3 ~]# arping -f 192.168.14.6 -I ens33|grep reply
Unicast reply from 192.168.14.6 [00:0E:C6:83:3B:F9]  1.007ms

翻译成python：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def get_mac(ip):
    import paramiko
    client = paramiko.SSHClient()
    private_key = paramiko.RSAKey.from_private_key_file('C:/Users/0717/Documents/id_rsa')
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    client.connect(
        hostname='192.168.14.173',
        username='root',
        port=22,
        pkey=private_key,)
    stdin, stdout, stderr = client.exec_command('arping -f %s -I ens33|grep reply' % ip)
    msg = stdout.read().decode('utf-8')
    client.close()
    return msg

检测ip

办公网络分有线和无线，两者的ip网段不一样。员工如果通过无线访问这个页面，要提示他仅有线网络需要提交IP信息，无线网络无需提交，请不要使用代理访问本页面

换成python表示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def check_ip(addr):
    #只匹配有线网络的网段
    v = re.compile('(192.168.14).(\d+)')
    return v.match(addr)

def record(request):
    ip = request.META.get('REMOTE_ADDR')

    if check_ip(ip):
        return render(request, 'ipinfo.html', {'ip':ip})
        #check_mac根据re.compile('.*(\w{2}:\w+:\w+:\w+:\w+:\w+).*')进行正则匹配
        if not check_mac(ip):
            ip = ip + '检测到MAC地址异常，请联系管理员'
            return render(request, 'ipinfo.html', {'ip': ip})
    else:
        ip = ip + '仅有线网络需要提交IP信息，无线网络无需提交，请不要使用代理访问本页面'
        return render(request, 'ipinfo.html', {'ip': ip})

根据姓名分配邮箱

根据员工网页提交的姓名，自动分配公司邮箱，格式为“名字拼音的简写+公司邮箱后缀”。

这里用到pypinyin模块

1
2
3
4
5
#安装命令，pip install pypinyin
from pypinyin import lazy_pinyin

print(lazy_pinyin('上将潘凤'))
['shang', 'jiang', 'pan', 'feng']

名字长度一般为2~4个汉字，解析成拼音后进行拼接，如’邢道荣’分配的邮箱为xingdr@163.com，’潘凤’为panfeng@163.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def test1(name_list):
    name_list = lazy_pinyin(name_list)
    if len(name_list) == 2:
        email_name = name_list[0] + name_list[1]
    elif len(name_list) == 3:
        email_name = name_list[0] + name_list[1][0] + name_list[2][0]
    elif len(name_list) == 4:
        email_name = name_list[0] + name_list[1] + name_list[2][0] + name_list[3][0]
    email = email_name + '@163.com'
    print(email)

test1('邢道荣')
xingdr@163.com
test1('潘凤')
panfeng@163.com

提交数据

用requests提交员工信息到后台

1
2
3
user_info = {'username': name, 'password': user_id, 'email': email, 'ip': ip, 'MAC': mac}
conn = requests.session()
ret = conn.post('http://127.0.0.1:8887/api/v1/users/', data=json.dumps(user_info),

交换机绑定MAC

登录思科交换机用到python的第三方模块ciscolib

1
2
3
4
switch = ciscolib.Device('192.168.14.10', '123456')
switch.connect()
switch.enable(password='BxAdmin')
switch.cmd("write")

这个可以在管理后台增加一个”保存”按钮，让它执行相关交换机命令。

绑定的相关命令如下：

  • 查看整个端口的ip-mac表 
    1
    cisco(config)#show mac-address-table
  • ip与mac地址的绑定 
    1
    cisco(config)#arp 192.168.14.6 0000.e268.9980 ARPA
  • ip和交换机端口的绑定，绑定后的端口只有此ip能用，改为别的ip后立即断网 
    1
    2
    3
    cisco(config)#interface FastEthernet0/17
cisco(config-if)#ip access-group 6 in        
cisco(config)#access-list 6 permit 192.168.14.6

    这样就将交换机的FastEthernet0/17与192.168.14.6绑定了

代码下载地址

包括html文件，已上传到 linux服务器上，http://ssw.fit/file/

小结

通过设计这样的网页办事窗口，员工入职从mac绑定到邮箱分配，再到其它信息登记，一条流水线服务，是不是规范和便捷呢，我的工作量也减少了，行政部的入职流程也更清晰了。

阅读全文 »

发表于 | 分类于

最近羊了个羊这个小游戏真的爆火，好多朋友玩得不亦乐乎，各大平台也是激起了广泛的讨论。

不过随着讨论度的上升，玩家们逐渐发现这个游戏，可能并没有表面看上去的那么“纯良”：随机生成的关卡并非必然有解，有的网友甚至晒出了消除到最后却无法通关的截图：

很多玩家直呼被骗，为自己浪费掉的时间感到可惜。不过没有关系，虽然游戏中无法通关，但我们可以通过直接向服务器发送通关信息的方式，增加排行榜中的通关次数，让你轻松成为朋友圈中的那只领头羊。

发送请求前，我们首先需要获取自己的token值，所以需要安装fiddler抓包工具。这个工具配置起来没有什么坑，网上教程有很多，大家可以自行查找。

其次由于PC端最新版微信无法抓取到来自小程序的请求，因此如果你的PC端微信是最新版本（3.7.6或以上）的话，需要会退回旧版本。（公众号后台回复“羊了个羊”，获取旧版微信安装包）

点击微信左下角更多->设置->关于微信，查看当前的版本号，这里由于我已经回退了，显示的是旧版。

旧版本的安装过程与正常流程完全相同，亲测没有遇到问题，有顾虑的朋友可以在安装前先备份相关文件。

回退版本后，首先打开fiddler，然后正常登录微信，打开羊了个羊小程序，在fiddler中就能抓取到host为cat-match.easygame2021.com的请求了。

如果到这一步没有抓取到请求，可以尝试先打开任务管理器，找到小程序的进程，右键打开文件所在位置。 （如果已经抓取到请求可以跳过下一步骤，直接进行值的获取token值）

打开文件位置后，向上找到WMPFRuntime目录，这时关闭PC微信进程，删除WMPFRuntime文件夹里面的所有文件（如果不退出会报正在占用，无法删除）

然后重新打开微信，将羊了个羊小程序移除，重新搜索进入，就能抓取到了。

抓取到请求后就可以开始token值的获取了，首先打开游戏正常玩到第二关，然后随便点几下，进入到通关失败的页面。

这时候切换到fiddler查看cat-match.easygame2021.com最新的请求，查看请求头，就能在里面找到自己的t值了。

然后我们要做的事情就很简单了，创建请求头，然后多次发送通关的信息，就能让排行榜的通关次数不断+1啦。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from time import sleep
import requests
 
header = {
    "t": "此处填入前面获取的token值"
}
 
def game():
    for i in range(10):
        requests.get("http://cat-match.easygame2021.com/sheep/v1/game/game_over?rank_score=1&rank_state=1&rank_time=15&rank_role=1&skin=1", headers=header)
        print(f"已通关{i+1}次，等待5秒...")
        sleep(5)
 
if __name__ == '__main__':
    print("执行开始...")
    game()
    print("执行完毕!")

替换掉请求头后，直接执行上述代码即可，简单粗暴。

代码没有什么需要解释的地方，这里要注意的首先是要设置一定的时间间隔，其次不要执行太多次，亲测请求频率过高会导致IP被禁一段时间。

以上方法亲测在9月17日是有效的，游戏后续不确定是否会升级后端的逻辑，因此不能保证此方法永久有效，所以有兴趣的朋友请尽快尝试啦。

（文中提到的安装包和代码已经整理好了，公众号后台回复“羊了个羊”获取）

阅读全文 »

发表于 | 分类于

前阵子请了年假，陪女朋友出了趟远门，一路心情愉悦景色宜人，不过累也是真的累，尤其在几天都没休息好还要一路颠簸回到家之后。

谁想到前脚刚踏回家门的我，刚准备休息，就收到了这样的消息：

把图片逐一保存，没想到她四天功夫竟然拍了小两百张照片…

这就有点让我为难了，首先我现在的工作不需要切图，PS也早就卸载了，其次就算有PS，光是给几百张图套上预设也得好一会儿才能搞定。

我有点一筹莫展，一边琢磨一边端详起这些照片来：

由于原图质量还可以，所以如果修的话其实不需要太多操作：因为当天云彩很多光线不是很好，照片颜色有点平淡，可以适当加一下饱和度；同时由于画面上好似覆盖着一层薄雾，可以考虑降低一下亮度，能做好这两点，就是一张不错的照片了。

这是我突然想起前阵子用OpenCV时看到的一个api，借助python，我们说不定能快速把这几百张图搞定。

首先介绍一下HSV颜色空间，HSV是一种颜色空间，与RGB通过红绿蓝的组合来描述颜色不同，HSV把颜色拆分为色调（H）、饱和度（S）和明度（V）三个维度，这样能够更直接的表达色彩的明暗以及鲜艳程度，因此广泛应用于图像识别领域。

借助opencv的split()函数，我们可以将图片的HSV变量分离出来，然后再用merge()函数合成一张新的图片，达到批量修改饱和度和明度的效果。

split也可以将图片的RGB三颜色通道分离出来，然后单独对某个通道进行修改。

话不多说，开始操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import cv2
import numpy as np
import os

def modify_image(img_path, target_dir):
    # 读取全部图片
    pic = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
    # 将图片修改为HSV
    pichsv = cv2.cvtColor(pic, cv2.COLOR_BGR2HSV)
    # 提取饱和度和明度
    H,S,V = cv2.split(pichsv)
    # S为饱和度，V为明度
    new_pic = cv2.merge([np.uint8(H), np.uint8(S*1.4), np.uint8(V*0.9)])
    # 将合并后的图片重置为RGB
    pictar = cv2.cvtColor(new_pic, cv2.COLOR_HSV2BGR)
    # 获取原文件名
    file_name = img_path.split("/")[-1]
    # 将图片写入目录
    cv2.imwrite(os.path.join(target_dir, file_name), pictar)

root, dirs, files = next(os.walk("./test/"))

for item in files:
    img_path = os.path.join(root,item)
    process_image(img_path, "./target/")

看眼手机的功夫，几百张图片就处理完毕了。左边修改前右边修改后，可以看到效果还是很明显的。

几分钟就搞定了所有的图片，女朋友喜笑颜开，我当然不会告诉她我是怎么做到的啦。

以上就是今天的全部内容，我们下次再见~

阅读全文 »

发表于 | 分类于

最近用vuepress建了个博客，音乐的背景图片需要网络地址。 还有博客自动复用的摘要图片也需地址 开始用的阿里云的免费对象存储oss，但又是登录又是设置读写权限的，稀碎的操作令人疲惫。 能不能简单点，自动上传，并且马上能得到文件的网络地址。

于是开始探索轻量级的方案，手动给自己搞一个，一键复制开箱即用的的上传页面： 把文件传到自己的云服务器上，传完后自带文件地址和copy按钮，流程顿时清爽了许多。

接下来的问题是，图片准备好了，十几张，怎么传更轻松点？这时背景音乐响起“王牌飞行员pyautogui请求出战”。优秀，机械重复的操作（如刷新网页、抢票、某些小游戏等）无疑是你的拿手好戏。

实时获取鼠标的当前坐标

这点很重要，因为所有的点击操作都基于坐标，就像selenium的操作基于xpath路径一样：

1
2
3
4
5
6
7
8
9
10
11
12
import time, os
import pyautogui as pag
try:
    while True:
        #print('Press Ctrl-C to end')
        x, y = pag.position() #返回鼠标的坐标
        print('Position : (%s, %s)' % (x, y)) # 打印坐标
        time.sleep(1) #每个1s中打印一次 , 并执行清屏
        os.system('cls') #执行系统清屏指令

except KeyboardInterrupt:
    print('end')

输出如下，鼠标放在哪就会显示哪个地方的x,y坐标：

1
2
3
4
Position : (937, 668)
Position : (1320, 689)
Position : (836, 579)
Position : (669, 585)

开始上传了

上传的操作页面我已建好：

http://ssw.fit/upload

获取到鼠标坐标就好办了，一路点击，疯狂输出。selenium还有验证码、反爬虫等限制，这个你自己的电脑，还不是想点哪就点哪。 先点击“选择文件”按钮，

1
2
3
4
5
6
7
import pyautogui
pyautogui.click(307, 227)
time.sleep(2.5)

# 弹出对话框后，点击路径那一栏，目的是为下一步粘贴路径
pyautogui.click(993, 332)
time.sleep(1.5)

typerwrite键入文件路径

每台电脑的文件路径不一样，让pyautogui的typerwrite输入图片文件夹的路径，不加时间参数，输入速度飞快

1
2
3
4
5
# 键入图片路径
pyautogui.typewrite('C:/Users/0717/Pictures/blog/upload')
# 按回车键
pyautogui.hotkey('enter')
time.sleep(1)

双击选中图片

图片的位置是固定的，所以可以取前5或前10张图片的坐标。下次再上传多张图的话，先清空文件夹，把图片拷贝到文件夹就好了

1
pyautogui.doubleClick(x,y)

点击“上传”按钮

上传需要时间，sleep一会

1
2
3
4
5
6
7
pyautogui.click(304, 278)
#上传需要时间，预算等多久
if x == 847:
	#847是第一张图片的x坐标，因为我上传的第一张是gif动图，文件大，上传多等几秒
	time.sleep(11)
else:
	time.sleep(2.5)

点击”copy”按钮

图片上传完后会自动生成copy按钮，点击它直接复制文件的网络地址

1
pyautogui.click(304, 278)

热键ctrl+v，回车，网页访问图片

1
2
3
pyautogui.hotkey('ctrl','v')
time.sleep(0.5)
pyautogui.hotkey('enter')

每张照片传完再自动粘贴地址和网页浏览，看看刚上传的图片多漂亮： 所以，脚本结束前，让我们欣赏美图3秒：

1
time.sleep(3)

点击浏览器的返回按钮

最后一步，欣赏完，返回主页面进入下一张图片的上传流程！

1
2
pyautogui.click(32, 67)
time.sleep(2)

完整脚本

总结一下，这里用到的pyautogui操作:

  • 单击click
  • 双击doubleClick
  • 输入文字typewrite
  • 热键组合hotkey('ctrl','v')，热键回车hotkey('enter')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import time
import pyautogui

def auto_upload(x,y,file_path):
    # 点击”选择文件“按钮
    pyautogui.click(307, 227)
    time.sleep(2.5)

    # 弹出对话框后，点击路径那一栏，目的是为下一步粘贴路径
    pyautogui.click(993, 332)
    time.sleep(1.5)

    # 键入图片路径
    pyautogui.typewrite(file_path)
    # 按回车键
    pyautogui.hotkey('enter')
    time.sleep(1)

    # 双击图片
    pyautogui.doubleClick(x,y)
    # 等文件出现
    time.sleep(6)

    # 点击“上传”按钮
    pyautogui.click(304, 278)
    #等几秒传完
    if x == 847:
        #847是第一张图片的x坐标，因为我上传的第一张是gif动图，文件大，上传多等几秒
        time.sleep(11)
    else:
        time.sleep(2.5)

    # 点击“copy”按钮
    pyautogui.click(297, 545)
    time.sleep(1)

    # 点击浏览器的地址栏
    pyautogui.click(410, 66)

    # 模拟键盘点击ctrl+v，然后按回车键
    pyautogui.hotkey('ctrl','v')
    time.sleep(0.5)
    pyautogui.hotkey('enter')

    #欣赏美女3秒
    time.sleep(3)

    # 点击浏览器的返回按钮
    pyautogui.click(32, 67)
    time.sleep(2)

#文件的x,y坐标
file_list = [(847, 489),(965, 490),(1136, 493),(1271, 504),(1391, 498)]
[ auto_upload(f[0],f[1],'C:/Users/0717/Pictures/blog/upload') for f in file_list]

运行过程

上传2张图片，整个脚本运行起来是这样的：

最后一个问题

上传了好几张，都到哪去了？这里可以看到啦： http://ssw.fit/free/

好了，这就是今天分享的全部内容，我们下次再见~

阅读全文 »

发表于 | 分类于

书接上回，上篇文章（）中，我们用python获取到了上海地区某平台的2w多条房源数据。

但上篇文章中只做了简单的筛选，这只是第一步，接下来，我们应当如何从这些数据中挑选出符合自己要求的房子呢？

为了确保换房后我和女友前往各自上班地点的通勤时间都在可接受范围内，我需要知道从各处房源位置前往两家公司所需的时间。为了获取这些信息，我们需要借助高德地图api这个工具。

使用高德api，我们能够轻松地根据地址或名称获取到地址对应的坐标位置，进而获取到对应地点的通勤和周边信息，十分的方便。

在使用api之前，我们首先需要获取到自己的Key值。进入高德开放平台网站，完成个人开发者注册和zfb实名认证后，点击控制台→应用管理→我的应用→创建新应用，来完成应用的创建。

之后点击右上角的添加，来为自己创建一个Key，注意这里服务平台要选择Web服务,不同选项对应的服务范围是不同的。

创建key值之后，就可以开始使用api获取数据了。

首先我们要根据地点名称得到对应的坐标值，然后用出发地和目的地的坐标调用接口，得到两个位置之间的通勤时间。

思路理清之后，就到了操作时间了。

获取房源坐标

因为总的房源数量太大，所以我们可以用小区的坐标位置代替房源的具体位置进行调用，这样需要进行的处理量就大大减小了，可以节省一些不必要的成本。

因此首先我们对上篇文章中获取到的数据做一个简单的处理，利用set对小区名做一个去重。

1
2
3
csv_read=pd.read_csv('../document/sh.csv',header=None)
village_set = set(csv_read[2])
village_list = list(village_set)

获取到小区列表后，我们尝试调用一下获取坐标的API。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 高德API的URL
geourl = 'https://restapi.amap.com/v3/geocode/geo'  

# 地址前要加地区名，否则可能定位到其他城市
params = {'key':'在这里填入个人的Key值',
        'address': '上海市国金中心'}
# 发送请求                
res = requests.get(geourl, params)
jd = json.loads(res.text)
# 返回值的具体格式可以在API文档中查看
geopoint_1 = jd['geocodes'][0]['location']

print(geopoint_1)
# 121.502021,31.236814

调用成功之后，我们就可以用相同的方法，获取到列表中所有小区的坐标。

获取路程时间

在得到各个小区的坐标位置之后，我们就可以调用api获取两个坐标之间的路程时间了。

举个例子，如果我需要获取两个坐标之间的公交地铁通勤时间，可以用如下的方法：

1
2
3
4
5
6
7
8
9
10
11
# 高德API的URL
puburl = 'https://restapi.amap.com/v3/direction/transit/integrated?origin={}&destination={}&key={}&time=9:00&city=上海'  

# 发送请求  
r=requests.get(puburl.format(geopoint_1, geopoint_vill, '在这里填入个人的Key值'))  
r=r.text  
jsonData=json.loads(r)
# 获取步行距离
publength = round(int(jsonData['route']['transits'][0]['walking_distance'])/1000, 2)
# 获取总时间
pubtime = round(int(jsonData['route']['transits'][0]['duration'])/60)

这里一般会获取到多条路线，不过因为第一条路线通常是用时最短的，所以这里就以第一条路线的数据为代表。

用类似的方法，通过使用不同的url，就能获取到驾车、步行等方式的路程时间。不过要注意不同的这些api的输入和输出参数是有一定区别的，具体的要参照文档。

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import pandas as pd
import requests
import json
import csv
import codecs

# 创建导出文件
with open(r'..\document\village.csv', 'wb+')as fp:
    fp.write(codecs.BOM_UTF8)
f = open(r'..\document\village.csv','w+',newline='', encoding='utf-8')
writer = csv.writer(f)
writer.writerow(("小区名", "坐标", "步行距离-地点1","通勤时间-地点1", "步行距离-地点2","通勤时间-地点2"))

geourl = 'https://restapi.amap.com/v3/geocode/geo'  
puburl = 'https://restapi.amap.com/v3/direction/transit/integrated?origin={}&destination={}&key={}&time=9:00&city=上海'  

# 读取文件
csv_read=pd.read_csv('../document/sh.csv',header=None)
village_set = set(csv_read[2])
village_list = list(village_set)

# 获取第一个坐标
geourl = 'https://restapi.amap.com/v3/geocode/geo'  
# 地址前要加地区名，否则可能定位到其他城市
params = {'key':'在这里填入个人的Key值',
        'address': '上海市国金中心'}
# 发送请求                
res = requests.get(geourl, params)
jd = json.loads(res.text)
# 返回值的具体格式可以在API文档中查看
geopoint_1 = jd['geocodes'][0]['location']

# 获取第二个坐标
params = {'key':'在这里填入个人的Key值',
        'address': '上海市国正中心'}               
res = requests.get(geourl, params)
jd = json.loads(res.text)
geopoint_2 = jd['geocodes'][0]['location']

for adr in village_list:
    # 获取小区坐标
    params = {'key':'在这里填入个人的Key值',
        'address': '上海市'+adr}                
    res = requests.get(geourl, params)
    jd = json.loads(res.text)
    geopoint = jd['geocodes'][0]['location']

    # 获取第一个位置的信息
    r=requests.get(puburl.format(geopoint_1, geopoint, '在这里填入个人的Key值'))  
    r=r.text  
    jsonData=json.loads(r)
    publength_1 = round(int(jsonData['route']['transits'][0]['walking_distance'])/1000, 2)
    pubtime_1 = round(int(jsonData['route']['transits'][0]['duration'])/60)  

    # 获取第二个位置的信息
    r=requests.get(puburl.format(geopoint_2, geopoint, '在这里填入个人的Key值'))  
    r=r.text  
    jsonData=json.loads(r)
    publength_2 = round(int(jsonData['route']['transits'][0]['walking_distance'])/1000, 2)
    pubtime_2 = round(int(jsonData['route']['transits'][0]['duration'])/60)  

    writer.writerow((adr, geopoint, publength_1, pubtime_1, publength_2, pubtime_2))

f.close()

将脚本执行后，就能获得各个小区距离目标地点的路程时间。后面再经过一些简单的筛选，就能大大缩小找房的选择范围了。

高德API还有很多其他的功能，比如POI周边搜索可以查询小区周边指定范围内（比如方圆1公里）是否有便利店，健身房等设施，结合前端组件还可以在地图中显示出指定的位置，合理运用这些功能，能够实现更多的个性化需求，文中只用了很小一部分，大伙可以参照API文档自行尝试。

不过也要注意一点，对于个人开发者而言，高德API每日的调用次数是有限制的，为了避免超额，大家在爬取数据的时候可以根据实际情况适度缩小范围，减少处理的数据量。

以上就是这次找房故事的全部内容了，希望能对大家有所帮助，感谢阅读，也祝愿每个打工人都能住的舒心，早日有房。

阅读全文 »

发表于 | 分类于

“这是从他们窝点电脑里导出的一份数据，你先看看能不能找出什么端倪，我再去找几个人问问话。”王队丢给我一个u盘，拿起饭盒胡乱塞了几口饭，便拎起帽子快步走出了办公室。

今晚我们根据情报，前往一处传销窝点实施了抓捕行动，一次性逮捕了十几个人。但现场没有发现什么重要证据，抓到的几个人也缄口不言，现在没法知道他们是否还有其他的窝点，也不知道他们的上线是谁在哪里。而此时我手中的这份文件，可能就会成为破局的关键。

我开始观察起这份人员名单：invite_id字段是不重复的，应该和人名是一对一的关系；而invited_id重复的很多，而且基本都是在invite_id出现过的数据，所以我们基本可以推断出，这是一份记录传销组织上下线关系的名单。数据足有数百条之多，可见这是一个不小的犯罪组织。

不到一个小时的功夫，王队回来了。

“没用，还是死鸭子嘴硬。”王队倒在椅子上，看了一眼时间，已经快到十二点了。“那份数据看的怎么样了，有没有找到什么线索？”

“这是一个很大的组织，总成员数有好几百，我们现在可能只抓到了冰山一角啊。”

“这对传销组织来说也正常，毕竟他们需要不断发展下线。”王队走到我的工位前，“所以我们现在的任务是先找到他们的上线，擒贼先擒王。但今晚抓到的这群人都审不出东西来，虽然能确定他们的身份，暂时也还是确定不了他们之间的关系啊。”

“你说他们之间的关系？”我突然想起前段时间看到的networkx这个库，这次说不定能派上用场。“交给我了，给我五分钟时间。”

首先用pandas导入文件中的数据，并筛选出我们需要的部分：

1
2
3
df = pd.read_excel('./doc/1_evidence.xls')
df = df.loc[:, ['id','name','invite_id','invited_id']]
df.columns = ['id','title','to', 'from']

然后调用networkx库，生成层级关系图并导出：

1
2
3
4
5
G = nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.DiGraph())

nt = net.Network('960px', '1280px', directed=True)
nt.from_nx(G)
nt.show('1_evidence.html')

这样我就得到了这份文件对应的层级关系图，上下线关系瞬间一目了然了：

一瞬间王队露出了惊喜的神色，但很快又恢复了严肃：“你这个是不是有点华而不实啊，虽然看着挺直观，但你能从里面找到谁是这个组织的最上级吗？”

这当然难不倒我，最上级也就是树的根节点，必然是没有其他的点指向它的，所以我们只要遍历所有节点，找到入度为0的点就可以了。

1
2
3
4
5
6
# 找到根节点
top_node = []
for node, degrees in G.in_degree():
    if degrees == 0:
        top_node.append(node)
print('Big Boss:', top_node)

“Big Boss: [100000]” 屏幕上出现了这样的输出。“100000这个编号在表中没有对应的人，但100000下只有一个编号162385的下线，他应该就是这个组织的头头了。”

“不错，要的就是这个！我去让其他同事找这个人的信息，你继续研究数据，把和这个人走的近的人全部找出来！”

这想必也不是难题，既然根节点已经找到了，我们便可以得到所有节点各自所在的层数。

1
2
3
4
5
6
7
8
9
10
11
12
13
# 设置所有节点级别
l = nx.shortest_path_length(G, 100000)
nx.set_node_attributes(G, l, 'level')

# 计算每级人员数目
data = {}
for node, level in l.items():
    if level in data.keys():
        data[level].append(node)
    else:
        data[level] = [node]
for level, nodes in data.items():
    print(level, len(nodes))

这个组织竟然已经足足发展了36层，想想真是让人直冒冷汗，还好及时被发现了。

然后根据层级给节点标注颜色，方便观察：

1
2
3
4
5
6
7
8
9
10
11
# 添加颜色
for node in G.nodes:
    G.nodes[node]['title'] = str(node)
    level = G.nodes[node]['level']

    if level == 0:
        G.nodes[node]['color'] = 'red'
    elif level == 1:
        G.nodes[node]['color'] = 'orange'
    elif level == 2:
        G.nodes[node]['color'] = 'yellow'

可以看到这个编号162385的人，自己只有两个下线，而这两个下线每人都各自另外发展了几十个下线，想想还蛮有意思。

“找到了！”王队回到办公室，虽然仍是一脸严肃，但也难掩心中的喜悦。“三个人都找到了，都在今晚逮捕的这群人里面，他们也都承认了，现在正在重点审。”

“你今晚立了件大功啊！”王队走过来拍了拍我的肩膀。“不过现在还没完，根据他们的口供，文件里的就是他们组织的全部人员信息了。你现在把他们发展下线最多的几个人给我找出来，我们根据信息，立刻安排定点抓捕。”

跟之前差不多，我只需要遍历所有节点的出度数，然后排序，取前几项就可以了。

1
2
3
4
5
6
7
# 给下线前十的目标添加颜色
degrees = G.out_degree()
top_nodes = sorted(degrees, key=lambda x: x[1], reverse=True)[:10]
print(top_nodes)

for node in top_nodes:
    G.nodes[node[0]]['color'] = 'green'

然后给目标节点加上颜色，方便观察，最终得到了这样的关系图：

“干得不错，只要再把这几个人抓到，就相当于切断了这个组织的大动脉，后面的慢慢收尾就可以了。”王队把文件合上，笑着对我说。“没想到你还有这本事，真是后生可畏呀！”

“今天抓到的那三条大鱼，现在审出什么结果了？”相对于其他，我还是对案情本身更感兴趣。

“哈哈别提了，都快笑死我了。这仨人一看见证据直接慌了神了，开始互相推卸责任，老大说人全是另外两个人拉来的他都没参与，另外俩人说事情全是老大策划的他俩就是打工的，现在估计还在吵着呢…”

(本文背景情节数据均为虚构，如有雷同纯属巧合) (公众号后台回复“乌鸦”，获取代码和实验数据)

阅读全文 »

发表于 | 分类于

明月几时有，难得的中秋假期，很多兄弟经历疫情后终于有机会和家人团聚，也有很多码农兄弟因为各种原因在他乡度过假期。无论是怎样的情感，程序员总有自己特别的表达方式。今天就让我们花上几分钟时间用Python写一个小游戏，给中秋假期增加一点不一样的趣味。

首先来看看最终的效果：

游戏所需的所有素材都帮大家整理好了，公众号后台回复“乌鸦”领取。

这次我们要用到pygame这个库，这种简单的玩法用其他语言实现起来也很容易，但大多都需要一些框架的辅助，有一定的学习成本，而pygame就是为这种场景设计的，使用门槛很薄，相信每个人只要看完这篇文章，都能学会如何写一个自己的玩法。

首先我们引入资源，完成初始化，之后就可以开始Coding啦。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 导入所需模块
import random
import pygame

# pygame初始化 
pygame.init()

# 设置主屏窗口
screen = pygame.display.set_mode((600, 800))

# 设置游戏名称
pygame.display.set_caption("明月几时有")

font = pygame.font.SysFont("Microsoft YaHei", 40)

我们的玩法设计是移动鼠标操作屏幕下方的嫦娥接住月饼，所以首先定义同屏中月饼的数量： 这里设计为x轴坐标随机，y轴坐标按规律值间隔，以免大量月饼黏在一起出现。

1
2
3
4
5
# 控制月饼密度
tar_pos = []

for i in range(0, 8):
    tar_pos.append([random.randint(50, 550),(i - 1) * 100])

然后开始定义游戏的主循环。主循环是在游戏运行的整个过程中一直运行的循环，所有的监听，判断和处理都应当编写进去。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exit()
    
    # 初始菜单
    screen.blit(bg_menu, (0, 0))
    screen.blit(word_menu, (0, -70))
    button.show()
    if button.click():
        time = 3
        score = 0
        score_num = font.render(str(score), True, (255, 255, 255))
        time_num = font.render(str(time), True, (255, 255, 255))

这里需要注意的是，pygame中的坐标轴是以左上角为原点，X轴向左递增，Y轴向下递增的，这点可能和习惯性认知不太一样，切记不要闹出乌龙，否则会找不到月饼在哪儿。

然后是运动的处理部分，这里首先要监听鼠标的移动，然后让人物跟随鼠标X轴运动，并加上窗口边界的判断。

1
2
3
4
5
6
7
8
# 角色移动
  if event.type == pygame.MOUSEMOTION:
      move_x, move_y = pygame.mouse.get_pos()
      now_pos = move_x - 75
  if now_pos < 0:
      now_pos = 0
  if now_pos > 600:
      now_pos = 525

然后是游戏中最重要的部分——接到月饼的判断了，这里首先使用最开始创建的月饼位置，通过Y轴坐标值的增加，实现下落的过程。

这里注意，之前创建月饼位置的时候，为了方便数值处理，原本的Y轴值减掉窗口高度后，才是月饼在Y轴的实际坐标，这里大家可以根据自己的习惯修改。

当月饼的xy轴左边均在人物的坐标范围内，或者月饼掉落出屏幕，即没有被接到时，重置Y轴坐标到窗口顶部，并重新随机x轴坐标，通过这种方式使得月饼不断出现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  for i in range(len(tar_pos)):
      screen.blit(pygame.transform.scale(target, (50, 50)), (tar_pos[i][0], tar_pos[i][1] - 800))
      tar_pos[i][1] += speed1
      if tar_pos[i][1] > 1600:
          tar_pos[i][1] = 800
          tar_pos[i][0] = random.randint(50, 550)
          score -= 2
          score_num = font.render(str(score), True, (255, 255, 255))
      # 边界判定
      if tar_pos[i][0] + 50 > now_pos and tar_pos[i][0]  < now_pos + 75 and tar_pos[i][1] >= 1300 and tar_pos[i][1] <= 1500:
          tar_pos[i][1] = 800
          tar_pos[i][0] = random.randint(50, 550)
          score += 10
          score_num = font.render(str(score), True, (255, 255, 255))

做到这里，游戏的基本玩法已经完成了————但这样还称不上一个游戏，因为没有限制也没有挑战，所以我们还需要给游戏加入一些其他的元素。

比如除了月饼之外，给玩家增加树枝的掉落，需要在抢月饼的同时躲避：同时增加生命值限制，如果多次碰到树枝则游戏结束：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 控制树枝密度
for i in range(0, 2):
    wro_pos.append([random.randint(50, 550),(i - 1) * 300])

while True:
    # 开始游戏
    if time > 0 and time < 4 and score >= 0:
    ...
    # 树枝运动路线
        for i in range(len(wro_pos)):
            screen.blit(pygame.transform.scale(wrong, (50, 50)), (wro_pos[i][0], wro_pos[i][1] - 800))
            wro_pos[i][1] += speed2
            if wro_pos[i][1] > 1600:
                wro_pos[i][1] = 800
                wro_pos[i][0] = random.randint(50, 550)
            # 边界判定
            if wro_pos[i][0] + 50 > now_pos and wro_pos[i][0] < now_pos + 75 and wro_pos[i][1] >= 1300 and wro_pos[i][1] <= 1500:
                wro_pos[i][1]= 800
                wro_pos[i][0] = random.randint(50, 550)
                time -= 1
                time_num = font.render(str(time), True, (255, 255, 255))

仅仅是躲避树很容易让人感到厌倦，所以我们可以加入一个难度变化，让节奏不断变快。 随着分数的增加，下落的速度会越来越快。

1
2
3
4
5
6
7
8
9
    # 速度变化
        if score <= 30:
            speed1 = 0.8
            speed2 = 1.2
        elif score <= 60:
            speed1 = 1
            speed2 = 1.5
        elif score <= 90:
    ...

至此游戏的整体玩法已经成型了，最后再在结束页面加一个分数展示，整个流程就比较的完整了~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    # 重新开始游戏
    if time == 0 or score < 0:
        # 初始化游戏
        now_pos = 0
        speed = 1
        # 月饼运动路线
        for i in range(len(tar_pos)):
            tar_pos[i][0] = random.randint(50, 550)
            tar_pos[i][1] = (i - 1) * 100
        # 树枝运动路线
        for i in range(len(wro_pos)):
            wro_pos[i][0] = random.randint(50, 550)
            wro_pos[i][1] = (i - 1) * 300
        end_text = font.render(end_word.format(score), True, (255, 255, 255))
        screen.blit(bg_menu, (0, 0))
        screen.blit(end_text, (50, 220))

至此这个抢月饼的游戏就完成了，文章篇幅有限，我已经将完整的源码和游戏素材上传，大家可以在公众号后台回复“乌鸦”获取下载链接，直接在本地运行体验。

我自己试玩了几次，到后面还是需要一点眼疾手快的，拿到了这样的分数~你们拿到了多少分呢？

最后祝大家中秋假期愉快，生活幸福美满~！

阅读全文 »

发表于 | 分类于

由于工作需要，服务器每周需巡检一次。除了内存、cpu、磁盘、网络连接等数据外，还有不同的服务。

为加快巡检速度和知晓服务器状况，我使用了multiprocessing.dummy多线程、pampy模式匹配和一个elementUI组件，这些工具确能帮忙处理实际问题：

  • 一行代码实现并行

    • 原本二十多台服务器巡检用shell需3分钟完成，用multiprocessing.dummy模块后只需十几秒

  • pampy模式匹配

搭配正则，匹配出2块磁盘的使用率，方便前端页面展示。数据是从真实服务器上获取的。

1
2
3
4
5
6
import re
from pampy import match
disk_usage = 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% diskname: /dev/vdb1 used: 278G nouse: 190G USAGE: 56.39%'
re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
m= match(disk_usage, re_regular, lambda a,b,c,d: b+','+d)
print(m)

结果如下：

35.35,56.39

匹配好后，这2个值很方便前端页面进行展示了

  • 使用elementUI的progress进度条展示内存百分比

这是elementUI官网的进度条组件

这是使用它的效果

下面详细介绍这3点

1. 一行代码实现并行

在某台服务器上做免密钥登录，能直连到其它服务器执行shell脚本，之前的巡检是通过shell脚本执行的：

1
2
#登录不同的ip，依次执行/home/ssw/目录下的检查脚本
for ip in `cat /home/ssw/iplist`;do ssh user@$ip "/bin/sh /home/ssw/weekly_check.sh";done

因为是串行执行，经常等到花儿都谢了。于是改用python去执行这些shell命令：cpu、内存、磁盘的检查命令都一样，不同的服务只需定义一个字典，根据ip添加相关命令。再pool.map()一行实现多线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# -*- coding: utf-8 -*-
import paramiko
import json
from datetime import datetime
import traceback
from pprint import pprint
from multiprocessing.dummy import Pool as ThreadPool

def weekly_check(ip):
    #基础巡检指标
    cmds_dict = {'cpu_usage':'TIME_INTERVAL=5;LAST_CPU_INFO=$(cat /proc/stat | grep -w cpu | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $2,$3,$4,$5,$6,$7,$8}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




);LAST_SYS_IDLE=$(echo $LAST_CPU_INFO | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $4}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




);LAST_TOTAL_CPU_T=$(echo $LAST_CPU_INFO | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $1+$2+$3+$4+$5+$6+$7}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




);sleep ${TIME_INTERVAL};NEXT_CPU_INFO=$(cat /proc/stat | grep -w cpu | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $2,$3,$4,$5,$6,$7,$8}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




);NEXT_SYS_IDLE=$(echo $NEXT_CPU_INFO | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $4}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




);NEXT_TOTAL_CPU_T=$(echo $NEXT_CPU_INFO | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $1+$2+$3+$4+$5+$6+$7}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




);SYSTEM_IDLE=`echo ${NEXT_SYS_IDLE} ${LAST_SYS_IDLE} | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $1-$2}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




`;TOTAL_TIME=`echo ${NEXT_TOTAL_CPU_T} ${LAST_TOTAL_CPU_T} | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $1-$2}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




`;CPU_USAGE=`echo ${SYSTEM_IDLE} ${TOTAL_TIME} | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{printf "%.2f", 100-$1/$2*100}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




`;echo ${CPU_USAGE}',
                 'mem_usage':'MEM_USAGE=`/usr/bin/free | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




/Mem/{printf("RAM Usage: %.2f%\n"), $3/$2*100}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




 |  awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $3}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




`;echo ${MEM_USAGE}',
                 'disk_status':'DISK_STATUS=`df -h | grep "^/dev/vd" | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{printf "diskname: %-10s used: %-5s nouse: %-5s USAGE: %.2f%\n",$1,$3,$4,$3/$2*100}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




`;echo ${DISK_STATUS}',
                 'network': 'if ping -c 5 www.baidu.com &>/dev/null;then echo "Network: OK";else echo "Network: NOT OK";fi',
                 'boot_log': 'B=`cat /var/log/boot.log`;if [ "$B" = "" ];then echo "Bootlog: OK";else echo"Bootlog: NOT OK";fi',
                }
    if ip == '172.16.1.21':
        cmds_dict['mysql'] = 'mysql_pid=`ps -ef | grep mysql | grep -v grep | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $2}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




`;if [ "${mysql_pid}" = "" ];then echo "Mysql_service: NOT OK";else echo "Mysql_service: OK!  pid is ${mysql_pid}";fi'
    elif ip == '172.16.1.22':
        cmds_dict['es'] = 'es_pid=`ps -ef | grep elasticsearch | grep -v grep  | awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $2}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




`;if [ "${es_pid}" = "" ];then echo "Es_service: NOT OK";else echo "Es_service: OK  pid is ${es_pid}";fi'
    elif ip == '172.16.1.23':
        cmds_dict['redis_cluster'] = 'NUM=` ps -ef | grep redis | grep -v grep |awk 

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




{print $2}

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]




2. 数据写入mysql（用到pampy）



    
  
  1. 创建数据库
    2. 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);




    
  
  1. 写入mysql
    2. 




pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))




这样数据库就有了巡检数据






    
  
  1. vue展示内存百分比
    2. 




el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色



1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>







小结



很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车




 | wc -l`;echo "the running redis-cluster node is $NUM"'
    try:
        #创建ssh客户端
        client = paramiko.SSHClient()
        #免密钥登录
        private_key = paramiko.RSAKey.from_private_key_file('/home/ssw/.ssh/id_rsa')
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        client.connect(
            hostname=ip,
            username='ssw',
            port=22,
            pkey=private_key,
            timeout=30
        )
        #新建一个空字典存储输出结果
        result = {}
        for k,v in cmds_dict.items():
            stdin, stdout, stderr = client.exec_command(v)
            if not stderr.read():
                result['ip'] = ip
                result[k] = stdout.read().decode('utf-8').strip()
            else:
                pass
    except Exception as e:
        pprint(ip+" error:"+str(e))
        pprint(traceback.format_exc())

    finally:
        client.close()
    return result

if __name__ == '__main__':
    ip_list = ['172.16.1.21','172.16.1.22','172.16.1.23']
    pool = ThreadPool(8)
    ret = pool.map(weekly_check,ip_list)
    pool.close()
    pool.join()
    #结果写入excel
    with open('/home/ssw/game_server_%s.xlsx' % datetime.now().__format__('%m-%d'),'w') as f:
        f.write(json.dumps(ret))

有些服务器有2块磁盘,有些只有1块，这是执行脚本后输出的部分数据，格式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK'},
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392'},
  ]

2. 数据写入mysql（用到pampy）

  1. 创建数据库
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
create table weekly_check
(
   id             int not null auto_increment,
   project         varchar(30),
   ip             varchar(30),
   cpu      varchar(30),
   mem      varchar(30),
   disk    LONGTEXT,
   network      varchar(60),
   vda1          varchar(20),
   vdb1    varchar(20),
   service          LONGTEXT,
   create_time timestamp null default current_timestamp,
   primary key (id)
);
  1. 写入mysql

pampy在这里的作用，主要是找出2块磁盘的使用率，作为数据插入到"vda1","vdb1"字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import json,pymysql
import re
from pampy import match, HEAD, TAIL, _
#前面巡检的部分数据
data = [{'cpu_usage': '11.67',
  'disk_status': 'diskname: /dev/vda1 used: 35G nouse: 59G USAGE: 35.35% '
                 'diskname: /dev/vdb1 used: 243G nouse: 225G USAGE: 49.29%',
  'es': 'Es_service: OK  pid is 20488',
  'ip': '172.16.1.21',
  'mem_usage': '27.13%',
  'network': 'Network: OK',
  'service': {'boot_log': 'Bootlog: OK',
              'front_service': 'Front_service: OK!  pid is 16608',
              'nodejs_service': 'nodejs_service: NOT OK'}
 },
 {'cpu_usage': '3.14',
  'disk_status': 'diskname: /dev/vda1 used: 23G nouse: 445G USAGE: 4.67%',
  'ip': '172.16.1.22',
  'mem_usage': '12.86%',
  'network': 'Network: OK',
  'rabbitmq': 'Rabbitmq_service: OK  pid is 1392',
  'service': {'mysql': 'mysql: OK'}
  }
  ]

def conn_mysql(sql,value):
    dbparam = {
        'host': '127.0.0.1',
        'port': 3306,
        'user': 'root',
        'password': '1024',
        'database': 'alerts',
        'charset': 'utf8'
    }
    conn = pymysql.connect(**dbparam)
    cursor = conn.cursor()

    try:
        cursor.execute(sql,value)
        conn.commit()
    except Exception as e:
        print('入库失败', e)
        conn.rollback()
    finally:
        cursor.close()
        conn.close()

for info in data:
    sql = "insert into weekly_check(project,ip,cpu,mem,disk,network,vda1,vdb1,service) values (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
    disk_status = info['disk_status']
    #多个“服务”用字符串拼接，举个🌰“nginx is ok”和"tomcat is ok"
    service = ''
    for k,v in info['service'].items():
        # 多个“服务”用<br>换行符分割，前端可以识别它进行换行
        service = service + v.split('pid')[0].strip() + '<br>'

    # 网络连接。主要是为了方便前端显示，如果ok则直接显示“正常”
    if info['network'] == 'Network: OK':
        info['network'] = '正常'
    else:
        info['network'] = '异常'
    # 磁盘字符串长度大于60说明有2块磁盘
    if len(disk_status) > 60:
        #取出两块磁盘vda1,vdb1的使用率
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)% diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b,c,d: b+','+d)
        vda1,vdb1 = m.split(',')

        disk_status = info['disk_status']
        #去掉第一个USAGE
        disk_status = re.sub('USAGE: .*% ', '', disk_status)
        # 去掉第二个USAGE
        disk_status = re.sub(' USAGE: .*%', '', disk_status)
        #去掉第一个diskname，第二个diskname替换为换行符<br>
        disk_status = disk_status.replace('diskname: ', '', 1).replace(' diskname: ', '<br><br>')

        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'),\
                         disk_status,info['network'],vda1,vdb1,service))
    else:
        #只有一块磁盘vda1
        re_regular = re.compile('diskname: (/\w+/\w+).*USAGE: (.*)%')
        m = match(disk_status, re_regular, lambda a,b: b)
        conn_mysql(sql, ('游戏',info['ip'], info['cpu_usage'], info['mem_usage'].strip('%'), info['disk_status'],info['network'],m,'无',service))

这样数据库就有了巡检数据

  1. vue展示内存百分比

el-progress组件，使用率小于50%显示绿色，50%~75%显示橙色

1
2
3
4
5
6
7
8
9
<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="success" v-if="scope.row[item.prop] < 50">
</el-progress>
</span>

<span v-if="item.prop === 'mem'"><el-progress :text-inside="true" :stroke-width="13" 
:percentage="scope.row[item.prop]" status="warning" v-if="scope.row[item.prop] >= 50 && scope.row[item.prop] < 75">
</el-progress>
</span>

小结

很多模块和工具开箱即用，是节省时间的利器，可以用它搭个便车

阅读全文 »

发表于 | 分类于

echarts官网有很多好看的图例，怎么结合起来放到自己的项目中呢？比如这种酷酷的首页：

看起来美观又大方，自己能用上就好了。其实是可以的，echarts上有现成的图例和示例代码，咱们只要改改数据源就可以了，至于好看的布局，比如上图这种，我们直接借鉴过来不就可以了🐎。

以公司网页为例，简单介绍一个例子，下图这么多网址的巡检如何用一个图例来展示。

可以把它们写到文件里：

先创建一个文件，比如叫config.cfg

1
2
3
[url]
优酷 = http://www.youku.com/
错误网址 = http://www.111.cn/

安装configparser模块

1
pip install configparser

读取这些网址

1
2
3
4
5
import configparser
cfg = configparser.ConfigParser()
cfg.read('config.cfg',encoding='utf-8')
urls = cfg.items('url')
print(urls)

结果如下：

[('优酷', 'http://www.youku.com/'), ('错误网址', 'http://www.111.cn/')]

echarts官网找图

接下来，怎么展示网站的状态码是否为200呢？

echarts上找了一下，看到一个“极坐标柱状图”，很适合这种判断True or False的场景，

比如网页状态码是否为200，是返回1，否返回0，然后将echarts的数据源替换成我们的就是这种效果：

数值为1（代表正常）的条目会显示蓝条，0为异常则用红色文字打印出来，整体巡检效果如下：

检查url

requests模块判断状态码是否为200

1
2
3
4
5
6
7
import requests
def check_url(url):
    try:
        r = requests.get(url, timeout=10)
        return r.status_code
    except Exception as e:
        return e

把config.cfg读到的网址，利用check_url函数检查完放到一个列表中

1
2
3
4
5
6
7
urls_state = []
for url in urls:
    status_code = check_url(url[1])
    if status_code == 200:
        urls_state.append([0,1])
    else:
        urls_state.append([1, 1,url[0]+' ConnectTimeout'])

结果如下：

1
2
3
4
5
6
[
 [0, 1],
 [1, 1, '优酷 ConnectTimeout'],
 [0, 1],
 [1, 1, '错误网址 ConnectTimeout']
]

把这些信息返回给前端

1
2
3
4
5
6
7
8
9
10
11
from rest_framework.views import APIView

class get_urls(APIView):
    def get(request,*args,**kwargs):
        urlsState = check_url.main()

        #网页的名字列表
        cities = ['公司主页', 'maas', 'maas1', 'maas2', 'maas3', 'maas4', '1小猫咪', '2小猫咪', '3小猫咪', '4小猫咪', '5小猫咪', '6小猫咪', '7小猫咪', '8小猫咪', '9小猫咪','10小猫咪','11小猫咪','12小猫咪', 'maas4','maas5', 'maas6','maas7', 'maas8', 'maas9', 'maas10', 'maas11','maas15', 'maas13', 'maas14', 'maas', '数据可视化系统', 'maas', 'maas', 'x1', 'maas','maas']
        return JsonResponse({'data': {
            'urlsData':{'name':'网页','urlsState':urlsState,'cities':cities},
        }})

这样前端在判断的时候，如果某个url信息的长度为3，说明有错误信息

1
2
3
4
5
urlsState.forEach(key => {
    if (key.length == 3) {
    this.echartData.urls.info.push(key[2] + '\n')
    }
})

至于vue怎么展示，src\components\check\check.vue有详细内容，已上传，地址见下面“源码下载和安装”

源码下载和安装

前端

1
2
3
4
git clone https://gitee.com/sswfit/vue-morning-shift.git
cd vue-morning-shift
npm install --registry=https://registry.npm.taobao.org
npm run serve

后端

1
2
3
4
git clone https://gitee.com/sswfit/morning_shift.git
cd morning_shift
pip install -r requirements.txt
python manage.py runserver localhost:8887

小结

这是一个很好的例子：

  • 前后端分离

  • 动态更新echarts数据

  • 用到DjangoRESTframework

更重要的是通过合并第1、2步，从检查到展示能一步到位，领导见了直夸有想法。

阅读全文 »

发表于 | 分类于

大家好，我是派森酱。

上次介绍了pandas的两表连接merge技能，有的酱友留言说那么点数据用excel就挺快，在这里说明一下，文章内容只是用部分代码来介绍功能的用法和最后的结果显示，不是真的用几个G的文件来展示，也展示不过来的。

熟悉了功能怎么用，就可以用自己的数据来操作了。

merge可以匹配两表的内容，但是merge只能连接两个表，不能多表连接，这次说说能用于多表连接的功能concat。

还是用上次的数据，这次多加了一个DataFrame，用于显示结果。

初始化数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
python
import pandas as pd

df1 = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '刘六', '齐四'],
    '号码': ['123', '456', '789', '987', '654']
})

df2 = pd.DataFrame({
    '姓名': ['张三', '张三', '张三', '李四', '李四', '李四', '李四', '王五', '王五', '刘玉', '胡军', '刘玉', '刘六', '刘六', '刘六', '刘六', '刘克', '刘玉', '齐七', '齐七', '齐七', '齐七', '冯亮', '刘玉', '王云'],

    '号码': ['123', '456', '789', '123', '123', '456', '456', '456', '456', '456', '741', '741', '741', '741', '741', '789', '789', '789', '789', '789', '852', '852', '852', '852', '852'],

    '日期': ['2022-03-13', '2022-03-06', '2022-01-30', '2022-01-04', '2022-02-26', '2022-03-26', '2022-03-06', '2022-01-30', '2022-01-29', '2022-03-13', '2022-03-06', '2022-02-19', '2022-02-04', '2022-03-10', '2022-04-19', '2022-03-10', '2022-01-29', '2022-02-19', '2022-03-06', '2022-03-26', '2022-01-04', '2022-02-04', '2022-04-19', '2022-02-26', '2022-03-06'],

    '方案': ['G1012', 'G1022', 'G1002', 'G1007', 'G1017', 'G1023', 'G1018', 'G1003', 'G1008', 'G1013', 'G1020', 'G1015', 'G1010', 'G1005', 'G1025', 'G1004', 'G1009', 'G1014', 'G1019', 'G1024', 'G1006', 'G1011', 'G1026', 'G1016', 'G1021']
})

df3 = pd.DataFrame({
    '姓名': ['张三', '李四', '王五', '刘六', '齐四'],
    '号码': ['123', '456', '789', '987', '654'],
    '年龄': ['25', '36', '41', '12', '54']
})

用法

说明

concat是一个轴向连接的功能，可以沿着一条轴将多个表对象堆叠到一起：how的模式是outer

axis=0是上下拼接，列重复的会自动合并，axis=1是左右拼接，行或索引重复的会自动合并

上下拼接

先连接两个表:
1
df = pd.concat([df1, df2], axis=0)

输出：

两个表的重复列名自动合并了，缺失的值为NaN

连接三个表：
1
df = pd.concat([df1, df2, df3], axis=0)

输出：

同时增加了另一个表的内容和增加了一列，缺失值同样为NaN

左右拼接

直接拼接三个表：
1
df = pd.concat([df1, df2, df3], axis=1)

输出：

这次是在右边拼接的，行是按内容行最多的来算，其它的内容为空，列一直在增加，是把三个表的列都拼接上了。

总结

merge和concat的表连接，都有各自的特点，我们需要按自己所需要的结果去用，想匹配内容的，就用merge，想全部连接到一起的，就用concat。

阅读全文 »

发表于 | 分类于

大家好，我是派森酱。

前天一个女同事找我帮忙，说有上百个表格需要合并到一起，我一看，都是相同表头的表格，这不是so easy吗，快速搞定​，妹子拿到结果很高兴。

​之前咱们讲过pandas的两表连接merge：可以按条件匹配数据，自动合并列名相同的列；

轴向连接concat：可以左右连接，也可以上下连接，相同的内容自动合并；

这次我用的是pandas的另一个多表连接append。

功能说明

pandas的append要求表的表头要一致才行，但是不会限制表的个数。

准备数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import pandas as pd

df1 = pd.DataFrame({
    'a': [1, 2, 3],
    'b': [0, 9, 8],
    'c': [7, 4, 1]
})

df2 = pd.DataFrame({
    'a': [4, 1, 2],
    'b': [5, 0, 9],
    'c': [6, 7, 4]
})

df3 = pd.DataFrame({
    'a': [0, 1, 2],
    'b': [2, 0, 9],
    'c': [3, 7, 4]
})

用法

可以用df.append(df1)来连接相同表头的两表

比如：

1
df = df1.append(df2)

输出：

   a  b  c
0  1  0  7
1  2  9  4
2  3  8  1
0  4  5  6
1  1  0  7
2  2  9  4

df.append(df1)只是个用法,一定要用一个变量去赋值才行哟，要不然会没有变化。

那么怎么多表连接呢，很简单，就是在后面不停的加append

1
df = df1.append(df2).append(df3)

输出：

   a  b  c
0  1  0  7
1  2  9  4
2  3  8  1
0  4  5  6
1  1  0  7
2  2  9  4
0  0  2  3
1  1  0  7
2  2  9  4

看，是不是简单。其实pandas的很多功能都很简单好用，只要知道了用法，都很强大的。

索引重置

上面的多表虽然连接好了，但是索引确是各自表的索引，很多都是重复的，如果有需要用索引操作内容的话，会把相同索引的内容都改掉，那么我们就需要重置索引：

可以用ignore_index=True来重置索引

1
df = df1.append(df2).append(df3, ignore_index=True)

输出：

   a  b  c
0  1  0  7
1  2  9  4
2  3  8  1
3  4  5  6
4  1  0  7
5  2  9  4
6  0  2  3
7  1  0  7
8  2  9  4

索引都被重置了

数据填补

同样的有时候各表的内容会有空值的怎么办呢？

可以用combin_first来填补空值

用使用场景

有两张表left和right，一般要求它们的表格结构一致，数据量也一致，使用right的数据去填补left的数据缺漏。如果在同一位置left与right数据不一致，保留left的数据

设置空值数据

1
2
3
4
5
6
7
8
9
10
11
df1 = pd.DataFrame({
    'a': [1, 2, 3],
    'b': [nan, 9, 8],
    'c': [nan, 4, 1]
})

df2 = pd