Python Demone Imballaggio Migliori Pratiche

StackOverflow https://stackoverflow.com/questions/588749

Domanda

Ho uno strumento che mi hanno scritto in python e in genere deve essere eseguito come un demone.Quali sono le migliori pratiche per il confezionamento di questo strumento per la distribuzione, in particolare su come dovrebbe impostazioni di file e il demone eseguibile/script essere gestito?

A tale riguardo ci sono strumenti comuni per la configurazione del demone in esecuzione all'avvio, come appropriato per una determinata piattaforma (es. init script su linux, servizi di windows, launchd su os x)?

È stato utile?

Soluzione

Per rispondere a una parte della tua domanda, non ci sono strumenti che conosco che farà configurazione demone portabile anche su sistemi Linux consentono di Windows da soli o Mac OS X.

maggior parte delle distribuzioni sembrano utilizzare start-stop-daemon all'interno di script di init ora, ma si sta ancora andando ad avere piccola differenza nella struttura del filesystem e grandi differenze nella confezione. Utilizzando autotools / configurare o distutils / easy_install se il progetto è tutto Python, andrà un lungo cammino per rendere più facile costruire i pacchetti per diverse distribuzioni Linux / BSD.

Windows è un intero gioco diverso e richiederà estensioni win32 di Mark Hammond e forse di Tim Golden WMI estensioni.

Non so launchd, tranne che "nessuna delle precedenti" sono rilevanti.

Per suggerimenti su daemonizing script Python, vorrei guardare alle applicazioni Python che sono effettivamente farlo nel mondo reale, ad esempio all'interno di ritorto.

Altri suggerimenti

Lo strumento migliore che ho trovato per aiutare con gli script init.d è "start-stop-daemon". Verrà eseguito qualsiasi applicazione, eseguire il monitor / file PID, crearli, se necessario, fornire modi per fermare il demone, ID di processo impostare utente / gruppo, e può persino sfondo il processo.

Ad esempio, questo è uno script in grado di avviare / arrestare un server WSGI: 

#! /bin/bash

case "$1" in
  start)
    echo "Starting server"

    # Activate the virtual environment
    . /home/ali/wer-gcms/g-env/bin/activate

    # Run start-stop-daemon, the $DAEMON variable contains the path to the
    # application to run
    start-stop-daemon --start --pidfile $WSGI_PIDFILE \
        --user www-data --group www-data \
        --chuid www-data \
        --exec "$DAEMON"
    ;;
  stop)
    echo "Stopping WSGI Application"

    # Start-stop daemon can also stop the application by sending sig 15
    # (configurable) to the process id contained in the run/pid file
    start-stop-daemon --stop --pidfile $WSGI_PIDFILE --verbose
    ;;
  *)
    # Refuse to do other stuff
    echo "Usage: /etc/init.d/wsgi-application.sh {start|stop}"
    exit 1
    ;;
esac

exit 0

È anche possibile vedere ci un esempio di come usarlo con un virtualenv, che io raccomando sempre.

Ci sono molti frammenti sull'offerta internet per scrivere un demone in puro python (nessuno script bash)

http://www.jejik.com/articles/2007/02/a_simple_unix_linux_daemon_in_python / sembra pulito ...

Se si vuole scrivere il proprio,
il principio è lo stesso con la funzione bash daemon.

In sostanza:

On inizio:

  • si forchetta per un altro processo
  • aprire un file di log per reindirizzare la tua stdout e stderr
  • Salvare il pid da qualche parte.

On stop:

  • Si invia SIGTERM al processo con pid memorizzata nel pidfile.
  • Con signal.signal (signal.SIGTERM, sigtermhandler) è possibile associare un arresto procedura per il segnale SIGTERM.

Non conosco alcun pacchetto ampiamente utilizzato fare questo però.

Controllare il modulo demone del Ben Finney. Ha iniziato a scrivere un pitone 3.X PEP targeting:

http://www.python.org/dev/peps/pep-3143 /

Ma un'implementazione è già disponibile qui:

http://pypi.python.org/pypi/python-daemon/

Non una pallottola d'argento per quello che stai chiedendo, ma guarda che supervisord . Gestisce tutti i bit divertenti dei processi di gestione. Io lo uso molto in un grande ambiente di produzione. Inoltre, è scritto in Python!

Non mi ricordo dove ho scaricato ... ma questo è il migliore sceneggiatura daemonizing che ho trovato. Esso funziona in modo bello (su Mac e Linux.) (Salvarlo come daemonize.py) 

