Lone Wolves

#1 Guido van Steen

#2 coolluck (http://tech.coolluck.org/)

#3 Sander Marechal (http://www.jejik.com)

#4 narthollis

#5 Anonymous Coward

#6 Sander Marechal (http://www.jejik.com)

#7 Jacob Singh (http://pajamadesign.com)

#8 Sander Marechal (http://www.jejik.com)

#9 Anonymous Coward

#10 Sander Marechal (http://www.jejik.com)

#11 Anonymous Coward

#12 Sander Marechal (http://www.jejik.com)

#13 Preston Hunt (http://prestonhunt.com)

#14 Guilherme Gall

#15 Jonathan Manning

#16 HosipLan (http://kdyby.org)

#17 Raj (http://rajorshi.net/blog)

#18 Anonymous Coward

#19 Sander Marechal (http://www.jejik.com)

#20 Anonymous Coward

#21 Sander Marechal (http://www.jejik.com)

#22 Vik

#23 Sander Marechal (http://www.jejik.com)

#24 Roel

#25 Sander Marechal (http://www.jejik.com)

#26 Andr

#!/usr/bin/env python

try:
    import os
    import sys
    import time
    import atexit
    from signal import SIGTERM
except StandardError, e:
    import sys
    print "Error while loading libraries: "
    print e
    sys.exit()

class HcpDaemon:
    """
    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):
        try:
            pid = os.fork()
            if pid > 0:
                # exit first parent
                sys.exit(0)
        except OSError, e:
            print >>sys.stderr, "fork #1 failed: %d (%s)" % (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, print eventual PID before
                print "Daemon PID %d" % pid
                sys.exit(0)
        except OSError, e:
            print >>sys.stderr, "fork #2 failed: %d (%s)" % (e.errno, e.strerror)
            sys.exit(1)

        sys.stdout.flush()
        sys.stderr.flush()
        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())

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

        atexit.register(self.delpid)

    def delpid(self):
        os.remove(self.pidfile)

    def stop(self):
        try:
            pf = file(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:
            while 1:
                os.kill(pid, SIGTERM)
                time.sleep(0.1)
        except OSError, 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):
        self.stop()
        self.start()

    def start(self):
        try:
            pf = file(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)
        self.daemonize()
        self.run()

    def run(self):
        """Override while subclassing"""

#27 Andr

#28 Sander Marechal (http://www.jejik.com)

#29 Andre

#30 Brian

#31 Robert

#32 Sander Marechal (http://www.jejik.com)

#33 Brian

#34 Vik

#35 Anonymous Coward

#36 Sander Marechal (http://www.jejik.com)

#37 Sander Marechal (http://www.jejik.com)

#38 Vik

#39 Sander Marechal (http://www.jejik.com)

#40 Justin

#41 Sander Marechal (http://www.jejik.com)

#42 Seth

"""\
Daemon base and control class.

