script bash per autostart programma python

[vinny74]

Ciao a tutti come da titolo avrei bisogno di aiuto per scrivere uno script in bash per mettere nei programmi di avvio automatico un programmino in python, purtroppo con bash ci litigo molto ho cercato di prendere spunto da script esistenti ma non riesco a farlo partire.

Ubuntu 14.04 python3.4 su raspberry.

Grazie

[nuzzopippo]

Ciao a tutti come da titolo avrei bisogno di aiuto per scrivere uno script in bash per mettere nei programmi di avvio automatico un programmino in python, purtroppo con bash ci litigo molto ho cercato di prendere spunto da script esistenti ma non riesco a farlo partire.

Ubuntu 14.04 python3.4 su raspberry.

Grazie

Non ho compreso cosa intendi con la frase evidenziata.
Riguardo un script python, puoi benissimo inserire una delle istruzioni che seguono :

Codice: Seleziona tutto

#!/usr/bin/python
o
#!/usr/bin/env python
per pyhon versioni 2.x, per le versioni 3.x aggiungere "3" alla stringa"

alla prima riga del Tuo script e poi renderlo eseguibile. La presenza di queste istruzioni farà eseguire da python (2 o 3) il corpo dello script

Se con "script all'avvio" intendi all'avvio di sistema, guarda qui, non ci ho mai provato (preferisco sempre agire a livello "user") ma è concettualmente semplice.

[vinny74]

No io parlo di fare uno script da mettere in /etc/init.d per l'avvio autamatico al reboot, oppure per dare un riavvio del programma con "service mio_programma restart", al momento lo faccio partire al reboot del pc avendolo messo in crontab ma vorrei qualcosa di più efficiente.

[nuzzopippo]

No io parlo di fare uno script da mettere in /etc/init.d per l'avvio autamatico al reboot ...

Beh ... mi sembra che sia proprio il target del link che ho inserito nel post precedente ... comunque, non sono certo che python sia direttamente disponibile all'avvio del sistema, così come eventuali servizi invocati, purtroppo non ho idee chiare in proposito, domani proverò qualche test.

... cercando nel forum ho trovato questo post del 2011 che affronta il problema del lancio di uno script python all'avvio del sistema.
Per altro, ho trovato un interessante post in inglese, per avviare al boot uno script python quale servizio.

Certo, credo che dipende anche un po' da cosa deve fare il Tuo script,

[rai]

No io parlo di fare uno script da mettere in /etc/init.d per l'avvio autamatico al reboot, oppure per dare un riavvio del programma con "service mio_programma restart", al momento lo faccio partire al reboot del pc avendolo messo in crontab ma vorrei qualcosa di più efficiente.

Ciao, mi intrometto senza risposte ma con una domanda: potresti spiegare in che modo avverti poca efficienza usando cron?
Non è una domanda retorica, chiedo per capire, eh

[vinny74]

No io parlo di fare uno script da mettere in /etc/init.d per l'avvio autamatico al reboot, oppure per dare un riavvio del programma con "service mio_programma restart", al momento lo faccio partire al reboot del pc avendolo messo in crontab ma vorrei qualcosa di più efficiente.

Ciao, mi intrometto senza risposte ma con una domanda: potresti spiegare in che modo avverti poca efficienza usando cron?
Non è una domanda retorica, chiedo per capire, eh

Usando cron non posso fermarlo o riavviarlo in quanto parte i backgroud e l'unico modo che ho per vedere se il programma gira e con "ps aux | grep nome_programma" almeno io conosco questo, invece creando un script posso farlo partire quando voglio magari in fase di test non sono obbligato a farlo partire all'avvio del pc, cosi come per fermarlo utilizzo lo stesso comando di prima mi segno il pid e lo killo.
Questi sono i miei motivi, ma sicuramente ce ne sono altri ancora più importanti

[nuzzopippo]

Usando cron non posso fermarlo o riavviarlo in quanto parte i backgroud e l'unico modo che ho per vedere se il programma gira e con "ps aux | grep nome_programma" almeno io conosco questo, invece creando un script posso farlo partire quando voglio magari in fase di test non sono obbligato a farlo partire all'avvio del pc, cosi come per fermarlo utilizzo lo stesso comando di prima mi segno il pid e lo killo.
Questi sono i miei motivi, ma sicuramente ce ne sono altri ancora più importanti

