files for daemon

daeRun.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+import sys, time
+from daemon import Daemon
+from infoRet import get_data_rss
+
+
+class MyDaemon(Daemon):
+    def run(self):
+        while True:
+            time.sleep(1)
+
+
+if __name__ == "__main__":
+    daemon = MyDaemon('/tmp/daemon-example.pid')
+    if len(sys.argv) == 2:
+        if 'start' == sys.argv[1]:
+            print('Daemon started')
+            daemon.start()
+        elif 'stop' == sys.argv[1]:
+            print('Daemon stopped')
+            daemon.stop()
+        elif 'restart' == sys.argv[1]:
+            print('Daemon restarted')
+            daemon.restart()
+        else:
+            print("Unknown command")
+            sys.exit(2)
+
+        sys.exit(0)
+    else:
+        print
+        "usage: %s start|stop|restart" % sys.argv[0]
+        sys.exit(2)

daemon.py

@@ -0,0 +1,145 @@
+"""
+
+import daemon
+from infoRet import get_data_rss
+from time import gmtime, strftime
+
+
+with daemon.
+
+    currTime = strftime("%H:%M:%S", gmtime())
+
+    if currTime == "19:33:00":
+        get_data_rss()
+"""
+
+#!/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)
+                http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
+                """
+                try:
+                        pid = os.fork()
+                        if pid > 0:
+                                # exit first parent
+                                sys.exit(0)
+                except OSError as e:
+                        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
+                        sys.exit(1)
+
+                # decouple from parent environment
+                os.chdir("/")
+                os.setsid()
+                os.umask(0)
+
+                # do second fork
+                try:
+                        pid = os.fork()
+                        if pid > 0:
+                                # exit from second parent
+                                sys.exit(0)
+                except OSError as e:
+                        sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
+                        sys.exit(1)
+
+                # redirect standard file descriptors
+                sys.stdout.flush()
+                sys.stderr.flush()
+                si = open(self.stdin, 'r')
+                so = open(self.stdout, 'a+')
+                se = open(self.stderr, 'a+')
+                os.dup2(si.fileno(), sys.stdin.fileno())
+                os.dup2(so.fileno(), sys.stdout.fileno())
+                os.dup2(se.fileno(), sys.stderr.fileno())
+
+                # write pidfile
+                atexit.register(self.delpid)
+                pid = str(os.getpid())
+                open(self.pidfile, 'w+').write("%s\n" % pid)
+
+        def delpid(self):
+                os.remove(self.pidfile)
+
+        def start(self):
+                """
+                Start the daemon
+                """
+                # Check for a pidfile to see if the daemon already runs
+                try:
+                        pf = open(self.pidfile, 'r')
+                        pid = int(pf.read().strip())
+                        pf.close()
+                except IOError:
+                        pid = None
+
+                if pid:
+                        message = "pidfile %s already exist. Daemon already running?\n"
+                        sys.stderr.write(message % self.pidfile)
+                        sys.exit(1)
+
+                # Start the daemon
+                self.daemonize()
+                self.run()
+
+        def stop(self):
+                """
+                Stop the daemon
+                """
+                # Get the pid from the pidfile
+                try:
+                        pf = open(self.pidfile, 'r')
+                        pid = int(pf.read().strip())
+                        pf.close()
+                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
+                try:
+                        while 1:
+                                os.kill(pid, SIGTERM)
+                                time.sleep(0.1)
+                except OSError as err:
+                        err = str(err)
+                        if err.find("No such process") > 0:
+                                if os.path.exists(self.pidfile):
+                                        os.remove(self.pidfile)
+                        else:
+                                print(str(err))
+                                sys.exit(1)
+
+        def restart(self):
+                """
+                Restart the daemon
+                """
+                self.stop()
+                self.start()
+
+        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().
+                """