This file contains the daemon base class for a UNIX daemon and the control
class for it. See test logic at the end of file and test_daemon.py to
understand how to use it.\
"""

import sys, os, time, atexit, signal

# -- generic daemon base class ------------------------------------------ #

class daemon_base:
	"""A generic daemon base class.
	
	Usage: subclass this class and override the run() method.
	"""
	def __init__(self, pidfile, workpath='/'):
		"""Constructor.

		We need the pidfile for the atexit cleanup method.
		The workpath is the path the daemon will operate
		in. Normally this is the root directory, but can be some
		data directory too, just make sure it exists.
		"""
		self.pidfile = pidfile
		self.workpath = workpath
	
	def perror(self, msg, err):
		"""Print error message and exit. (helper method)
		"""
		msg = msg + '\n'
		sys.stderr.write(msg.format(err))
		sys.exit(1)

	def daemonize(self):
		"""Deamonize calss process. (UNIX double fork mechanism).
		"""
		if not os.path.isdir(self.workpath):
			self.perror('workpath does not exist!', '')

		try: # exit first parent process
			pid = os.fork() 
			if pid > 0: sys.exit(0) 
		except OSError as err:
			self.perror('fork #1 failed: {0}', err)
	
		# decouple from parent environment
		try: os.chdir(self.workpath)
		except OSError as err:
			self.perror('path change failed: {0}', err)

		os.setsid() 
		os.umask(0) 
	
		try: # exit from second parent
			pid = os.fork() 
			if pid > 0: sys.exit(0) 
		except OSError as err:
			self.perror('fork #2 failed: {0}', err)
	
		# redirect standard file descriptors
		sys.stdout.flush()
		sys.stderr.flush()
		si = open(os.devnull, 'r')
		so = open(os.devnull, 'a+')
		se = open(os.devnull, '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(os.remove, self.pidfile)
		pid = str(os.getpid())
		with open(self.pidfile,'w+') as f:
			f.write(pid + '\n')
		self.run()
	
	def run(self):
		"""Worker method.
		
		It will be called after the process has been daemonized
		by start() or restart(). You'll have to overwrite this
		method with the daemon program logic.
		"""
		while True:
			time.sleep(1)

# -- daemon control class ----------------------------------------------- #

class daemon_ctl:
	"""Control class for a daemon.

	Usage:
	>>>	dc = daemon_ctl(daemon_base, '/tmp/foo.pid')
	>>>	dc.start()

	This class is the control wrapper for the above (daemon_base)
	class. It adds start/stop/restart functionality for it withouth
	creating a new daemon every time.
	"""
	def __init__(self, daemon, pidfile, workdir='/'):
		"""Constructor.

		@param daemon: daemon class (not instance)
		@param pidfile: daemon pid file
		@param workdir: daemon working directory
		"""
		self.daemon = daemon
		self.pidfile = pidfile
		self.workdir = workdir
	
	def start(self):
		"""Start the daemon.
		"""
		try: # check for pidfile to see if the daemon already runs
			with open(self.pidfile, 'r') as pf:
				pid = int(pf.read().strip())
		except IOError: pid = None
	
		if pid:
			message = "pidfile {0} already exist. " + \
					"Daemon already running?\n"
			sys.stderr.write(message.format(self.pidfile))
			sys.exit(1)
		
		# Start the daemon
		d = self.daemon(self.pidfile, self.workdir)
		d.daemonize()

	def stop(self):
		"""Stop the daemon.

		This is purely based on the pidfile / process control
		and does not reference the daemon class directly.
		"""
		try: # get the pid from the pidfile
			with open(self.pidfile,'r') as pf:
				pid = int(pf.read().strip())
		except IOError: pid = None
	
		if not pid:
			message = "pidfile {0} does not exist. " + \
					"Daemon not running?\n"
			sys.stderr.write(message.format(self.pidfile))
			return # not an error in a restart

		try: # try killing the daemon process	
			while 1:
				os.kill(pid, signal.SIGTERM)
				time.sleep(0.1)
		except OSError as err:
			e = str(err.args)
			if e.find("No such process") > 0:
				if os.path.exists(self.pidfile):
					os.remove(self.pidfile)
			else:
				print (str(err.args))
				sys.exit(1)

	def restart(self):
		"""Restart the daemon.
		"""
		self.stop()
		self.start()

# -- test logic --------------------------------------------------------- #

if __name__ == '__main__':
	"""Daemon test logic.

	This logic must be called as seperate executable (i.e. python3
	daemon.py start/stop/restart).	See test_daemon.py for
	implementation.
	"""
	usage = 'Missing parameter, usage of test logic:\n' + \
			' % python3 daemon.py start|restart|stop\n'
	if len(sys.argv) < 2:
		sys.stderr.write(usage)
		sys.exit(2)

	pidfile = '/tmp/test_daemon.pid'
	dc = daemon_ctl(daemon_base, pidfile)

	if sys.argv[1] == 'start':
		dc.start()
	elif sys.argv[1] == 'stop':
		dc.stop()
	elif sys.argv[1] == 'restart':
		dc.restart()

"""\
Base daemon test file.

