python编写PLM的定时重启服务程序-requests检测服务状态，钉钉通知

1、需求:

        因为PLM系统服务出现问题，每天上班前都要手动重启服务，写个程序自动重启加钉钉通知，有两台服务器，需要通信一起重启服务，通过requests模块对web页面登录进行检测，登录失败就进行服务重启，socket模块进行两台服务器通信。
       

---

2、主服务器

        每天早上进行登录测试

        1、成功出退出登录，发送钉钉通知。

        2、失败重启本机服务，发送重启信号到另一台服务器，发送钉钉消息通知。

        3、保存日志信息。

import subprocess
import requests
import time
import hmac
import hashlib
import base64
import urllib.parse
import datetime
import socket
import threading
import tkinter as tk
from tkinter import messagebox

# 全局变量
PLM_login_success = False
server_running = False
server_thread = None

# 定时关闭服务
def stop_services():
    try:
        bat_path = 通过bat文件关闭服务
        subprocess.Popen(bat_path)
        time.sleep(100)
    except Exception as e:
        send_ding_ding_message("关闭服务时发生错误")
        log_error(f"关闭服务时发生错误: {e}")

# 定时启动服务
def start_services():
    try:
        bat_path = 通过bat文件启动服务
        subprocess.Popen(bat_path)
        time.sleep(100)
    except Exception as e:
        send_ding_ding_message("启动服务时发生错误")
        log_error(f"启动服务时发生错误: {e}")

