Aplikacja śledzenia uruchomiony z pliku Pythona

głosy
0

Napotkałem sytuacji, gdy myślałem, że będzie to dobry pomysł, aby stworzyć wyrzutnię dla aplikacji które mają tendencję do uruchomienia kilku instancji. Ma to zapewnić, że ja i aplikacja uzyskać dostęp do poszukiwanych zmiennych środowiskowych, które mogą być przewidziane i ustalonych dla każdej instancji.

import os
import subprocess


def launch():
    
    Launches application.
    
    # create environment
    os.environ['APPLICATION_ENVIRON'] = 'usr/path'

    # launch application
    application_path = 'path/to/application'
    app = subprocess.Popen([application_path])
    pid = app.pid
    app.wait()

    print 'done with process: {}'.format(pid)


if __name__ == '__main__':
    launch()

Chcę, aby móc śledzić aplikacji, mogę zrzucić PID w pliku i usunąć je, gdy zamyka proces? Mogę uruchomić usługę, że komunikacja?

Będąc dość nowy w programowaniu w ogóle nie wiem, czy jestem brakuje termin w slangu lub po prostu myślenie błędne. Ale byłem czytania na demonów i usług do śledzenia aplikacji i nie mógł wymyślić właściwą odpowiedź. Mówiąc prościej, nieco zagubiony, jak go podejść.

Utwórz 24/01/2016 o 12:22
źródło użytkownik
W innych językach...                            


2 odpowiedzi

głosy
0

Oto przykładowy kod, aby pomóc zilustrować jak to może pracować dla Ciebie.

Należy pamiętać, że można uchwycić stdout z procesów w czasie rzeczywistym w skrypcie przyjmującego; Może to być przydatne, jeśli program używasz korzysta z konsoli.

(Na marginesie na przykład: Prawdopodobnie będzie chciał zmienić adresy IP: są to z mojej sieci wewnętrznej Bądź miły dla wszelkich zewnętrznych stron może chcesz użyć, proszę Uruchomienie tysiące procesów o tym samym celu może być.. interpretowana jako gest wrogim).

(Dodatkowa uwaga strona na tym przykładzie: Możliwe jest, że stracę niektórych moich próbek czasowych przy ocenie rurę wyjściową ... jeśli podproces zapisuje je do konsoli fragmentaryczny, nie jest wykluczone, że może od czasu do czasu złapać go dokładnie tak, jak jest partway zrobić. - co oznacza, że ​​mogę dostać połowie „czas = xxms” oświadczenie, powodując RE tego przegapić zrobiłem złą robotę sprawdzanie tej możliwości (czyli nie może być jedno, na przykład) . jest to jedno z zagrożeń związanych z programowaniem wielowątkowym / wieloprocesowego które trzeba mieć świadomość, jeśli robisz to dużo).

# Subprocessor.py
#
# Launch a console application repeatedly and test its state.
#

import subprocess
import re


NUMBER_OF_PROCESSES_TO_OPEN = 3
DELAY_BETWEEN_CHECKS = 5
CMD = "ping"
ARGS = ([CMD, "-n", "8", "192.168.0.60"], [CMD, "-n", "12", "192.168.0.20"], [CMD, "-n", "4", "192.168.0.21"])

def go():
    processes = {}
    stopped = [False, False, False]

    samples = [0]*NUMBER_OF_PROCESSES_TO_OPEN
    times = [0.0]*NUMBER_OF_PROCESSES_TO_OPEN

    print "Opening processes..."
    for i in range(NUMBER_OF_PROCESSES_TO_OPEN):

        # The next line creates a subprocess, this is a non-blocking call so
        # the program will complete it more or less instantly.

        newprocess = subprocess.Popen(args = ARGS[i], stdout = subprocess.PIPE)
        processes[i] = newprocess
        print "    process {} open, pid == {}.".format(i, processes[i].pid)

    # Build a regular expression to work with the stdout.
    gettimere = re.compile("time=([0-9]*)ms")

    while len(processes) > 0:
        for i, p in processes.iteritems():

            # Popen.poll() asks the process if it is still running - it is
            # a non-blocking call that completes instantly.
            isrunning = (p.poll() == None)

            data = p.stdout.readline()  # Get the stdout from the process.
            matchobj = gettimere.search(data)
            if matchobj:
                for time in matchobj.groups():
                    samples[i] += 1
                    times[i] = (times[i] * (samples[i] - 1) + int(time)) / samples[i]

            # If the process was stopped before we read the last of the
            # data from its output pipe, flag it so we don't keep messing
            # with it.
            if not isrunning:
                stopped[i] = True
                print "Process {} stopped, pid == {}, average time == {}".format(i, processes[i].pid, times[i])

        # This code segment deletes the stopped processes from the dict
        # so we don't keep checking them (and know when to stop the main
        # program loop).
        for i in range(len(stopped)):
            if stopped[i] and processes.has_key(i):
                del processes[i]


if __name__ == '__main__':
    go()
Odpowiedział 24/01/2016 o 13:28
źródło użytkownik

głosy
1

Co jesteś już robi wydaje się rozsądne. I prawdopodobnie rozszerzenie go na coś takiego:

import os
import subprocess


def launch_app():
    os.environ['APPLICATION_ENVIRON'] = 'usr/path'
    application_path = 'path/to/application'
    return subprocess.Popen([application_path])


def _purge_finished_apps(apps):
    still_running = set()
    for app in apps:
        return_code = app.poll()
        if return_code is not None:
            print "  PID {} no longer running (return code {})".format(app.pid, return_code)
        else:
            still_running.add(app)
    return still_running


def ui():
    apps = set()

    while True:
        print
        print "1. To launch new instance"
        print "2. To view all instances"
        print "3. To exit, terminating all running instances"
        print "4. To exit, leaving instances running"
        opt = int(raw_input())

        apps = _purge_finished_apps(apps)

        if opt == 1:
            app = launch_app()
            apps.add(app)
            print "  PID {} launched".format(app.pid)

        elif opt == 2:
            if not apps:
                print "There are no instances running"
            for app in apps:
                print "  PID {} running".format(app.pid)

        elif opt == 3:
            for app in apps:
                print "Terminating PID {}".format(app.pid)
                app.terminate()
            for app in apps:
                app.wait()
                print "PID {} finished".format(app.pid)
            return

        elif opt == 4:
            return


if __name__ == "__main__":
    ui()
Odpowiedział 24/01/2016 o 13:48
źródło użytkownik

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more