This file tests the base daemon (runs it's test logic). The daemon is
started, then stopped, then started then restarted then stopped again.

The output of this file should look like this (with different pids):

starting daemon
listing processes
15554 ?        S      0:00 python3 daemon.py start
-rw-rw-rw- 1 seth seth 6 2009-06-13 14:55 /tmp/test_daemon.pid
stopping daemon
listing processes
ls: cannot access /tmp/test_daemon.pid: No such file or directory
starting daemon
listing processes
15572 ?        S      0:00 python3 daemon.py start
-rw-rw-rw- 1 seth seth 6 2009-06-13 14:55 /tmp/test_daemon.pid
restarting daemon
listing processes
15582 ?        S      0:00 python3 daemon.py restart
-rw-rw-rw- 1 seth seth 6 2009-06-13 14:55 /tmp/test_daemon.pid
stopping daemon
listing processes
ls: cannot access /tmp/test_daemon.pid: No such file or directory
"""

import os, time

if __name__ == '__main__':
	start_cmd = 'python3 daemon.py start'
	stop_cmd = 'python3 daemon.py stop'
	restart_cmd = 'python3 daemon.py restart'

	os.chdir(os.path.abspath(os.path.dirname(__file__)))
	
	print('starting daemon')
	os.system(start_cmd)
	time.sleep(0.2)
	print('listing processes')
	os.system('ps x | grep "python3 daemon.py" | grep -v grep')
	os.system('ls -l /tmp/test_daemon.pid')

	print('stopping daemon')
	os.system(stop_cmd)
	time.sleep(0.2)
	print('listing processes')
	os.system('ps x | grep "python3 daemon.py" | grep -v grep')
	os.system('ls -l /tmp/test_daemon.pid')
	
	print('starting daemon')
	os.system(start_cmd)
	time.sleep(0.2)
	print('listing processes')
	os.system('ps x | grep "python3 daemon.py" | grep -v grep')
	os.system('ls -l /tmp/test_daemon.pid')
	print('restarting daemon')
	os.system(restart_cmd)
	time.sleep(0.2)
	print('listing processes')
	os.system('ps x | grep "python3 daemon.py" | grep -v grep')
	os.system('ls -l /tmp/test_daemon.pid')
	print('stopping daemon')
	os.system(stop_cmd)
	time.sleep(0.2)
	print('listing processes')
	os.system('ps x | grep "python3 daemon.py" | grep -v grep')
	os.system('ls -l /tmp/test_daemon.pid')

#43 Vik

#44 Sander Marechal (http://www.jejik.com)

#45 Vik

#46 acid (http://blutrache.blogspot.com)

#47 Sander Marechal (http://www.jejik.com)

#48 acid (http://blutrache.blogspot.com)

#49 Sander Marechal (http://www.jejik.com)

#50 Doug

#51 Sander Marechal (http://www.jejik.com)

#52 Doug

#53 Doug

#54 Chenix

#55 Sander Marechal (http://www.jejik.com)

#56 Mike

#57 Sander Marechal (http://www.jejik.com)

# Tell MPD to terminate
os.kill (mpd_pid, signal.SIGTERM)
# wait a few seconds for MPD to finish
time.sleep(3)
# If MPD still lives, kill it the hard way
try:
    os.kill (mpd_pid, signal.SIGKILL)
except OSError:
    pass # SIGTERM already shut down MPD

#58 Mike

#59 Sander Marechal (http://www.jejik.com)

#60 Mike

#61 Seth

import signal

[...]

def cleanup_handler(signum, frame):
	os.remove(pidfile)

signal.signal(signal.SIGTERM, cleanup_handler)

#62 Sander Marechal (http://www.jejik.com)

#63 stelvis

#64 stelvis

#65 Sander Marechal (http://www.jejik.com)

#66 stelvis

#67 Sander Marechal (http://www.jejik.com)

#68 dik123

#69 prakash

def run(self):
    while True:
        Date=date.today()
        open('/proc/net/dev','r')
        Lines=DevFile.readlines()
        Line1=Lines[3].split(':')
        Line2=Line1[1].split()
        Ty=Date.strftime("%y")
        Tm=Date.strftime("%m")
        Td=Date.strftime("%d")
        TH=time.strftime("%H")
        TM=time.strftime("%M")
        TS=time.strftime("%S")
        #L=open("log.txt",'a')
        #L.write("in run of my daemon")
        path=Ty+"/"+Tm+"/"+Td+"/"+TH+"/"+TM
        Ap=open(path,"a")   
        Ap.write(Ty+":"+Tm+":"+Td+":"+TH+":"+TM+":"+TS+":"+
                 Line2[0]+":"+Line2[8]+"\n")
        Ap.close()      
        time.sleep(1)

#70 Sander Marechal (http://www.jejik.com)

#71 Peter (http://sourceforge.net/projects/cozy/)

#72 solarn

#73 solarn

#74 solarn

#75 Sander Marechal (http://www.jejik.com)

#76 eromirou

#77 Girish Venkatachalam (http://spam-cheetah.com)

#78 Sander Marechal (http://www.jejik.com)

#79 eromirou

#80 Sander Marechal (http://www.jejik.com)

#81 Monte Davis

#82 Sander Marechal (http://www.jejik.com)

# redirect standard file descriptors
sys.stdout.flush()
sys.stderr.flush()

# Close the old descriptors
sys.stdin.close()
sys.stdout.close()
sys.stderr.close()
os.close(0)
os.close(1)
os.close(2)

# Create the new file descriptors and attach them
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())

#83 Megaman821

#84 Sander Marechal (http://www.jejik.com)

#85 Adam Collard

#86 CMFL

#!/usr/bin/python                                  
#############################################################
# Script: sighandler.py                                      
# Description:                                               
#   Demonstrate generic polymorphism example of how to setup and
#   handle implemented signals through python.                  
#                                                               
# Author: Cody Lane                                             
# Date: 12-4-2009                                               
#############################################################   

import signal
import sys   
import os    

class SignalHandler:
    '''             
    This class is used to handle and trap a signal and associate
    it back to a python callable object. When a new SignalHandler
    object is created you must call the register() method to register
    the signal and callback.  See register() for details.            

    This superclass has an abstract method called 'handler' which
    should be defined in a sub-class.                            

    This class is a super class for SigAction. SigAction is the 
    class that performs the signal event handling.              
    '''                                                         
    SIGNALS = ()                                                
                                                                
    def register(self, signum, callback):                       
        '''                                                     
        Registers a new signal handler action object (SigAction) 
        for trapping a signal and then calling a python object.  

        When this method is called it also updates the static SIGNALS
        tuple appending the new SigAction class.  To get this tuple  
        see getActions().                                            

        @param signum: int -> Should be signal int.  Ex: signal.SIGTERM
        @param callback: pythonObj -> Should be python object.  Ex: somemethod
            NOTE: Don't put () around your callback function or the function  
                  will be called when the callback is initialized..           
        '''                                                                   
        self.SIGNALS += (SigAction(signum, callback), )                       

    def getActions(self):
        '''              
        Return a tuple of defined signal actions if any.  If defined, 
        the tuple will contain SigAction instances.                   
        '''                                                           
        return self.SIGNALS                                           

    def handler(self, signum, frame):
        '''                          
        Abstract method, which must be defined when sub-classing.
        If the method is not defined, an AssertionError will be raised.
        '''                                                            
        assert 0, "You must define a handler(signum, frame) method in %s" %(self)

    def __repr__(self):
        '''            
        Custom string method when printing the class object.  
            Example:                                          
                >>> print self                                
                <Class: SignalHandler>                        
        '''                                                   
        return "<Class:%s>" %(self.__class__.__name__)        

class SigAction(SignalHandler):
    '''                        
    This class defines how a signal should be traped and what do when
    a signal trap occurs.  This class should NOT be instantiated because
    the superclass SignalHandler will setup and create a SigAction object
    when the SignalHandler.register() method is called.                  

    '''
    def __init__(self, signum, callback):
        '''                              
        Create a SigAction object.  Also setup the signal trap.

        @param signum: int -> Should be signal int.  Ex: signal.SIGTERM
        @param callback: pythonObj -> Should be python object.  Ex: somemethod
            NOTE: Don't put () around your callback function or the function  
                  will be called when the callback is initialized..           
        '''                                                                   
        self.signum = signum                                                  
        self.callback = callback                                              
        signal.signal(self.signum, self.handler)                              

    def handler(self, signum, frame):
        '''                          
        Overrides the superclass definition so that each new signal performs
        it's own action.                                                    

        NOTE: You do not have to pass arguments to this method. See help(signal)
        for details.                                                            
        '''
        self.callback()

    def __repr__(self):
        '''
        Custom string message when class object is printed.

        Example:
            >>> print self
            <Class:SigAction signal:15>
        '''
        return "<Class:%s signal:%s>" %(self.__class__.__name__, self.signum)

def stop():
    print "Called the stop().... Exitting 0"
    sys.exit(0)

def abort():
    print "Called abort().... Exitting 1"
    sys.exit(1)

if __name__ == '__main__':
    # Create SignalHandler object
    sighandler = SignalHandler()

    # Now register a SIGTERM (kill -15) and callback
    # object when signal is trapped.
    sighandler.register( signal.SIGTERM, stop)

    # Register a SIGINT (kill -2) and callback
    # object when sign is trapped.
    # This is equivalent to CTRL-C
    sighandler.register( signal.SIGINT, abort )

    # Display the current registered signal events.
    # This is just for show and tell purposes.
    print "Implemented Signals: ", sighandler.getActions()

    while True:
        print "Waiting for signal.... Running pid: %s" %(os.getpid())
        signal.pause()

$ ./sighandler.py
Implemented Signals:  (<Class:SigAction signal:15>, <Class:SigAction signal:2>)
Waiting for signal.... Running pid: 5276
^CCalled abort().... Exitting 1

$ ./sighandler.py &
[1] 5277
Implemented Signals:  (<Class:SigAction signal:15>, <Class:SigAction signal:2>)
Waiting for signal.... Running pid: 5277

$ kill 5277
Called the stop().... Exitting 0
$

#87 Sander Marechal (http://www.jejik.com)

#88 CMFL

#89 Anonymous Coward

#90 Sander Marechal (http://www.jejik.com)

#91 Batista

#92 Alfredo

#93 Josh R

#94 Anonymous Coward

#95 Vindicar

#96 haridsv

#97 thcourbon (http://blog.cafeaumiel.com)

#98 Senton

#99 James (http://linux-101.org)

#100 J_Skrilla

#101 Anonymous Coward

#102 Anonymous Coward

#103 Sander Marechal (http://www.jejik.com)

#104 Rico (http://www.rodaddys.com)

#105 Sander Marechal (http://www.jejik.com)

#106 Greggory Hernandez (http://www.icount.com)

#107 Sander Marechal (http://www.jejik.com)

#108 Andreas

def run(self):
while True:
foo.bar()
time.sleep(1)

#109 Sander Marechal (http://www.jejik.com)

#110 Andreas

#111 olavgg

#112 Sander Marechal (http://www.jejik.com)

#113 Ryan (http://www.ryanbrady.org)

#114 chzealot (http://blog.losthit.com)

#115 Sam Thomson

<code>
# main program
Daemon('a').start() # first daemon
print "we're in the first daemon now, so you'll never see this"
Daemon('b').start() # second daemon
print "we're in the second daemon now. you'll also never see this"
</code>

<code>
*** daemon.py	2010-12-10 17:01:20.000000000 -0500
--- daemon2.py	2010-12-10 17:21:17.000000000 -0500
***************
*** 20,31 ****
  		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, e: 
  			sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
  			sys.exit(1)
--- 20,32 ----
  		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
+                 Returns True in the child process, False in the parent
  		"""
  		try: 
  			pid = os.fork() 
  			if pid > 0:
!                             # return to the first parent's normal operation
!                             return False
  		except OSError, e: 
  			sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
  			sys.exit(1)
***************
*** 59,64 ****
--- 60,66 ----
  		atexit.register(self.delpid)
  		pid = str(os.getpid())
  		file(self.pidfile,'w+').write("%s\n" % pid)
+                 return True
  	
  	def delpid(self):
  		os.remove(self.pidfile)
***************
*** 81,89 ****
  			sys.exit(1)
  		
  		# Start the daemon
! 		self.daemonize()
! 		self.run()
! 
  	def stop(self):
  		"""
  		Stop the daemon
--- 83,94 ----
  			sys.exit(1)
  		
  		# Start the daemon
! 		if self.daemonize():
!                     # we're in the child now
!                     self.run()
!                     sys.exit(0)
!                 # otherwise, we're in the parent. return to where we were called from
!         
  	def stop(self):
  		"""
  		Stop the daemon

</code>

#116 Sander Marechal (http://www.jejik.com)

#117 Jill

#118 kaliko

#119 Sander Marechal (http://www.jejik.com)

#120 PoTe

#121 Sander Marechal (http://www.jejik.com)

#122 Francisco Ram rez

#123 Sander Marechal (http://www.jejik.com)

#124 Francisco Ramirez

#125 Francisco Ramirez

#126 Francisco Ramirez

#127 Sander Marechal (http://www.jejik.com)

#128 Hammy Havoc (http://www.hammyhavoc.com)

#129 Strae

#130 Sander Marechal (http://www.jejik.com)

#131 Mike Fuzzy Partin

#132 David Underhill (http://www.dound.com)

#133 Jan de Jager (http://www.bleepsquare.co.za)

#!/usr/bin/env python



import sys, time

import SocketServer

import pymongo

import datetime

from daemon import Daemon



class EchoRequestHandler(SocketServer.BaseRequestHandler):

	def handle(self):

		while 1:

			data = self.request.recv(1024)

			from bson.objectid import ObjectId    

			gpsdata = self.data.replace('+++','').split('|')

			post = {

				"_id" : ObjectId(),

				"serial" : gpsdata[0],

				"date" : datetime.datetime.utcnow(),

				"latitude" : float(gpsdata[1]),

				"longitude" : float(gpsdata[2]),

				"altitude" : float(gpsdata[3]),

				"course" : float(gpsdata[4]),

				"speed" : float(gpsdata[5]),

				"horizontalAccuracy" : 0,

				"verticalAccuracy" : 0

			}

			from pymongo import Connection

			connection = Connection()

			db = connection.test

			ping = db['ping']

			ping.insert(post)

			self.request.send("0")



class BleepDaemon(Daemon):

	def run(self):

		server = SocketServer.ThreadingTCPServer(('0.0.0.0', 81), EchoRequestHandler)

		server.serve_forever()

		while True:

			time.sleep(1)



if __name__ == "__main__":

	daemon = BleepDaemon('/tmp/daemon-bleep.pid')

	if len(sys.argv) == 2:

		if 'start' == sys.argv[1]:

			daemon.start()

		elif 'stop' == sys.argv[1]:

			daemon.stop()

		elif 'restart' == sys.argv[1]:

			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)

