Help: how to run python applications as NT service?

[zxo102]

Thanks for your help, Larry.

Finally, I got it my python script run as NT service with
the attached python code which is from the site:

http://www.schooltool.org/products/schooltool-calendar/documentation/how-to/running-as-a-windows-service/schooltool-service.py/view


##############################################################################
#
# Copyright (c) 2005 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public
License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this
distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND
FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################

"""
Windows NT/2K service installer/controller for Zope/ZEO/ZRS instances.
"""

# With trivial modifications for use with SchoolBell and SchoolTool.

import sys, os, time
import pywintypes
import win32serviceutil
import win32service
import win32event
import win32process

# the max seconds we're allowed to spend backing off
BACKOFF_MAX = 300
# if the process runs successfully for more than BACKOFF_CLEAR_TIME
# seconds, we reset the backoff stats to their initial values
BACKOFF_CLEAR_TIME = 30
# the initial backoff interval (the amount of time we wait to restart
# a dead process)
BACKOFF_INITIAL_INTERVAL = 5

class Service(win32serviceutil.ServiceFramework):
    """ A class representing a Windows NT service that can manage an
    instance-home-based Zope/ZEO/ZRS processes """

    # The comment below is mostly irrelevant if you're running a
standalone
    # SchoolBell server, I think. -TEH

    # The PythonService model requires that an actual on-disk class
declaration
    # represent a single service.  Thus, the below definition of
start_cmd,
    # must be overridden in a subclass in a file within the instance
home for
    # each instance.  The below-defined start_cmd (and
_svc_display_name_
    # and _svc_name_) are just examples.

    # To use this script with SchoolTool, just replace "SchoolBell"
    # with "SchoolTool" in the variables below.
    # You'll also need to change 'Python24' to 'Python23' if that's
    # what you've got.  -TEH

    _svc_name_ = r'SchoolBell'
    _svc_display_name_ = r'SchoolBell Server'

    start_cmd = (
	r'"C:\Python24\python.exe" '
	r'"C:\Program Files\SchoolBell\schoolbell-server.py" '
        )

    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        # Create an event which we will use to wait on.
        # The "service stop" request will set this event.
        self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
        self.redirectOutput()

    def redirectOutput(self):
        sys.stdout.close()
        sys.stderr.close()
        sys.stdout = NullOutput()
        sys.stderr = NullOutput()

    def SvcStop(self):
        # Before we do anything, tell the SCM we are starting the stop
process.
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)

        # TODO:  This TerminateProcess call doesn't make much sense:
it's
        # doing a hard kill _first_, never giving the process a chance
to
        # shut down cleanly.  Compare to current Zope2 service code,
which
        # uses Windows events to give the process a chance to shut down
        # cleanly, doing a hard kill only if that doesn't succeed.

        # stop the process if necessary
        try:
            win32process.TerminateProcess(self.hZope, 0)
        except pywintypes.error:
            # the process may already have been terminated
            pass
        # And set my event.
        win32event.SetEvent(self.hWaitStop)

    # SvcStop only gets triggered when the user explictly stops (or
restarts)
    # the service.  To shut the service down cleanly when Windows is
shutting
    # down, we also need to hook SvcShutdown.
    SvcShutdown = SvcStop

    def createProcess(self, cmd):
        return win32process.CreateProcess(
            None, cmd, None, None, 0, 0, None, None,
            win32process.STARTUPINFO())

    def SvcDoRun(self):
        # indicate to Zope that the process is daemon managed
