Bagaimana untuk memantau data masa nyata hos jauh dalam Python

1 Dokumen Penerangan Program

1.1 Pelayan

Program ini ialah program pelayan berdasarkan protokol TCP, yang boleh menerima arahan yang dihantar oleh klien dan melaksanakan operasi yang sepadan, dan akhirnya akan beroperasi Hasilnya dikembalikan kepada pelanggan. Program ini berjalan pada port 8888 localhost (mesin ini).

Fungsi dan arahan utama:

• Dapatkan penggunaan CPU: arahan "cpu"

• ; Dapatkan maklumat jalur lebar rangkaian: arahan "rangkaian"

• 🎜>• Dapatkan masa semasa: perintah "masa"

• > • Dapatkan senarai sambungan rangkaian: arahan "sambungan"

• Dapatkan penggunaan GPU: arahan "gpu"

• >Untuk arahan yang berbeza, atur cara menggunakan fungsi perpustakaan yang berbeza untuk pemerolehan dan pemprosesan data, seperti berikut:

• Untuk arahan "cpu", gunakan perpustakaan psutil untuk mendapatkan penggunaan CPU.

• Untuk arahan "memori", gunakan perpustakaan psutil untuk mendapatkan penggunaan memori.

• Untuk arahan "rangkaian", gunakan perpustakaan speedtest-cli untuk mendapatkan maklumat lebar jalur rangkaian.

• Untuk arahan "pengguna", gunakan perpustakaan psutil untuk mendapatkan pengguna log masuk semasa.

• Untuk arahan "loadavg", gunakan perpustakaan os untuk mendapatkan beban sistem.

• Untuk arahan "masa", gunakan perpustakaan datetime untuk mendapatkan masa semasa.

• Untuk arahan "proses", gunakan perpustakaan psutil untuk mendapatkan senarai proses. Program ini menyusun proses mengikut penggunaan memori dan hanya mengembalikan 10 proses teratas.

• Untuk arahan "sistem", gunakan perpustakaan platform untuk mendapatkan maklumat sistem.

• Untuk arahan "sambungan", gunakan perpustakaan psutil untuk mendapatkan senarai sambungan rangkaian. Program ini mengisih sambungan mengikut ID proses dan hanya mengembalikan 10 sambungan pertama.

• Untuk arahan "gpu", gunakan alat nvidia-smi untuk mendapatkan penggunaan GPU.

• Untuk arahan "cakera", gunakan perpustakaan psutil untuk mendapatkan penggunaan cakera.

Hasil pemprosesan setiap arahan dikembalikan kepada klien dalam bentuk rentetan. Semasa memproses arahan, program menentukan sama ada data yang diterima kosong. Jika kosong, putuskan sambungan dan tutup soket klien. Fungsi handle_client dalam program ialah fungsi thread yang bertanggungjawab untuk berkomunikasi dengan satu klien Setiap sambungan klien memulakan thread.

1.2 Pelanggan

Atur cara ini ialah klien TCP mudah yang boleh menyambung ke pelayan dan menghantar permintaan kepadanya, dan kemudian menunggu respons pelayan. Program ini menggunakan modul soket Python untuk mencipta soket TCP dan menyambung ke alamat pelayan menggunakan kaedah sambungan. Program ini secara berterusan menunggu pengguna memasukkan jenis data permintaan melalui gelung, kemudian mengekod jenis data permintaan ke dalam format UTF-8 dan menghantarnya ke pelayan menggunakan kaedah sendall. Program kemudian menunggu pelayan untuk bertindak balas, menyahkod data tindak balas ke dalam format UTF-8 dan mencetaknya. Akhirnya, program ini menutup soket pelanggan.

Proses utama program adalah seperti berikut:

1 Import modul soket.

2. Cipta objek soket TCP.

3. Sambung ke alamat pelayan yang ditentukan.

4. Gelung menunggu pengguna memasukkan jenis data permintaan.

5. Kodkan jenis data permintaan ke dalam format UTF-8 dan hantar ke pelayan.

6 Tunggu pelayan membalas dan menerima data respons.

7. Nyahkod data respons ke dalam format UTF-8 dan mencetaknya.

8. Tutup soket pelanggan.

Atur cara ini boleh digunakan untuk berkomunikasi dengan pelayan yang menyediakan jenis data tertentu. Pengguna boleh memasukkan jenis data permintaan yang berbeza untuk mendapatkan jenis data yang berbeza. Pelayan akan mengembalikan data yang sesuai berdasarkan jenis permintaan. Operasi program bergantung pada ketersediaan dan kelajuan tindak balas pelayan. Jika pelayan gagal bertindak balas, program akan menunggu sehingga pelayan bertindak balas atau program terganggu.

2 Kod

Pelayan

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()

Pelanggan

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()

Atas ialah kandungan terperinci Bagaimana untuk memantau data masa nyata hos jauh dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!