Se capisco bene, allora il punto non è farlo partire all'avvio ma lanciarlo "a volontà" in background ed utilizzarlo come daemon ... il discorso cambia un po', forse Ti converrebbe leggere la PEP 3143
ed organizzarti le cose secondo tali indirizzi.
Inoltre, in tale circostanza (non all'avvio computer) forse è "/usr/bin" la locazione più idonea per posizionare il Tuo script.

[Edit] ... discorso non semplice, almeno per me, ho fatto qualche ricerca in merito, ho trovato questo pdf che sembra interessante, lo segnalo

[vinny74]

Usando cron non posso fermarlo o riavviarlo in quanto parte i backgroud e l'unico modo che ho per vedere se il programma gira e con "ps aux | grep nome_programma" almeno io conosco questo, invece creando un script posso farlo partire quando voglio magari in fase di test non sono obbligato a farlo partire all'avvio del pc, cosi come per fermarlo utilizzo lo stesso comando di prima mi segno il pid e lo killo.
Questi sono i miei motivi, ma sicuramente ce ne sono altri ancora più importanti

Se capisco bene, allora il punto non è farlo partire all'avvio ma lanciarlo "a volontà" in background ed utilizzarlo come daemon ... il discorso cambia un po', forse Ti converrebbe leggere la PEP 3143
ed organizzarti le cose secondo tali indirizzi.
Inoltre, in tale circostanza (non all'avvio computer) forse è "/usr/bin" la locazione più idonea per posizionare il Tuo script.

[Edit] ... discorso non semplice, almeno per me, ho fatto qualche ricerca in merito, ho trovato questo pdf che sembra interessante, lo segnalo

Alla fine dei test dovra partire in automatico con il riavvio del pc.
Però forse mi sono spiegato male, il programma in python l'ho già finito, lo sto testando e per il momento lo faccio partire in automatico con crontab con questa riga
"@reboot python3 /home/myhome/myprogram.py".

Lo script che dovrei realizzare dovrebbe essere in bash, da dover poi mettere nella directory "/etc/init.d" ed utilizzando il comando "update-rc myscript defaults" questo parta in automatico all'avvio del pc e quindi faccia partire il mio programma in python.
In questo modo potrei usare service myscript start oppure restart o status in modo da avviare riavviare o controllare lo stato del mio programma scritto in python

[nuzzopippo]

... per il momento lo faccio partire in automatico con crontab con questa riga
"@reboot python3 /home/myhome/myprogram.py".

Lo script che dovrei realizzare dovrebbe essere in bash, da dover poi mettere nella directory "/etc/init.d" ed utilizzando il comando "update-rc myscript defaults" questo parta in automatico all'avvio del pc e quindi faccia partire il mio programma in python.
In questo modo potrei usare service myscript start oppure restart o status in modo da avviare riavviare o controllare lo stato del mio programma scritto in python

Vedo che la discussione è ferma ... intrigato dal problema, mi son messo a vedere come funzionano le cose di init.d, ho ideato un generico programma di test e mi è riuscito di realizzare tutte le fasi da Te proposte meno una importante : non mi riesce di avviare in automatico tramite lo "update-rc.d".
Quest'ultima circostanza penso sia dovuta al fatto che la metodologia "System V" è deprecata e la maggior parte dei sistemi sono passati alla metodologia "systemd", a me sembrerebbe che attualmente il comando "update-rc.d <script> default" NON provveda a stabilire i run-level per l'avvio ...

questo stralcio

systemd does not support SysV scripts as part of early boot, so all
wrapper units are ordered after basic.target.

del manuale di "systemd-sysv-generator" sembrerebbe confermare la mia ipotesi prima riportata ma, su questo particolare, sarebbe gradita indicazione dai più esperti.

Comunque, avendo "realizzato" il resto (cercando e scopiazzando impudentemente), Ti espongo ciò che ho fatto e quel (poco) che ho capito ... in fase di test potresti far partire con crontab lo script di lancio posto in init.d e poi sfruttare gli "altri" mezzi.

intanto il codice; script pyton (mypyd.py) per il test :

Codice: Seleziona tutto

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

import sys, os, datetime, time

# rilevo la direttrice applicazione
my_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
# definisco il nome-file del log
tempo = datetime.datetime.now()
fn = my_dir + '/logs/' + tempo.date().isoformat() + '_mypyd.log'
# definisco e scrivo messaggio iniziale
strtmp = tempo.isoformat() + ' : Avvio di mypyd'

try:
    with open(fn, 'a') as f:
        f.write(strtmp + '\n')
except:
    pass

# scrivo 10 messaggi, 1 per minuto
count = 0

while count < 10:
    time.sleep(60)
    tempo = datetime.datetime.now()
    strtmp = tempo.isoformat() + ' : eseguo istruzione ' + str(count + 1)
    try:
        with open(fn, 'a') as f:
            f.write(strtmp + '\n')
    except:
        pass
    count += 1

Non fa altro che scrivere, una riga al minuto, 10 righe in un file di log giornaliero posto in una sotto-directory di quella della applicazione (che deve esistere); ho imposto il limite di 10 operazioni/minuti per darmi il tempo di effettuare i test ed evitare (nel caso partisse al boot e lo dimenticassi) che rompa gli zebedei a lungo.
da notare la "#!/usr/bin/python3", ho preferito evitare di usare env per invocare python.

Per "distinguere" anche lo script di lancio scrive nello stesso file di log, piccole differenze permettono di indentificare chi ha scritto cosa, esempio del log

Codice: Seleziona tutto

2018-11-15T08:45:21+01:00 Avvio di mypyd.py
2018-11-15T08:45:21.082799 : Avvio di mypyd
2018-11-15T08:46:21.142949 : eseguo istruzione 1
2018-11-15T08:46:36+01:00  Arresto mypyd.py eseguito
2018-11-15T08:47:40+01:00 Avvio di mypyd.py
2018-11-15T08:47:40.510575 : Avvio di mypyd
2018-11-15T08:48:40.570746 : eseguo istruzione 1
2018-11-15T08:49:40.631117 : eseguo istruzione 2
2018-11-15T08:50:17+01:00  Arresto mypyd.py eseguito
2018-11-15T08:50:17+01:00 Avvio di mypyd.py
2018-11-15T08:50:17.712671 : Avvio di mypyd
2018-11-15T08:50:47+01:00  Arresto mypyd.py eseguito

scaturente dalla seguente sessione :

Codice: Seleziona tutto

:~$ sudo service inv_mypyd start
g:~$ sudo service inv_mypyd status
● inv_mypyd.service
   Loaded: loaded (/etc/init.d/inv_mypyd; generated)
   Active: active (running) since Thu 2018-11-15 08:47:40 CET; 24s ago
     Docs: man:systemd-sysv-generator(8)
  Process: 9173 ExecStart=/etc/init.d/inv_mypyd start (code=exited, status=0/SUCCESS)
    Tasks: 1 (limit: 4915)
   CGroup: /system.slice/inv_mypyd.service
           └─9179 /usr/bin/python3 /home/nuzzo/my_tmp/test/pyt/dae/mypyd.py

nov 15 08:47:40 ng systemd[1]: Starting inv_mypyd.service...
nov 15 08:47:40 ng inv_mypyd[9173]: Avvio inv_mypyd
nov 15 08:47:40 ng systemd[1]: Started inv_mypyd.service.
:~$ sudo service inv_mypyd restart
:~$ sudo service inv_mypyd stop
:~$ sudo service inv_mypyd status
[sudo] password di nuzzo: 
● inv_mypyd.service
   Loaded: loaded (/etc/init.d/inv_mypyd; generated)
   Active: inactive (dead)
     Docs: man:systemd-sysv-generator(8)

nov 15 08:47:40 ng systemd[1]: Started inv_mypyd.service.
nov 15 08:50:17 ng systemd[1]: Stopping inv_mypyd.service...
nov 15 08:50:17 ng inv_mypyd[9216]: inv_mypyd fermato
nov 15 08:50:17 ng systemd[1]: Stopped inv_mypyd.service.
nov 15 08:50:17 ng systemd[1]: Starting inv_mypyd.service...
nov 15 08:50:17 ng inv_mypyd[9221]: Avvio inv_mypyd
nov 15 08:50:17 ng systemd[1]: Started inv_mypyd.service.
nov 15 08:50:47 ng systemd[1]: Stopping inv_mypyd.service...
nov 15 08:50:47 ng inv_mypyd[9265]: inv_mypyd fermato
nov 15 08:50:47 ng systemd[1]: Stopped inv_mypyd.service.
:~$

Nella sessione ho eseguito due invocazioni di "status" a processo attivo e fermo.

Ora il codice dello script bash di invocazione (inv_mypyd) :

Codice: Seleziona tutto

#!/bin/bash
### BEGIN INIT INFO
# Provides :			inv_mypyd
# Required-Start :		all
# Required-Stop :
# Default-Start :		2 3 4 5
# Default-Stop :	  	0 1 6
# Short-Description :	Avvio test mypyd
# Description :			Avvio test mypyd
### END INIT INFO

DAEMON=/home/nuzzo/test/pyt/dae/mypyd.py
NAME=mypyd
DESC=mypyd
DAEMON_OPTS=""

LOG=/home/nuzzo/test/pyt/dae/logs/`date +%Y-%m-%d`_mypyd.log

vai() {
	echo `date --iso-8601=seconds` " Avvio di mypyd.py" >> "$LOG"
	echo "Avvio $DESC"
	start-stop-daemon --start --quiet --pidfile /var/run/$NAME.pid \
     --background --exec $DAEMON
}

ferma() {
	for pid in `pidof -x $DAEMON`; do
		kill $pid;
	done
	echo `date --iso-8601=seconds` " Arresto mypyd.py eseguito" >> "$LOG"
	echo "$DESC fermato"
}

case "$1" in
start)
	vai
	;;
stop)
	ferma
	;;
