Come si crea un demone in Python?

La ricerca su Google rivela frammenti di codice x2. Il primo risultato è questa ricetta di codice che ha molta documentazione e spiegazione, insieme ad alcune utili discussioni di seguito.

Tuttavia, un altro esempio di codice , sebbene non contenga tanta documentazione, include un codice di esempio per passare comandi come start, stop e restart. Crea anche un file PID che può essere utile per verificare se il daemon è già in esecuzione, ecc.

Entrambi questi esempi spiegano come creare il demone. Ci sono altre cose che devono essere considerate? Un campione è migliore dell'altro e perché?

Soluzione attuale

Un'implementazione di riferimento di PEP 3143 (libreria dei processi daemon standard) è ora disponibile come demone python .

Risposta storica

L' esempio di codice di Sander Marechal è superiore all'originale, originariamente pubblicato nel 2004. Una volta ho contribuito con un demone per Pyro, ma probabilmente avrei usato il codice di Sander se avessi dovuto farlo.

Ci sono molte cose difficili da gestire quando si diventa un processo demone ben educato :

• prevenire core dump (molti daemon vengono eseguiti come root e i core dump possono contenere informazioni riservate)

• comportarsi correttamente all'interno di una chrootprigione

• impostare UID, GID, directory di lavoro, umask e altri parametri di processo in modo appropriato per il caso d'uso

• rinunciare elevati suid, sgidprivilegi

• chiudi tutti i descrittori di file aperti, con esclusioni a seconda del caso d'uso

• comportarsi correttamente se avviato all'interno di un contesto già a schiera, ad esempio init, inetdecc

• impostare gestori di segnale per comportamenti demoni sensibili, ma anche con gestori specifici determinati dal caso d'uso

• reindirizzare i flussi standard stdin, stdout, stderrdal momento che un processo demone non ha un terminale di controllo

• gestire un file PID come blocco consultivo cooperativo, che è un'intera lattina di worm in sé con molti modi contraddittori ma validi per comportarsi

• consentire un'adeguata pulizia al termine del processo

• in realtà diventa un processo daemon senza portare a zombi

Alcuni di questi sono standard , come descritto nella letteratura canonica Unix ( Advanced Programming in UNIX Environment , del compianto W. Richard Stevens, Addison-Wesley, 1992). Altri, come il reindirizzamento dello stream e la gestione dei file PID , sono comportamenti convenzionali che la maggior parte degli utenti di demoni si aspettano, ma che sono meno standardizzati.

Tutti questi sono coperti dalla specifica PEP 3143 "Standard daemon process library" . L' implementazione di riferimento python-daemon funziona su Python 2.7 o versioni successive e Python 3.2 o versioni successive.

Ecco il mio demone Python 'Howdy World' di base con cui inizio, quando sto sviluppando una nuova applicazione demone.

#!/usr/bin/python
import time
from daemon import runner

class App():
    def __init__(self):
        self.stdin_path = '/dev/null'
        self.stdout_path = '/dev/tty'
        self.stderr_path = '/dev/tty'
        self.pidfile_path =  '/tmp/foo.pid'
        self.pidfile_timeout = 5
    def run(self):
        while True:
            print("Howdy!  Gig'em!  Whoop!")
            time.sleep(10)

app = App()
daemon_runner = runner.DaemonRunner(app)
daemon_runner.do_action()

Nota che avrai bisogno della python-daemonbiblioteca. Puoi installarlo tramite:

pip install python-daemon

Quindi basta avviarlo con ./howdy.py starte fermarlo con ./howdy.py stop.

Nota il pacchetto python-daemon che risolve immediatamente molti problemi dietro i demoni.

Tra le altre funzionalità che abilita (dalla descrizione del pacchetto Debian):

• Scollegare il processo nel proprio gruppo di processi.
• Impostare l'ambiente di processo appropriato per l'esecuzione all'interno di un chroot.
• Rinuncia ai privilegi di suid e sgid.
• Chiudi tutti i descrittori di file aperti.
• Cambia la directory di lavoro, uid, gid e umask.
• Impostare i gestori di segnale appropriati.
• Apri nuovi descrittori di file per stdin, stdout e stderr.
• Gestire un file di blocco PID specificato.
• Registrare le funzioni di pulizia per l'elaborazione all'uscita.

Un'alternativa: crea un normale programma Python non demonizzato e poi demonimizzalo esternamente usando supervisord . Questo può risparmiare un sacco di mal di testa ed è * nix- e linguaggio-portatile.

Probabilmente non è una risposta diretta alla domanda, ma systemd può essere utilizzato per eseguire l'applicazione come demone. Ecco un esempio:

[Unit]
Description=Python daemon
After=syslog.target
After=network.target

[Service]
Type=simple
User=<run as user>
Group=<run as group group>
ExecStart=/usr/bin/python <python script home>/script.py

# Give the script some time to startup
TimeoutSec=300

[Install]
WantedBy=multi-user.target

Preferisco questo metodo perché gran parte del lavoro è fatto per te, e quindi il tuo script daemon si comporta in modo simile al resto del tuo sistema.

-Orby

YapDi è un modulo Python relativamente nuovo che è apparso in Hacker News. Sembra abbastanza utile, può essere usato per convertire uno script Python in modalità demone dall'interno dello script.

dal momento che python-daemon non ha ancora supportato python 3.xe da ciò che può essere letto sulla mailing list, potrebbe non esserlo mai, ho scritto una nuova implementazione di PEP 3143: pep3143daemon

pep3143daemon dovrebbe supportare almeno python 2.6, 2.7 e 3.x

