Process Watcher

#You need the psutil library and PyQt4 installed!
from PyQt4 import QtGui,QtCore
import psutil,sys,datetime

class watcher(QtGui.QMainWindow):

    def __init__(self):
        super(watcher, self).__init__()
        self.initWatchMenu()
        self.initMain()

    def initMain(self):
        def initWidgets():
            self.watchedProc = None
            self.refreshBtn = QtGui.QPushButton('Refresh',self);self.refreshBtn.setGeometry(10,440,100,40);self.refreshBtn.clicked.connect(self.mainActions);self.refreshBtn.setToolTip('<html><head/><body><p><span style=" font-size:15pt; font-weight:600;">Look for new process</span></p></body></html>')
            self.DumpBtn = QtGui.QPushButton('Dump',self);self.DumpBtn.setEnabled(False);self.DumpBtn.setGeometry(130,440,100,40);self.DumpBtn.clicked.connect(self.dump);self.DumpBtn.setToolTip('<html><head/><body><p><span style=" font-size:15pt; font-weight:600;">Dump process informations in a text file.</span></p></body></html>')
            self.WatchBtn = QtGui.QPushButton('Watch',self);self.WatchBtn.setEnabled(False);self.WatchBtn.setGeometry(250,440,100,40);self.WatchBtn.clicked.connect(self.mainActions);self.WatchBtn.setToolTip('<html><head/><body><p><span style=" font-size:15pt; font-weight:600;">Start watching a process.</span></p></body></html>')
            self.processList = QtGui.QListWidget(self);self.processList.setGeometry(10,10,340,420);self.processList.setSortingEnabled(True);self.processList.itemPressed.connect(self.mainActions)

        try:
            style = open('QNovaDark.py','r')
            exec(style.read()) in globals(),locals()
        except:
            pass
        self.setFixedSize(360,490)
        self.setWindowTitle('Process Watcher - by dberube4')
        self.setWindowFlags(QtCore.Qt.CustomizeWindowHint|QtCore.Qt.WindowTitleHint|QtCore.Qt.WindowCloseButtonHint)
        initWidgets()
        self.show()
    def initWatchMenu(self):
        def initWidgets(self1):
            self.watchTimer =  QtCore.QTimer(self);self.watchTimer.setInterval(1000);self.watchTimer.timeout.connect(self.watchAction)
            self.basicTab = QtGui.QWidget(self1);self.advTab = QtGui.QWidget(self1);self.utilityTab = QtGui.QWidget(self1);self.adv2Tab = QtGui.QWidget(self1);self.netTab = QtGui.QWidget(self1)
            self.holder = QtGui.QTabWidget(self1);self.holder.setGeometry(10,5,480,230);self.holder.addTab(self.basicTab,'Basic');self.holder.addTab(self.advTab,'Advanced 1');self.holder.addTab(self.adv2Tab,'Advanced 2');self.holder.addTab(self.netTab,'Connections');self.holder.addTab(self.utilityTab,'Utility')
            #Basic
            label1 = QtGui.QLabel('PID: ',self.basicTab);label1.setGeometry(10,12,200,20);label2 = QtGui.QLabel('PPID: ',self.basicTab);label2.setGeometry(160,12,200,20)
            label3 = QtGui.QLabel('Parent: ',self.basicTab);label3.setGeometry(305,12,200,20);label4 = QtGui.QLabel('Path: ',self.basicTab);label4.setGeometry(10,47,200,20)
            label5 = QtGui.QLabel('Cmd: ',self.basicTab);label5.setGeometry(10,87,200,20);label6 = QtGui.QLabel('Creation: ',self.basicTab);label6.setGeometry(10,127,200,20)
            label7 = QtGui.QLabel('Owner: ',self.basicTab);label7.setGeometry(250,127,200,20);label8 = QtGui.QLabel('Status: ',self.basicTab);label8.setGeometry(10,167,200,20)
            label9 = QtGui.QLabel('Priority: ',self.basicTab);label9.setGeometry(250,167,200,20)
            self.pidBox = QtGui.QLineEdit(self.basicTab);self.pidBox.setGeometry(55,10,80,25);self.pidBox.setReadOnly(True);self.pidBox.setToolTip('The process PID')
            self.ppidBox = QtGui.QLineEdit(self.basicTab);self.ppidBox.setGeometry(220,10,80,25);self.ppidBox.setReadOnly(True);self.ppidBox.setToolTip('The process parent PID (if any)')
            self.parentBox = QtGui.QLineEdit(self.basicTab);self.parentBox.setGeometry(365,10,100,25);self.parentBox.setReadOnly(True);self.parentBox.setToolTip('The process parent name (if any)')
            self.pathBox = QtGui.QLineEdit(self.basicTab);self.pathBox.setGeometry(60,45,400,25);self.pathBox.setReadOnly(True);self.pathBox.setToolTip('The process executable as an absolute path name.')
            self.cmdBox = QtGui.QLineEdit(self.basicTab);self.cmdBox.setGeometry(60,85,400,25);self.cmdBox.setReadOnly(True);self.cmdBox.setToolTip('The command line process has been called with. ')
            self.creationBox = QtGui.QLineEdit(self.basicTab);self.creationBox.setGeometry(90,125,130,25);self.creationBox.setReadOnly(True);self.creationBox.setToolTip('The process creation date')
            self.ownerBox = QtGui.QLineEdit(self.basicTab);self.ownerBox.setGeometry(320,125,130,25);self.ownerBox.setReadOnly(True);self.ownerBox.setToolTip('Owner of the process.')
            self.statusBox = QtGui.QLineEdit(self.basicTab);self.statusBox.setGeometry(80,165,130,25);self.statusBox.setReadOnly(True);self.statusBox.setToolTip('Status of the process.')
            self.priorityBox = QtGui.QLineEdit(self.basicTab);self.priorityBox.setGeometry(320,165,130,25);self.priorityBox.setReadOnly(True);self.priorityBox.setToolTip('Priority of the process.')
            #Advanced 1
            label10 = QtGui.QLabel('CWD: ',self.advTab);label10.setGeometry(10,12,200,20);label11 = QtGui.QLabel('Read Count: ',self.advTab);label11.setGeometry(10,48,200,20)
            label12 = QtGui.QLabel('Byte Read: ',self.advTab);label12.setGeometry(250,48,200,20);label13 = QtGui.QLabel('Write Count: ',self.advTab);label13.setGeometry(10,88,200,20)
            label14 = QtGui.QLabel('Byte written: ',self.advTab);label14.setGeometry(250,88,200,20);label15 = QtGui.QLabel('Threads number: ',self.advTab);label15.setGeometry(10,128,200,20)
            self.cwdBox = QtGui.QLineEdit(self.advTab);self.cwdBox.setGeometry(65,10,390,25);self.cwdBox.setReadOnly(True);self.cwdBox.setToolTip('The process current working directory. ')
            self.readBox = QtGui.QLineEdit(self.advTab);self.readBox.setGeometry(120,45,120,25);self.readBox.setReadOnly(True);self.readBox.setToolTip("Amount of 'read' action called.")
            self.breadBox = QtGui.QLineEdit(self.advTab);self.breadBox.setGeometry(340,45,120,25);self.breadBox.setReadOnly(True);self.breadBox.setToolTip("Amount of byte read.")
            self.writeBox = QtGui.QLineEdit(self.advTab);self.writeBox.setGeometry(120,85,120,25);self.writeBox.setReadOnly(True);self.writeBox.setToolTip("Amount of 'write' action called.")
            self.bwriteBox = QtGui.QLineEdit(self.advTab);self.bwriteBox.setGeometry(350,85,120,25);self.bwriteBox.setReadOnly(True);self.bwriteBox.setToolTip("Amount of byte wrote.")
            self.threadNBox = QtGui.QLineEdit(self.advTab);self.threadNBox.setGeometry(150,125,120,25);self.threadNBox.setReadOnly(True);self.threadNBox.setToolTip("Number of threads of the process.")
            #Advanced 2
            label16 = QtGui.QLabel('Children',self.adv2Tab);label16.setGeometry(70,12,200,20);label17 = QtGui.QLabel('Files',self.adv2Tab);label17.setGeometry(340,12,200,20)
            self.threadList = QtGui.QListWidget(self.adv2Tab);self.threadList.setGeometry(10,40,200,150);self.threadList.setSortingEnabled(True);
            self.fileList = QtGui.QListWidget(self.adv2Tab);self.fileList.setGeometry(260,40,200,150);self.fileList.setSortingEnabled(True);
            self.refreshBtn2 = QtGui.QPushButton('Refresh',self.adv2Tab);self.refreshBtn2.setGeometry(200,5,70,30);self.refreshBtn2.setToolTip('Refresh data...');self.refreshBtn2.clicked.connect(self.watchAction)
            #Utility
            self.stopBtn = QtGui.QPushButton('Stop watching',self.utilityTab);self.stopBtn.setGeometry(10,10,210,40);self.stopBtn.setToolTip('Stop watching this process');self.stopBtn.clicked.connect(self.watchAction)
            self.killBtn = QtGui.QPushButton('Kill process',self.utilityTab);self.killBtn.setGeometry(260,10,210,40);self.killBtn.setToolTip('Close the process.');self.killBtn.clicked.connect(self.watchAction)
            self.suspendBtn = QtGui.QPushButton('Suspend process',self.utilityTab);self.suspendBtn.setGeometry(10,60,210,40);self.suspendBtn.setToolTip('Pause the process.');self.suspendBtn.clicked.connect(self.watchAction)
            self.resumeBtn = QtGui.QPushButton('Resume process',self.utilityTab);self.resumeBtn.setGeometry(260,60,210,40);self.resumeBtn.setToolTip('Resume the process.');self.resumeBtn.clicked.connect(self.watchAction)
            self.popBtn = QtGui.QPushButton('Monitor',self.utilityTab);self.popBtn.setGeometry(10,110,460,80);self.popBtn.setToolTip('Restart the process as a subprocess.\nMonitorized process have more information available.');self.popBtn.clicked.connect(self.watchAction)
            #Connections
            self.connList = QtGui.QListWidget(self.netTab);self.connList.setGeometry(10,10,450,90);self.connList.itemPressed.connect(self.watchAction)
            label18 = QtGui.QLabel('Family:',self.netTab);label18.setGeometry(10,112,200,20);label19= QtGui.QLabel('Type:',self.netTab);label19.setGeometry(10,152,200,20)
            label20= QtGui.QLabel('Status:',self.netTab);label20.setGeometry(230,112,200,20);
            self.sFamilyBox = QtGui.QLineEdit(self.netTab);self.sFamilyBox.setGeometry(80,112,120,25);self.sFamilyBox.setReadOnly(True);self.sFamilyBox.setToolTip("Family of the socket.(AF_INET or AF_INET6) ")
            self.sTypeBox = QtGui.QLineEdit(self.netTab);self.sTypeBox.setGeometry(80,152,120,25);self.sTypeBox.setReadOnly(True);self.sTypeBox.setToolTip("Type of the socket.(SOCK_STREAM or SOCK_DGRAM) ")
            self.sStatusBox = QtGui.QLineEdit(self.netTab);self.sStatusBox.setGeometry(310,112,120,25);self.sStatusBox.setReadOnly(True);self.sStatusBox.setToolTip("Status of the socket (UDP always return 'None')")
            self.refreshBtn3 = QtGui.QPushButton('Refresh',self.netTab);self.refreshBtn3.setGeometry(230,152,210,40);self.refreshBtn3.setToolTip('Refresh conections...');self.refreshBtn3.clicked.connect(self.watchAction)

        self.watchMenu = QtGui.QWidget()
        smallFont = QtGui.QFont('Arial',11,100)
        self.watchMenu.setWindowTitle('Watching - ')
        self.watchMenu.setFont(smallFont)
        self.watchMenu.setWindowFlags(QtCore.Qt.CustomizeWindowHint|QtCore.Qt.WindowMinimizeButtonHint)
        self.watchMenu.setFixedSize(500,250)
        initWidgets(self.watchMenu)

    def mainActions(self,*argv):
        sender = self.sender()
        if sender == self.refreshBtn:
            self.processList.clear()
            self.WatchBtn.setEnabled(False)
            for i in psutil.process_iter():
                if i.name != self.watchedProc:
                    item = QtGui.QListWidgetItem(i.name)
                    self.processList.addItem(item)
                    item.pid = i.pid
            if self.watchedProc != None:
                witem = QtGui.QListWidgetItem(self.watchedProc+'      <!Watching!>' );witem.setTextColor(QtGui.QColor(140,0,255,255))
                self.processList.addItem(witem)
                witem.pid = self.WatchedPid
        elif sender == self.processList:
            self.WatchBtn.setEnabled(True)
        elif sender == self.WatchBtn:
            if self.watchedProc == None:
                self.watchedProc = self.processList.item(self.processList.currentRow()).text()
                self.WatchedPid = self.processList.item(self.processList.currentRow()).pid
                itemz = self.processList.item(self.processList.currentRow())
                itemz.setTextColor(QtGui.QColor(140,0,255,255));itemz.setText(self.watchedProc + '      <!Watching!>')
                self.DumpBtn.setEnabled(True);self.watchMenu.setWindowTitle('Watching - '+self.watchedProc)
                reply = QtGui.QMessageBox.information(self, 'Info',"Start watching process...", QtGui.QMessageBox.Ok)
                self.watchMenu.show();self.watchTimer.start()
            else:
                reply = QtGui.QMessageBox.question(self, 'Warning',"A process is currently watched\nDo you want to stop watching it?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
                if reply ==  QtGui.QMessageBox.Yes:
                    self.watchedProc = self.processList.item(self.processList.currentRow()).text()
                    self.WatchedPid = self.processList.item(self.processList.currentRow()).pid
                    itemz = self.processList.item(self.processList.currentRow())
                    self.DumpBtn.setEnabled(True);self.watchMenu.setWindowTitle('Watching - '+self.watchedProc)
                    itemz.setTextColor(QtGui.QColor(140,0,255,255));itemz.setText(self.watchedProc + '      <!Watching!>')
                    reply = QtGui.QMessageBox.information(self, 'Info',"Start watching process...", QtGui.QMessageBox.Ok)
                    self.processList.clear();self.watchMenu.show();self.watchTimer.start()
                    for i in psutil.process_iter():
                        if i.name != self.watchedProc:
                            item = QtGui.QListWidgetItem(i.name)
                            self.processList.addItem(item)
                            item.pid = i.pid
                    if self.watchedProc != None:
                        witem = QtGui.QListWidgetItem(self.watchedProc+'      <!Watching!>' );witem.setTextColor(QtGui.QColor(140,0,255,255))
                        self.processList.addItem(witem)
                        witem.pid = self.WatchedPid
    def watchAction(self,*argv):
        sender = self.sender()
        if sender == self.watchTimer:
            try:
                proc=psutil.Process(self.WatchedPid)
                if str(proc.pid) != self.pidBox.text():
                    self.pidBox.setText(str(proc.pid))
                    self.ppidBox.setText(str(proc.ppid))

                    try:
                        self.ownerBox.setText(proc.username)
                    except:
                        self.ownerBox.setText('Access Denied')
                    try:
                        self.creationBox.setText(datetime.datetime.fromtimestamp(proc.create_time).strftime("%Y-%m-%d %H:%M"))
                    except:
                        self.creationBox.setText('Access Denied')
                    try:
                        self.parentBox.setText(str(psutil.Process(proc.ppid).name))
                    except :
                        self.parentBox.setText('None')
                    try:
                        self.pathBox.setText(proc.exe)
                    except:
                        self.pathBox.setText('Access Denied')
                    try:
                        self.cmdBox.setText(str(proc.cmdline))
                    except:
                        self.cmdBox.setText('Access Denied')
                    try:
                        self.cwdBox.setText(proc.getcwd())
                    except:
                        self.cwdBox.setText('Access Denied')
                    try:
                        self.threadNBox.setText(str(proc.get_num_threads()))
                    except:
                        self.threadNBox.setText('Access Denied')
                try:
                    self.readBox.setText(str(proc.get_io_counters().read_count))
                    self.breadBox.setText(str(proc.get_io_counters().read_bytes))
                    self.writeBox.setText(str(proc.get_io_counters().write_count))
                    self.bwriteBox.setText(str(proc.get_io_counters().write_bytes))
                except:
                    self.readBox.setText('Access Denied')
                    self.breadBox.setText('Access Denied')
                    self.writeBox.setText('Access Denied')
                    self.bwriteBox.setText('Access Denied')

                self.statusBox.setText(str(proc.status))
                try:
                    self.priorityBox.setText(str(proc.nice))
                except:
                    self.priorityBox.setText('Access Denied')

            except:
                self.watchTimer.stop()
                self.watchMenu.hide()
                reply = QtGui.QMessageBox.critical(self, 'Error',"Process not found! Stopping watching.", QtGui.QMessageBox.Ok)
        elif sender == self.refreshBtn2:
            proc=psutil.Process(self.WatchedPid)
            self.threadList.clear()
            self.fileList.clear()
            try:
                for i in proc.get_children():
                    item = QtGui.QListWidgetItem(i.name+':'+str(i.pid))
                    self.threadList.addItem(item)
            except:
                    self.threadList.addItem('Access Denied')
            try:
                for i in proc.get_open_files():
                    item = QtGui.QListWidgetItem(i.path)
                    self.fileList.addItem(item)
            except:
                    self.fileList.addItem('Access Denied')
        elif sender == self.stopBtn:
            reply = QtGui.QMessageBox.information(self.watchMenu, 'Info',"Stopped watching {0}".format(self.watchedProc), QtGui.QMessageBox.Ok)
            self.watchTimer.stop()
            self.watchedProc = None
            self.WatchedPid = None
            self.watchMenu.hide()
            self.processList.clear()
            self.WatchBtn.setEnabled(False)
            self.DumpBtn.setEnabled(False)
            for i in psutil.process_iter():
                if i.name != self.watchedProc:
                    item = QtGui.QListWidgetItem(i.name)
                    self.processList.addItem(item)
                    item.pid = i.pid
        elif sender == self.killBtn:
            reply = QtGui.QMessageBox.question(self.watchMenu, 'Info',"Do you want to stop this program?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
            try:
                if reply == QtGui.QMessageBox.Yes:
                    proc=psutil.Process(self.WatchedPid)
                    self.watchTimer.stop()
                    proc.kill()
                    self.watchedProc = None
                    self.WatchedPid = None
                    self.watchMenu.hide()
                    self.processList.clear()
                    self.WatchBtn.setEnabled(False)
                    self.DumpBtn.setEnabled(False)
                    for i in psutil.process_iter():
                        if i.name != self.watchedProc:
                            item = QtGui.QListWidgetItem(i.name)
                            self.processList.addItem(item)
                            item.pid = i.pid
            except:
                reply = QtGui.QMessageBox.critical(self.watchMenu, 'Error',"Could not kill process\nReason: Access Denied", QtGui.QMessageBox.Ok)
        elif sender == self.suspendBtn:
            reply = QtGui.QMessageBox.question(self.watchMenu, 'Info',"Do you want to suspend this program?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                try:
                    proc=psutil.Process(self.WatchedPid)
                    proc.suspend()
                except:
                    reply = QtGui.QMessageBox.critical(self.watchMenu, 'Error',"Could not suspend process\nReason: Access Denied", QtGui.QMessageBox.Ok)
        elif sender == self.resumeBtn:
            reply = QtGui.QMessageBox.question(self.watchMenu, 'Info',"Do you want to resume this program?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                try:
                    proc=psutil.Process(self.WatchedPid)
                    proc.resume()
                except:
                    reply = QtGui.QMessageBox.critical(self.watchMenu, 'Error',"Could not resume process\nReason: Not suspended", QtGui.QMessageBox.Ok)
        elif sender == self.popBtn:
            reply = QtGui.QMessageBox.question(self.watchMenu, 'Info',"Do you want to monitor this process?This will restart it.", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                proc=psutil.Process(self.WatchedPid)
                try:
                    dire = proc.exe
                    proc.kill()
                    proc = psutil.Popen(dire)
                    self.watchedProc = proc.name
                    self.WatchedPid = proc.pid
                except:
                    reply = QtGui.QMessageBox.critical(self.watchMenu, 'Error',"Could not monitor process\nReason: Access Denied.", QtGui.QMessageBox.Ok)
        elif sender == self.refreshBtn3:
            try:
                proc=psutil.Process(self.WatchedPid)
                self.connList.clear()
                for i in proc.get_connections('inet'):
                    item = QtGui.QListWidgetItem(i.local_address[0]+':'+str(i.local_address[1])+ ' to '+ i.remote_address[0]+':'+str(i.remote_address[1]))
                    item.data = i
                    self.connList.addItem(item)
            except:
                self.connList.addItem('Access Denied')
        elif sender == self.connList:
            watchedConn = self.connList.item(self.connList.currentRow()).data
            self.sFamilyBox.setText(str(watchedConn.family))
            self.sStatusBox.setText(str(watchedConn.status))
            self.sTypeBox.setText(str(watchedConn.type))
    def dump(self):
        dump = QtGui.QFileDialog.getSaveFileName(filter = '*.txt')
        dump = open(dump,'w')
        proc = psutil.Process(self.WatchedPid)
        dump.write('======================INFO======================\n')
        dump.write('Process ID: '+self.pidBox.text()+'\n')
        dump.write('Parent Process ID: '+self.ppidBox.text()+'\n')
        dump.write('Parent Process: '+self.parentBox.text()+'\n')
        dump.write('Exe path: '+self.pathBox.text()+'\n')
        dump.write('Start Command Line : '+self.cmdBox.text()+'\n')
        dump.write('Owner : '+self.ownerBox.text()+'\n')
        dump.write('Creation Date : '+self.creationBox.text()+'\n')
        dump.write('Status : '+self.statusBox.text()+'\n')
        dump.write('Process priority : '+self.priorityBox.text()+'\n')
        dump.write('Current working directory : '+self.cwdBox.text()+'\n')
        try:
            for i in proc.get_children():
                dump.write('    '+str(i)+'\n')
        except AssertionError:
            dump.write('    Access Denied\n')
        dump.write('======================IO======================\n')
        dump.write('Read action : '+self.readBox.text()+'\n')
        dump.write('Read byte : '+self.breadBox.text()+'\n')
        dump.write('Write action : '+self.writeBox.text()+'\n')
        dump.write('Byte wrote : '+self.bwriteBox.text()+'\n')
        dump.write('Files handled : \n')
        try:
            for i in proc.get_open_files():
                dump.write('    '+str(i)+'\n')
        except AttributeError:
                dump.write('    Access Denied\n')
        dump.write('======================Connections======================\n')
        dump.write('Connections : \n')
        try:
            for i in proc.get_connections('inet'):
                dump.write('    '+str(i)+'\n')
        except ArithmeticError:
                dump.write('    Access Denied\n')
        reply = QtGui.QMessageBox.information(self, 'Info',"Process dump created succesfully", QtGui.QMessageBox.Ok)
    def closeEvent(self,event):
        self.watchMenu.hide()

if __name__ == '__main__':
    global app
    appFont = QtGui.QFont('Arial',14,10)
    app = QtGui.QApplication(sys.argv);app.setFont(appFont);
    watcher = watcher()
    sys.exit(app.exec_())