I have written a Python script that checks a certain e-mail address and passes new e-mails to an external program. How can I get this script to execute 24/7, such as turning it into daemon or service in Linux. Would I also need a loop that never ends in the program, or can it be done by just having the code re executed multiple times?

Solution 1

You have two options here.

  1. Make a proper cron job that calls your script. Cron is a common name for a GNU/Linux daemon that periodically launches scripts according to a schedule you set. You add your script into a crontab or place a symlink to it into a special directory and the daemon handles the job of launching it in the background. You can read more at Wikipedia. There is a variety of different cron daemons, but your GNU/Linux system should have it already installed.

  2. Use some kind of python approach (a library, for example) for your script to be able to daemonize itself. Yes, it will require a simple event loop (where your events are timer triggering, possibly, provided by sleep function).

I wouldn't recommend you to choose 2., because you would be, in fact, repeating cron functionality. The Linux system paradigm is to let multiple simple tools interact and solve your problems. Unless there are additional reasons why you should make a daemon (in addition to trigger periodically), choose the other approach.

Also, if you use daemonize with a loop and a crash happens, no one will check the mail after that (as pointed out by Ivan Nevostruev in comments to this answer). While if the script is added as a cron job, it will just trigger again.

Solution 2

Here's a nice class that is taken from here:

#!/usr/bin/env python

import sys, os, time, atexit
from signal import SIGTERM

class Daemon:
        A generic daemon class.

        Usage: subclass the Daemon class and override the run() method
        def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
                self.stdin = stdin
                self.stdout = stdout
                self.stderr = stderr
                self.pidfile = pidfile

        def daemonize(self):
                do the UNIX double-fork magic, see Stevens' "Advanced
                Programming in the UNIX Environment" for details (ISBN 0201563177)
                        pid = os.fork()
                        if pid > 0:
                                # exit first parent
                except OSError, e:
                        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))

                # decouple from parent environment

                # do second fork
                        pid = os.fork()
                        if pid > 0:
                                # exit from second parent
                except OSError, e:
                        sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))

                # redirect standard file descriptors
                si = file(self.stdin, 'r')
                so = file(self.stdout, 'a+')
                se = file(self.stderr, 'a+', 0)
                os.dup2(si.fileno(), sys.stdin.fileno())
                os.dup2(so.fileno(), sys.stdout.fileno())
                os.dup2(se.fileno(), sys.stderr.fileno())

                # write pidfile
                pid = str(os.getpid())
                file(self.pidfile,'w+').write("%s\n" % pid)

        def delpid(self):

        def start(self):
                Start the daemon
                # Check for a pidfile to see if the daemon already runs
                        pf = file(self.pidfile,'r')
                        pid = int(pf.read().strip())
                except IOError:
                        pid = None

                if pid:
                        message = "pidfile %s already exist. Daemon already running?\n"
                        sys.stderr.write(message % self.pidfile)

                # Start the daemon

        def stop(self):
                Stop the daemon
                # Get the pid from the pidfile
                        pf = file(self.pidfile,'r')
                        pid = int(pf.read().strip())
                except IOError:
                        pid = None

                if not pid:
                        message = "pidfile %s does not exist. Daemon not running?\n"
                        sys.stderr.write(message % self.pidfile)
                        return # not an error in a restart

                # Try killing the daemon process       
                        while 1:
                                os.kill(pid, SIGTERM)
                except OSError, err:
                        err = str(err)
                        if err.find("No such process") > 0:
                                if os.path.exists(self.pidfile):
                                print str(err)

        def restart(self):
                Restart the daemon

        def run(self):
                You should override this method when you subclass Daemon. It will be called after the process has been
                daemonized by start() or restart().

Solution 3

You should use the python-daemon library, it takes care of everything.

From PyPI: Library to implement a well-behaved Unix daemon process.

Solution 4

Assuming that you would really want your loop to run 24/7 as a background service

For a solution that doesn't involve injecting your code with libraries, you can simply create a service template, since you are using linux:

Description = <Your service description here>
After = network.target # Assuming you want to start after network interfaces are made available
Type = simple
ExecStart = python <Path of the script you want to run>
User = # User to run the script as
Group = # Group to run the script as
Restart = on-failure # Restart when there are errors
SyslogIdentifier = <Name of logs for the service>
RestartSec = 5
TimeoutStartSec = infinity
WantedBy = multi-user.target # Make it accessible to other users

Place that file in your daemon service folder (usually /etc/systemd/system/), in a *.service file, and install it using the following systemctl commands (will likely require sudo privileges):

systemctl enable <service file name without .service extension>

systemctl daemon-reload

systemctl start <service file name without .service extension>

You can then check that your service is running by using the command:

systemctl | grep running

Solution 5

You can use fork() to detach your script from the tty and have it continue to run, like so:

import os, sys
fpid = os.fork()
if fpid!=0:
  # Running as daemon now. PID is fpid

