|
#!/usr/bin/env python |
|
# -*- coding: utf-8 -*- |
|
# |
|
# Attribution: Hijacked from tracservice.py by Florent Xicluna <laxyf@yahoo.fr> |
|
# http://trac-hacks.org/wiki/WindowsServiceScript |
|
# |
|
# To use this class, users must do the following: |
|
# 1. Download and install the PyWin32all package |
|
# (http://starship.python.net/crew/mhammond/win32/) |
|
# 2. Edit the constants section with the proper information. |
|
# 3. Open a command prompt with administrator rights and navigate to the directory |
|
# where this file is located. Use one of the following commands to |
|
# install/start/stop/remove the service: |
|
# > django_service.py install |
|
# > django_service.py start |
|
# > django_service.py stop |
|
# > django_service.py remove |
|
# Additionally, typing "django_service.py" will present the user with all of the |
|
# available options. |
|
# |
|
# Once installed, the service will be accessible through the Services |
|
# management console just like any other Windows Service. All service |
|
# startup exceptions encountered by the DjangoWindowsService class will be |
|
# viewable in the Windows event viewer (this is useful for debugging |
|
# service startup errors); all application specific output or exceptions that |
|
# are not captured by the standard Django logging mechanism should |
|
# appear in the stdout/stderr logs. |
|
# |
|
|
|
import sys |
|
import os |
|
from distutils import sysconfig |
|
|
|
import win32serviceutil |
|
import win32service |
|
|
|
# == Editable CONSTANTS SECTION ============================================ |
|
|
|
DJANGO_PROJECT = '%HOME%\\Documents\\django_projects\\myProject' |
|
|
|
OPTS = { |
|
'hostname': 'myComputer.myDomain.com', |
|
'port': '80', |
|
} |
|
|
|
# == End of CONSTANTS SECTION ============================================== |
|
|
|
# Other constants |
|
PYTHONDIR = sysconfig.get_python_lib() # gets site-packages folder |
|
PYTHONSERVICE_EXE=os.path.join(PYTHONDIR, 'win32', 'pythonservice.exe') |
|
LOG_DIR = os.path.join(DJANGO_PROJECT, 'log') |
|
SETTINGS = os.path.basename(DJANGO_PROJECT) + '.' + 'settings' |
|
|
|
# Django Project |
|
ARGS = [os.path.join(DJANGO_PROJECT, 'manage.py'), |
|
'runserver', |
|
'--pythonpath=' + DJANGO_PROJECT, |
|
'--noreload', |
|
OPTS['hostname'] + ':' + OPTS['port']] |
|
|
|
class DjangoWindowsService(win32serviceutil.ServiceFramework): |
|
"""Django Windows Service helper class. |
|
|
|
The DjangoWindowsService class contains all the functionality required |
|
for running Django application as a Windows Service. |
|
|
|
For information on installing the application, please refer to the |
|
documentation at the end of this module or navigate to the directory |
|
where this module is located and type "django_service.py" from the command |
|
prompt. |
|
""" |
|
|
|
_svc_name_ = 'Django_%s' % str(hash(DJANGO_PROJECT)) |
|
_svc_display_name_ = 'Django project at %s' % DJANGO_PROJECT |
|
_exe_name_ = PYTHONSERVICE_EXE |
|
|
|
def SvcDoRun(self): |
|
""" Called when the Windows Service runs. """ |
|
|
|
self.ReportServiceStatus(win32service.SERVICE_START_PENDING) |
|
self.httpd = self.django_init() |
|
self.ReportServiceStatus(win32service.SERVICE_RUNNING) |
|
try: |
|
self.httpd.serve_forever() |
|
except OSError: |
|
sys.exit(1) |
|
|
|
def SvcStop(self): |
|
"""Called when Windows receives a service stop request.""" |
|
|
|
self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) |
|
if self.httpd: |
|
self.httpd.server_close() |
|
self.ReportServiceStatus(win32service.SERVICE_STOPPED) |
|
|
|
def django_init(self): |
|
""" Checks for the required data and initializes the application. """ |
|
|
|
# manage.py |
|
os.environ.setdefault("DJANGO_SETTINGS_MODULE", SETTINGS) |
|
|
|
# django.core.management.execute_from_command_line(argv=ARGS) |
|
""" |
|
A simple method that runs a ManagementUtility. |
|
""" |
|
from django.core.management import ManagementUtility |
|
utility = ManagementUtility(ARGS) |
|
|
|
# utility.execute() |
|
""" |
|
Given the command-line arguments, this figures out which subcommand is |
|
being run, creates a parser appropriate to that command, and runs it. |
|
""" |
|
from django.core.management import LaxOptionParser |
|
# For backwards compatibility: get_version() used to be in this module. |
|
from django import get_version |
|
from django.core.management.base import BaseCommand, handle_default_options |
|
# Preprocess options to extract --settings and --pythonpath. |
|
# These options could affect the commands that are available, so they |
|
# must be processed early. |
|
parser = LaxOptionParser(usage="%prog subcommand [options] [args]", |
|
version=get_version(), |
|
option_list=BaseCommand.option_list) |
|
utility.autocomplete() |
|
try: |
|
options, args = parser.parse_args(utility.argv) |
|
handle_default_options(options) |
|
except: |
|
pass # Ignore any option errors at this point. |
|
subcommand = utility.argv[1] |
|
klass = utility.fetch_command(subcommand) |
|
|
|
# klass.run_from_argv(utility.argv) |
|
""" |
|
Set up any environment changes requested (e.g., Python path |
|
and Django settings), then run this command. If the |
|
command raises a ``CommandError``, intercept it and print it sensibly |
|
to stderr. If the ``--traceback`` option is present or the raised |
|
``Exception`` is not ``CommandError``, raise it. |
|
""" |
|
from django.core.management.base import CommandError |
|
parser = klass.create_parser(utility.argv[0], utility.argv[1]) |
|
options, args = parser.parse_args(utility.argv[2:]) |
|
handle_default_options(options) |
|
|
|
options = options.__dict__ |
|
# klass.execute(*args, **options.__dict__) |
|
""" |
|
Try to execute this command, performing model validation if |
|
needed (as controlled by the attribute |
|
``klass.requires_model_validation``, except if force-skipped). |
|
""" |
|
from django.core.management.base import OutputWrapper |
|
klass.stdout = OutputWrapper(options.get('stdout', sys.stdout)) |
|
klass.stderr = OutputWrapper(options.get('stderr', sys.stderr), klass.style.ERROR) |
|
|
|
#klass.can_import_settings = True |
|
from django.conf import settings |
|
|
|
saved_locale = None |
|
#klass.leave_locale_alone = False |
|
# Only mess with locales if we can assume we have a working |
|
# settings file, because django.utils.translation requires settings |
|
# (The final saying about whether the i18n machinery is active will be |
|
# found in the value of the USE_I18N setting) |
|
|
|
#klass.can_import_settings = True |
|
|
|
# Switch to US English, because django-admin.py creates database |
|
# content like permissions, and those shouldn't contain any |
|
# translations. |
|
from django.utils import translation |
|
saved_locale = translation.get_language() |
|
translation.activate('en-us') |
|
|
|
try: |
|
# Validation is called explicitly each time the server is reloaded. |
|
#klass.requires_model_validation = False |
|
|
|
addrport = args[0] |
|
print 'addrport %s' % addrport |
|
args = args[1:] |
|
# klass.handle(addrport='', *args, **options) |
|
import re |
|
from django.core.management.commands.runserver import naiveip_re, DEFAULT_PORT |
|
from django.conf import settings |
|
|
|
if not settings.DEBUG and not settings.ALLOWED_HOSTS: |
|
raise CommandError('You must set settings.ALLOWED_HOSTS if DEBUG is False.') |
|
|
|
klass.use_ipv6 = options.get('use_ipv6') |
|
if klass.use_ipv6 and not socket.has_ipv6: |
|
raise CommandError('Your Python does not support IPv6.') |
|
if args: |
|
raise CommandError('Usage is runserver %s' % klass.args) |
|
klass._raw_ipv6 = False |
|
if not addrport: |
|
klass.addr = '' |
|
klass.port = DEFAULT_PORT |
|
else: |
|
m = re.match(naiveip_re, addrport) |
|
if m is None: |
|
raise CommandError('"%s" is not a valid port number ' |
|
'or address:port pair.' % addrport) |
|
klass.addr, _ipv4, _ipv6, _fqdn, klass.port = m.groups() |
|
if not klass.port.isdigit(): |
|
raise CommandError("%r is not a valid port number." % klass.port) |
|
if klass.addr: |
|
if _ipv6: |
|
klass.addr = klass.addr[1:-1] |
|
klass.use_ipv6 = True |
|
klass._raw_ipv6 = True |
|
elif klass.use_ipv6 and not _fqdn: |
|
raise CommandError('"%s" is not a valid IPv6 address.' % klass.addr) |
|
if not klass.addr: |
|
klass.addr = '::1' if klass.use_ipv6 else '127.0.0.1' |
|
klass._raw_ipv6 = bool(klass.use_ipv6) |
|
|
|
# klass.run(*args, **options) |
|
""" |
|
Runs the server, using the autoreloader if needed |
|
""" |
|
#from django.utils import autoreload |
|
use_reloader = options.get('use_reloader') |
|
if use_reloader: |
|
# use queue and threading to start httpd |
|
# skip for now |
|
print 'reloader bypassed for Windows service' |
|
pass |
|
|
|
# klass.inner_run(*args, **options) |
|
import errno |
|
import socket |
|
from django.utils import six |
|
from django.utils.six.moves import socketserver |
|
from django.core.servers.basehttp import WSGIServer, WSGIRequestHandler |
|
from datetime import datetime |
|
from django.conf import settings |
|
from django.utils import translation |
|
|
|
threading = options.get('use_threading') |
|
shutdown_message = options.get('shutdown_message', '') |
|
quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' |
|
|
|
klass.stdout.write("Validating models...\n\n") |
|
klass.validate(display_num_errors=True) |
|
klass.stdout.write(( |
|
"%(started_at)s\n" |
|
"Django version %(version)s, using settings %(settings)r\n" |
|
"Starting development server at http://%(addr)s:%(port)s/\n" |
|
"Quit the server with %(quit_command)s.\n" |
|
) % { |
|
"started_at": datetime.now().strftime('%B %d, %Y - %X'), |
|
"version": klass.get_version(), |
|
"settings": settings.SETTINGS_MODULE, |
|
"addr": '[%s]' % klass.addr if klass._raw_ipv6 else klass.addr, |
|
"port": klass.port, |
|
"quit_command": quit_command, |
|
}) |
|
# django.core.management.base forces the locale to en-us. We should |
|
# set it up correctly for the first request (particularly important |
|
# in the "--noreload" case). |
|
translation.activate(settings.LANGUAGE_CODE) |
|
|
|
try: |
|
handler = klass.get_handler(*args, **options) |
|
# run(addr=klass.addr, port=int(klass.port), wsgi_handler=handler, |
|
# ipv6=klass.use_ipv6, threading=threading) |
|
server_address = (klass.addr, int(klass.port)) |
|
if threading: |
|
httpd_cls = type(str('WSGIServer'), (socketserver.ThreadingMixIn, WSGIServer), {}) |
|
else: |
|
httpd_cls = WSGIServer |
|
httpd = httpd_cls(server_address, WSGIRequestHandler, ipv6=klass.use_ipv6) |
|
httpd.set_app(handler) |
|
|
|
except socket.error as e: |
|
# Use helpful error messages instead of ugly tracebacks. |
|
ERRORS = { |
|
errno.EACCES: "You don't have permission to access that port.", |
|
errno.EADDRINUSE: "That port is already in use.", |
|
errno.EADDRNOTAVAIL: "That IP address can't be assigned-to.", |
|
} |
|
try: |
|
error_text = ERRORS[e.errno] |
|
except KeyError: |
|
error_text = str(e) |
|
klass.stderr.write("Error: %s" % error_text) |
|
# Need to use an OS exit because sys.exit doesn't work in a thread |
|
os._exit(1) |
|
|
|
finally: |
|
if saved_locale is not None: |
|
translation.activate(saved_locale) |
|
return httpd |
|
|
|
|
|
if __name__ == '__main__': |
|
# The following are the most common command-line arguments that are used |
|
# with this module: |
|
# django_service.py install (Installs the service with manual startup) |
|
# django_service.py --startup auto install (Installs the service with auto startup) |
|
# django_service.py start (Starts the service) |
|
# django_service.py stop (Stops the service) |
|
# django_service.py remove (Removes the service) |
|
# |
|
# For a full list of arguments, simply type "django_service.py". |
|
win32serviceutil.HandleCommandLine(DjangoWindowsService) |