#134 John Randall

#135 computerquip

#136 Justin Barber (https://github.com/barberj/Saerpent)

#137 Anonymous Coward

	def stop(self):
		"""
		Stop the daemon
		"""
		# Get the pid from the pidfile
		try:
			pf = file(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
                else:
                    if os.path.exists(self.pidfile):
                        os.remove(self.pidfile)
                        time.sleep(3)

		# Try killing the daemon process	
		try:
			while 1:
				os.kill(pid, SIGTERM)
				time.sleep(2)
		except OSError, 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)

class MyDaemon(Daemon):

    def checkpid(self):

        try:
            pf = file(self.pidfile,'r')
            pid = int(pf.read().strip())
            pf.close()
        except:
            pid=0

        # logging.debug('PID: %i.' % (pid))

        return pid

    def run(self):

        logging.debug('Running...')

        pid = self.checkpid()

        while (pid > 0):

            ...
       
            pid = self.checkpid()
            # End of loop

        # out of the loop
        logging.debug('Shutting down %i' % (pid))

        # Logging
        logging.shutdown()

        # System
        sys.exit(0)

#138 Wawrzek (http://wawrzek.name)

#139 Kasun

#140 Sander Marechal (http://www.jejik.com)

#141 Sander Marechal (http://www.jejik.com)