restart|reload|force-reload)
	ferma
	vai
	;;
status)
	status_of_proc "$NAME" "$DAEMON" && exit 0 || exit $?
	;;	
*)
	echo "Utilizzo : /etc/init.d/inv_mypyd (start|stop|restart|reload|force-reload|status)"
	exit 2
	;;
esac
exit 0

N.B. : tanto allo script di avvio quanto il file python devono aver assegnato il "chmod +x" con sudo, è lo script in init.d che crea il file di logo, quindi esso è in sola lettura per l'utente ordinario.

Nel codice sono definite due funzioni, vai() e ferma() che provvedono ad avviare e fermare lo script mypyd.py.

La funzione vai() utilizza il comando "start-stop-daemon" per avviare il programma python. Comando complesso (vedi il man) in particolare "--start" avvia il processo e --pidfile definisce dove scrivere l'identificativo del processo, in base al "NAME" da me definito, la parte "--exec" avvia il programma python da me definito come "DAEMON".

Qualche dubbio lo ho sulla funzione "ferma()", che stoppa tutti i processi identificabili con il programma python definito ... canonico sarebbe stato utilizzare il pid definito con una istruzione "start-stop-daemon --stop --pidfile /var/run/$NAME.pid --retry 10" che ettenderebbe eventuali processi di chiusura dell'applicazione, ma dato che funziona e non avevo pretese l'ho lasciata così.

