In this post I will explain how to set up scripts so that they automatically start at boot time.

In questo post vi spiego come impostare gli script cosìcche si avviino automaticamente a sistema caricato.

[Debian] How to set scripts to execute at boot time easily

As I said in the previous post, I cannot always use monitors, so I figured out another way to use my laptop, which resulted into configuring a ssh server, that I could connect to.
To do this, I had to instruct Debian to do both, connect to my wireless lan and start the ssh server at boot time.
While ssh is usually set to execute at startup, this is not true for the wireless lan connection, but if you use graphical user interfaces, this can be done easily (in wicd for example, there's an option to do that).

For learning reasons though, I got rid of network managers, so that I could learn to connect from command line.
After that, I just made a script to automatize this task.
To prepare scripts/programs for execution at boot time in Unix and Unix-like systems, you must know the concept of "runlevel".
Runlevels are "software configurations" used by this type of systems to determine the services that the computer can provide.
Basically, different runlevels will provide different services.
Usually there are 8 runlevels, runlevel 0 through 6 and runlevel S.
Runlevel 0 is used to halt the system, runlevel 6 is the same as runlevel 0, but it reboots the system instead of halting it, and S, is for the "single-user mode", which can be used for maintenance.

As you may probably guess, runlevels are used to start programs that are thought to be daemons, so that certain services are available during the normal computer use (networking, database management systems, web servers, console sessions, X graphical environment, etcetera).
Runlevels information is (usually) stored in the directories "/etc/init.d" (here are stored the "service scripts") and in the directories "/etc/rcN.d" with N being a runlevel (from 0 to 6 and S).
If you take a look at the content of any "/etc/rcN.d" directory, you'll notice some files (soft links to files residing in "/etc/init.d") named in a certain way.
Of course the nomenclature is not casual, the name of those soft links start with a capital S if the service must be started, or, with a capital K if the service must be stopped, and after that, you'll find a number which represents their priority (the lower number is executed earlier).
Only at the end of the name, you'll find the name of the service.
If two soft links are named similarly up to the number, the priority will be established according to the alphabetical order of the final part, the service which comes earlier in respect to that order will be executed/killed for first.

So, to allow boot time execution you need to create service scripts in the "/etc/init.d" directory, and then set soft links to it in the various "/etc/rcN.d" according to your needs.

Even though doing this manually is very educative, it is very difficult for beginners, so we're not going to cover this (maybe I'll do that in the future).
Today, I will show what to do if we need to set up some basic scripts to start at boot time in Debian (this cannot be generic because every distribution may do that differently).

  1. First of all, create the script/program you need.
    It may be as simple as this shell script:
    touch /home/YOURUSERNAME/testbootupscript
    This simple script will create the file "/home/YOURUSERNAME/testbootupscript", where YOURUSERNAME is your user name.
    You may use this to test if everything went correctly.
    Store it somewhere and make it executable.
  2. Now, open a terminal window (if in GUI) or switch to one of the ttys and after performing the login, go to the directory "/etc/init.d".
    We've said that here reside all service scripts, there's also a "skeleton" file, used to make new scripts from scratch.
    What you want to do is to make a copy of it in this same directory, rename the copy, and customize it (you'll need super user permissions to do all this).
    If that skeleton file is a bit complicated for your task, here it is a simplified version:
    #! /bin/sh
    ### BEGIN INIT INFO
    # Provides:          skeleton
    # Required-Start:    $remote_fs $syslog
    # Required-Stop:     $remote_fs $syslog
    # Default-Start:     2 3 4 5
    # Default-Stop:      0 1 6
    # Short-Description: Example initscript
    # Description:       This file should be used to construct scripts to be
    #                    placed in /etc/init.d.
    ### END INIT INFO
    
    # Author: Foo Bar <foobar@baz.org>
    #
    # Please remove the "Author" lines above and replace them
    # with your own name if you copy and modify this script.
    
    # Define LSB log_* functions.
    # Depend on lsb-base (>= 3.2-14) to ensure that this file is present
    # and status_of_proc is working.
    . /lib/lsb/init-functions
    
    #Initial code checks that do not depend on the chosen action here...
    
    case "$1" in
      start)
     #Code to start the service here
     ;;
      stop)
     #Code to stop the service here
     ;;
      status)
     #Code to show the status here
     ;;
      restart)
     #Code to restart the service here
     ;;
      force-reload)
     #Code to reload service's configurations files here
     ;;
      *)
     ;;
     echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
     exit 3
     ;;
    esac
    
    :
    Everything is pretty self-explanatory, just write the code where you need it.
    Usually, you would need to write code at least in the "start" and "stop" actions, but in this example, we're fine by writing code only in the "start" action portion, like the following:
    #! /bin/sh
    ### BEGIN INIT INFO
    # Provides:          skeleton
    # Required-Start:    $remote_fs $syslog
    # Required-Stop:     $remote_fs $syslog
    # Default-Start:     2 3 4 5
    # Default-Stop:      0 1 6
    # Short-Description: Example initscript
    # Description:       This file should be used to construct scripts to be
    #                    placed in /etc/init.d.
    ### END INIT INFO
    
    # Author: Foo Bar <foobar@baz.org>
    #
    # Please remove the "Author" lines above and replace them
    # with your own name if you copy and modify this script.
    
    # Define LSB log_* functions.
    # Depend on lsb-base (>= 3.2-14) to ensure that this file is present
    # and status_of_proc is working.
    . /lib/lsb/init-functions
    
    
    case "$1" in
      start)
     /PATH/TO/SCRIPT
     ;;
      stop)
     ;;
      status)
     ;;
      restart)
     ;;
      force-reload)
     ;;
      *)
     ;;
     echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
     exit 3
     ;;
    esac
    
    :
    where "/PATH/TO/SCRIPT" is an absolute path to the script you created.
    Please notice that even though we're not going to use them, I've kept all the actions, because as far as I know, in Debian, the script won't work if one of them is missing.
    Be also sure that the permissions for this service file are set to 755.
  3. Now, the last part, it's time to learn how to enable/disable a service.
    We've said before, that theoretically, we should manually insert/remove soft links in the "/etc/rcN.d" directories.
    Fortunately, most distributions have programs that perform just this, all we need to do is to tell the name of the service, and ask to whether enable or disable it, and additionally, if needed, prepare custom parameters (such as the priority or the specific runlevel).
    In Debian the "update-rc.d" tool is used.
    To enable the service, type:
    sudo update-rc.d SERVICENAME defaults
    where SERVICENAME is the name you gave to the service script stored in "/etc/init.d".
    To disable the service, just type:
    sudo update-rc.d SERVICENAME remove
    Considering that "update-rc.d" is a script usually used by packaging tools, the "remove" option I've shown here will work until program update, which means that, if there's an update of the service, and you perform the update, it will be set again to start at boot time.
    In our case this should not be a problem, because the script/program is ours, there's no automation.
    To check other available options, please see the manual for this by typing:
    man update-rc.d

