Comment surveiller les données en temps réel de l'hôte distant en Python

1 Document de description du programme

1.1 Serveur

Ce programme est un programme serveur basé sur le protocole TCP, qui peut recevoir les instructions envoyées par le client et exécuter l'opération correspondante , et renvoie enfin le résultat de l'opération au client. Le programme s'exécute sur le port 8888 de localhost (cette machine).

Fonctions et commandes principales :

• Obtenez l'utilisation du processeur : commande "cpu"

• 🎜🎜#

• Obtenez les informations sur la bande passante du réseau : commande "network"

• Obtenez l'utilisateur actuellement connecté : commande "user"

• get Charge du système : commande "loadavg"

• Obtenir l'heure actuelle : commande "time"

• 🎜#• Obtenir les informations système : commande "system"

• Obtenir la liste des connexions réseau : commande "connection"

• 🎜🎜#

• Obtenir l'utilisation du disque : commande "disk"

Pour différentes instructions, le programme utilise différentes fonctions de bibliothèque pour l'acquisition et le traitement des données, comme suit : #🎜🎜 ##🎜 🎜#• Pour l'instruction "cpu", utilisez la bibliothèque psutil pour obtenir l'utilisation du CPU.

• Pour l'instruction "mémoire", utilisez la bibliothèque psutil pour obtenir l'utilisation de la mémoire.

• Pour la commande "network", utilisez la bibliothèque speedtest-cli pour obtenir des informations sur la bande passante du réseau.

• Pour la commande "user", utilisez la bibliothèque psutil pour obtenir l'utilisateur actuellement connecté.

• Pour la commande "loadavg", utilisez la librairie os pour obtenir la charge système.

• Pour l'instruction "time", utilisez la bibliothèque datetime pour obtenir l'heure actuelle.

• Pour l'instruction "process", utilisez la bibliothèque psutil pour obtenir la liste des processus. Le programme trie les processus en fonction de l'utilisation de la mémoire et renvoie uniquement les 10 premiers processus.

• Pour la commande "system", utilisez la bibliothèque de la plateforme pour obtenir les informations système.

• Pour la commande "connexion", utilisez la bibliothèque psutil pour obtenir la liste des connexions réseau. Le programme trie les connexions par ID de processus et renvoie uniquement les 10 premières connexions.

• Pour l'instruction "gpu", utilisez l'outil nvidia-smi pour obtenir l'utilisation du GPU.

• Pour la commande "disk", utilisez la bibliothèque psutil pour obtenir l'utilisation du disque.

Le résultat du traitement de chaque instruction est renvoyé au client sous la forme d'une chaîne. Lors du traitement de l'instruction, le programme détermine si les données reçues sont vides. S’il est vide, déconnectez et fermez le socket client. La fonction handle_client du programme est une fonction de thread chargée de communiquer avec un seul client. Chaque connexion client démarre un thread.

1.2 Client

Le programme est un simple client TCP qui peut se connecter à un serveur et lui envoyer des requêtes, puis attendre la réponse du serveur. Le programme utilise le module socket de Python pour créer un socket TCP et se connecte à une adresse de serveur à l'aide de la méthode connect. Le programme attend en permanence que l'utilisateur saisisse le type de données de la demande via une boucle, puis code le type de données de la demande au format UTF-8 et l'envoie au serveur à l'aide de la méthode sendall. Le programme attend ensuite la réponse du serveur, décode les données de réponse au format UTF-8 et les imprime. Enfin, le programme ferme le socket client.

Le processus principal du programme est le suivant :

1.

2. Créez un objet socket TCP.

3. Connectez-vous à l'adresse du serveur spécifiée.

4. Boucle en attente que l'utilisateur saisisse le type de données de la requête.

5. Encodez le type de données de la requête au format UTF-8 et envoyez-le au serveur.

6. Attendez que le serveur réponde et reçoive les données de réponse.

7. Décodez les données de réponse au format UTF-8 et imprimez-les.

8. Fermez le socket client.

Ce programme peut être utilisé pour communiquer avec des serveurs qui fournissent des types de données spécifiques. Les utilisateurs peuvent saisir différents types de données de demande pour obtenir différents types de données. Le serveur renverra les données appropriées en fonction du type de demande. Le fonctionnement du programme dépend de la disponibilité et de la vitesse de réponse du serveur. Si le serveur ne répond pas, le programme attendra que le serveur réponde ou que le programme soit interrompu.

2 Code

Serveur

import os
import socket
import subprocess
import threading
from datetime import datetime
from sys import platform

import psutil
from speedtest import Speedtest

# 创建TCP套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定IP和端口
server_address = ('localhost', 8888)
server_socket.bind(server_address)

# 监听连接请求
server_socket.listen(5)


