Stoppable Threading XMLRPC-Server

[gerold]

Hallo!

Dieser Threading-XMLRPC-Server lässt sich vom Client aus stoppen:
server.py

Code: Alles auswählen

#!/usr/bin/env python
#coding: utf-8
# Stoppable Threading XMLRPC-Server


import sys
import time
import threading
import socket; socket.setdefaulttimeout(3) # Timeout auf 3 sec. setzen 
from SocketServer import ThreadingTCPServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
from SimpleXMLRPCServer import SimpleXMLRPCDispatcher


class StoppableThreadingXMLRPCServer(
    ThreadingTCPServer, SimpleXMLRPCDispatcher, threading.Thread
):
    
    def __init__(
        self, addr, requestHandler = SimpleXMLRPCRequestHandler, logRequests = True
    ):
        self.logRequests = logRequests
        if sys.version_info[:2] < (2, 5):
            SimpleXMLRPCDispatcher.__init__(self)
        else:
            SimpleXMLRPCDispatcher.__init__(self, allow_none = False, encoding = None)
        ThreadingTCPServer.__init__(self, addr, requestHandler)
        threading.Thread.__init__(self)
    
    
    def run(self):
        # *serve_forever* muss in einem eigenen Thread laufen, damit man es
        # unterbrechen kann!
        self.serve_forever()
        print "Thread beendet"
    
    
    def stop(self):
        self.shutdown()


class XmlrpcHandler:
    
    def __init__(self, server):
        self._server = server
    
    
    def get_time(self):
        time.sleep(0.2) # nur zum Testen der Threads!
        return time.asctime()
    
    
    def close(self, password):
        if password == "12345":
            self._stoptimer = threading.Timer(1, self._server.stop)
            self._stoptimer.start()
            return "Befehl zum Stoppen erteilt"
        return "falsches Passwort - Server wird nicht gestoppt"


def main():
    server = StoppableThreadingXMLRPCServer(("localhost", 50505), logRequests = True)
    handler = XmlrpcHandler(server)
    server.register_instance(handler)
    
    print "Der XMLRPC-Server horcht auf http://localhost:50505."
    print "Er kann mit STRG+C oder STRG+PAUSE beendet werden."
    print
    
    server.start()
    try:
        while server.is_alive():
            time.sleep(0.1)
    except KeyboardInterrupt:
        server.stop()


if __name__ == "__main__":
    main()

Hierbei handelt es sich um eine Weiterentwicklung des "Einfachen Threading XMLRPC-Servers"

Dieser Client testet den obigen Server:
client.py

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# XMLRPC-Client mit 50 Threads zum Testen der Belastungsfähigkeit
# des "Stoppable Threading XMLRPC-Servers".

import time
import threading
import socket; socket.setdefaulttimeout(3) # Timeout auf 3 sec. setzen
import xmlrpclib


class MyThread(threading.Thread):
    
    def run(self):
        server = xmlrpclib.ServerProxy("http://localhost:50505")
        print "\n" + server.get_time(),


def main():
    # 50 Threads im Abstand von 0.01 sec. starten
    threads = []
    for i in range(50):
        threads.append(MyThread())
        threads[-1].start()
        time.sleep(0.01)
    print "\n" + "Alle Threads gestartet",
    
    # Auf die Threads warten
    for t in threads:
        t.join()
    print "\n" + "Alle Threads fertig"
    
    # Server stoppen
    server = xmlrpclib.ServerProxy("http://localhost:50505")
    print server.close("12345")


if __name__ == "__main__":
    main()

mfg
Gerold


Suchworte: beenden schließen stoppbar stoppen Threading XML-RPC quit close