Contiene anche una classe PidFile.

La libreria dipende solo dalla libreria standard e dal modulo sei.

Può essere usato come drop in sostituzione di python-daemon.

Ecco la documentazione .

Questa funzione trasformerà un'applicazione in un demone:

import sys
import os

def daemonize():
    try:
        pid = os.fork()
        if pid > 0:
            # exit first parent
            sys.exit(0)
    except OSError as err:
        sys.stderr.write('_Fork #1 failed: {0}\n'.format(err))
        sys.exit(1)
    # decouple from parent environment
    os.chdir('/')
    os.setsid()
    os.umask(0)
    # do second fork
    try:
        pid = os.fork()
        if pid > 0:
            # exit from second parent
            sys.exit(0)
    except OSError as err:
        sys.stderr.write('_Fork #2 failed: {0}\n'.format(err))
        sys.exit(1)
    # redirect standard file descriptors
    sys.stdout.flush()
    sys.stderr.flush()
    si = open(os.devnull, 'r')
    so = open(os.devnull, 'w')
    se = open(os.devnull, 'w')
    os.dup2(si.fileno(), sys.stdin.fileno())
    os.dup2(so.fileno(), sys.stdout.fileno())
    os.dup2(se.fileno(), sys.stderr.fileno())

Temo che il modulo demone menzionato da @Dustin non abbia funzionato per me. Invece ho installato python-daemon e ho usato il seguente codice:

# filename myDaemon.py
import sys
import daemon
sys.path.append('/home/ubuntu/samplemodule') # till __init__.py
from samplemodule import moduleclass 

with daemon.DaemonContext():
    moduleclass.do_running() # I have do_running() function and whatever I was doing in __main__() in module.py I copied in it.

Correre è facile

> python myDaemon.py

solo per completezza ecco il contenuto della directory samplemodule

>ls samplemodule
__init__.py __init__.pyc moduleclass.py

Il contenuto di moduleclass.py può essere

class moduleclass():
    ...

def do_running():
    m = moduleclass()
    # do whatever daemon is required to do.

Un'altra cosa a cui pensare quando demonizzare in Python:

Se stai usando la registrazione Python e vuoi continuare a usarla dopo la demonizzazione, assicurati di chiamare close()i gestori (in particolare i gestori di file).

Se non lo fai, il gestore può ancora pensare che i file siano aperti e i tuoi messaggi scompariranno semplicemente, in altre parole assicurati che il logger sappia che i suoi file sono chiusi!

Ciò presuppone che quando si esegue la demonizzazione si stanno chiudendo TUTTI i descrittori di file aperti indiscriminatamente - invece si potrebbe provare a chiudere tutti tranne i file di registro (ma di solito è più semplice chiudere tutti quindi riaprire quelli desiderati).

Anche se potresti preferire la pura soluzione Python fornita dal modulo python-daemon, esiste una daemon(3)funzione libc, almeno su BSD e Linux , che farà la cosa giusta.

Chiamarlo da Python è facile:

import ctypes

ctypes.CDLL(None).daemon(0, 0) # Read the man-page for the arguments' meanings

L'unica cosa rimasta da fare è la creazione (e il blocco) del file PID. Ma che puoi gestire te stesso ...

Ho modificato alcune righe nell'esempio di codice di Sander Marechal (menzionato da @JeffBauer nella risposta accettata ) per aggiungere un quit()metodo che viene eseguito prima che il demone venga arrestato. Questo a volte è molto utile.

Ecco qui.

Nota: non uso il modulo "python-daemon" perché manca ancora la documentazione (vedi anche molte altre domande SO) ed è piuttosto oscuro (come avviare / arrestare correttamente un demone dalla riga di comando con questo modulo?)

Dopo alcuni anni e molti tentativi (ho provato tutte le risposte fornite qui, ma alla fine tutti hanno avuto piccoli inconvenienti), ora mi rendo conto che esiste un modo migliore di voler avviare, arrestare, riavviare un demone direttamente da Python : utilizzare invece gli strumenti del sistema operativo.

Ad esempio, per Linux, invece di farlo python myapp starte python myapp stop, lo faccio per avviare l'app:

screen -S myapp python myapp.py    
CTRL+A, D to detach

o screen -dmS myapp python myapp.pyper avviarlo e staccarlo in un solo comando .

Poi:

screen -r myapp

per ricollegarsi a questo terminale. Una volta nel terminal, è possibile utilizzare CTRL + C per fermarlo.

Il modo più semplice per creare un demone con Python è usare il framework Twisted basato sugli eventi. Gestisce tutte le cose necessarie per la demonizzazione per te. Utilizza il modello di reattore per gestire le richieste simultanee.

L'80% delle volte, quando la gente dice "demone", vuole solo un server. Poiché la domanda non è perfettamente chiara su questo punto, è difficile dire quale possa essere il possibile dominio di risposte. Poiché un server è adeguato, inizia da lì. Se è effettivamente necessario un vero "demone" (questo è raro), continua a leggere nohupcome un modo per demonizzare un server.

Fino a quando non è effettivamente richiesto un demone reale, basta scrivere un semplice server.

Guarda anche l' implementazione di riferimento WSGI .

Guarda anche il server HTTP semplice .

"Ci sono altre cose che devono essere considerate?" Sì. Circa un milione di cose. Quale protocollo? Quante richieste? Quanto tempo per soddisfare ogni richiesta? Con quale frequenza arriveranno? Userai un processo dedicato? Le discussioni? Sottoprocessi? Scrivere un demone è un grosso lavoro.