Jak stworzyć usługę Windows Seler?

Question

Próbuję utworzyć usługę systemu Windows, aby uruchomić system Seler. Natknąłem się na artykuł, który robi to przy użyciu Task Scheduler. Wydaje się jednak, że uruchamia liczne przypadki selera i utrzymuje zapasy pamięci, dopóki maszyna nie umiera. Czy istnieje sposób, aby uruchomić go jako usługę Windows?

Answer 1

Dostałem odpowiedź z innej strony internetowej. Celeryd (usługa demona dla Selera) działa jako aplikacja paster, wyszukując "Paster Windows Service" prowadzi mnie here. Opisuje, jak uruchomić aplikację Pylons jako usługę systemu Windows. Będąc nowicjuszem w tworzeniu frameworka i hostingiem serwisów internetowych Pythona, nie myślałem o tym od razu. Ale to rozwiązanie działa dla Selera z niewielką zmianą tu i tam w scenariuszu.

Zmodyfikowałem skrypt, aby ułatwić modyfikowanie ustawień selera. Zasadnicze zmiany to:

1. Utwórz plik INI z ustawieniami usługi naciowego (przedstawione poniżej)
2. Utwórz skrypt Pythona, aby utworzyć usługę Windows.

ustawienia

plików INI (celeryd.ini):

[celery:service] 
service_name = CeleryService 
service_display_name = Celery Service 
service_description = WSCGI Windows Celery Service 
service_logfile = celeryd.log 

Python skrypt do tworzenia systemu Windows Service (CeleryService.py):

""" 
The most basic (working) Windows service possible. 
Requires Mark Hammond's pywin32 package. 
Most of the code was taken from a CherryPy 2.2 example of how to set up a service 
""" 
import pkg_resources 
import win32serviceutil 
from paste.script.serve import ServeCommand as Server 
import os, sys 
import ConfigParser 

import win32service 
import win32event 

SCRIPT_DIR   = os.path.abspath(os.path.dirname(__file__)) 
INI_FILE   = 'celeryd.ini' 
SERV_SECTION  = 'celery:service' 
SERV_NAME   = 'service_name' 
SERV_DISPLAY_NAME = 'service_display_name' 
SERV_DESC   = 'service_description' 
SERV_LOG_FILE  = 'service_logfile' 
SERV_APPLICATION = 'celeryd' 
SERV_LOG_FILE_VAR = 'CELERYD_LOG_FILE' 

# Default Values 
SERV_NAME_DEFAULT   = 'CeleryService' 
SERV_DISPLAY_NAME_DEFAULT = 'Celery Service' 
SERV_DESC_DEFAULT   = 'WSCGI Windows Celery Service' 
SERV_LOG_FILE_DEFAULT  = r'D:\logs\celery.log' 

class DefaultSettings(object): 
    def __init__(self): 
     if SCRIPT_DIR: 
      os.chdir(SCRIPT_DIR) 
     # find the ini file 
     self.ini = os.path.join(SCRIPT_DIR,INI_FILE) 
     # create a config parser opject and populate it with the ini file 
     c = ConfigParser.SafeConfigParser() 
     c.read(self.ini) 
     self.c = c 

    def getDefaults(self): 
     ''' 
     Check for and get the default settings 
     ''' 
     if (
      (not self.c.has_section(SERV_SECTION)) or 
      (not self.c.has_option(SERV_SECTION, SERV_NAME)) or 
      (not self.c.has_option(SERV_SECTION, SERV_DISPLAY_NAME)) or 
      (not self.c.has_option(SERV_SECTION, SERV_DESC)) or 
      (not self.c.has_option(SERV_SECTION, SERV_LOG_FILE)) 
      ): 
      print 'setting defaults' 
      self.setDefaults() 
     service_name = self.c.get(SERV_SECTION, SERV_NAME) 
     service_display_name = self.c.get(SERV_SECTION, SERV_DISPLAY_NAME) 
     service_description = self.c.get(SERV_SECTION, SERV_DESC) 
     iniFile = self.ini 
     service_logfile = self.c.get(SERV_SECTION, SERV_LOG_FILE) 
     return service_name, service_display_name, service_description, iniFile, service_logfile 

    def setDefaults(self): 
     ''' 
     set and add the default setting to the ini file 
     ''' 
     if not self.c.has_section(SERV_SECTION): 
      self.c.add_section(SERV_SECTION) 
     self.c.set(SERV_SECTION, SERV_NAME, SERV_NAME_DEFAULT) 
     self.c.set(SERV_SECTION, SERV_DISPLAY_NAME, SERV_DISPLAY_NAME_DEFAULT) 
     self.c.set(SERV_SECTION, SERV_DESC, SERV_DESC_DEFAULT) 
     self.c.set(SERV_SECTION, SERV_LOG_FILE, SERV_LOG_FILE_DEFAULT) 
     cfg = file(self.ini, 'wr') 
     self.c.write(cfg) 
     cfg.close() 
     print ''' 
you must set the celery:service section service_name, service_display_name, 
and service_description options to define the service 
in the %s file 
''' % self.ini 
     sys.exit() 


