python找人脚本_python获取机器信息脚本(网上寻找的)

获取机器信息(待测试)

# -*- coding: UTF-8 -*-

import psutil

import json

import os

import socket

import struct

import time

import sys

# 当前时间函数

def now_time():

now_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))

return now_time

# 获取硬盘信息函数

def disk_info():

disk_dict = {}

disk_name = []

disk_parttions = psutil.disk_partitions()

for i in range(len(disk_parttions)):

parttions_name = disk_parttions[i].device

mountpoint = disk_parttions[i].mountpoint

mountfstype = disk_parttions[i].fstype

disk_info = psutil.disk_usage(mountpoint)

total = disk_info.total

used = disk_info.used

free = disk_info.free

disk_io = psutil.disk_io_counters(perdisk=True)

disk_name.append(str(parttions_name.split('/', parttions_name.count('/'))[-1]))

for key1 in disk_name:

tmp_disk_list = []

for key2 in disk_io.keys():

tmp_disk_list.append(key2)

if key1 in tmp_disk_list:

disk_dict[parttions_name] = {

"read_bytes": disk_io[key1].read_bytes,

"write_bytes": disk_io[key1].write_bytes,

"read_count": disk_io[key1].read_count,

"write_count": disk_io[key1].write_count,

"mountpoint": mountpoint,

"mountfstype": mountfstype,

"total": total,

"used": used,

"free": free

}

else:

pass

return disk_dict

# 获取内存信息函数

def mem_info():

mem_dict_list = psutil.virtual_memory()

mem_total = mem_dict_list.total

mem_used = mem_dict_list.used

mem_free = mem_dict_list.free

cpu_use = psutil.cpu_percent(interval=True)

host_runtime = psutil.boot_time()

mem_list_info = {

"mem_total": mem_total,

"mem_used": mem_used,

"mem_free": mem_free,

"cpu_used": cpu_use,

"host_run": host_runtime

}

return mem_list_info

# 获取CPU信息函数

def cpu_info():

cpu_use = psutil.cpu_percent(interval=True)

cpu_usage = {

"cpu_used": cpu_use

}

return cpu_usage

# 获取网卡信息函数

def net_info():

net_dict_list = {}

net_dev = psutil.net_io_counters(pernic=True)

for dev_name in net_dev.keys():

net_dict_list[dev_name] = {

"RX_b": net_dev[dev_name].bytes_recv,

"TX_b": net_dev[dev_name].bytes_sent,

"Dropout": net_dev[dev_name].dropout,

"Dropint": net_dev[dev_name].dropin

}

return net_dict_list

# 获取用户信息函数

def user_info():

user_dict_list = []

user_dict = psutil.users()

for i in range(len(user_dict)):

user_dict_tmp = {}

user_dict_tmp[user_dict[i].name] = {

"terminal": user_dict[i].terminal,

"host": user_dict[i].host,

"start_time": user_dict[i].started

}

user_dict_list.append(user_dict_tmp)

return user_dict_list

# 获取内存消耗前10的进程函数

def process_info():

process_dict_list_tmp = []

pid_dict = psutil.pids()

for i in pid_dict:

pid = psutil.Process(i)

pid_tuple = (i, pid.name(), pid.memory_percent(), pid.create_time(), pid.status(), pid.cwd(), pid.exe())

process_dict_list_tmp.append(pid_tuple)

process_dict_list_tmp.sort(key=lambda mem1: mem1[2], reverse=True)

process_dict_list = process_dict_list_tmp[0:10]

return process_dict_list

# 获取开机时间函数

def runtime_info():

host_runtime = psutil.boot_time()

host_run_time = {

"host_runtime": host_runtime

}

return host_run_time

# 没用的函数

def get_info():

host_info = {

'disk_info': disk_info(),

'mem_info': mem_info(),

'cpu_info': cpu_info(),

'net_info': net_info(),

'process_info': process_info(),

'user_info': user_info(),

'runtime_info': runtime_info()

}

return repr(host_info)

# socket数据发送函数

def socket_send(socket_server=None, socket_port=None, cammds=None, type=None, PackName=None):

if type == 'regs':

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((socket_server, socket_port))

s.sendall(cammds)

request = str(s.recv(18))

s.close()

return request

elif type == 'data':

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((socket_server, socket_port))

s.sendall(cammds)

request = str(s.recv(128))

if request == 'OK':

Rtime = now_time()

PackSize = sys.getsizeof(cammds)