Of course you also need to implement an endless loop, like

while 1:

Hope this get's you started.

Solution 6

You can also make the python script run as a service using a shell script. First create a shell script to run the python script like this (scriptname arbitary name)

script='/home/.. full path to script'
/usr/bin/python $script &

now make a file in /etc/init.d/scriptname

#! /bin/sh

DAEMON=/home/.. path to shell script scriptname created to run python script

test -x $DAEMON || exit 0

. /lib/lsb/init-functions

case "$1" in
     log_daemon_msg "Starting feedparser"
     start_daemon -p $PIDFILE $DAEMON
     log_end_msg $?
     log_daemon_msg "Stopping feedparser"
     killproc -p $PIDFILE $DAEMON
     PID=`ps x |grep feed | head -1 | awk '{print $1}'`
     kill -9 $PID       
     log_end_msg $?
     $0 stop
     $0 start
     status_of_proc -p $PIDFILE $DAEMON atd && exit 0 || exit $?
   echo "Usage: /etc/init.d/atd {start|stop|restart|force-reload|status}"
   exit 1

exit 0

Now you can start and stop your python script using the command /etc/init.d/scriptname start or stop.

Solution 7

A simple and supported version is Daemonize.

Install it from Python Package Index (PyPI):

$ pip install daemonize

and then use like:

import os, sys
from daemonize import Daemonize
def main()
      # your code here

if __name__ == '__main__':
        pidfile='/tmp/%s' % myname       # any name
        daemon = Daemonize(app=myname,pid=pidfile, action=main)

Solution 8

cron is clearly a great choice for many purposes. However it doesn't create a service or daemon as you requested in the OP. cron just runs jobs periodically (meaning the job starts and stops), and no more often than once / minute. There are issues with cron -- for example, if a prior instance of your script is still running the next time the cron schedule comes around and launches a new instance, is that OK? cron doesn't handle dependencies; it just tries to start a job when the schedule says to.

If you find a situation where you truly need a daemon (a process that never stops running), take a look at supervisord. It provides a simple way to wrapper a normal, non-daemonized script or program and make it operate like a daemon. This is a much better way than creating a native Python daemon.

Solution 9

how about using $nohup command on linux?

I use it for running my commands on my Bluehost server.

Please advice if I am wrong.

Solution 10

Ubuntu has a very simple way to manage a service. For python the difference is that ALL the dependencies (packages) have to be in the same directory, where the main file is run from.

I just manage to create such a service to provide weather info to my clients. Steps:

  • Create your python application project as you normally do.

  • Install all dependencies locally like: sudo pip3 install package_name -t .

  • Create your command line variables and handle them in code (if you need any)

  • Create the service file. Something (minimalist) like:

      Description=1Droid Weather meddleware provider
      ExecStart=/usr/bin/python3 /home/ubuntu/weather/main.py httpport=9570  provider=OWMap
  • Save the file as myweather.service (for example)

  • Make sure that your app runs if started in the current directory

      python3  main.py httpport=9570  provider=OWMap
  • The service file produced above and named myweather.service (important to have the extension .service) will be treated by the system as the name of your service. That is the name that you will use to interact with your service.

  • Copy the service file:

      sudo cp myweather.service /lib/systemd/system/myweather.service
  • Refresh demon registry:

      sudo systemctl daemon-reload
  • Stop the service (if it was running)

      sudo service myweather stop
  • Start the service:

      sudo service myweather start
  • Check the status (log file with where your print statements go):

      tail -f /var/log/syslog
  • Or check the status with:

      sudo service myweather status
  • Back to the start with another iteration if needed

This service is now running and even if you log out it will not be affected. And YES if the host is shutdown and restarted this service will be restarted...

Solution 11

If you are using terminal(ssh or something) and you want to keep a long-time script working after you log out from the terminal, you can try this:


apt-get install screen

create a virtual terminal inside( namely abc): screen -dmS abc

now we connect to abc: screen -r abc

So, now we can run python script: python keep_sending_mails.py

from now on, you can directly close your terminal, however, the python script will keep running rather than being shut down

Since this keep_sending_mails.py's PID is a child process of the virtual screen rather than the terminal(ssh)

If you want to go back check your script running status, you can use screen -r abc again

Solution 12

First, read up on mail aliases. A mail alias will do this inside the mail system without you having to fool around with daemons or services or anything of the sort.

You can write a simple script that will be executed by sendmail each time a mail message is sent to a specific mailbox.

See http://www.feep.net/sendmail/tutorial/intro/aliases.html

If you really want to write a needlessly complex server, you can do this.

nohup python myscript.py &

That's all it takes. Your script simply loops and sleeps.

import time
def do_the_work():
    # one round of polling -- checking email, whatever.
while True:
    time.sleep( 600 ) # 10 min.

Solution 13

I would recommend this solution. You need to inherit and override method run.

