लिनक्स में सेवा या डेमॉन की तरह पायथन स्क्रिप्ट को कैसे चलाया जाता है

Question

मैंने एक पायथन स्क्रिप्ट लिखी है जो एक निश्चित ई-मेल पते की जांच करती है और नए ई-मेल को एक बाहरी प्रोग्राम में भेजती है। मैं इस स्क्रिप्ट को 24/7 निष्पादित करने के लिए कैसे प्राप्त कर सकता हूं, जैसे कि इसे लिनक्स में डेमन या सर्विस में बदलना। क्या मुझे भी एक लूप की आवश्यकता होगी जो प्रोग्राम में कभी समाप्त न हो, या यह कोड को कई बार निष्पादित करने से ही हो सकता है?

Comments

SO प्रश्न देखें: stackoverflow.com/questions/1423345/…

— mjv

"एक निश्चित ई-मेल पते की जांच करता है और एक बाहरी कार्यक्रम में नए ई-मेल पास करता है" क्या यह नहीं है कि सेंडमेल क्या करता है? मेलबॉक्स को स्क्रिप्ट पर ले जाने के लिए आप मेल उपनाम को परिभाषित कर सकते हैं। आप ऐसा करने के लिए मेल उपनामों का उपयोग क्यों नहीं कर रहे हैं?

— S.Lott

एक आधुनिक लिनेक्स जिस पर systemdआपके पास यहाँdaemon वर्णित के रूप में एक प्रणालीगत सेवा बना सकते हैं । इसे भी देखें: freedesktop.org/software/systemd/man/systemd.service.html

— ccpizza

अगर linux system सिस्टम को सपोर्ट करता है, तो यहां दिए गए दृष्टिकोण का उपयोग करें ।

— गेरार्डव

Answer 1

आपके पास यहां दो विकल्प हैं।

1. एक उचित क्रोन काम करें जो आपकी स्क्रिप्ट को कॉल करता है। क्रोन एक GNU / लिनक्स डेमॉन के लिए एक सामान्य नाम है जो समय-समय पर आपके द्वारा निर्धारित कार्यक्रम के अनुसार स्क्रिप्ट लॉन्च करता है। आप अपनी स्क्रिप्ट को एक क्रॉस्टैब में जोड़ते हैं या इसे एक विशेष निर्देशिका में सिमलिंक डालते हैं और डेमॉन इसे पृष्ठभूमि में लॉन्च करने का काम संभालता है। आप विकिपीडिया पर अधिक पढ़ सकते हैं । विभिन्न क्रोन डेमन्स की एक किस्म है, लेकिन आपके जीएनयू / लिनक्स सिस्टम को पहले से ही स्थापित होना चाहिए।

2. अपनी स्क्रिप्ट के लिए कुछ प्रकार के अजगर दृष्टिकोण (एक पुस्तकालय, उदाहरण के लिए) का उपयोग करें जो स्वयं को निष्क्रिय करने में सक्षम हो। हां, इसके लिए एक साधारण ईवेंट लूप की आवश्यकता होगी (जहां आपके ईवेंट टाइमर ट्रिगर हैं, संभवतः, स्लीप फ़ंक्शन द्वारा प्रदान किया गया है)।

मैं आपको 2. चुनने की सलाह नहीं दूंगा, क्योंकि आप वास्तव में, क्रोन कार्यक्षमता दोहराएंगे। लिनक्स सिस्टम प्रतिमान कई सरल उपकरणों को बातचीत करने और आपकी समस्याओं को हल करने के लिए है। जब तक अतिरिक्त कारण नहीं हैं कि आपको समय-समय पर ट्रिगर करने के अलावा डेमॉन क्यों बनाना चाहिए, तो अन्य दृष्टिकोण चुनें।

इसके अलावा, यदि आप एक लूप के साथ डेमनीज का उपयोग करते हैं और एक दुर्घटना होती है, तो कोई भी उसके बाद मेल की जांच नहीं करेगा (जैसा कि इस उत्तर में इवान नेवस्त्रुव द्वारा कहा गया है )। जबकि अगर स्क्रिप्ट को क्रोन जॉब के रूप में जोड़ा जाता है, तो यह बस फिर से ट्रिगर हो जाएगा।