Very well, did you find this post useful?
Do you have doubts?
Please feel free to comment.
Greetings from Antonio Daniele.
See you next month.

Go back to the top, Share, Look at the comments or Comment yourself!

[Debian] Come impostare script da eseguire all'avvio facilmente

Come già detto nel post precedente, non posso sempre usare i monitor, perciò mi sono inventato un altro modo per usare il portatile, cioè configuare un server ssh, a cui potevo collegarmi.
Per far ciò, ho dovuto istruire Debian a fare due cose, all'avvio del sistema, collegarsi alla mia lan senza fili ed avviare il server ssh.
Mentre ssh è solitamente già impostato per essere eseguito all'avvio, ciò è falso nel caso della connessione alla lan senza fili, ma se usate interfacce grafiche, questo si può fare facilmente (in wicd ad esempio, c'è un opzione per fare ciò).

A scopo educativo, io ho eliminato i gestori delle reti, per imparare a collegarmi da riga di comando.
Dopodiché, ho creato uno script per automatizzarmi il compito.
Per preparare gli script/programmi per essere eseguiti all'avvio sui sistemi Unix e Unix-like, dovete conoscere il concetto di "runlevel".
I runlevel sono "configurazioni software" utilizzate da questi tipi di sistemi per determinare i servizi che il computer può offrire.
In pratica, diversi runlevel offriranno diversi servizi.
Di solito ci sono 8 runlevel, dal runlevel 0 a 6 e runlevel S.
Il runlevel 0 viene usato per spegnere il sistema, il runlevel 6 è uguale al runlevel 0, ma riavvia il sistema anziché spegnerlo, e l'S viene usato per la "modalità utente singolo", utilizzata per manutenzione.