import sys
import os
from signal import SIGTERM
from abc import ABCMeta, abstractmethod

class Daemon(object):
    __metaclass__ = ABCMeta

    def __init__(self, pidfile):
        self._pidfile = pidfile

    def run(self):

    def _daemonize(self):
        # decouple threads
        pid = os.fork()

        # stop first thread
        if pid > 0:

        # write pid into a pidfile
        with open(self._pidfile, 'w') as f:
            print >> f, os.getpid()

    def start(self):
        # if daemon is started throw an error
        if os.path.exists(self._pidfile):
            raise Exception("Daemon is already started")

        # create and switch to daemon thread

        # run the body of the daemon

    def stop(self):
        # check the pidfile existing
        if os.path.exists(self._pidfile):
            # read pid from the file
            with open(self._pidfile, 'r') as f:
                pid = int(f.read().strip())

            # remove the pidfile

            # kill daemon
            os.kill(pid, SIGTERM)

            raise Exception("Daemon is not started")

    def restart(self):

Solution 14

to creating some thing that is running like service you can use this thing :

The first thing that you must do is installing the Cement framework: Cement frame work is a CLI frame work that you can deploy your application on it.

command line interface of the app :


 from cement.core.foundation import CementApp
 from cement.core.controller import CementBaseController, expose
 from YourApp import yourApp

 class Meta:
    label = 'base'
    description = "your application description"
    arguments = [
        (['-r' , '--run'],
          dict(action='store_true', help='Run your application')),
        (['-v', '--version'],
          dict(action='version', version="Your app version")),
        (['-s', '--stop'],
          dict(action='store_true', help="Stop your application")),

    def default(self):
        if self.app.pargs.run:
            #Start to running the your app from there !
        if self.app.pargs.stop:
            #Stop your application

 class App(CementApp):
       class Meta:
       label = 'Uptime'
       base_controller = 'base'
       handlers = [MyBaseController]

 with App() as app:

YourApp.py class:

 import threading

 class yourApp:
     def __init__:
        self.loger = log_exception.exception_loger()
        thread = threading.Thread(target=self.start, args=())
        thread.daemon = True

     def start(self):
        #Do every thing you want
     def stop(self):
        #Do some things to stop your application

Keep in mind that your app must run on a thread to be daemon

To run the app just do this in command line

python interface.py --help

Solution 15

Use whatever service manager your system offers - for example under Ubuntu use upstart. This will handle all the details for you such as start on boot, restart on crash, etc.

Solution 16

You could use Docker for that. The only thing you need then, is to make a script run forever, for example with while True.

  1. The script:
    #!/usr/bin/env python3 
    import time
    from datetime import datetime
    while True:
        cur_time = datetime.now().isoformat()
        print(f"Hey! I'm still there! The time is: {cur_time}")
  2. Command to run
    docker run \
        -d -it \
        --restart always \
        -v "$(pwd)/script.py:/opt/script.py" \
        --entrypoint=python3 \
        --name my_daemon \
        pycontribs/alpine:latest \
    • pycontribs/alpine:latest - is an image of a lightweight Linux distro with Python 3.8 preinstalled
    • --name my_daemon - is a clear name for your container
    • --entrypoint=python3 - program to start container with, python3 in the example
    • -v "$(pwd)/script.py:/opt/script.py" - the way to put your script from host inside container to /opt/script.py. Where $(pwd)/script.py - is a path to the script on host system. Better to change it to absolute path, then it would be something like -v "/home/user/Scripts/script.py:/opt/script.py"
    • /opt/script.py - argument to python3 to start with, so in container it would actually be python3 /opt/script.py
    • --restart always - to make the container autostart when the host system starts
  3. Checking the script is running in background:
    $ docker logs my_daemon  -f
    Hey! I'm still there! The time is: 2022-04-20T07:09:11.308271
    Hey! I'm still there! The time is: 2022-04-20T07:09:12.309203
    Hey! I'm still there! The time is: 2022-04-20T07:09:13.310255
    Hey! I'm still there! The time is: 2022-04-20T07:09:14.311309
    Hey! I'm still there! The time is: 2022-04-20T07:09:15.312361
    Hey! I'm still there! The time is: 2022-04-20T07:09:16.313175
    Hey! I'm still there! The time is: 2022-04-20T07:09:17.314242
    Hey! I'm still there! The time is: 2022-04-20T07:09:18.315321
    Hey! I'm still there! The time is: 2022-04-20T07:09:19.315465
    Hey! I'm still there! The time is: 2022-04-20T07:09:20.315807
    Hey! I'm still there! The time is: 2022-04-20T07:09:21.316895
    Hey! I'm still there! The time is: 2022-04-20T07:09:22.317253

Solution 17

You can run a process as a subprocess inside a script or in another script like this

subprocess.Popen(arguments, close_fds=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL)

Or use a ready-made utility