class CeleryService(win32serviceutil.ServiceFramework): 
    """NT Service.""" 

    d = DefaultSettings() 
    service_name, service_display_name, service_description, iniFile, logFile = d.getDefaults() 

    _svc_name_ = service_name 
    _svc_display_name_ = service_display_name 
    _svc_description_ = service_description 

    def __init__(self, args): 
     win32serviceutil.ServiceFramework.__init__(self, args) 
     # create an event that SvcDoRun can wait on and SvcStop 
     # can set. 
     self.stop_event = win32event.CreateEvent(None, 0, 0, None) 

    def SvcDoRun(self): 
     os.chdir(SCRIPT_DIR) 
     s = Server(SERV_APPLICATION) 
     os.environ[SERV_LOG_FILE_VAR] = self.logFile 
     s.run([self.iniFile]) 
     win32event.WaitForSingleObject(self.stop_event, win32event.INFINITE) 

    def SvcStop(self): 
     self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) 
     #win32event.SetEvent(self.stop_event) 
     self.ReportServiceStatus(win32service.SERVICE_STOPPED) 
     sys.exit() 

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

Aby zainstalować cyklu roboczego python CeleryService.py install a następnie python CeleryService.py start aby uruchomić usługę. UWAGA: Te polecenia należy uruchamiać w wierszu polecenia z uprawnieniami administratora.

Jeśli usługa musi zostać usunięta, uruchom python CeleryService.py remove.

Próbowałem hostować Celery w ramach ulepszania mojej instalacji RhodeCode. To rozwiązanie wydaje się działać. Mam nadzieję, że to pomoże komuś.

Answer 2

Przyjęta odpowiedź nie dotyczy biegu selera z aplikacją Django. Ale to zainspirowało mnie do znalezienia rozwiązania do prowadzenia selera jako usługi Windows z Django. Zwróć uwagę, że poniższe są tylko dla projektów Django. Może działać z innymi aplikacjami z pewnymi modyfikacjami.

Tworzenie celery_service.py pliku (lub cokolwiek chcesz) wewnątrz folderu najwyższego poziomu Twojego projektu Django, tym samym poziomie co manage.py, o następującej treści:

'''Usage : python celery_service.py install (start/stop/remove) 
Run celery as a Windows service 
''' 
import win32service 
import win32serviceutil 
import win32api 
import win32con 
import win32event 
import subprocess 
import sys 
import os 
import shlex 
import logging 
import time 

# The directory for celery.log and celery_service.log 
# Default: the directory of this script 
INSTDIR = os.path.dirname(os.path.realpath(__file__)) 
# The path of python Scripts 
# Usually it is in PYTHON_INSTALL_DIR/Scripts. e.g. 
# r'C:\Python27\Scripts' 
# If it is already in system PATH, then it can be set as '' 
PYTHONSCRIPTPATH = '' 
# The directory name of django project 
# Note: it is the directory at the same level of manage.py 
# not the parent directory 
PROJECTDIR = 'proj' 

