Python 监控脚本
整体通过psutil模块动态获取资源信息。下为示例图：
1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 # @Time: 2019-07-01 17:23:01 4 # @Author: Kevin.Xiang 5 #----------------------------------------- 6 # Start margin size: 100x100 7 # The startup script: python3 monitoring.py 8 # Close the script: q 9 # matters need attention: forbid "ctrl + c" 10 #----------------------------------------- 11 # ############# debugger ############## # 12 # from pudb import set_trace;set_trace()# 13 14 import queue 15 import threading 16 import os 17 import sys 18 import psutil 19 import time 20 import term 21 import tty 22 import termios 23 import datetime 24 import platform 25 from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor 26 27 28 class Run(object): 29 """Perform each task""" 30 31 def run(self): 32 """Enable multithreading to complete tasks""" 33 34 global flag 35 flag = True 36 37 thread_get = threading.Thread( 38 target=Manage("get").mamage_get) 39 thread_cpu = threading.Thread( 40 target=Manage("frames_cpu").mamage_put) 41 thread_memory = threading.Thread( 42 target=Manage("frames_memory").mamage_put) 43 thread_swap = threading.Thread( 44 target=Manage("frames_swap").mamage_put) 45 thread_disk = threading.Thread( 46 target=Manage("frames_disk").mamage_put) 47 thread_diskio = threading.Thread( 48 target=Manage("frames_diskio").mamage_put) 49 thread_system = threading.Thread( 50 target=Manage("frames_system").mamage_put) 51 thread_network = threading.Thread( 52 target=Manage("frames_network").mamage_put) 53 thread_version = threading.Thread( 54 target=Manage("frames_version").mamage_put) 55 thread_process = threading.Thread( 56 target=Manage("frames_process").mamage_put) 57 58 thread_process.start() 59 thread_cpu.start() 60 thread_memory.start() 61 thread_swap.start() 62 thread_disk.start() 63 thread_diskio.start() 64 thread_network.start() 65 thread_system.start() 66 thread_version.start() 67 thread_get.start() 68 69 # Short execution framewor 70 frames = Frames() 71 time.sleep(1) 72 term.clear() 73 term.pos(1, 0) 74 frames.header() 75 term.pos(2, 0) 76 time.sleep(3) 77 78 # Judge the input and exit 79 fd = sys.stdin.fileno() 80 old_settings = termios.tcgetattr(fd) 81 tty.setraw(sys.stdin.fileno()) 82 quit = sys.stdin.read(1) 83 termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) 84 if len(quit) == 1: 85 flag = False 86 time.sleep(1) 87 que.queue.clear() 88 # Reduction of the cursor 89 os.system("echo -e \033[?25h") 90 term.pos(1, 0) 91 term.clear() 92 93 94 class Manage(object): 95 """Manage the operations of each class""" 96 97 def __init__(self, name): 98 self.name = name 99 100 def mamage_put(self): 101 """Threads are specified by reflection as methods""" 102 103 frames = Frames() 104 while flag: 105 getattr(frames, self.name)() 106 time.sleep(0.1) 107 108 def mamage_get(self): 109 """Output the value under the fixed method according to the category""" 110 111 while flag: 112 value = que.get() 113 value_type = value["type"] 114 if value_type == "cpu": 115 self.mamage_cpu(value) 116 if value_type == "memory": 117 self.mamage_memory(value) 118 if value_type == "swap": 119 self.mamage_swap(value) 120 if value_type == "disk": 121 self.mamage_disk(value) 122 if value_type == "diskio": 123 self.mamage_diskio(value) 124 if value_type == "network": 125 self.mamage_network(value) 126 if value_type == "system": 127 self.mamage_system(value) 128 if value_type == "version": 129 self.mamage_version(value) 130 if value_type == "process": 131 self.mamage_process(value) 132 # Second judgment to clean message queue 133 if flag == False: 134 que.queue.clear() 135 time.sleep(0.01) 136 137 def mamage_cpu(self, value): 138 """CPU output format""" 139 140 term.pos(7, 4) 141 term.write("CPU", term.bold) 142 term.pos(7, 19) 143 term.write(" ") 144 term.pos(7, 8) 145 # Output progress bar 146 percent = ("%s%%" % (int(value["total"]))) 147 term.write("[%-10s]%s" % ("|" * int(value["total"]/10), percent)) 148 term.pos(7, 30) 149 term.write("-CPU-", term.bold) 150 term.pos(7, 45) 151 term.write(" ") 152 term.pos(7, 39) 153 term.write("total: %s %%" % (round(value["total"], 1))) 154 term.pos(7, 60) 155 term.write(" ") 156 term.pos(7, 55) 157 term.write("used: %s %%" % (round(value["user"], 1))) 158 term.pos(7, 75) 159 term.write(" ") 160 term.pos(7, 70) 161 term.write("syst: %s %%" % (round(value["system"], 1))) 162 term.pos(8, 45) 163 term.write(" ") 164 term.pos(8, 39) 165 term.write("iowai: %s %%" % (round(value["iowait"], 1))) 166 term.pos(8, 60) 167 term.write(" ") 168 term.pos(8, 55) 169 term.write("nice: %s %%" % (round(value["nice"], 1))) 170 term.pos(8, 75) 171 term.write(" ") 172 term.pos(8, 70) 173 term.write("nice: %s %%" % (round(value["idle"], 1))) 174 term.pos(7, 4) 175 176 def mamage_memory(self, value): 177 """Memory output format""" 178 179 term.pos(9, 4) 180 term.write("Mem", term.bold) 181 term.pos(9, 8) 182 total = (value["used"]/value["total"]) * 100 183 percent = ("%s%%" % (int(total))) 184 term.write("[%-10s]%s" % ("|" * int(total/10), percent)) 185 term.pos(9, 30) 186 term.write("-MEM-", term.bold) 187 term.pos(9, 39) 188 term.write("total: %s MB" % (int(value["total"]))) 189 term.pos(9, 55) 190 term.write("used: %s MB" % (int(value["used"]))) 191 term.pos(9, 70) 192 term.write("free: %s MB" % (int(value["free"]))) 193 term.pos(10, 39) 194 term.write("activ: %s MB" % (int(value["active"]))) 195 term.pos(10, 55) 196 term.write("buff: %s MB" % (int(value["buffers"]))) 197 term.pos(10, 70) 198 term.write("cach: %s MB" % (int(value["cached"]))) 199 term.pos(9, 4) 200 201 def mamage_swap(self, value): 202 """Swap output format""" 203 204 term.pos(11, 3) 205 term.write("Swap", term.bold) 206 term.pos(11, 8) 207 # Determine if the value is 0 and the exception is caught 208 try: 209 total = (int(value["used"])/int(value["total"])) * 100 210 except ZeroDivisionError: 211 total = 0 212 percent = ("%s%%" % (int(total))) 213 term.write("[%-10s]%s" % ("|" * int(total/10), percent)) 214 term.pos(11, 30) 215 term.write("-Swap-", term.bold) 216 term.pos(11, 39) 217 term.write("total: %s MB" % (int(value["total"]))) 218 term.pos(11, 55) 219 term.write("used: %s MB" % (int(value["used"]))) 220 term.pos(11, 70) 221 term.write("free: %s MB" % (int(value["free"]))) 222 term.pos(12, 41) 223 term.write("sin: %s MB" % (int(value["sin"]))) 224 term.pos(12, 55) 225 term.write("sout: %s MB" % (int(value["sout"]))) 226 term.pos(12, 70) 227 term.write("perc: %s %%" % (str(value["percent"]))) 228 term.pos(11, 3) 229 230 def mamage_disk(self, value): 231 """Disk output format""" 232 233 term.pos(13, 3) 234 term.write("Disk", term.bold) 235 term.pos(13, 8) 236 total = (value["used"]/value["total"]) * 100 237 percent = ("%s%%" % (int(total))) 238 term.write("[%-10s]%s" % ("|" * int(total/10), percent)) 239 term.pos(13, 30) 240 term.write("-Disk-", term.bold) 241 term.pos(13, 39) 242 term.write("total: %s GB" % (int(value["total"]))) 243 term.pos(13, 55) 244 term.write("used: %s GB" % (int(value["used"]))) 245 term.pos(13, 70) 246 term.write("free: %s GB" % (int(value["free"]))) 247 term.pos(13, 3) 248 249 def mamage_system(self, value): 250 """System output format""" 251 252 day, now = time.strftime("%Y-%m-%d %H:%M:%S").split() 253 course_pid = psutil.pids() 254 course_count = 0 255 for i in course_pid: 256 course_count = course_count + 1 257 258 term.pos(2, 4) 259 term.write("USER: " + str(value["username"])) 260 term.pos(2, 16) 261 term.write("T: " + str(value["terminal"])) 262 term.pos(2, 28) 263 term.write("-") 264 term.pos(2, 33) 265 term.write("Process: " + str(course_count)) 266 term.pos(2, 48) 267 term.write("-") 268 term.pos(2, 53) 269 term.write("BootTime: " + str(value["BootTime"])) 270 term.pos(4, 4) 271 term.write("HOST: " + str(value["hostname"])) 272 term.pos(4, 28) 273 term.write("-") 274 term.pos(4, 32) 275 term.write("Sec: " + str(now)) 276 term.pos(4, 48) 277 term.write("-") 278 term.pos(4, 53) 279 term.write("LogiTime: " + str(value["started"])) 280 term.pos(2, 3) 281 282 def mamage_network(self, value): 283 """Network output format""" 284 285 term.pos(20, 68) 286 term.clearLineFromPos() 287 term.write("TX: " + str(round(value["send"], 2)) + " KB") 288 term.pos(20, 88) 289 term.write("|", term.bold) 290 term.pos(21, 68) 291 term.clearLineFromPos() 292 term.write("RX: " + str(round(value["recv"], 2)) + " KB") 293 term.pos(21, 88) 294 term.write("|", term.bold) 295 term.pos(22, 67) 296 term.write("TXP: " + str(value["packets_sent"])) 297 term.pos(23, 67) 298 term.write("TXP: " + str(value["packets_recv"])) 299 term.pos(20, 68) 300 301 def mamage_diskio(self, value): 302 """Disk IO output format""" 303 304 term.pos(31, 68) 305 term.clearLineFromPos() 306 term.write("Read: " + str(round(value["read"], 2)) + " KB") 307 term.pos(31, 88) 308 term.write("|", term.bold) 309 term.pos(32, 68) 310 term.clearLineFromPos() 311 term.write("Wrtn: " + str(round(value["write"], 2)) + " KB") 312 term.pos(32, 88) 313 term.write("|", term.bold) 314 term.pos(33, 68) 315 term.write("Rsec: " + str(value["read_count"])) 316 term.pos(34, 68) 317 term.write("Wsec: " + str(value["write_count"])) 318 term.pos(35, 69) 319 term.write("Tps: " + str(value["tps"])) 320 term.pos(32, 68) 321 322 def mamage_process(self, value): 323 """Process output format""" 324 325 value = value["key"] 326 count = 19 327 # Loop outputs each process 328 for v in value: 329 term.pos(count, 3) 330 term.write(v["user"]) 331 term.pos(count, 11) 332 term.write(str(v["pid"])) 333 term.pos(count, 18) 334 term.write(str(v["cpu"])) 335 term.pos(count, 26) 336 term.write(str(round(v["memory"], 2))) 337 term.pos(count, 34) 338 term.write(str(v["threads"])) 339 term.pos(count, 42) 340 term.write(str(v["name"])) 341 count = count + 1 342 term.pos(18, 4) 343 344 def mamage_version(self, value): 345 """Version of the output""" 346 347 term.pos(16, 3) 348 term.write(value["system"]) 349 term.pos(16, 10) 350 term.write(value["version"]) 351 352 353 class Frames(object): 354 """Terminal screen module""" 355 356 def header(self): 357 """Frame structure format output""" 358 359 # upper part 360 bold = term.format("#", term.bold) 361 frame_up = bold.ljust(100, "=") 362 frame_up_format = term.format(frame_up) 363 term.write(frame_up_format+bold) 364 365 # center section 1 366 term.pos(3, 0) 367 frame_three = term.format("+".ljust(87, "-")) 368 term.write(frame_three+"+") 369 370 # center section 2 371 term.pos(5, 0) 372 frame_five = term.format("+".ljust(87, "-")) 373 term.write(frame_five+"+") 374 375 # center section 3 376 frame_centre1 = "+".ljust(87, "=") 377 term.pos(15, 0) 378 term.write(frame_centre1+"+") 379 380 # center section 4 381 frame_centre2 = "+".ljust(59, "=") 382 term.pos(17, 0) 383 term.write(frame_centre2) 384 term.pos(17, 88) 385 term.write("|", term.bold) 386 387 # Producer information 388 kevin = "Kevin.Xiang" 389 term.pos(16, 47) 390 term.write(kevin) 391 392 # next part 393 frame_down = bold.ljust(100, "=") 394 term.pos(39, 0) 395 term.write(frame_down+bold) 396 397 # border style 398 for i1 in range(7, 14): 399 term.pos(i1, 26) 400 term.write("|") 401 402 for i2 in range(16, 39): 403 term.pos(i2, 60) 404 term.write("|", term.bold) 405 406 # Border output style IO 407 term.pos(16, 61) 408 frame_back = term.format("".rjust(27, " "), term.bgwhite) 409 term.write(frame_back) 410 term.pos(16, 71) 411 frame_network = term.format("NETWORK", term.black, term.bgwhite) 412 term.write(frame_network) 413 term.pos(27, 61) 414 term.write(frame_back) 415 term.pos(27, 73) 416 frame_disk = term.format("DISK", term.black, term.bgwhite) 417 term.write(frame_disk) 418 419 # Process output style 420 term.pos(18, 0) 421 space = "".center(4, " ") 422 frame = term.format(" USER" 423 + space 424 + "PID" 425 + space 426 + "CPU%" 427 + space 428 + "MEM%" 429 + space 430 + "THRE" 431 + space 432 + "NAME", term.bold) 433 term.write(frame) 434 435 # Border output style 436 list_down = [2, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 19, 20, 21, 437 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38] 438 for i3 in list_down: 439 term.pos(i3, 0) 440 term.write("|", term.bold) 441 term.pos(i3, 88) 442 term.write("|", term.bold) 443 444 def frames_cpu(self): 445 """CPU statistics""" 446 447 t1 = psutil.cpu_times() 448 time.sleep(1) 449 t2 = psutil.cpu_times() 450 451 value = [] 452 for v1, v2 in zip(t1, t2): 453 value.append(v2-v1) 454 455 count = 0 456 for v in value: 457 count = count + v 458 459 user = value[0] 460 nice = value[1] 461 system = value[2] 462 idle = value[3] 463 iowait = value[4] 464 irq = value[5] 465 softirq = value[6] 466 steal = value[7] 467 guest = value[8] 468 guest_nice = value[9] 469 total = count 470 471 cpu = Cpu(user, nice, system, idle, iowait, 472 irq, softirq, steal, guest, guest_nice, total) 473 474 cpu_out = { 475 "total": cpu.cpu_total(), 476 "user": cpu.cpu_user(), 477 "system": cpu.cpu_system(), 478 "idle": cpu.cpu_idle(), 479 "iowait": cpu.cpu_iowait(), 480 "nice": cpu.cpu_nice(), 481 "type": "cpu" 482 } 483 484 que.put(cpu_out) 485 486 def frames_memory(self): 487 """Memory statistics""" 488 489 time.sleep(1) 490 value = psutil.virtual_memory() 491 used = value.used 492 free = value.free 493 active = value.active 494 inactive = value.inactive 495 buffers = value.buffers 496 cached = value.cached 497 total = value.total 498 499 memory = Memory(used, free, active, inactive, 500 buffers, cached, total) 501 502 memory_out = { 503 "total": memory.memory_total(), 504 "used": memory.memory_used(), 505 "free": memory.memory_free(), 506 "active": memory.memory_active(), 507 "buffers": memory.memory_buffers(), 508 "cached": memory.memory_cached(), 509 "type": "memory" 510 } 511 que.put(memory_out) 512 513 def frames_swap(self): 514 """Swap information statistics""" 515 516 time.sleep(1) 517 value = psutil.swap_memory() 518 used = value.used 519 free = value.free 520 sin = value.sin 521 sout = value.sout 522 total = value.total 523 percent = value.percent 524 525 swap = Swap(used, free, sin, sout, total, percent) 526 527 swap_out = { 528 "total": swap.swap_total(), 529 "used": swap.swap_used(), 530 "free": swap.swap_free(), 531 "sin": swap.swap_sin(), 532 "sout": swap.swap_sout(), 533 "percent": swap.swap_percent(), 534 "type": "swap" 535 } 536 537 que.put(swap_out) 538 539 def frames_disk(self): 540 """Information statistics only get / contents disk""" 541 542 time.sleep(1) 543 value = psutil.disk_usage('/') 544 used = value.used 545 free = value.free 546 total = value.total 547 548 disk = Disk(used, free, total) 549 550 disk_out = { 551 "total": disk.disk_total(), 552 "used": disk.disk_used(), 553 "free": disk.disk_free(), 554 "type": "disk" 555 } 556 557 que.put(disk_out) 558 559 def frames_diskio(self): 560 """Disk IO statistics""" 561 562 t1_diskio = psutil.disk_io_counters() 563 time.sleep(1) 564 t2_diskio = psutil.disk_io_counters() 565 566 read = t2_diskio.read_bytes - t1_diskio.read_bytes 567 write = t2_diskio.write_bytes - t1_diskio.write_bytes 568 read_count = t2_diskio.read_count - t1_diskio.read_count 569 write_count = t2_diskio.write_count - t1_diskio.write_count 570 tps = t2_diskio.read_count + t2_diskio.write_count - \ 571 t1_diskio.read_count - t1_diskio.write_count 572 573 diskio = Diskio(read, write, read_count, write_count, tps) 574 575 diskio_out = { 576 "read": diskio.diskio_read(), 577 "write": diskio.diskio_write(), 578 "read_count": diskio.diskio_read_count(), 579 "write_count": diskio.diskio_write_count(), 580 "tps": diskio.diskio_tps(), 581 "type": "diskio" 582 } 583 que.put(diskio_out) 584 585 def frames_network(self): 586 """Network statistics""" 587 588 t1 = psutil.net_io_counters() 589 time.sleep(1) 590 t2 = psutil.net_io_counters() 591 592 value = [] 593 for v1, v2 in zip(t1, t2): 594 value.append(v2-v1) 595 596 bytes_sent = value[0] 597 bytes_recv = value[1] 598 packets_sent = value[2] 599 packets_recv = value[3] 600 601 network = Network(bytes_sent, bytes_recv, 602 packets_sent, packets_recv) 603 604 network_out = { 605 "send": network.network_bytes_sent(), 606 "recv": network.network_bytes_recv(), 607 "packets_sent": network.network_packets_sent(), 608 "packets_recv": network.network_packets_recv(), 609 "type": "network" 610 } 611 612 que.put(network_out) 613 614 def frames_system(self): 615 """System of statistical""" 616 617 time.sleep(1) 618 boot_time = psutil.boot_time() 619 tty = os.popen("tty").read().replace('/dev/', '', 1).strip() 620 value = psutil.users() 621 for v in value: 622 if v.terminal == tty: 623 username = v.name 624 terminal = v.terminal 625 hostname = v.host 626 started = v.started 627 userpid = v.pid 628 629 system = System(boot_time, username, 630 terminal, hostname, started, userpid) 631 632 system_out = { 633 "BootTime": system.system_boot_time(), 634 "username": system.system_username(), 635 "terminal": system.system_terminal(), 636 "hostname": system.system_hostname(), 637 "started": system.system_started(), 638 "userpid": system.system_userpid(), 639 "type": "system", 640 } 641 que.put(system_out) 642 643 def frames_version(self): 644 """Version statistics""" 645 646 time.sleep(1) 647 value = platform.uname() 648 system = value.system 649 localhost = value.node 650 kernel = value.release 651 sysver = value.version 652 machine = value.machine 653 654 version = Version(system, localhost, kernel, sysver, machine) 655 656 version_out = { 657 "system": version.version_system(), 658 "localhost": version.version_localhost(), 659 "kernel": version.version_kernel(), 660 "version": version.version_sysver(), 661 "machine": version.version_machine(), 662 "type": "version" 663 } 664 665 que.put(version_out) 666 667 def frames_process(self): 668 """Process statistics""" 669 670 time.sleep(1) 671 list1 = [] 672 673 PID = psutil.pids() 674 675 for p in PID: 676 try: 677 proc = psutil.Process(p) 678 user = proc.uids()[0] 679 name = proc.name() 680 pid = p 681 cpu = proc.cpu_percent(interval=0) 682 memory = proc.memory_percent() 683 status = proc.status() 684 threads = proc.num_threads() 685 686 process = Process(user, name, pid, cpu, 687 memory, status, threads) 688 dist1 = { 689 "user": process.process_user(), 690 "name": process.process_name(), 691 "pid": process.process_pid(), 692 "cpu": process.process_cpu(), 693 "memory": process.process_memory(), 694 "status": process.process_status(), 695 "threads": process.process_threads(), 696 } 697 list1.append(dist1) 698 except: 699 continue 700 701 # Arrange by key in the dictionary 702 list2 = sorted(list1, key=lambda x: x["threads"], reverse=True) 703 704 list3 = [] 705 count = 0 706 for p2 in list2: 707 list3.append(p2) 708 count = count + 1 709 if count == 19: 710 break 711 712 process_out = { 713 "key": list3, 714 "type": "process" 715 } 716 717 que.put(process_out) 718 719 720 class Cpu(object): 721 """ CPU usage information """ 722 723 def __init__(self, user, nice, system, idle, iowait, irq, 724 softirq, steal, guest, guest_nice, total): 725 726 self.user = user 727 self.nice = nice 728 self.system = system 729 self.idle = idle 730 self.iowait = iowait 731 self.irq = irq 732 self.softirq = softirq 733 self.steal = steal 734 self.guest = guest 735 self.guest_nice = guest_nice 736 self.total = total 737 738 def cpu_user(self): 739 """User utilization""" 740 741 cpu_user = (self.user / self.total) * 100 742 return cpu_user 743 744 def cpu_nice(self): 745 """Nice usage rate""" 746 747 cpu_nice = (self.nice / self.total) * 100 748 return cpu_nice 749 750 def cpu_system(self): 751 """System utilization""" 752 753 cpu_system = (self.system / self.total) * 100 754 return cpu_system 755 756 def cpu_idle(self): 757 """CPU available space""" 758 759 cpu_idle = (self.idle / self.total) * 100 760 return cpu_idle 761 762 def cpu_iowait(self): 763 """Disk IO usage""" 764 765 cpu_iowait = (self.iowait / self.total) * 100 766 return cpu_iowait 767 768 def cpu_total(self): 769 """The total usage""" 770 771 cpu_total = self.user 772 cpu_total = ((self.total - self.idle) / self.total) * 100 773 return cpu_total 774 775 776 class Memory(object): 777 """Memory information details""" 778 779 def __init__(self, used, free, active, inactive, buffers, cached, total): 780 781 self.used = used 782 self.free = free 783 self.active = active 784 self.inactive = inactive 785 self.buffers = buffers 786 self.cached = cached 787 self.total = total 788 789 def memory_used(self): 790 """Memory user usage""" 791 792 memory_used = self.used/1024/1024 793 return memory_used 794 795 def memory_free(self): 796 """The true remaining memory size""" 797 798 memory_free = self.free/1024/1024 799 return memory_free 800 801 def memory_active(self): 802 """The memory program considers the size available to contain the cache buffer""" 803 804 memory_active = self.active/1024/1024 805 return memory_active 806 807 def memory_inactive(self): 808 """Unused memory does not contain caches""" 809 810 memory_inactive = self.inactive/1024/1024 811 return memory_inactive 812 813 def memory_buffers(self): 814 """Buffer usage memory""" 815 816 memory_buffers = self.buffers/1024/1024 817 return memory_buffers 818 819 def memory_cached(self): 820 """Unused memory does not contain caches""" 821 822 memory_cached = self.cached/1024/1024 823 return memory_cached 824 825 def memory_total(self): 826 """Total memory size""" 827 828 memory_total = self.total/1024/1024 829 return memory_total 830 831 832 class Swap(object): 833 """Virtual memory information""" 834 835 def __init__(self, used, free, sin, sout, total, percent): 836 self.used = used 837 self.free = free 838 self.sin = sin 839 self.sout = sout 840 self.total = total 841 self.percent = percent 842 843 def swap_used(self): 844 """Virtual memory used by users""" 845 846 swap_used = self.used/1024/1024 847 return swap_used 848 849 def swap_free(self): 850 """Virtual memory remaining space""" 851 852 swap_free = self.free/1024/1024 853 return swap_free 854 855 def swap_sin(self): 856 """The system accumulates the number of MB swapped in from disk""" 857 858 swap_sin = self.sin/1024/1024 859 return swap_sin 860 861 def swap_sout(self): 862 """The number of MB the system accumulates from disk """ 863 864 swap_sout = self.sin/1024/1024 865 return swap_sout 866 867 def swap_total(self): 868 """Total virtual memory size""" 869 870 swap_total = self.total/1024/1024 871 return swap_total 872 873 def swap_percent(self): 874 """Using percentage swap""" 875 876 swap_percent = self.percent 877 return swap_percent 878 879 880 class Disk(object): 881 """Disk resource information""" 882 883 def __init__(self, used, free, total): 884 self.used = used 885 self.free = free 886 self.total = total 887 888 def disk_used(self): 889 """Disk user use GB """ 890 891 disk_used = self.used/1024/1024/1024 892 return disk_used 893 894 def disk_free(self): 895 """Disk space GB""" 896 897 disk_free = self.free/1024/1024/1024 898 return disk_free 899 900 def disk_total(self): 901 """Total disk size GB""" 902 903 disk_total = self.total/1024/1024/1024 904 return disk_total 905 906 907 class Diskio(object): 908 """View disk IO""" 909 910 def __init__(self, read, write, read_count, write_count, tps): 911 self.read = read 912 self.write = write 913 self.read_count = read_count 914 self.write_count = write_count 915 self.tps = tps 916 917 def diskio_read(self): 918 """A disk read kb""" 919 920 diskio_read = self.read/1024 921 return diskio_read 922 923 def diskio_write(self): 924 """A disk read kb""" 925 926 diskio_write = self.write/1024 927 return diskio_write 928 929 def diskio_read_count(self): 930 """Merge reads""" 931 932 diskio_read_count = self.read_count 933 return diskio_read_count 934 935 def diskio_write_count(self): 936 """Merge write times""" 937 938 diskio_write_count = self.write_count 939 return diskio_write_count 940 941 def diskio_tps(self): 942 """Read/write IO handles a response transaction""" 943 944 diskio_tps = self.tps 945 return diskio_tps 946 947 948 class Network(object): 949 """Network resource information""" 950 951 def __init__(self, bytes_sent, bytes_recv, packets_sent, packets_recv): 952 self.bytes_sent = bytes_sent 953 self.bytes_recv = bytes_recv 954 self.packets_sent = packets_sent 955 self.packets_recv = packets_recv 956 957 def network_bytes_sent(self): 958 """The network sends packets in kilobytes per second""" 959 960 network_bytes_sent = self.bytes_sent/1024 961 return network_bytes_sent 962 963 def network_bytes_recv(self): 964 """The network receives traffic in kilobytes per second""" 965 966 network_bytes_recv = self.bytes_recv/1024 967 return network_bytes_recv 968 969 def network_packets_sent(self): 970 """Number of packets sent per second""" 971 972 network_packets_sent = self.packets_sent 973 return network_packets_sent 974 975 def network_packets_recv(self): 976 """Number of packets received per second""" 977 978 network_packets_recv = self.packets_recv 979 return network_packets_recv 980 981 982 class System(object): 983 """System resource information""" 984 985 def __init__(self, boot_time, username, terminal, hostname, started, userpid): 986 self.boot_time = boot_time 987 self.username = username 988 self.terminal = terminal 989 self.hostname = hostname 990 self.started = started 991 self.userpid = userpid 992 993 def system_boot_time(self): 994 """System startup time""" 995 996 system_boot_time = datetime.datetime.fromtimestamp( 997 self.boot_time).strftime("%Y-%m-%d %H:%M:%S") 998 return system_boot_time 999 1000 def system_username(self): 1001 """Current logged-in user""" 1002 1003 system_username = self.username 1004 return system_username 1005 1006 def system_terminal(self): 1007 """User access terminal""" 1008 1009 system_terminal = self.terminal 1010 return system_terminal 1011 1012 def system_hostname(self): 1013 """Connect user IP""" 1014 1015 system_hostname = self.hostname 1016 return system_hostname 1017 1018 def system_started(self): 1019 """User time""" 1020 1021 system_started = datetime.datetime.fromtimestamp( 1022 self.started).strftime("%Y-%m-%d %H:%M:%S") 1023 1024 return system_started 1025 1026 def system_userpid(self): 1027 """User pid""" 1028 1029 system_userpid = self.userpid 1030 return system_userpid 1031 1032 1033 class Version(object): 1034 """system version""" 1035 1036 def __init__(self, system, localhost, kernel, sysver, machine): 1037 self.system = system 1038 self.localhost = localhost 1039 self.kernel = kernel 1040 self.sysver = sysver 1041 self.machine = machine 1042 1043 def version_system(self): 1044 """system type""" 1045 1046 version_system = self.system 1047 return version_system 1048 1049 def version_localhost(self): 1050 """Localhost name""" 1051 1052 version_localhost = self.localhost 1053 return version_localhost 1054 1055 def version_kernel(self): 1056 """Kernel version""" 1057 1058 version_kernel = self.kernel 1059 return version_kernel 1060 1061 def version_sysver(self): 1062 """system version""" 1063 1064 version_sysver = self.sysver 1065 return version_sysver 1066 1067 def version_machine(self): 1068 """System digits""" 1069 1070 version_machine = self.machine 1071 return version_machine 1072 1073 1074 class Process(object): 1075 """Process information""" 1076 1077 def __init__(self, user, name, pid, cpu, memory, status, threads): 1078 self.user = user 1079 self.name = name 1080 self.pid = pid 1081 self.cpu = cpu 1082 self.memory = memory 1083 self.status = status 1084 self.threads = threads 1085 1086 def process_user(self): 1087 process_user = os.popen( 1088 "getent passwd %s | awk -F':' '{print $1}'" % (self.user)) 1089 user = process_user.read() 1090 process_user = user 1091 1092 return process_user 1093 1094 def process_name(self): 1095 """process name""" 1096 1097 process_name = self.name 1098 return process_name 1099 1100 def process_pid(self): 1101 """process pid""" 1102 1103 process_pid = self.pid 1104 return process_pid 1105 1106 def process_cpu(self): 1107 """process cpu""" 1108 1109 process_cpu = self.cpu 1110 1111 return process_cpu 1112 1113 def process_memory(self): 1114 """process memory""" 1115 1116 process_memory = self.memory 1117 return process_memory 1118 1119 def process_status(self): 1120 """process status""" 1121 1122 process_status = self.status 1123 return process_status 1124 1125 def process_threads(self): 1126 """process threads""" 1127 1128 process_threads = self.threads 1129 return process_threads 1130 1131 1132 if __name__ == '__main__': 1133 que = queue.Queue() 1134 start = Run() 1135 os.system("echo -e \033[?25l") 1136 start.run()