timer file descriptor HOWTO
***************************

Release:
   1.13

This HOWTO discusses Python's support for the linux timer file
descriptor.


Examples
========

The following example shows how to use a timer file descriptor to
execute a function twice a second:

   # Practical scripts should use really use a non-blocking timer,
   # we use a blocking timer here for simplicity.
   import os, time

   # Create the timer file descriptor
   fd = os.timerfd_create(time.CLOCK_REALTIME)

   # Start the timer in 1 second, with an interval of half a second
   os.timerfd_settime(fd, initial=1, interval=0.5)

   try:
       # Process timer events four times.
       for _ in range(4):
           # read() will block until the timer expires
           _ = os.read(fd, 8)
           print("Timer expired")
   finally:
       # Remember to close the timer file descriptor!
       os.close(fd)

To avoid the precision loss caused by the "float" type, timer file
descriptors allow specifying initial expiration and interval in
integer nanoseconds with "_ns" variants of the functions.

This example shows how "epoll()" can be used with timer file
descriptors to wait until the file descriptor is ready for reading:

   import os, time, select, socket, sys

   # Create an epoll object
   ep = select.epoll()

   # In this example, use loopback address to send "stop" command to the server.
   #
   # $ telnet 127.0.0.1 1234
   # Trying 127.0.0.1...
   # Connected to 127.0.0.1.
   # Escape character is '^]'.
   # stop
   # Connection closed by foreign host.
   #
   sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   sock.bind(("127.0.0.1", 1234))
   sock.setblocking(False)
   sock.listen(1)
   ep.register(sock, select.EPOLLIN)

   # Create timer file descriptors in non-blocking mode.
   num = 3
   fds = []
   for _ in range(num):
       fd = os.timerfd_create(time.CLOCK_REALTIME, flags=os.TFD_NONBLOCK)
       fds.append(fd)
       # Register the timer file descriptor for read events
       ep.register(fd, select.EPOLLIN)

   # Start the timer with os.timerfd_settime_ns() in nanoseconds.
   # Timer 1 fires every 0.25 seconds; timer 2 every 0.5 seconds; etc
   for i, fd in enumerate(fds, start=1):
       one_sec_in_nsec = 10**9
       i = i * one_sec_in_nsec
       os.timerfd_settime_ns(fd, initial=i//4, interval=i//4)

   timeout = 3
   try:
       conn = None
       is_active = True
       while is_active:
           # Wait for the timer to expire for 3 seconds.
           # epoll.poll() returns a list of (fd, event) pairs.
           # fd is a file descriptor.
           # sock and conn[=returned value of socket.accept()] are socket objects, not file descriptors.
           # So use sock.fileno() and conn.fileno() to get the file descriptors.
           events = ep.poll(timeout)

           # If more than one timer file descriptors are ready for reading at once,
           # epoll.poll() returns a list of (fd, event) pairs.
           #
           # In this example settings,
           #    1st timer fires every 0.25 seconds in 0.25 seconds. (0.25, 0.5, 0.75, 1.0, ...)
           #    2nd timer every 0.5 seconds in 0.5 seconds. (0.5, 1.0, 1.5, 2.0, ...)
           #    3rd timer every 0.75 seconds in 0.75 seconds. (0.75, 1.5, 2.25, 3.0, ...)
           #
           #    In 0.25 seconds, only 1st timer fires.
           #    In 0.5 seconds, 1st timer and 2nd timer fires at once.
           #    In 0.75 seconds, 1st timer and 3rd timer fires at once.
           #    In 1.5 seconds, 1st timer, 2nd timer and 3rd timer fires at once.
           #
           # If a timer file descriptor is signaled more than once since
           # the last os.read() call, os.read() returns the number of signaled
           # as host order of class bytes.
           print(f"Signaled events={events}")
           for fd, event in events:
               if event & select.EPOLLIN:
                   if fd == sock.fileno():
                       # Check if there is a connection request.
                       print(f"Accepting connection {fd}")
                       conn, addr = sock.accept()
                       conn.setblocking(False)
                       print(f"Accepted connection {conn} from {addr}")
                       ep.register(conn, select.EPOLLIN)
                   elif conn and fd == conn.fileno():
                       # Check if there is data to read.
                       print(f"Reading data {fd}")
                       data = conn.recv(1024)
                       if data:
                           # You should catch UnicodeDecodeError exception for safety.
                           cmd = data.decode()
                           if cmd.startswith("stop"):
                               print(f"Stopping server")
                               is_active = False
                           else:
                               print(f"Unknown command: {cmd}")
                       else:
                           # No more data, close connection
                           print(f"Closing connection {fd}")
                           ep.unregister(conn)
                           conn.close()
                           conn = None
                   elif fd in fds:
                       print(f"Reading timer {fd}")
                       count = int.from_bytes(os.read(fd, 8), byteorder=sys.byteorder)
                       print(f"Timer {fds.index(fd) + 1} expired {count} times")
                   else:
                       print(f"Unknown file descriptor {fd}")
   finally:
       for fd in fds:
           ep.unregister(fd)
           os.close(fd)
       ep.close()

This example shows how "select()" can be used with timer file
descriptors to wait until the file descriptor is ready for reading:

   import os, time, select, socket, sys

   # In this example, use loopback address to send "stop" command to the server.
   #
   # $ telnet 127.0.0.1 1234
   # Trying 127.0.0.1...
   # Connected to 127.0.0.1.
   # Escape character is '^]'.
   # stop
   # Connection closed by foreign host.
   #
   sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   sock.bind(("127.0.0.1", 1234))
   sock.setblocking(False)
   sock.listen(1)

   # Create timer file descriptors in non-blocking mode.
   num = 3
   fds = [os.timerfd_create(time.CLOCK_REALTIME, flags=os.TFD_NONBLOCK)
          for _ in range(num)]
   select_fds = fds + [sock]

   # Start the timers with os.timerfd_settime() in seconds.
   # Timer 1 fires every 0.25 seconds; timer 2 every 0.5 seconds; etc
   for i, fd in enumerate(fds, start=1):
      os.timerfd_settime(fd, initial=i/4, interval=i/4)

   timeout = 3
   try:
       conn = None
       is_active = True
       while is_active:
          # Wait for the timer to expire for 3 seconds.
          # select.select() returns a list of file descriptors or objects.
          rfd, wfd, xfd = select.select(select_fds, select_fds, select_fds, timeout)
          for fd in rfd:
              if fd == sock:
                  # Check if there is a connection request.
                  print(f"Accepting connection {fd}")
                  conn, addr = sock.accept()
                  conn.setblocking(False)
                  print(f"Accepted connection {conn} from {addr}")
                  select_fds.append(conn)
              elif conn and fd == conn:
                  # Check if there is data to read.
                  print(f"Reading data {fd}")
                  data = conn.recv(1024)
                  if data:
                      # You should catch UnicodeDecodeError exception for safety.
                      cmd = data.decode()
                      if cmd.startswith("stop"):
                          print(f"Stopping server")
                          is_active = False
                      else:
                          print(f"Unknown command: {cmd}")
                  else:
                      # No more data, close connection
                      print(f"Closing connection {fd}")
                      select_fds.remove(conn)
                      conn.close()
                      conn = None
              elif fd in fds:
                  print(f"Reading timer {fd}")
                  count = int.from_bytes(os.read(fd, 8), byteorder=sys.byteorder)
                  print(f"Timer {fds.index(fd) + 1} expired {count} times")
              else:
                  print(f"Unknown file descriptor {fd}")
   finally:
       for fd in fds:
          os.close(fd)
       sock.close()
       sock = None