# 测试链接是否可以登录
def test_login():
    try:
        user = "账号"
        pwd = "密码"
        csrf_url = "http://127.0.0.1:3100"
        session = requests.Session()
        response = session.get(csrf_url)
        
        url = "http://127.0.0.1:3100/tc/login"
        payload = {
            "header": {
 
            "body": {
                "credentials": {
                    "user": user,
                    "password": pwd,
                    "group": "",
                    "role": "",
                    "locale": "zh_CN",
                    "descrimator": "AWC19900"
                }
            }
        }

        headers = {
            'Content-Type': 'application/json'
        }

        response = session.post(url, headers=headers, json=payload)

        if response.status_code == 200:
            log_error(f"登录成功")
            return True, session
            
        else:
            log_error(f"登录失败")
            return False, None        
           
    except Exception as e:
        send_ding_ding_message("测试登录时发生错误")
        log_error(f"登录时发生错误: {e}")
        return False, None

def logoutput(session):#退出登录
    try:
        payload =  {
            "header":{
                "state":{
                    "clientVersion":"10000.1.2",
                    "stateless":True,
                    "unloadObjects":True,
                    "enableServerStateHeaders":True,
                    "formatProperties":True,
                    "clientID":"ActiveWorkspaceClient",
                    "locale":"zh_CN"
                    
                },
                "policy":{}
            },
            
            "body":{}
        }

        headers = {
                'Content-Type': 'application/json'
        }

        url = "http://127.0.0.1:3100/tc/logout"
        response = session.post(url, headers=headers, json=payload)
        if response.status_code == 200:
            log_error("账号退出成功")

        else:
            log_error("账号退出失败")

    except Exception as e:
        log_error(f"退出账号时发生错误: {e}")


# 发送钉钉消息
def send_ding_ding_message(text):#text为发送信息
    try:
        webhook = "https://oapi.dingtalk.com/robot/send?access_token=钉钉给的"
        timestamp = str(round(time.time() * 1000))
        secret = '钉钉给的'
        
        secret_enc = secret.encode('utf-8')
        string_to_sign = '{}\n{}'.format(timestamp, secret)
        string_to_sign_enc = string_to_sign.encode('utf-8')
        hmac_code = hmac.new(secret_enc, string_to_sign_enc, digestmod=hashlib.sha256).digest()
        sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
        webhook = "{}&timestamp={}&sign={}".format(webhook, timestamp, sign)
        
        headers = {'Content-Type': 'application/json;charset=utf-8'}
        data = {
            "msgtype": "text",
            "text": {
                "content": text
            },
            "at": {
                "isAtAll": False,#@所有人
                "atMobiles": ["手机号"]#@人
            }
        }
        
        import json
        resp = requests.post(webhook, data=json.dumps(data).encode("utf-8"), headers=headers)
    except Exception as e:
        log_error(f"发送钉钉消息时发生错误: {e}")


#保存日志
def log_error(e):
    time_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    with open(r'C:\restartservicesLog.txt', 'a') as f:
        f.write(f"{time_str}----{e}\n")

# 发送信息到服务器
def send_data(data):#data发送的信息
    try:
        host = 'VOL服务器IP'
        port = 端口
        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client_socket.connect((host, port))
        client_socket.sendall(data.encode())
        response = client_socket.recv(1024).decode()
        client_socket.close()
        return response
    except Exception as e:
        log_error(f"发送LOV服务器消息时发生错误: {e}")
        return None

# 检查时间并执行操作
def check_time_and_execute():
    global PLM_login_success, server_running
    while server_running:
        now = datetime.datetime.now()
        current_hour = now.hour
        current_minute = now.minute
        #7点半检测
        if current_hour == 7 and current_minute >= 30 and not PLM_login_success:
            ret, session = test_login()
            if not ret:
                send_ding_ding_message("PLM登录失败，开始重启服务")
                stop_services()
                time.sleep(300)
                retvol = send_data('关闭')
                if retvol == '已关闭':
                    time.sleep(300)
                    start_services()
                    time.sleep(300)
                    retvol = send_data('启动')
                    if retvol == '已启动':
                        time.sleep(300)
                        ret, session = test_login()
                        if ret:
                            send_ding_ding_message("PLM登录已经正常，服务重启成功")
                            PLM_login_success = True
                            time.sleep(30)
                            logoutput(session)
                        else:
                            send_ding_ding_message("重启服务后，PLM登录失败")
                            time.sleep(3000)
                    else:
                        send_ding_ding_message("VOL的服务启动失败")
                else:
                    send_ding_ding_message("VOL的服务关闭失败")
            else:
                PLM_login_success = True
                send_ding_ding_message("今天的PLM登录正常")
                time.sleep(30)
                logoutput(session)
                time.sleep(3000)


        time.sleep(600)
        if current_hour == 11 and PLM_login_success:
            PLM_login_success = False
            log_error("11点整，PLM登录状态已清除")

# GUI部分


def create_gui():
    def start_server():
        global server_running, server_thread
        if not server_running:
            server_running = True
            server_thread = threading.Thread(target=check_time_and_execute)
            server_thread.daemon = True
            server_thread.start()
            start_button.config(state=tk.DISABLED)
            stop_button.config(state=tk.NORMAL)
            messagebox.showinfo("信息", "服务器已启动")
            log_error("程序开启")


    def stop_server():
        global server_running
        if server_running:
            server_running = False
            start_button.config(state=tk.NORMAL)
            stop_button.config(state=tk.DISABLED)
            messagebox.showinfo("信息", "服务器已停止")
            log_error("程序停止")

    window = tk.Tk()
    window.title("PLM服务定时重启器")
    window.geometry('300x150')

    start_button = tk.Button(window, text="启动服务", command=start_server)
    start_button.pack(pady=10)

    stop_button = tk.Button(window, text="关闭服务", command=stop_server)
    stop_button.pack(pady=10)
    stop_button.config(state=tk.DISABLED)

    window.mainloop()

if __name__ == "__main__":
    create_gui()

---

3、VOL服务器接收信息重启服务

        1、接收消息

        2、重启服务

import socket
import subprocess
import threading
import tkinter as tk
from tkinter import messagebox
import datetime

# 服务器运行标志
server_running = False

def start_server(host, port):
    global server_running
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((host, port))
    server_socket.listen(1)
    log_error(f"Server listening on {host}:{port}")

    while server_running:
        try:
            server_socket.settimeout(1.0)  # 设置超时，以便在server_running=False时能退出循环
            client_socket, addr = server_socket.accept()
            log_error(f"Connection from {addr}")
            data = client_socket.recv(1024).decode()
            log_error(f"Received data: {data}")

            if data == '启动':
                try:
                    bat_file = 'bat启动服务文件的路径'
                    subprocess.Popen(bat_file)
                    log_error("正在启动服务")
                    client_socket.sendall('已启动'.encode())
                except Exception as e:
                    log_error(f"启动服务时发生错误: {e}")
                    client_socket.sendall(f"启动服务时发生错误: {e}".encode())

            elif data == '关闭':
                try:
                    bat_file = 'bat关闭服务文件的路径'
                    subprocess.Popen(bat_file)
                    log_error("正在关闭服务")
                    client_socket.sendall('已关闭'.encode())
                except Exception as e:
                    log_error(f"关闭服务时发生错误: {e}")
                    client_socket.sendall(f"关闭服务时发生错误: {e}".encode())

            client_socket.close()
        except socket.timeout:
            continue
        except Exception as e:
            log_error(f"处理客户端连接时发生错误: {e}")

    server_socket.close()
    log_error("Server stopped")

#保存日志
def log_error(e):
    time_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    with open(r'C:\restartservicesLog.txt', 'a') as f:
        f.write(f"{time_str}----{e}\n")


def start_server_thread(host, port):
    global server_running
    server_running = True
    server_thread = threading.Thread(target=start_server, args=(host, port))
    server_thread.daemon = True
    server_thread.start()

def stop_server():
    global server_running
    server_running = False

def create_gui():
    def on_start():
        host = '本机ip'
        port = 端口
        start_server_thread(host, port)
        messagebox.showinfo("信息", "服务器已启动")
        start_button.config(state=tk.DISABLED)
        stop_button.config(state=tk.NORMAL)
        log_error("服务器已启动")

    def on_stop():
        stop_server()
        messagebox.showinfo("信息", "服务器已停止")
        start_button.config(state=tk.NORMAL)
        stop_button.config(state=tk.DISABLED)
        log_error("服务器已停止")

    # 创建GUI窗口
    window = tk.Tk()
    window.title("VOL服务重启工具")
    window.geometry("300x150")

    # 创建启动按钮
    start_button = tk.Button(window, text="启动服务", command=on_start)
    start_button.pack(pady=10)

    stop_button = tk.Button(window, text="关闭服务", command=on_stop)
    stop_button.pack(pady=10)
    stop_button.config(state=tk.DISABLED)

    window.mainloop()

if __name__ == "__main__":
    create_gui()