Comments

क्रोनजॉब के लिए +1। मुझे नहीं लगता कि यह प्रश्न निर्दिष्ट करता है कि यह एक स्थानीय मेल खाते की जाँच कर रहा है, इसलिए मेल फ़िल्टर लागू नहीं होते हैं

— जॉन ला रोय

पायथन कार्यक्रम में समाप्ति के बिना एक लूप का उपयोग क्या होता है और फिर इसे crontabसूची में दर्ज करना होगा? यदि मैं .pyप्रति घंटा के लिए इस तरह की स्थापना करता हूं , तो क्या यह कई प्रक्रियाएं बनाएगा जो कभी समाप्त नहीं होंगे? यदि हां, तो मुझे लगता है कि यह डेमन को काफी पसंद आएगा।

— Veck Hsiao

मैं देख सकता हूं कि क्रोन एक स्पष्ट समाधान है यदि आप एक मिनट में एक बार ईमेल की जांच करते हैं (जो क्रोन के लिए सबसे कम समय का संकल्प है)। लेकिन क्या होगा अगर मैं हर 10 सेकंड में ईमेल की जांच करना चाहता हूं? क्या मुझे 60 बार क्वेरी चलाने के लिए पायथन स्क्रिप्ट लिखनी चाहिए, जिसका अर्थ है कि यह 50 सेकंड के बाद समाप्त हो जाती है, और फिर क्रोन स्क्रिप्ट को 10 सेकंड बाद फिर से शुरू करना चाहिए?

— मैड्स स्केजर्न

मैंने डेमॉन / सेवाओं के साथ काम नहीं किया है, लेकिन मैं इस धारणा के तहत था कि यह (ओएस / init / init.d / upstart या इसे क्या कहा जाता है) एक डेमॉन को पुनरारंभ करने का ख्याल रखता है जब वह समाप्त होता है / क्रैश होता है।

— मैड्स स्केजर्न

@VeckHsiao हाँ, crontab एक स्क्रिप्ट को आपके अजगर स्क्रिप्ट के कई उदाहरण कहते हैं, हर किसी को इसके पाश के साथ बुलाया जाएगा ....

— Pipo

Answer 2

यहाँ एक अच्छा वर्ग से लिया जाता है है यहाँ :

#!/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, 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, 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 = 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
                atexit.register(self.delpid)
                pid = str(os.getpid())
                file(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 = 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)

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

        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

                # Try killing the daemon process       
                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):
                """
                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().
                """

Comments

सिस्टम के पुनरारंभ होने पर यह पुनः आरंभ होता है? क्योंकि जब सिस्टम रीस्टार्ट हो गया तो प्रक्रिया ठीक से मार दी जाएगी?

— शिवप्रसाद

Answer 3

आपको अजगर-डेमन पुस्तकालय का उपयोग करना चाहिए , यह सब कुछ का ख्याल रखता है।

PyPI से: पुस्तकालय एक अच्छी तरह से व्यवहार यूनिक्स डेमन प्रक्रिया को लागू करने के लिए।

Comments

डिट्टो जोर्ज वर्गास की टिप्पणी। कोड को देखने के बाद, यह वास्तव में कोड का एक अच्छा टुकड़ा जैसा दिखता है, लेकिन डॉक्स और उदाहरणों की पूरी कमी से इसका उपयोग करना बहुत मुश्किल हो जाता है, जिसका अर्थ है कि अधिकांश डेवलपर्स बेहतर दस्तावेज विकल्पों के लिए इसे अनदेखा कर देंगे।

— सेरिन

अजगर 3.5 में ठीक से काम नहीं करने लगता है: gist.github.com/MartinThoma/fa4deb2b4c71ffcd726b24b7ab581ae2

— मार्टिन थोमा

उम्मीद के मुताबिक काम नहीं हुआ। क्या यह अच्छा होगा अगर यह किया।

— हरलिन

यूनिक्स! = लिनक्स - क्या यह परेशानी हो सकती है?

— दाना

Answer 4

आप अपनी स्क्रिप्ट को tty से अलग करने के लिए कांटा () का उपयोग कर सकते हैं और इसे चलाना जारी रखें, जैसे:

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

