Source

PyShutdownBox / PyShutdownBox.py

Full commit
#!/usr/bin/env python2

import os
import ConfigParser
import time

import psutil
import dbus
import pygtk
import gtk

pygtk.require("2.0")

class ProcessManager(object):
    def __init__(self):
        self.process_gen = psutil.process_iter()
    
    def pkill(self, pname, ksignal=9):
        for i in self.process_gen:
            if pname == i.name:
                i.kill(ksignal)
                while i.is_running():
                    time.sleep(1)

class DbusConsoleKitManager(object):
    def __init__(self):
        bus = dbus.SystemBus()
        manager = bus.get_object('org.freedesktop.ConsoleKit', '/org/freedesktop/ConsoleKit/Manager')
        self.manager_interface = dbus.Interface(manager, dbus_interface='org.freedesktop.ConsoleKit.Manager')

    def Restart(self):
        self.manager_interface.Restart()

    def Stop(self):
        self.manager_interface.Stop()

class PyShutdownBox(object):
    def __init__(self):
        # create or read from our config file
        self.rc_shutdown = 'None'
        self.plist = 'None'

        config_dir = os.path.join(os.getenv('XDG_CONFIG_HOME'), 'PyShutdownBox')
        config_file = os.path.join(config_dir, 'PyShutdownBoxrc')

        # define sections name
        command_run = 'Command to run before shutdown'
        process_list = 'List of process to close before shutdown, separated by comma'
        logout_command = 'Command used to logout'

        config = ConfigParser.RawConfigParser()

        if os.path.isfile(config_file):
            config.read(config_file)

            self.rc_shutdown = config.get(command_run, 'command')
            self.plist = config.get(process_list, 'process_list')
            self.logout_cmd = config.get(logout_command, 'logout_command')

        else:
            if not os.path.isdir(config_dir):
                os.mkdir(config_dir)

            config.add_section(command_run)
            config.set(command_run, 'command', 'None')

            config.add_section(process_list)
            config.set(process_list, 'process_list', 'None')

            config.add_section(logout_command)
            config.set(process_list, 'logout_command', 'None')

            with open(config_file, 'wb') as configfile:
                config.write(configfile)

        # create and connect to our UI
        builder = gtk.Builder()
        builder.add_from_file("PyShutdownBox.glade")
        builder.connect_signals(
            {
                #"on_exit_button_clicked" : gtk.main_quit,
                "on_exit_button_clicked" : self.exit,
                "on_logout_button_clicked" : self.logout,
                "on_restart_button_clicked" : self.restart,
                "on_shutdown_button_clicked" : self.shutdown
            }
        )

        self.window = builder.get_object("MainWindow")
        self.window.stick()
        self.window.set_keep_above(True)
        #self.window.show()

        self.pwm = DbusConsoleKitManager()

    def CloseProcesses(self, process_list):
        plist = process_list.split(',')
        
        for i in plist:
            j = i.split(':')

            pman = ProcessManager()

            if len(j) > 1:
                print 'killing: {0} using {1} signal'.format(j[0].strip(), j[1].strip())
                pman.pkill(j[0].strip(), int(j[1].strip()))
                print 'done!'

            else:
                print 'killing: {0}'.format(j[0].strip())
                pman.pkill(j[0].strip())
                print 'done!'

    def logout(self, widget):
        if not self.rc_shutdown == 'None':
            os.system(self.rc_shutdown)
        self.CloseProcesses(self.plist)

        os.system(self.logout_cmd)

    def restart(self, widget):
        if not self.rc_shutdown == 'None':
            os.system(self.rc_shutdown)
        self.CloseProcesses(self.plist)

        self.pwm.Restart()

    def shutdown(self, widget):
        if not self.rc_shutdown == 'None':
            os.system(self.rc_shutdown)
        self.CloseProcesses(self.plist)

        self.pwm.Stop()

    def exit(self, widget):
        gtk.main_quit()
        print 'Command to run: {0}'.format(self.rc_shutdown)
        print 'List of process to close: {0}'.format(self.plist)

if __name__ == "__main__":
    app = PyShutdownBox()
    app.window.show()

    gtk.main()