• Több szálon fut, egyszerre több kérelmet is kiszolgálhat
• Több platformon is működik (Windows/Linux/FreeBSD)
• A háttérben, szolgáltatásként fut

1. Config.py - A szerver konfigurációja. Nincs benne számottevő kód, csak konstansok.
2. ServiceLog.py - Naplózó eszköz. Egységesített módon teszi lehetővé a szerverrel kapcsolatot események naplózását.
3. Application.py - Egy wrapper program ami a szervert alkalmazásként vagy UNIX szerverként futtatja.
4. Service.py - Egy wrapper program that ami a szervert win32 szerverként futtatja.
5. Processor.py - A lényegi kód, ami a szolgáltatást valósítja meg. Ez az egyetlen lényeges modul amit át kell írni, ha más szolgáltatást akarsz írni.

import os
from socket import *

# Service configuration below
# A win32 szolgáltatás neve
SERVICE_NAME = 'SimpleHTTPService'
# A win32 szolgáltatás leírása
SERVICE_DISPLAY = SERVICE_NAME
# Ide írd be a szolgáltatás könyvtárát (ahol az Python állományok vannak)
BASEDIR = 't:\\Python\\Projects\\SimpleHTTPService'
# Ide fogjuk menteni a naplót
LOGDIR =  BASEDIR + os.sep + 'Log'

# Ez lesz a szolgáltatott állományok könyvtára
DOCUMENTROOT = BASEDIR + os.sep + 'DocumentRoot'
# Itt fogadjuk a kérelmeket (IP cím)
LISTEN_HOST = ''
# ...ezen a porton
LISTEN_PORT = 8000
# Service configuration above

import sys
import os
# Ez itt a Python beépített naplózó modulja
import logging
# Naplózást végző "kezelő" osztály.
from   logging.handlers import RotatingFileHandler

• StreamHandler - állományba ír
• RotatingFileHandler - állományba ír, de egy bizonyos méret után új állományt kezd, az állományokat rotálja
• TimedRotatingFileHandler - állományba ír, de egy bizonyos idő után új állományt kezd, az állományokat rotálja
• SocketHandler - TCP/IP socket-be ír
• DatagramHandler - UDP/IP socket-be ír
• SMTPHandler - e-mail üzenetben küldi el az eseményt
• SysLogHandler - (csak UNIX) syslog-ba írja az eseményt
• HTTPHandler - HTTP GET vagy POST kérelemben küldi el az eseményt egy távoli szervernek

import sys
import os
import logging
from   logging.handlers import RotatingFileHandler

import Config

# Ha a naplóállományok könyvtára még nem létezik
# akkor létrehozzuk.
logdir = Config.LOGDIR
if not os.path.isdir(logdir):
   os.mkdir(logdir)

# A saját kezelő osztályunk a standard output-ra ír
class StdOutHandler(logging.Handler):
    def handle(self,record):
        print self.format(record)

formatter  = logging.Formatter('%(asctime)s %(levelname)s %(name)s %(message)s')
handler_1 = RotatingFileHandler(
    logdir + os.sep + 'Service.log',
    maxBytes = 2*1024*1024,
    backupCount = 10
)
handler_2= StdOutHandler()
handler_1.setFormatter(formatter)
handler_2.setFormatter(formatter)
# Ez állítja be a naplózás szintjét
loglevel = logging.DEBUG
# Configure above

def getLogger(name,level=None):
    if level is None:
        level = loglevel
    logger = logging.getLogger('.'+name)
    logger.addHandler(handler_1)
    logger.addHandler(handler_2)
    logger.setLevel(level)
    return logger

1. Beállítjuk a 'stopped' Event-et
2. Megvárjuk, hogy a processor objektum által működtetett szolgáltatás szabályosan leálljon, és csak ezután naplózzuk ki a leállás tényét.

import thread,threading,time

from Config import *
from Processor import *
from ServiceLog import *

# Az alkalmazás naplózó objektuma
logger = getLogger('Application')
logger.info("Staring as application. Please press CTRL+C to stop service.")


# Új Event létrehozása
stopped = threading.Event()
# Event törlése
stopped.clear()
# A szolgáltatás létrehozása
processor = Processor(stopped)
# A szolgáltatás indítása új szálban
thread.start_new_thread(processor.Process,())
# Várakozunk egy ciklusban...
while 1:
    try:
        time.sleep(1)
    except:
        # Ha kivétel történt, akkor leállítjuk a szolgáltatást.
        break
logger.info("Stopping application " + SERVICE_NAME)
# Megkérjük a szolgáltatást, hogy álljon le
stopped.set()
# Megvárjuk, hogy szabályosan leálljon
while not processor.stopped.isSet():
    logger.debug("Waiting for the processor to finish...")
    time.sleep(1)

logger.info("Application stopped.")

• A szolgáltatás telepítésekor
• A szolgáltatás eltávolításakor
• A szolgáltatás futtatásakor

• SvcDoRun - Akkor hívódik meg, amikor a szolgáltatás el akarjuk indítani
• SvcStop - Akkor hívódik meg, amikor a szolgáltatás le akarjuk állítani

from Config import *
from Processor import *
from ServiceLog import *

import win32serviceutil, win32service
import pywintypes, win32con, winerror
from win32event import *
from win32file import *
from win32pipe import *
from win32api import *
from ntsecuritycon import *

import traceback
import thread,threading