बेशक आपको एक अंतहीन लूप लागू करने की आवश्यकता है, जैसे

while 1:
  do_your_check()
  sleep(5)

आशा है कि यह आपको मिल जाएगा।

Comments

हैलो, मैंने यह कोशिश की है और यह मेरे लिए काम करता है। लेकिन जब मैं टर्मिनल बंद करता हूं या ssh सत्र से बाहर निकलता हूं, तो स्क्रिप्ट काम करना भी बंद कर देती है !!

— डेविड ओक्वी

@DavidOkwii nohup/ disownकमांड कंसोल से प्रक्रिया को अलग कर देंगे और यह मर नहीं जाएगी। या आप इसे init.d

— pholat

Answer 5

आप शेल स्क्रिप्ट का उपयोग करके अजगर स्क्रिप्ट को सेवा के रूप में चला सकते हैं। अजगर स्क्रिप्ट को इस तरह चलाने के लिए सबसे पहले एक शेल स्क्रिप्ट बनाएं (स्क्रिप्ट नाम मध्यस्थ नाम)

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

अब /etc/init.d/scriptname में एक फ़ाइल बनाएं

#! /bin/sh

PATH=/bin:/usr/bin:/sbin:/usr/sbin
DAEMON=/home/.. path to shell script scriptname created to run python script
PIDFILE=/var/run/scriptname.pid

test -x $DAEMON || exit 0

. /lib/lsb/init-functions

case "$1" in
  start)
     log_daemon_msg "Starting feedparser"
     start_daemon -p $PIDFILE $DAEMON
     log_end_msg $?
   ;;
  stop)
     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 $?
   ;;
  force-reload|restart)
     $0 stop
     $0 start
   ;;
  status)
     status_of_proc -p $PIDFILE $DAEMON atd && exit 0 || exit $?
   ;;
 *)
   echo "Usage: /etc/init.d/atd {start|stop|restart|force-reload|status}"
   exit 1
  ;;
esac

exit 0

अब आप कमांड /etc/init.d/scriptname प्रारंभ या बंद का उपयोग करके अपनी अजगर स्क्रिप्ट को शुरू और बंद कर सकते हैं।

Comments

मैंने बस यह कोशिश की, और यह पता चला कि यह प्रक्रिया शुरू कर देगा, लेकिन इसे विमुद्रीकृत नहीं किया जाएगा (अर्थात यह अभी भी टर्मिनल से जुड़ा हुआ है)। यदि आप अपडेट-आरडीडी चलाते हैं और इसे बूट पर चलाते हैं तो यह संभवत: ठीक काम करेगा (मेरा मानना ​​है कि ये स्क्रिप्ट चलने पर कोई टर्मिनल संलग्न नहीं होता है), लेकिन यह काम नहीं करता है यदि आप इसे मैन्युअल रूप से लागू करते हैं। पर्यवेक्षक की तरह लगता है एक बेहतर समाधान हो सकता है।

— रुय्यंशी

Answer 6

एक सरल और समर्थित संस्करण है Daemonize।

इसे पायथन पैकेज इंडेक्स (PyPI) से स्थापित करें:

$ pip install daemonize

और फिर उपयोग करें:

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

if __name__ == '__main__':
        myname=os.path.basename(sys.argv[0])
        pidfile='/tmp/%s' % myname       # any name
        daemon = Daemonize(app=myname,pid=pidfile, action=main)
        daemon.start()

Comments

सिस्टम के पुनरारंभ होने पर यह पुनः आरंभ होता है? क्योंकि जब सिस्टम रीस्टार्ट हो गया तो प्रक्रिया ठीक से मार दी जाएगी?

— शिवप्रसाद

@ शिवप्रसाद यू को इसका उत्तर मिला?

— 1UC1F3R616

सिस्टम रिस्टार्ट के बाद रिस्टार्ट एक दानव फंक्शन नहीं है। स्टार्टअप पर अपना ऐप चलाने के लिए क्रॉन, सिस्टमक्टेल, स्टार्टअप हुक या अन्य टूल का उपयोग करें।

— fcm

