Arubertoson
Arubertoson

Reputation: 38

Tracking application launched with a python file

I've encountered a situation where I thought it would be a good idea to create a launcher for an application which I tend to run several instances of. This is to ensure that I and the application get access to the wanted environment variables that can be provided and set for each instance.

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()

I want to be able to track the applications, do I dump the pids in a file and remove them when the process closes? Do I launch a service that I communicate with?

Being fairly new to programming in general I don't know if I'm missing a term in the lingo or just thinking wrong. But I was reading up on Daemons and services to track the applications and couldn't come up with a proper answer. Put simply, a bit lost how to approach it.

Upvotes: 0

Views: 854

Answers (2)

TPDMarchHare
TPDMarchHare

Reputation: 135

Here's a code sample to help illustrate how it might work for you.

Note that you can capture the stdout from the processes in real time in your host script; this might be useful if the program you're running uses the console.

(As a side note on the example: You probably would want to change the IP addresses: these are from my internal network. Be kind to any external sites you might want to use, please. Launching thousands of processes with the same target might be construed as a hostile gesture.)

(An additional side note on this example: It is conceivable that I will lose some of my time samples when evaluating the output pipe...if the subprocess writes it to the console piecemeal, it is conceivable that I might occasionally catch it exactly as it is partway done - meaning I might get half of the "time=xxms" statement, causing the RE to miss it. I've done a poor job of checking for this possibility (i.e. I couldn't be bothered for the example). This is one of the hazards of multiprocess/multithreaded programming that you'll need to be aware of if you do it much.)

# 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()

Upvotes: 0

Tom Dalton
Tom Dalton

Reputation: 6190

What you're doing already seems reasonable. I'd probably extend it to something like this:

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()

Upvotes: 1

Related Questions