import sys, os
def daemonize (stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
    # Perform first fork.
    try:
        pid = os.fork( )
        if pid > 0:
            sys.exit(0) # Exit first parent.
    except OSError, e:
        sys.stderr.write("fork #1 failed: (%d) %sn" % (e.errno, e.strerror))
        sys.exit(1)
    # Decouple from parent environment.
    os.chdir("/")
    os.umask(0)
    os.setsid( )
    # Perform second fork.
    try:
        pid = os.fork( )
        if pid > 0:
            sys.exit(0) # Exit second parent.
    except OSError, e:
        sys.stderr.write("fork #2 failed: (%d) %sn" % (e.errno, e.strerror))
        sys.exit(1)
    # The process is now daemonized, redirect standard file descriptors.
    for f in sys.stdout, sys.stderr: f.flush( )
    si = file(stdin, 'r')
    so = file(stdout, 'a+')
    se = file(stderr, 'a+', 0)
    os.dup2(si.fileno( ), sys.stdin.fileno( ))
    os.dup2(so.fileno( ), sys.stdout.fileno( ))
    os.dup2(se.fileno( ), sys.stderr.fileno( ))

Nello script, si sarebbe semplicemente: 

from daemonize import daemonize
daemonize()

E si può anche specificare i luoghi di reindirizzare lo stdio, err, ecc ...

Su sistemi Linux, il responsabile del sistema dei pacchetti (Portage per Gentoo, Attitudine per Ubuntu / Debian, yum per Fedora, ecc), di solito si prende cura di installare il programma compresa l'immissione script di init nei posti giusti. Se si vuole distribuire il programma per Linux, si potrebbe voler guardare in bundling in su nel formato corretto per gestori di pacchetti varie distribuzioni.

Questo consiglio è ovviamente irrilevante su sistemi che non hanno gestori di pacchetti (Windows, Mac e credo).

Questo blog messo in chiaro per me che ci sono in realtà due modi comuni per avere il vostro programma in Python eseguito come demone (non avevo capito che così chiaramente dalle esistenti risposte):

Ci sono due approcci alla scrittura di demone applicazioni come server in Python.

  • Il primo è quello di di gestire tutte le attività di che comincia e l'arresto di demoni il codice Python stesso.Il modo più semplice per fare questo è con il python-daemon pacchetto che potrebbe finalmente fare la sua strada nella distribuzione di Python.

Poeljapon risposta è un esempio di questo 1 ° approccio, anche se non uso il python-daemon pacchetto, ma i collegamenti per una custom, ma molto pulito script python.

  • L'altro approccio è quello di utilizzare gli strumenti fornito dal sistema operativo.In caso di Debain, questo significa la scrittura di uno script di init, che fa uso di start-stop-daemon programma.

Ali Afshar risposta è un esempio di script di shell del 2 ° approccio, utilizzando il start-stop-daemon.

Il blog che ho citato è un esempio di script di shell, e alcuni dettagli aggiuntivi su cose come l'avvio il demone all'avvio del sistema e riavviare il demone automaticamente quando si è fermato per un qualsiasi motivo.

mi corregga se sbaglio, ma credo che la questione è come distribuire il demone. Impostare la vostra applicazione da installare tramite pip e poi fare l'entry_point un cli(daemon()). Quindi creare un init script che viene eseguito semplicemente $app_name &

"generalmente dovrebbe essere eseguito come un demone?"

non - sulla superficie - fare un sacco di senso. "In generale" non è sensato. E 'sia un un demone o no. Si potrebbe desiderare di aggiornare la tua domanda.

Per esempi di demoni, leggere su demoni come httpd del Apache o qualsiasi server di database (sono demoni) o il demone smtpd di posta.

O, forse, leggere su qualcosa di più semplice, come il demone FTP, demone SSH, Telnet daemon.

Nel mondo Linux, avrete il vostro directory di installazione dell'applicazione, alcune directory di lavoro, più le directory del file di configurazione.

Usiamo /opt/ourapp per l'applicazione (è Python, ma noi non installare in lib/site-packages di Python)

Usiamo /var/ourapp per i file di lavoro ed i nostri file di configurazione.

Potremmo usare /etc/ourapp per i file di configurazione - sarebbe coerente -. Ma noi no

Noi non - ancora - utilizzare gli script init.d per l'avvio. Ma questo è il pezzo finale, l'avvio automatico. Per adesso, abbiamo amministratori di sistema avviare i demoni.

Questo si basa, in parte, su http://www.pathname.com/fhs/ e http://tldp.org/LDP/ Linux-Filesystem Hierarchy-/ html / Linux-Filesystem-Hierarchy.html .

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top