Daemons de unix y casos prácticos con NetCore

Menos que dioses (Sistema operativo, Kernel) pero más como mortales (programas), los Daemons de Unix, mal llamados demonios en español, son procesos/servicios en segundo plano que no requieren de interacción directa del usuario de sistema para ejecutarse, es decir no requieren indicaciones desde ninguna interfaz ni terminal. 

Los Daemons nos sirven cuando necesitamos un proceso recurrente que trabaje en silencio en nuestro ordenador. 

Algunos ejemplos prácticos podrían ser crear un programa que nos envíe un recordatorio o alerta de algún tema en específico cada tanto tiempo, o algo mas complejo como replicar datos locales de una base de datos a otra.

De igual forma podemos configurar los Daemons para que se ejecuten al arranque de sistema incluyéndolos en systemd.

Los Daemons trabajan a nivel sistema operativo, pudiendo ejecutar cualquier tipo de programa o instrucción que deseemos. En el presente caso utilizaremos NetCore para generar breves ejemplos.

NetCore es lo mejor de Microsoft para Linux, en el tiempo que lo he utilizado me ha parecido un esquema muy agradable para trabajar.

Para todo esto tendremos que haber configurado nuestro ordenador para poder ejecutar entornos NetCore.

 

1. Generar el programa  

Abrimos Visual Studio y el tipo de proyecto que elegiremos para crear es "Aplicación de Consola", verificando que tenga la opción de compatibilidad con Linux:

 Fig. 1) Proyecto a elegir en Visual Studio (Aplicación de consola multiplataforma)

En nuestro programa principal (Program.cs) tendremos una sencilla función cuyo propósito será escribir en un archivo al estilo log:

     private static void WriteLog(string msg)  
     {  
       Console.WriteLine(msg);  
         System.IO.Directory.CreateDirectory("/home/euclides/Replicator/Logs");  
         string strFile = "/home/euclides/Replicator/Logs/ReplicaLog-" + DateTime.Now.Date.ToString("dd-MM-yyyy") + ".txt";  
         bool fileExists = File.Exists(strFile);  
         if (fileExists)  
         {  
           using (StreamWriter sw = new StreamWriter(File.Open(strFile, FileMode.Append)))  
           {  
             sw.WriteLine(msg);  
           }  
         }  
         else  
         {  
           using (StreamWriter sw = new StreamWriter(File.Open(strFile, FileMode.OpenOrCreate)))  
           {  
             sw.WriteLine(msg);  
           }  
         }  
     }  

De igual forma añadiremos un temporizador para controlar los tiempos en los cuales se ejecute nuestra función:

     private Timer _tmEscritura = null;  
     private AutoResetEvent _autoEvent = null;  
     private void StartTimer()  
     {  
       try  
       {  
         WriteLog("Configurando temporizador");  
         //dueTime muestra cuando se realizará la primera ejecución (1000 MS),  
         //period es después de ello cada cuanto tiempo (timespan.fromminutes)  
         _autoEvent = new AutoResetEvent(true);  
         _tmEscritura = new Timer(WriteLog("La hora es: " + DateTime.Now.ToString()), _autoEvent, 1000, (int)TimeSpan.FromMinutes(5).TotalMilliseconds);  
         WriteLog("Fin de configuracion de temporizador");  
         while (true) ; //Instrucción para que prevalezca en ejecución  
       }  
       catch (Exception ex)  
       {  
         WriteLog("ERROR DE EJECUCIÓN: " + ex.Message);  
       }  
     }  

Finalmente, nuestro hilo principal quedaría así con el temporizador:

     private static void Main(string[] args)  
     {  
       WriteLog("INICIO DE EJECUCIÓN");  
       Program p = new Program();  
       p.StartTimer();  
     }  

Una vez hecho esto compilamos en Release, y publicamos con compatibilidad Linux. Lo cargamos por FTP al directorio que deseemos y le damos permisos de escritura, lectura y ejecución.

2. Crear el Daemon

Para crear el Daemon escribiremos un archivo de texto con extensión .service en el cual indicaremos la ubicación de nuestro programa ejecutable y la descripción del mismo, así como el nombre mediante el cual lo identificaremos y el usuario o grupo de usuarios que tienen permiso de manipularlo.

 [Unit]  
 Description=Programa de escritura de logs de hora con temporizador  
 [Service]  
 # systemd will run this executable to start the service  
 ExecStart=/home/euclides/WriteLog/WriteLog  
 # to query logs using journalctl, set a logical name here  
 SyslogIdentifier=WriteLog  
 # Use your username to keep things simple.  
 # If you pick a different user, make sure dotnet and all permissions are set correctly to run the app  
 # To update permissions, use 'chown yourusername -R /srv/HelloWorld' to take ownership of the folder and files,  
 #    Use 'chmod +x /srv/HelloWorld/HelloWorld' to allow execution of the executable file  
 User=euclides 
 [Install]  
 WantedBy=multi-user.target  

Este archivo deberá almacenarse en la ruta /etc/systemd/system/ 

Los últimos pasos para tener nuestro Daemon en ejecución son recargar la pila de daemons y habilitarlo al arranque del sistema operativo mediante los siguientes comandos:

 //Recarga la pila de daemons  
 sudo systemctl daemon-reload  
 //Habilita la ejecución al arranque del sistema   
 sudo systemctl enable WriteLog.service  
 //Inicia el daemon  
 sudo systemctl start WriteLog.service  

Listo, hemos creado un Daemon de Unix en NetCore con un temporizador y función para escritura de archivos al estilo log.