Come potrete immaginare, i runlevel vengono utilizzati per avviare programmi che vengono pensati come demòni, cosìcche alcuni servizi siano disponibili durante il normale uso del computer (la rete, i sistemi di gestione delle basi di dati, i web server, le sessioni da console, l'ambiente grafico X, eccetera).
Le informazioni sui runlevel vengono (di solito) immagazzinate nelle cartelle "/etc/init.d" (qui vengono immagazzinati gli "script di servizio") e nelle cartelle "/etc/rcN.d" dove N è un runlevel (da 0 a 6 e S).
Se date un'occhiata al contenuto di una qualsiasi cartella "/etc/rcN.d", noterete alcuni file (soft link a file risiedenti in "/etc/init.d") nominati in un certo modo.
Ovviamente la nomenclatura non è casuale, il nome di quei soft link inizia con una S maiuscola se il servizio dev'essere avviato, o con una K maiuscola, se il servizio dev'essere arrestato, in seguito, troverete un numero che rappresenta la loro priorità (il numero più piccolo verrà eseguito prima).
Solo alla fine del nome, trovetere il nome del servizio.
Se due soft link sono nominati nella stessa maniera fino al numero, la priorità verrà stabilita in base all'ordine alfabetico delle parti finali, il servizio che viene prima rispetto a tale ordine verrà eseguito/fermato per primo.

Quindi, per permette l'esecuzione all'avvio è necessario creare script di servizio nella cartella "/etc/init.d", e poi, impostare soft link che puntano allo script nelle varie cartelle "/etc/rcN.d", in base alle vostre esigenze.

Anche se fare ciò manualmente è molto educativo, è parecchio difficile per chi inizia, perciò non coprirò questo caso (magari lo farò in futuro).
Oggi, vi mostro cosa fare se avete bisogno di esegure script di base all'avvio di Debian (questo non può essere generico perché ogni distribuzione potrebbe farlo in maniera diversa).

  1. Prima di tutto, create lo script/programma di cui avete bisogno.
    Potrebbe essere semplicissimo, come il seguente script shell:
    touch /home/VOSTRONOMEUTENTE/testbootupscript
    Questo semplice script creerà il file "/home/VOSTRONOMEUTENTE/testbootupscript", dove VOSTRONOMEUTENTE è il vostro nome utente.
    Potreste usare questo script per testare se tutto è andato bene.
    Immagazzinatelo da qualche parte e rendetelo eseguibile.
  2. Ora, aprite una finestra di terminale (se usate interfacce grafiche) o spostatevi su uno dei teletype (terminali virtuali) e dopo aver effettuato il login, andate nella cartella "/etc/init.d".
    Abbiamo detto che qui risiedono tutti gli script di servizio, c'è anche un file "skeleton" (scheletro), utilizzato per creare nuovi script da zero.
    Quel che dovete fare è creare una copia di tale file nella stessa cartella, rinominare la copia, e personalizzarla (vi serviranno i permessi di super utente per fare tutto ciò).
    Se quel file "skeleton" è un po' complicato per quel che dovete fare, ecco una versione semplificata:
    #! /bin/sh
    ### BEGIN INIT INFO
    # Provides:          skeleton
    # Required-Start:    $remote_fs $syslog
    # Required-Stop:     $remote_fs $syslog
    # Default-Start:     2 3 4 5
    # Default-Stop:      0 1 6
    # Short-Description: Example initscript
    # Description:       This file should be used to construct scripts to be
    #                    placed in /etc/init.d.
    ### END INIT INFO
    
    # Author: Foo Bar <foobar@baz.org>
    #
    # Please remove the "Author" lines above and replace them
    # with your own name if you copy and modify this script.
    
    # Define LSB log_* functions.
    # Depend on lsb-base (>= 3.2-14) to ensure that this file is present
    # and status_of_proc is working.
    . /lib/lsb/init-functions
    
    #Initial code checks that do not depend on the chosen action here...
    
    case "$1" in
      start)
     #Code to start the service here
     ;;
      stop)
     #Code to stop the service here
     ;;
      status)
     #Code to show the status here
     ;;
      restart)
     #Code to restart the service here
     ;;
      force-reload)
     #Code to reload service's configurations files here
     ;;
      *)
     ;;
     echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
     exit 3
     ;;
    esac
    
    :
    Tutto è abbastanza auto esplicativo, scrivete il codice dove ne avete bisogno.
    Di solito, avrete bisogno di scrivere codice almeno nelle azioni "start" e "stop", ma in questo esempio, ce la caveremo scrivendo codice solo nella porzione dell'azione "start", come di seguito:
    #! /bin/sh
    ### BEGIN INIT INFO
    # Provides:          skeleton
    # Required-Start:    $remote_fs $syslog
    # Required-Stop:     $remote_fs $syslog
    # Default-Start:     2 3 4 5
    # Default-Stop:      0 1 6
    # Short-Description: Example initscript
    # Description:       This file should be used to construct scripts to be
    #                    placed in /etc/init.d.
    ### END INIT INFO
    
    # Author: Foo Bar <foobar@baz.org>
    #
    # Please remove the "Author" lines above and replace them
    # with your own name if you copy and modify this script.
    
    # Define LSB log_* functions.
    # Depend on lsb-base (>= 3.2-14) to ensure that this file is present
    # and status_of_proc is working.
    . /lib/lsb/init-functions
    
    
    case "$1" in
      start)
     /PERCORSO/ALLO/SCRIPT
     ;;
      stop)
     ;;
      status)
     ;;
      restart)
     ;;
      force-reload)
     ;;
      *)
     ;;
     echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
     exit 3
     ;;
    esac
    
    :
    dove "/PERCORSO/ALLO/SCRIPT" è un percorso assoluto allo script che avete creato.
    Vi faccio notare che anche se non li useremo tutte, ho mantenuto tutte le azioni, perché per quanto ne so, su Debian, lo script non funzionerà se ne manca qualcuna.
    Assicuratevi che i permessi per questo file di servizio siano impostati a 755.
  3. Ora l'ultima parte, è tempo di imparare come abilitare/disabilitare un servizio.
    Abbiamo detto prima, che in teoria, dovremmo inserire/rimuovere i soft link manualmente all'interno delle cartelle "/etc/rcN.d".
    Fortunatamente, molte delle distribuzioni hanno programmi che fanno proprio questo, tutto quel che dobbiamo fare è dire il nome del servizio e chiedere se abilitarlo o disabilitarlo, e se necessario, aggiungere parametri personalizzati (come la priorità o i runlevel specifici).
    Su Debian si usa il programma "update-rc.d".
    Per abilitare il servizio, digitate:
    sudo update-rc.d NOMESERVIZIO defaults
    dove NOMESERVIZIO è il nome che avete dato allo script di servizio immagazzinato in "/etc/init.d".
    Per disabilitare il servizio, digitate:
    sudo update-rc.d NOMESERVIZIO remove
    Considerando che "update-rc.d" è uno script solitamente utilizzato da programmi di gestione pacchetti, l'opzione "remove" che ho mostrato qui, funzionerà fino all'aggiornamento del programma, il che vuol dire, che se c'è un aggiornamento del servizio, ed eseguite tale aggiornamento, esso verrà di nuovo reimpostato per partire all'avvio.
    Nel nostro caso questo non dovrebbe essere un problema, poiché lo script/programma è nostro, non c'è automazione.
    Per controllare altre opzioni disponibili, controllate il manuale digitando:
    man update-rc.d

Molto bene, avete trovato utile questo post?
Avete dubbi?
Sentitevi liberi di commentare.
Saluti da Antonio Daniele.
Ci si vede il mese prossimo.

Torna in cima, Condividi, Guarda i commenti o Commenta tu stesso!