Kontrollfunktion für Programm-Start und -Ende

gui_break.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

### Import Module
from Tkinter import *
import tkMessageBox
from prog_control import end

# Programmparameter
from prog_param import BREAKTITEL, BREAKINFO


def info_func():
    root = Tk()
    InfoFenster = tkMessageBox.showinfo(BREAKTITEL, BREAKINFO)
    if InfoFenster == 'ok':
        sys.exit(1)
    root.destroy()

if __name__ == "__main__":
    info_func()

gui_start.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

### Import Module
from Tkinter import *
import tkMessageBox, os, time, subprocess
from prog_control import start, end

# Programmparameter
from prog_param import PATH, FENSTERZEIT, GUITITEL, GUISTARTINFO, GUIBREAK


### Programm
def info_func():
    root = Tk()
    DialogFenster = tkMessageBox.askquestion(GUITITEL, GUISTARTINFO)
    if DialogFenster == 'yes':
        start()
        sys.exit(1)
    elif DialogFenster == 'no':
        subprocess.Popen(['python', '{}/{}'.format(PATH, GUIBREAK)],)

        time.sleep(int(FENSTERZEIT))
        end()
    root.destroy()

if __name__ == "__main__":
   info_func()

prog_control.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

### Import Module
from Tkinter import *
import tkMessageBox, subprocess, psutil, sys, os, time

# Programmparameter
from prog_param import PATH, PROGRAMM, PROGRAMMTITEL, AUTOZEIT, STARTCONTROL, GUISTART, GUIBREAK


'''
Kontrollfunktion für das Starten und Beenden von Programmen,
sowie das vermeiden von Doppelstarts von Programmen.
Es werden grafische Fenster, für den Ablauf verwendet.

Funktionsübersicht:
- Kontrolle der aktuellen PIDś
  mit Zeitstempel des jeweiligen Programmstarts.
- Automatischer Programmstart nach vorgegebener Zeit in Sekunden.

Programmparameter sind in prog_param.py hinterlegt
und können von dort aus aufgerufen werden.
'''


# Programm
counter = 0
pid = set()
def prog(progname):
    global counter
    for prog in psutil.process_iter():
        if progname[:15] in prog.name or progname in prog.cmdline:
            counter += 1
            pidtime = psutil.Process(prog.pid).create_time
            pidwert = (pidtime, prog.pid)
            pid.add(pidwert)


def prog_kill(progname):
    for prog in psutil.process_iter():
        if progname[:15] in prog.name or progname in prog.cmdline:
            psutil.Process(prog.pid).terminate()


def start():
    prog_kill(GUISTART)
    prog_kill(STARTCONTROL)
    sys.exit(1)


def end():
    prog_kill(PROGRAMM)
    prog_kill(GUIBREAK)
    prog_kill(GUISTART)
    prog_kill(STARTCONTROL)
    sys.exit(1)


def check():
    if counter > 1:
        for i in pid:
            exist_pid = i[1]
            break

        for i in pid:
            if i != exist_pid:
                kill_pid = i[1]

        info = '''Programm %s
läuft schon mit PID %s!

Möchten Sie dieses Programm beenden?''' % (PROGRAMMTITEL, exist_pid)
        root = Tk()
        DialogFenster = tkMessageBox.askquestion(PROGRAMMTITEL, info)
        root.destroy()

        if DialogFenster == 'yes':
            psutil.Process(int(exist_pid)).terminate()
            psutil.Process(int(kill_pid)).terminate()
            sys.exit(1)
        elif DialogFenster == 'no':
            psutil.Process(int(kill_pid)).terminate()
            sys.exit(1)


def gui_start():
    subprocess.Popen(['python', '{}/{}'.format(PATH, GUISTART)],)

    time.sleep(int(AUTOZEIT))
    prog_kill(GUISTART)
    prog_kill(GUIBREAK)
    prog_kill(STARTCONTROL)
    sys.exit(1)


def prog_start():
    prog(PROGRAMM)
    check()
    gui_start()

if __name__ == "__main__":
    prog_start()

prog_param.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

### Import Module
import sys, os


'''
Zentrale Parameter für Module.

Folgender Eintrag in den Modulen hinzu fügen:

from prog_param import PATH, ORDNER, PROGRAMM, PROGRAMMTITEL, AUTOZEIT, FENSTERZEIT, STARTCONTROL, GUISTART, GUITITEL, GUISTARTINFO, GUIBREAK, BREAKTITEL, BREAKINFO, EXISTINFO

Die nicht benötigten Parameter sind aus der Importliste zu löschen.
ODER

from prog_param import *

Die Importnamen sind gleichfalls die Parameternamen.

Programmspezifische Änderung der Parameter
:param ORDNER: string, Ordnernamen
:param PROGRAMM: string, Programmnamen
:param PROGRAMMTITEL: string, Programmtitel
:param ZEITSPANNE: int, Angabe in Sekunden

Parameter ohne Änderung
:param PATH: string, Installationspfad
:param STARTCONTROL: string, Modulnamen der Kontrollfunktion
:param GUISTART: string, Modulnamen des Dialog-Fensters bei Start
:param GUITITEL: string, Titelnamen des Dialog-Fensters bei Start
:param GUISTARTINFO: string, Info des Dialog-Fensters bei Start
:param GUIBREAK: string, Modulnamen des Info-Fensters bei Abbruch
:param BREAKTITEL: string, Titelnamen des Info-Fensters bei Abbruch
:param BREAKINFO: string, Info des Info-Fensters bei Abbruch
'''


# Programmparameter
# Programmpfad, bei Links wird der Originalpfad verwendet
PATH = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0])))

# Programmspezifische Änderung der Parameter
ORDNER = 'lieferantenbestellung'
PROGRAMM = 'lbestellorder.py'
PROGRAMMTITEL = 'Lieferanten-Bestellungen'

# Zeitspanne in Sekunden, bis automatischer Start
AUTOZEIT = 8

# Zeitspanne in Sekunden für automatisches Schließen des Fensters
FENSTERZEIT = 2

# Parameter ohne Änderung
STARTCONTROL = 'prog_control.py'
GUISTART = 'gui_start.py'
GUITITEL = 'Programmstart'
GUIBREAK = 'gui_break.py'
BREAKTITEL = 'Programmabbruch'

GUISTARTINFO = '''Programm für %s
wird gestartet!''' % PROGRAMMTITEL

BREAKINFO = '''Der Programmstart für
%s
wurde abgebrochen!''' % PROGRAMMTITEL

startcontrol()

### Programm-Start und -Kontrolle ###
def startcontrol():
    '''
    Einstiegsfunktion beim Programmstart.
    Es startet das Modul prog_control, das als Kontrollfunktion
    für das Starten und Beenden des Programms dient.
    '''

    start = 'prog_control.py'

    path = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0])))
    subprocess.Popen(['python', '{}/{}'.format(path, start)],)
startcontrol()