Discussion :

[Antoine_935]

Salut à toutes et à tous

Je m'amuse un peu avec asyncore et asynchat, tentant de faire un petit serveur HTTP.

Jusqu'à présent, le serveur fonctionne, mais est leeeeeent... De une à deux secondes par requête
Alors est-ce que j'ai fait n'importe quoi, ou est-ce que asyncore / asynchat est hyper lent (ce dont je doute honnêtement...)

Pour info, je bosse sous Windows Vista.
Voici le code du serveur. C'est vrai que ce n'est pas très optimisé, mais quand même...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
class HttpHandler(asynchat.async_chat):
        ac_out_buffer_size = 1 << 16
 
        def __init__(self, app, conn, addr):
            asynchat.async_chat.__init__(self, conn)
            self.__app = app
            self.__addr = addr
            self.__headersDone = False
            self.__headersString = ""
 
            self.__headers = {}
            self.__method = ""
            self.__uri = ""
            self.__contents = ""
 
            self.__remainingLength = 0
 
            self.set_terminator("\r\n\r\n")
 
        def collect_incoming_data(self, data):
            if self.__headersDone and self.__remainingLength > 0:
                self.__contents += data
                self.__remainingLength -= len(data)
 
                if self.__remainingLength <= 0:
                    self.__process()
 
            else:
                self.__headersString += data
 
        def found_terminator(self):
            self.__headersDone = True
 
            self.__parseRequest()
 
        def __parseRequest(self):
            lines = iter(self.__headersString.split("\r\n"))
            request = lines.next()
 
            self.__method, self.__uri, version = request.split(" ")
 
            for header in lines:
                name, value = header.split(": ")
                self.__headers[name] = value
 
            if not "Content-Length" in self.__headers:
                self.__process()
 
        def __process(self):
#            output = StringIO()
#            req = HttpRequest(self.__method, self.__uri, self.__headers, output)
#            self.__app.handle(req)
 
            #self.push(output.read())
            self.push("HTTP/1.1 200 OK\r\nContent-Length: 13\r\nContent-Type: text/plain\r\n\r\nHello World !")
            self.close_when_done()
 
class HttpServer(asyncore.dispatcher):
    def __init__(self, host, port, app):
        asyncore.dispatcher.__init__(self)
        self.__app = app
 
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.set_reuse_addr()
        self.bind((host, port))
        self.listen(5)
 
    def handle_read(self):
        pass
 
    def handle_connect(self):
        pass
 
    def handle_accept(self):
        try:
            conn, addr = self.accept()
        except socket.error:
            print "Socket error"
            return
        except TypeError:
            return
 
        HttpHandler(self.__app, conn, addr)

Si quelqu'un pouvait m'éclairer...

Edit: après des investigations un peu mieux menées, il semblerait que le serveur n'arrive à handle_accept qu'après un très long moment... La suite du traitement étant instantanée. A quoi cela peut-il être du ?

[Antoine_935]

Haha, je me permets de répondre à mon propre message: j'ai trouvé le souci.

Windows n'a pas l'air d'apprécier le loopback.
En gros, quand l'adresse du serveur est localhost ou 127.0.0.1, il est lent.
Quand je prends l'adresse sur le réseau local, soit 172.x.x.x en l'occurence, la réaction est instantanée.