(restartable)
        os.environ['ZMANAGED'] = '1'

        # daemon behavior:  we want to to restart the process if it
        # dies, but if it dies too many times, we need to give up.

        # we use a simple backoff algorithm to determine whether
        # we should try to restart a dead process:  for each
        # time the process dies unexpectedly, we wait some number of
        # seconds to restart it, as determined by the backoff interval,
        # which doubles each time the process dies.  if we exceed
        # BACKOFF_MAX seconds in cumulative backoff time, we give up.
        # at any time if we successfully run the process for more thab
        # BACKOFF_CLEAR_TIME seconds, the backoff stats are reset.

        # the initial number of seconds between process start attempts
        backoff_interval = BACKOFF_INITIAL_INTERVAL
        # the cumulative backoff seconds counter
        backoff_cumulative = 0

        import servicemanager

        # log a service started message
        servicemanager.LogMsg(
            servicemanager.EVENTLOG_INFORMATION_TYPE,
            servicemanager.PYS_SERVICE_STARTED,
            (self._svc_name_, ' (%s)' % self._svc_display_name_))

        while 1:
            start_time = time.time()
            info = self.createProcess(self.start_cmd)
            self.hZope = info[0] # the pid
            if backoff_interval > BACKOFF_INITIAL_INTERVAL:
                # if we're in a backoff state, log a message about
                # starting a new process
                servicemanager.LogInfoMsg(
                    '%s (%s): recovering from died process, new process
'
                    'started' % (self._svc_name_,
self._svc_display_name_)
                    )
            rc = win32event.WaitForMultipleObjects(
                (self.hWaitStop, self.hZope), 0, win32event.INFINITE)
            if rc == win32event.WAIT_OBJECT_0:
                # user sent a stop service request
                self.SvcStop()
                break
            else:
                # user did not send a service stop request, but
                # the process died; this may be an error condition
                status = win32process.GetExitCodeProcess(self.hZope)
                if status == 0:
                    # the user shut the process down from the web
                    # interface (or it otherwise exited cleanly)
                    break
                else:
                    # this was an abormal shutdown.  if we can, we want
to
                    # restart the process but if it seems hopeless,
                    # don't restart an infinite number of times.
                    if backoff_cumulative > BACKOFF_MAX:
                        # it's hopeless
                        servicemanager.LogErrorMsg(
                          '%s (%s): process could not be restarted due
to max '
                          'restart attempts exceeded' % (
                            self._svc_display_name_, self._svc_name_
                          ))
                        self.SvcStop()
                        break
                    servicemanager.LogWarningMsg(
                       '%s (%s): process died unexpectedly.  Will
attempt '
                       'restart after %s seconds.' % (
                            self._svc_name_, self._svc_display_name_,
                            backoff_interval
                            )
                       )
                    # if BACKOFF_CLEAR_TIME seconds have elapsed since
we last
                    # started the process, reset the backoff interval
                    # and the cumulative backoff time to their original
                    # states
                    if time.time() - start_time > BACKOFF_CLEAR_TIME:
                        backoff_interval = BACKOFF_INITIAL_INTERVAL
                        backoff_cumulative = 0
                    # we sleep for the backoff interval.  since this is
async
                    # code, it would be better done by sending and
                    # catching a timed event (a service
                    # stop request will need to wait for us to stop
sleeping),
                    # but this works well enough for me.
                    time.sleep(backoff_interval)
                    # update backoff_cumulative with the time we spent
                    # backing off.
                    backoff_cumulative = backoff_cumulative +
backoff_interval
                    # bump the backoff interval up by 2* the last
interval
                    backoff_interval = backoff_interval * 2

                    # loop and try to restart the process

        # log a service stopped message
        servicemanager.LogMsg(
            servicemanager.EVENTLOG_INFORMATION_TYPE,
            servicemanager.PYS_SERVICE_STOPPED,
            (self._svc_name_, ' (%s) ' % self._svc_display_name_))


class NullOutput:
    """A stdout / stderr replacement that discards everything."""

    def noop(self, *args, **kw):
        pass

    write = writelines = close = seek = flush = truncate = noop

    def __iter__(self):
        return self

    def next(self):
        raise StopIteration

    def isatty(self):
        return False

    def tell(self):
        return 0

    def read(self, *args, **kw):
        return ''

    readline = read

    def readlines(self, *args, **kw):
        return []


if __name__=='__main__':
    win32serviceutil.HandleCommandLine(Service)