per lo "status" del processo ho utilizzato la funzione di shell (non documentata) "status_of_proc", non necessariamente presente in tutti i sistemi, alternativa potrebbe essere il comando "systemctl status <nomeservizio", richiamabile direttamente dalla shell.

le varie opzioni di invocazione sono contenute in "$1", il primo parametro di chiamata dello script posto in init.d, e vengono selezionate in un blocco "case/esac", ("Select/Case" in altri linguaggi) che in python non esiste, li dovresti porre una serie di "if/elif/else", comunque di sintassi abbastanza semplice : segnaposto (es. "start)") istruzioni, chiusura del blocco di istruzioni con ";;"

Pongo alla Tua attenzione il blocco "### BEGIN INIT INFO / ### END INIT INFO" che tal volta, nelle ricerche, non è presente, strutturalmente rigido e definito dalla LSB, da la possibilità di stabilire molti fattori utili (da una occhiata qui) tra cui risorse eventualmente necessarie alla applicazione ed i run-level funzionali (frustrati nel mio tentativo), può essere più complesso di così.

Certo, c'è moltissimo altro (un mondo) da apprendere ma forse questo potrebbe essere un "la" sufficiente per delle prove, per un discorso più "serioso", secondo me, c'è da studiarsi il "systemd", che ha sostituito il "system V" (init.d) attualmente parzialmente supportato ma deprecato.

Spero quanto su Ti sia utile come spunto, ciao

[vinny74]

Si infatti avevo trovato in rete qualcosa di simile a quello che hai scritto ma non ho avuto ancora tempo di provarlo, appena sono un po piu comodo col lavoro faccio queste prove.

Grazie comunque dell'interessamento