@Kush हाँ मैं चाहता हूँ की कोशिश इस जांच करने के लिए है, तो सिस्टम पुनरारंभ या आदेशों को मैं systemd कार्यों इस्तेमाल की तरह इस्तेमाल करने के बाद पुनः आरंभ करना चाहता था access.redhat.com/documentation/en-us/red_hat_enterprise_linux/...

— ShivaPrasad

@ शिवाप्रसाद थैंक्स ब्रो

— 1UC1F3R616

Answer 7

cronस्पष्ट रूप से कई उद्देश्यों के लिए एक बढ़िया विकल्प है। हालाँकि, यह ओपी में आपके अनुरोध के अनुसार सेवा या डेमॉन नहीं बनाता है। cronबस समय-समय पर नौकरी चलाता है (जिसका अर्थ है कि नौकरी शुरू होती है और रुक जाती है), और एक बार / मिनट से अधिक नहीं। इसके साथ समस्याएँ हैं cron- उदाहरण के लिए, यदि आपकी स्क्रिप्ट का एक पूर्व उदाहरण अभी भी चल रहा है, तो अगली बार cronशेड्यूल के आसपास आने और एक नया उदाहरण लॉन्च करने के लिए, क्या यह ठीक है? cronनिर्भरता नहीं संभालती है; जब शेड्यूल कहता है तो यह केवल नौकरी शुरू करने की कोशिश करता है।

यदि आप एक ऐसी स्थिति पाते हैं, जहाँ आपको वास्तव में एक डेमॉन की आवश्यकता होती है (एक प्रक्रिया जो कभी भी चलना बंद नहीं करती है), तो एक नज़र डालें supervisord। यह एक सामान्य, गैर-डेमनीकृत स्क्रिप्ट या प्रोग्राम को लपेटने और इसे एक डेमन की तरह संचालित करने का एक सरल तरीका प्रदान करता है। देशी पायथन डेमॉन बनाने की तुलना में यह एक बेहतर तरीका है।

Answer 8

कैसे $nohupलिनक्स पर कमांड का उपयोग करने के बारे में ?

मैं इसे अपने Bluehost सर्वर पर अपने कमांड चलाने के लिए उपयोग करता हूं।

कृपया सलाह दें यदि मैं गलत हूं।

Comments

मैं उस का भी उपयोग करता हूं, एक आकर्षण की तरह काम करता है। "अगर मैं गलत हूं तो कृपया सलाह दें।"

— अलेक्जेंड्रे मजेल

Answer 9

यदि आप टर्मिनल (ssh या कुछ) का उपयोग कर रहे हैं और आप टर्मिनल से लॉग आउट करने के बाद एक लंबे समय तक स्क्रिप्ट काम करना चाहते हैं, तो आप यह कोशिश कर सकते हैं:

screen

apt-get install screen

अंदर एक वर्चुअल टर्मिनल बनाएं (अर्थात् abc): screen -dmS abc

अब हम abc से जुड़ते हैं: screen -r abc

तो, अब हम अजगर स्क्रिप्ट चला सकते हैं: python keep_sending_mails.py

अब से, आप अपने टर्मिनल को सीधे बंद कर सकते हैं, हालांकि, अजगर स्क्रिप्ट बंद होने के बजाय चालू रहेगी

चूंकि यह keep_sending_mails.pyPID टर्मिनल (ssh) के बजाय वर्चुअल स्क्रीन की एक बाल प्रक्रिया है

यदि आप अपनी स्क्रिप्ट चलाने की स्थिति की जांच करना चाहते हैं, तो आप screen -r abcफिर से उपयोग कर सकते हैं

Comments

जबकि यह काम करता है, यह बहुत जल्दी और गंदा है और उत्पादन में बचा जाना चाहिए

— pcnate

Answer 10

सबसे पहले, मेल उपनामों पर पढ़ें। एक मेल उपनाम आपके बिना मेल सिस्टम के अंदर ऐसा करेगा, जैसे कि डेमॉन या सेवाओं या किसी भी प्रकार के साथ बेवकूफ बनाने के लिए।

आप एक साधारण स्क्रिप्ट लिख सकते हैं जिसे सेंडमेल द्वारा हर बार एक मेल संदेश को एक विशिष्ट मेलबॉक्स को भेजा जाता है।