logging.basicConfig(
    filename = os.path.join(INSTDIR, 'celery_service.log'), 
    level = logging.DEBUG, 
    format = '[%(asctime)-15s: %(levelname)-7.7s] %(message)s' 
) 

class CeleryService(win32serviceutil.ServiceFramework): 

    _svc_name_ = "Celery" 
    _svc_display_name_ = "Celery Distributed Task Queue Service" 

    def __init__(self, args): 
     win32serviceutil.ServiceFramework.__init__(self, args) 
     self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)   

    def SvcStop(self): 
     logging.info('Stopping {name} service ...'.format(name=self._svc_name_))   
     self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) 
     win32event.SetEvent(self.hWaitStop) 
     self.ReportServiceStatus(win32service.SERVICE_STOPPED) 
     sys.exit()   

    def SvcDoRun(self): 
     logging.info('Starting {name} service ...'.format(name=self._svc_name_)) 
     os.chdir(INSTDIR) # so that proj worker can be found 
     logging.info('cwd: ' + os.getcwd()) 
     self.ReportServiceStatus(win32service.SERVICE_RUNNING) 
     command = '"{celery_path}" -A {proj_dir} worker -f "{log_path}" -l info'.format(
      celery_path=os.path.join(PYTHONSCRIPTPATH, 'celery.exe'), 
      proj_dir=PROJECTDIR, 
      log_path=os.path.join(INSTDIR,'celery.log')) 
     logging.info('command: ' + command) 
     args = shlex.split(command) 
     proc = subprocess.Popen(args) 
     logging.info('pid: {pid}'.format(pid=proc.pid)) 
     self.timeout = 3000 
     while True: 
      rc = win32event.WaitForSingleObject(self.hWaitStop, self.timeout) 
      if rc == win32event.WAIT_OBJECT_0: 
       # stop signal encountered 
       # terminate process 'proc' 
       PROCESS_TERMINATE = 1 
       handle = win32api.OpenProcess(PROCESS_TERMINATE, False, proc.pid) 
       win32api.TerminateProcess(handle, -1) 
       win32api.CloseHandle(handle)     
       break 

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

Przed skrypt można uruchomić, musisz

1. Zainstaluj pywin32.

2. prawidłowo ustawione PYTHONSCRIPTPATH ​​i PROJECTDIR w celery_service.py

PYTHONSCRIPTPATH ​​jest zwykle "Skrypty" Folder pod ścieżkę instalacji Pythona, w

npC: \ Python27 \ Scripts

Albo dołączyć go do PATH systemowym,

lub edytować celery_service.py

PYTHONSCRIPTPATH = r'C:\Python27\Scripts' 

PROJECTDIR jest nazwą katalogu projektu Django.

Jest to katalog na tym samym poziomie co plik manage.py, a nie katalog nadrzędny.

Teraz można zainstalować/start/stop/usunąć usługę z:

python celery_service.py install 
python celery_service.py start 
python celery_service.py stop 
python celery_service.py remove 

stworzyłem demo projektu Django z selera uruchomiony jako usługa systemu Windows:

https://github.com/azalea/django_celery_windows_service

w przypadku jesteś zainteresowany działającym przykładem.

Answer 3

odpowiedź @azalea „s bardzo mi pomogło, ale jedno chciałbym podkreślić tutaj jest usługa (celery_service.py) musi być zainstalowany z użytkownika/hasła, w przeciwnym razie, po uruchomieniu subprocess.Popen(args) in SvcDoRun() funkcję, nic stanie się, ponieważ wystąpi problem z pozwoleniem. Aby ustawić użytkownika/hasła, można wybrać jedną z dwóch metod:

1. Korzystanie z wiersza polecenia:

   python33 .\celeryService1.py --username .\USERNAME --password PASSWORD 
   

2. idź do Zarządzanie komputerem (lokalne)> Usługi i aplikacje> Usługi, spotkania serwer (na przykład @ azalia jest, że jest „Seler Ukazuje Task Queue Service”), a następnie prawym przyciskiem myszy, aby otworzyć stronę Właściwości, wejściowego „konto” w kartę Logowanie