#142 jazzuell

#143 aprendice

#144 Sander Marechal (http://www.jejik.com)

#145 Anonymous Coward (http://deneme.com)

#146 Sander Marechal (http://www.jejik.com)

#147 sun

#148 Anonymous Coward

#149 Sander Marechal (http://www.jejik.com)

#150 paroariax

#151 paroariax

#152 Sander Marechal (http://www.jejik.com)

/usr/bin/my-daemon.py --working-dir=/home/foo --some-option --other-option --config=/etc/my/daemon.ini --etcetera

/etc/init.d/my-daemon start

#153 Amir

#154 geeky583

#155 Niklas (https://github.com/nthorne/xmppmote)

#156 David Karlsson (http://automagically.weebly.com)

#157 megrez80

#158 Anonymous Coward

#!/usr/bin/env python
import sys, os, time, atexit
from signal import SIGTERM
import fcntl
import subprocess

class Pidfile(object):
    def __init__(self, pidfile, procname):
        try:
            self.fd = os.open(pidfile, os.O_CREAT | os.O_RDWR)
        except IOError, e:
            sys.exit("Failed to open pidfile: %s" % str(e))
        self.pidfile = pidfile
        self.procname = procname
        assert not fcntl.flock(self.fd, fcntl.LOCK_EX)

    def unlock(self):
        assert not fcntl.flock(self.fd, fcntl.LOCK_UN)

    def write(self, pid):
        os.ftruncate(self.fd, 0)
        os.write(self.fd, "%d" % int(pid))
        os.fsync(self.fd)

    def kill(self):
        pid = int(os.read(self.fd, 4096))
        os.lseek(self.fd, 0, os.SEEK_SET)

        try:
            os.kill(pid, SIGTERM)
            time.sleep(0.1)
        except OSError, err:
            err = str(err)
            if err.find("No such process") > 0:
                if os.path.exists(self.pidfile):
                    os.remove(self.pidfile)
            else:
                return str(err)

        if self.is_running():
            return "Failed to kill %d" % pid

    def is_running(self):
        contents = os.read(self.fd, 4096)
        os.lseek(self.fd, 0, os.SEEK_SET)

        if not contents:
            return False

        p = subprocess.Popen(["ps", "-o", "comm", "-p", str(int(contents))],
                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        stdout, stderr = p.communicate()
        if stdout == "COMM\n":
            return False

        if self.procname in stdout[stdout.find("\n")+1:]:
            return True

        return False


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(pidfile, "python")

    def daemonize(self):
        ...
        # write pidfile
        atexit.register(self.delpid)
        pid = str(os.getpid())
        self.pidfile.write(pid)

    def start(self):
        """
        Start the daemon
        """
        # Check for a pidfile to see if the daemon already runs
        if self.pidfile.is_running():
            self.pidfile.unlock()
            sys.exit("Daemon already running.")

        # Start the daemon
        self.daemonize()
        self.pidfile.unlock()
        self.run()

    def stop(self):
        """
        Stop the daemon
        """
        # Get the pid from the pidfile
        if not self.pidfile.is_running():
            self.pidfile.unlock()
            print >>sys.stderr,"Daemon not running."
            return

        # Try killing the daemon process
        error = self.pidfile.kill()
        if error:
            self.pidfile.unlock()
            sys.exit(error)

#159 Anonymous Coward

#160 Ariel Monaco

#161 Sander Marechal (http://www.jejik.com)

#162 jPLOS

#163 Oleg

#164 bbwolf

#165 jiamo

#166 Sander Marechal (http://www.jejik.com)

#167 hagak

Comments have been retired for this article.