print(" '%s' : transfer TCP Package '%s' Size '%s' sucessful ") % (Rtime, PackName, PackSize)

s.close()

# 构架TCP格式数据包函数

def trans_pack(commands=None, type=None):

Net_type = 4 # package versions

Mem_type = 1

Cpu_type = 2

Disk_type = 3

Runtime_type = 5

if type == 'Mem':

machine_number = json_conf()["machine_number"] # 获取机器码

body = json.dumps(dict(commands)) # 生成JSON格式包体

header = [Mem_type, body.__len__(), machine_number] # 组成包头格式为:版本,包体长度,机器码

headPack = struct.pack("!3I", *header) # 生成包头

sendPack = headPack + body.encode() # 构建TCP数据包

return sendPack

elif type == 'Net':

machine_number = json_conf()["machine_number"] # 获取机器码

body = json.dumps(dict(commands)) # 生成JSON格式包体

header = [Net_type, body.__len__(), machine_number] # 组成包头格式为:版本,包体长度,机器码

headPack = struct.pack("!3I", *header) # 生成包头

sendPack = headPack + body.encode() # 构建TCP数据包

return sendPack

elif type == 'Cpu':

machine_number = json_conf()["machine_number"] # 获取机器码

body = json.dumps(dict(commands)) # 生成JSON格式包体

header = [Cpu_type, body.__len__(), machine_number] # 组成包头格式为:版本,包体长度,机器码

headPack = struct.pack("!3I", *header) # 生成包头

sendPack = headPack + body.encode() # 构建TCP数据包

return sendPack

elif type == 'Disk':

machine_number = json_conf()["machine_number"] # 获取机器码

body = json.dumps(dict(commands)) # 生成JSON格式包体

header = [Disk_type, body.__len__(), machine_number] # 组成包头格式为:版本,包体长度,机器码

headPack = struct.pack("!3I", *header) # 生成包头

sendPack = headPack + body.encode() # 构建TCP数据包

return sendPack

elif type == 'Run':

machine_number = json_conf()["machine_number"] # 获取机器码

body = json.dumps(dict(commands)) # 生成JSON格式包体

header = [Runtime_type, body.__len__(), machine_number] # 组成包头格式为:版本,包体长度,机器码

headPack = struct.pack("!3I", *header) # 生成包头

sendPack = headPack + body.encode() # 构建TCP数据包

return sendPack

# 读取JSON配置函数

def json_conf():

a = os.getcwd()

# os.chdir("%s/client/conf" % a) # 改变工作目录为JSON文件目录

json_list = file("%s/client/conf/client_conf.json" % a) # 读取JSON配置文件

m = json_list.read()

json_list.seek(0)

json_conf = json.loads(json_list.read()) # 取出JSON配置文件

json_list.close()

return json_conf

def json_write(command=None):

a = os.getcwd()

os.chdir("%s/client/conf" % a)

print(command)

b = type(command)

m = open("client_conf.json", 'w')

# agent第一次注册函数

def client_regs():

host_info = json.dumps({'ip': str(json_conf()['local_adder']), 'mac': str(json_conf()['local_mac'])})

regs_addr = json_conf()['send_server']

regs_port = json_conf()['server_regs_port']

server_request = str(socket_send(socket_server=regs_addr, socket_port=regs_port, cammds=host_info, type='regs'))

conf = json_conf()

conf['machine_number'] = server_request

conf = json.dumps(conf)

json_write(command=conf)

# 数据包发送函数

def send_data():

DiskPack = trans_pack(commands=disk_info(), type='Disk') # 生成TCP数据包

MemPack = trans_pack(commands=mem_info(), type='Mem')

NetPack = trans_pack(commands=net_info(), type='Net')

regs_addr = json_conf()['send_server'] # 获取服务器地址

regs_port = json_conf()['send_port'] # 获取服务器端口

socket_send(socket_server=regs_addr, socket_port=regs_port, cammds=DiskPack, type='data',

PackName='DiskPack') # 向服务器发送数据包

socket_send(socket_server=regs_addr, socket_port=regs_port, cammds=MemPack, type='data', PackName='MemPack')

socket_send(socket_server=regs_addr, socket_port=regs_port, cammds=NetPack, type='data', PackName='NetPack')

time.sleep(json_conf()['sendoff_time']) # 等待延时

def check_client():

print('start get client info....')

machine_number = json_conf()['machine_number']

if machine_number:

print(machine_number)

print(11111)

else:

print(machine_number)

print(22222)

if __name__ == '__main__':

while True:

send_data()