class Service(win32serviceutil.ServiceFramework):
    _svc_name_ = SERVICE_NAME
    _svc_display_name_ = SERVICE_DISPLAY
    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        self.stopped = threading.Event()
        self.stopped.clear()
        self.logger = getLogger(SERVICE_NAME)

    def SvcStop(self):
        self.logger.info("Got SvcStop, trying to stop service...")
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        self.stopped.set()

    def SvcDoRun(self):
        try:
            import servicemanager
            # Bejegyezzük az eseménynaplóba, hogy a szolgáltatás elindult.
            servicemanager.LogMsg(
                    servicemanager.EVENTLOG_INFORMATION_TYPE,
                    servicemanager.PYS_SERVICE_STARTED,
                    (self._svc_name_, '')
                    )
            self.logger.info("Started.")
            # Itt hozzuk létre az új szálat, ami a tényleges
            # szolgáltatást végzi.
            self.logger.debug("Creating processor instance")
            processor = Processor(self.stopped)
            self.logger.debug("Starting processor thread")
            thread.start_new_thread(processor.Process,())
            # Addig várakozunk, amíg a processor leállítási kérelmet nem kap
            self.logger.debug("Waiting for the processor thread to finish")
            self.stopped.wait()
            self.logger.debug("Stopping")
            time.sleep(1)
            # Addig várunk, amíg tényleg le nem áll, de közben
            # már jelezzük a Windows felé hogy a szolgáltatás
            # épp leállítás alatt van
            while not processor.stopped.isSet():
                self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING, 5000)
                time.sleep(5)
            # Végül bejegyezzük az eseménynaplóba is
            # a leállás tényét
            servicemanager.LogMsg(
                    servicemanager.EVENTLOG_INFORMATION_TYPE,
                    servicemanager.PYS_SERVICE_STOPPED,
                    (self._svc_name_, "")
                    )
            self.logger.info("Stopped")
        except:
            # Kivétel esetén a kivétel információit is
            # külön ki kell írni a naplóba, hogy lehessen
            # látni, mitől állt le.
            self.logger.error('',exc_info = sys.exc_info())

# Ha parancssorból indítjuk, akkor a parancssori 
# paraméterket egy előre megírt metódus feldolgozza.
if __name__=='__main__':
    win32serviceutil.HandleCommandLine(Service)

import time
import traceback
import thread,threading
import os,stat
import select

from Config import *
from ServiceLog import *

from SimpleHTTPServer import SimpleHTTPRequestHandler
from SocketServer     import ThreadingTCPServer


class MyHTTPServer(ThreadingTCPServer):
    def createlogger(self):
        self.logger = getLogger("MyHTTPServer")

class MyHTTPRequestHandler(SimpleHTTPRequestHandler):
    def log_message(self,format,*args):
        self.server.logger.info(format % args)

class Processor(object):
    """Implement your service code here."""
    def __init__(self,stop_requested):
        """Do not change this constructor.

        The constructor creates these attributes:

            stop_requested  
              - this is an Event. You should 
                periodically check it and stop your 
                service when set.
            stopped         
              - after you stopped your service, 
                you must set this Event
            logger          
              - this is a logger object. You MUST 
                log all events to loggers created 
                by the L{getLogger} function.
        """
        self.stopped = threading.Event()
        self.stopped.clear()
        self.stop_requested =  stop_requested
        self.logger = getLogger("Processor")
        # Custom initialization
        self.startup()
        
    def startup(self):
        """Place your own initialization code here"""
        # Létrehozunk egy MyHTTPServer példányt
        self.server = MyHTTPServer((Config.LISTEN_HOST,Config.LISTEN_PORT),MyHTTPRequestHandler)
        # Létrehozzuk a naplózó objektumot
        self.server.createlogger()
        # Az aktuális könyvtárat átállítjuk (a szerver az aktuális 
        # könyvtár állományait publikálja)
        os.chdir(Config.DOCUMENTROOT)

    def shutdown(self):
        """Place your cleanup code here."""
        pass

    def Process(self):
        """This is the main loop that does the service.

        Place your code here. Do not forget to periodically check
        the stop_requested event and stop your service when requested."""
        srvfd = self.server.fileno() # Szerver socket file
        while not self.stop_requested.isSet(): # Amíg nincs leállítási kérelem...
            # Maximum 1 másodpercet várunk,
            # hogy kapcsolódjon valaki
            ready = select.select([srvfd], [], [], 1)
            if srvfd in ready[0]: # Ha valaki már kapcsolódni kíván...
                self.server.handle_request() # ...akkor kiszolgáljuk őt egy új szálban
            else:
                pass # egyébként nem csinálunk semmit
        self.shutdown() # A szerver leállítása itt történik
        self.stopped.set() # Visszaigazoljuk a leállást
        self.logger.info("Server stopped")

• Minden szoftvernek lesz egy kijelölt helye, ahol a frissítéseket tároljuk. Például, a "Cerebellum" nevű szoftver frissítései a "/Cerebellum" könyvtárban kapnak helyet.
• A kijelölt könyvtáron belül minden verzióhoz tartozik egy külön könyvtár. A könyvtár neve lehet a verziószám, vagy a dátum. Az a lényeg, hogy névsorrendbe rendezve a legutolsó könyvtár tartalmazza a legfrissebb fájlokat.
• A verziót tartalmazó könyvtárokon belül egy tetszőleges könyvtár- és filestruktúra elhelyezhető; ezen a könyvtárak és állományok letöltése jelenti magát a frissítést

1. Letölti a verziók listáját, és megnézi hogy van-e új verzió
2. Ha van új verzió, akkor letölti az állományokat és eltárolja az utolsó letöltött verzió nevét
3. Végül elindítja az (előre megadható) programot