def handle_client(client_socket, client_address):
    while True:
        # 接收客户端发送的数据
        data = client_socket.recv(1024)

        # 如果接收到空数据，则断开连接
        if not data:
            client_socket.close()
            print(f"Connection with {client_address} closed")
            break

        # 处理接收到的数据
        request = data.decode('utf-8')
        if request == 'cpu':
            # 使用psutil库获取CPU使用率
            cpu_percent = psutil.cpu_percent(interval=1)
            response_data = f'CPU使用率：{cpu_percent}%'.encode('utf-8')
        elif request == 'memory':
            # 使用psutil库获取内存使用率
            memory_percent = psutil.virtual_memory().percent
            response_data = f'内存使用率：{memory_percent}%'.encode('utf-8')
        elif request == 'network':
            # 使用speedtest-cli库获取网络带宽信息
            st = Speedtest()
            download_speed = st.download()
            upload_speed = st.upload()
            response_data = f'下载速度：{download_speed / 1000000}Mbps，上传速度：{upload_speed / 1000000}Mbps'.encode('utf-8')
        elif request == 'user':
            # 使用psutil库获取当前登录用户
            username = psutil.users()[0].name
            response_data = f'当前登录用户：{username}'.encode('utf-8')
        elif request == 'loadavg':
            # 使用os库获取系统负载情况
            load_avg = os.getloadavg()
            response_data = f'系统负载情况：{load_avg}'.encode('utf-8')
        elif request == 'time':
            # 使用datetime库获取当前时间
            current_time = datetime.datetime.now()
            response_data = f'当前时间：{current_time}'.encode('utf-8')
        elif request == 'process':
            # 使用psutil库获取进程列表
            process_list = []
            for process in psutil.process_iter(['pid', 'name', 'memory_info']):
                try:
                    process_list.append((process.info['pid'], process.info['name'], process.info['memory_info'].rss))
                except (psutil.AccessDenied, psutil.NoSuchProcess):
                    pass
            process_list.sort(key=lambda x: x[2], reverse=True)
            response_data = ''
            for i, (pid, name, memory) in enumerate(process_list[:10]):
                response_data += f'{i + 1}. 进程名称：{name}，进程ID：{pid}，占用内存：{memory / 1024 / 1024:.2f}MB\n'
            response_data = response_data.encode('utf-8')
        elif request == 'system':
            # 使用platform库获取系统信息
            system_info = f'操作系统：{platform.system()} {platform.release()}\n处理器：{platform.processor()}\nPython版本：{platform.python_version()}'
            response_data = system_info.encode('utf-8')
        elif request == 'connection':
            # 使用psutil库获取网络连接列表
            conn_list = []
            for conn in psutil.net_connections():
                if conn.status == psutil.CONN_ESTABLISHED:
                    conn_list.append((conn.laddr.ip, conn.laddr.port, conn.raddr.ip, conn.raddr.port, conn.pid))
            conn_list.sort(key=lambda x: x[4])
            response_data = ''
            for i, (laddr_ip, laddr_port, raddr_ip, raddr_port, pid) in enumerate(conn_list[:10]):
                response_data += f'{i + 1}. 本地地址：{laddr_ip}:{laddr_port}，远程地址：{raddr_ip}:{raddr_port}，进程ID：{pid}\n'
            response_data = response_data.encode('utf-8')
        elif request == 'disk':
            # 使用psutil库获取磁盘使用情况
            disk_usage = psutil.disk_usage('/')
            disk_info = f'磁盘总容量：{disk_usage.total / 1024 / 1024 / 1024:.2f}GB，已用容量：{disk_usage.used / 1024 / 1024 / 1024:.2f}GB，可用容量：{disk_usage.free / 1024 / 1024 / 1024:.2f}GB'
            response_data = disk_info.encode('utf-8')
        elif request == 'load':
            # 使用psutil库获取系统负载
            load_avg = psutil.getloadavg()
            load_info = f'1分钟内平均负载：{load_avg[0]:.2f}，5分钟内平均负载：{load_avg[1]:.2f}，15分钟内平均负载：{load_avg[2]:.2f}'
            response_data = load_info.encode('utf-8')
        elif request == 'thread':
            # 使用psutil库获取进程线程数
            thread_info = f'当前进程线程数：{psutil.Process().num_threads()}'
            response_data = thread_info.encode('utf-8')
        else:
            response_data = b'Invalid request'

        # 发送响应数据
        client_socket.sendall(response_data)


# 接收多个客户端连接
while True:
    client_socket, client_address = server_socket.accept()
    print(f"New connection from {client_address}")
    # 创建新线程处理客户端连接
    client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address))
    client_thread.start()

Client

import socket

# 创建TCP套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接服务器
server_address = ('localhost', 8888)
client_socket.connect(server_address)

while True:
    # 发送请求数据给服务器
    request = input("请输入要请求的数据类型（cpu/memory/network/user/loadavg/time/process/system/connection/disk/load/thread）：")
    client_socket.sendall(request.encode('utf-8'))

    # 接收服务器响应数据
    response_data = client_socket.recv(1024)

    # 处理接收到的数据
    response = response_data.decode('utf-8')
    print(response)

# 关闭客户端套接字
client_socket.close()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!