by

Creating a Linux Daemon (service) in Delphi.

Edit: I originally wrote this post back in April 2017. Three months after I did, Paolo Rossi (MVP) also published a post on writing a Linux Daemon in Delphi entitled “Building a (real) Linux daemon with Delphi” I have to assume, given that Linux support was still new in Delphi and that there weren’t any other articles on the subject, that the “real” in his title may have been a response to my post. My post is really quite light on detail, intentionally so, showing only the fork() mechanism for daemonizing an application. Paolo goes into more detail, including handling system “signals” in order to create a genuine daemon that plays nice with the operating system. I did mention in my conclusion that further reading on handling signals may be required, and so I hand it to Paolo, his post is superior to mine in its completeness and attention to the detail. None the less, I feel my post stands as good information to get started. I recommend that you might read his instead, or else both since this is quite short.

With the introduction of the Linux target for Delphi, a wide range of possibilities are opened up to Delphi developers, to create Linux server applications. Unfortunately there are currently a limited number of project types available from the RAD Studio IDE, and those do not include creating a service (or Daemon as it’s called in the Linux world).

In this post I am assuming you are already configured to deploy an application to Linux and understand how to launch it from the Linux command line. If this is not the case, see my earlier posts covering these subjects:
 
https://chapmanworld.com/embarcadero-delphi-linux-bootcamp/
https://chapmanworld.com/configure-delphi-and-redhat-or-ubuntu-for-linux-development/

Under the Linux operating system, a Daemon is simply an executable which continues running while ignoring the standard input and output streams. That-is, they do not accept input from the keyboard, and they do not present data to the screen (except in special circumstances). So an application which simply continues to run in the background without using the standard input and output, is a Daemon.

One other property of a Daemon application is that it runs in the background. Applications run from the terminal window in Linux are provided with the standard input and output streams, and therefore the terminal becomes unusable until the application terminates. To demonstrate, create a new command line application and set it’s source code to read as follows…

program Project1;
{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

begin
  try
    while true do sleep(100);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

If you run this application from the command line, you’ll find that it enters into an infinite loop (the while loop), and you do not regain control of the terminal window until you issue [CTRL] + [C] to abort the application.

Lets now turn this application into a Daemon. Alter your source code to read as follows…

program Project1;
{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  Posix.Unistd;

begin
  try
    if fork()<>0 then begin
      exit;
    end;
    while true do sleep(100);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Now, when you attempt to run this application from the command line, it will immediately exit. It will appear as though the application did nothing. However, issue the instruction:


ps -e

You’ll notice that “Project1” is actually still running, it’s simply been moved to the background.
As a side note, you can kill the application by making a note of it’s process ID (in my case 16898 from the screenshot) and issuing the appropriate kill instruction: 


kill 16898

You could now replace the infinite while loop with whatever application logic you need within your daemon.

How does this work?

The key to this working is the “fork()” method, which can be found in the unit “Posix.Unistd”. The fork method is a part of the standard posix API, who’s documentation may be found here: https://linux.die.net/man/3/fork

What fork does is to create a copy of which-ever process calls it, in our case Project1.
So at the moment fork is called, our application execution either continues in the originating process, or it continues in the copy process.

The return value of the call to fork tells us which instance of the process we are executing in. A return value of zero tells us that we are executing in the child process (the copy), and any other value tells us that we are executing in the parent process (the originator). In fact, when the return of fork is not zero, it is the process ID of the newly created child process. We simply call ‘exit’ to exit the application when we determine that we are in the parent process, allowing the child copy to proceed on to the infinite while loop.

Conclusion

At this point you are able to create daemon applications. You may wish to research the Linux (posix) API’s in a little more detail to see how to handle ‘signals’ which may be used to gracefully terminate your application, rather than using the brute force termination of a kill instruction. You might also want some way to communicate with your daemon process. There are many ways to communicate with the process, but possibly the most familiar to a Delphi developer would be to use TCP/IP. Turning your service into a TCP/IP server would allow you to send data and instructions to it.

Regardless of what you decide to do with your daemon, I hope you found this brief instructional useful.

Thanks for reading!