Http://www.feep.net/sendmail/tutorial/intro/aliases.html देखें

यदि आप वास्तव में एक अनावश्यक रूप से जटिल सर्वर लिखना चाहते हैं, तो आप ऐसा कर सकते हैं।

nohup python myscript.py &

बस इतना ही लगता है। आपकी स्क्रिप्ट बस लूप और सोती है।

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

Comments

यहां समस्या यह है कि do_the_work()स्क्रिप्ट को क्रैश कर सकता है और कोई भी इसे फिर से नहीं चला सकता है

— इवान नेवस्त्रुव

यदि फ़ंक्शन do_the_work () क्रैश करता है, तो इसे 10 मिनट बाद फिर से कॉल किया जाएगा, क्योंकि केवल एक फ़ंक्शन कॉल में त्रुटि होती है। लेकिन लूप को क्रैश करने के बजाय सिर्फ tryभाग विफल except:हो जाता है और इसके बजाय भाग को बुलाया जाएगा (इस मामले में कुछ भी नहीं) लेकिन लूप जारी रहेगा और फ़ंक्शन को कॉल करने का प्रयास करता रहेगा।

— सरबत

Answer 11

यह मानते हुए कि आप अपने पाश को पृष्ठभूमि सेवा के रूप में 24/7 चलाना चाहते हैं

एक समाधान के लिए जिसमें आपके कोड को पुस्तकालयों के साथ इंजेक्ट करना शामिल नहीं है, आप बस एक सेवा टेम्पलेट बना सकते हैं, क्योंकि आप लिनक्स का उपयोग कर रहे हैं:

उस फाइल को अपने डेमॉन सर्विस फोल्डर (आमतौर पर /etc/systemd/system/) में रखें, और इसे निम्नलिखित सिस्टमटाइल कमांड्स का उपयोग करके इंस्टॉल करें (संभवतः sudo विशेषाधिकार की आवश्यकता होगी):

systemctl enable <service file name without extension>

systemctl daemon-reload

systemctl start <service file name without extension>

तब आप जांच सकते हैं कि आपकी सेवा कमांड का उपयोग करके चल रही है:

systemctl | grep running

Answer 12

मैं इस समाधान की सिफारिश करूंगा। आपको विरासत और ओवरराइड विधि की आवश्यकता है 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


    @abstractmethod
    def run(self):
        pass


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

        # stop first thread
        if pid > 0:
            sys.exit(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
        self._daemonize()

        # run the body of the daemon
        self.run()


    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
            os.remove(self._pidfile)

            # kill daemon
            os.kill(pid, SIGTERM)

        else:
            raise Exception("Daemon is not started")


    def restart(self):
        self.stop()
        self.start()

Answer 13

सेवा की तरह चलने वाली कुछ चीज़ बनाने के लिए आप इस चीज़ का उपयोग कर सकते हैं:

पहली चीज जो आपको करनी चाहिए वह है सीमेंट फ्रेमवर्क को स्थापित करना : सीमेंट फ्रेम वर्क एक सीएलआई फ्रेम वर्क है जिसे आप इस पर अपना एप्लिकेशन तैनात कर सकते हैं।

एप्लिकेशन का कमांड लाइन इंटरफ़ेस:

interface.py

 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")),
        ]

    @expose(hide=True)
    def default(self):
        if self.app.pargs.run:
            #Start to running the your app from there !
            YourApp.yourApp()
        if self.app.pargs.stop:
            #Stop your application
            YourApp.yourApp.stop()

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

 with App() as app:
       app.run()

YourApp.py वर्ग:

 import threading

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

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

ध्यान रखें कि आपका ऐप डेमॉन होने के लिए थ्रेड पर चलना चाहिए

ऐप को चलाने के लिए सिर्फ कमांड लाइन में ऐसा करें

अजगर इंटरफेस -एचएचपीपी

Answer 14

आपके सिस्टम में जो भी सेवा प्रबंधक प्रदान करता है, उसका उपयोग करें - उदाहरण के लिए, उबंटू उपयोग अपस्टार्ट के तहत । यह आपके लिए सभी विवरण जैसे कि बूट पर शुरू, क्रैश पर पुनरारंभ, आदि को संभाल लेगा।