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