← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/HttpServer.py

  • Committer: John Arbash Meinel
  • Date: 2007-10-10 21:18:06 UTC
  • mto: This revision was merged to the branch mainline in revision 2909.
  • Revision ID: john@arbash-meinel.com-20071010211806-2j9rg6wzrqh7yy4u
Switch from __new__ to __init__ to avoid potential pyrex upgrade problems.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/HttpServer.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
import BaseHTTPServer
17
18
import errno
18
 
import httplib
19
19
import os
 
20
from SimpleHTTPServer import SimpleHTTPRequestHandler
 
21
import socket
20
22
import posixpath
21
23
import random
22
24
import re
23
 
import select
24
 
import SimpleHTTPServer
25
 
import socket
26
 
import SocketServer
27
25
import sys
28
26
import threading
29
27
import time
30
28
import urllib
31
29
import urlparse
32
30
 
33
 
from bzrlib import transport
34
 
from bzrlib.tests import test_server
35
 
from bzrlib.transport import local
 
31
from bzrlib.transport import Server
 
32
from bzrlib.transport.local import LocalURLServer
 
33
 
 
34
 
 
35
class WebserverNotAvailable(Exception):
 
36
    pass
36
37
 
37
38
 
38
39
class BadWebserverPath(ValueError):
40
41
        return 'path %s is not in %s' % self.args
41
42
 
42
43
 
43
 
class TestingHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
 
44
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
44
45
    """Handles one request.
45
46
 
46
 
    A TestingHTTPRequestHandler is instantiated for every request received by
47
 
    the associated server. Note that 'request' here is inherited from the base
48
 
    TCPServer class, for the HTTP server it is really a connection which itself
49
 
    will handle one or several HTTP requests.
 
47
    A TestingHTTPRequestHandler is instantiated for every request
 
48
    received by the associated server.
50
49
    """
51
 
    # Default protocol version
52
 
    protocol_version = 'HTTP/1.1'
53
 
 
54
 
    # The Message-like class used to parse the request headers
55
 
    MessageClass = httplib.HTTPMessage
56
 
 
57
 
    def setup(self):
58
 
        SimpleHTTPServer.SimpleHTTPRequestHandler.setup(self)
59
 
        self._cwd = self.server._home_dir
60
 
        tcs = self.server.test_case_server
61
 
        if tcs.protocol_version is not None:
62
 
            # If the test server forced a protocol version, use it
63
 
            self.protocol_version = tcs.protocol_version
64
50
 
65
51
    def log_message(self, format, *args):
66
52
        tcs = self.server.test_case_server
78
64
        connection early to avoid polluting the test results.
79
65
        """
80
66
        try:
81
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
 
67
            self._handle_one_request()
82
68
        except socket.error, e:
83
 
            # Any socket error should close the connection, but some errors are
84
 
            # due to the client closing early and we don't want to pollute test
85
 
            # results, so we raise only the others.
 
69
            if (len(e.args) > 0
 
70
                and e.args[0] in (errno.EPIPE, errno.ECONNRESET,
 
71
                                  errno.ECONNABORTED,)):
 
72
                self.close_connection = 1
 
73
                pass
 
74
            else:
 
75
                raise
 
76
 
 
77
    def _handle_one_request(self):
 
78
        """
 
79
        Request handling as defined in the base class.
 
80
 
 
81
        You normally don't need to override this method; see the class
 
82
        __doc__ string for information on how to handle specific HTTP
 
83
        commands such as GET and POST.
 
84
 
 
85
        On some platforms, notably OS X, a lot of EAGAIN (resource temporary
 
86
        unavailable) occur. We retry silently at most 10 times.
 
87
        """
 
88
        for i in xrange(1,11): # Don't try more than 10 times
 
89
            try:
 
90
                self.raw_requestline = self.rfile.readline()
 
91
            except socket.error, e:
 
92
                if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
 
93
                    # omitted for now because some tests look at the log of
 
94
                    # the server and expect to see no errors.  see recent
 
95
                    # email thread. -- mbp 20051021. 
 
96
                    ## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
 
97
                    time.sleep(0.01)
 
98
                    continue
 
99
                raise
 
100
            else:
 
101
                break
 
102
        if not self.raw_requestline:
86
103
            self.close_connection = 1
87
 
            if (len(e.args) == 0
88
 
                or e.args[0] not in (errno.EPIPE, errno.ECONNRESET,
89
 
                                     errno.ECONNABORTED, errno.EBADF)):
90
 
                raise
 
104
            return
 
105
        if not self.parse_request(): # An error code has been sent, just exit
 
106
            return
 
107
        mname = 'do_' + self.command
 
108
        if getattr(self, mname, None) is None:
 
109
            self.send_error(501, "Unsupported method (%r)" % self.command)
 
110
            return
 
111
        method = getattr(self, mname)
 
112
        method()
91
113
 
92
114
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
93
115
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
125
147
                    return 0, []
126
148
        return tail, ranges
127
149
 
128
 
    def _header_line_length(self, keyword, value):
129
 
        header_line = '%s: %s\r\n' % (keyword, value)
130
 
        return len(header_line)
131
 
 
132
 
    def send_head(self):
133
 
        """Overrides base implementation to work around a bug in python2.5."""
134
 
        path = self.translate_path(self.path)
135
 
        if os.path.isdir(path) and not self.path.endswith('/'):
136
 
            # redirect browser - doing basically what apache does when
137
 
            # DirectorySlash option is On which is quite common (braindead, but
138
 
            # common)
139
 
            self.send_response(301)
140
 
            self.send_header("Location", self.path + "/")
141
 
            # Indicates that the body is empty for HTTP/1.1 clients
142
 
            self.send_header('Content-Length', '0')
143
 
            self.end_headers()
144
 
            return None
145
 
 
146
 
        return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
147
 
 
148
150
    def send_range_content(self, file, start, length):
149
151
        file.seek(start)
150
152
        self.wfile.write(file.read(length))
165
167
    def get_multiple_ranges(self, file, file_size, ranges):
166
168
        self.send_response(206)
167
169
        self.send_header('Accept-Ranges', 'bytes')
168
 
        boundary = '%d' % random.randint(0,0x7FFFFFFF)
169
 
        self.send_header('Content-Type',
170
 
                         'multipart/byteranges; boundary=%s' % boundary)
171
 
        boundary_line = '--%s\r\n' % boundary
172
 
        # Calculate the Content-Length
173
 
        content_length = 0
174
 
        for (start, end) in ranges:
175
 
            content_length += len(boundary_line)
176
 
            content_length += self._header_line_length(
177
 
                'Content-type', 'application/octet-stream')
178
 
            content_length += self._header_line_length(
179
 
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
180
 
            content_length += len('\r\n') # end headers
181
 
            content_length += end - start + 1
182
 
        content_length += len(boundary_line)
183
 
        self.send_header('Content-length', content_length)
 
170
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
171
        self.send_header("Content-Type",
 
172
                         "multipart/byteranges; boundary=%s" % boundary)
184
173
        self.end_headers()
185
 
 
186
 
        # Send the multipart body
187
174
        for (start, end) in ranges:
188
 
            self.wfile.write(boundary_line)
189
 
            self.send_header('Content-type', 'application/octet-stream')
190
 
            self.send_header('Content-Range', 'bytes %d-%d/%d'
191
 
                             % (start, end, file_size))
 
175
            self.wfile.write("--%s\r\n" % boundary)
 
176
            self.send_header("Content-type", 'application/octet-stream')
 
177
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
178
                                                                  end,
 
179
                                                                  file_size))
192
180
            self.end_headers()
193
181
            self.send_range_content(file, start, end - start + 1)
194
 
        # Final boundary
195
 
        self.wfile.write(boundary_line)
 
182
            self.wfile.write("--%s\r\n" % boundary)
196
183
 
197
184
    def do_GET(self):
198
185
        """Serve a GET request.
199
186
 
200
187
        Handles the Range header.
201
188
        """
202
 
        # Update statistics
203
 
        self.server.test_case_server.GET_request_nb += 1
204
189
 
205
190
        path = self.translate_path(self.path)
206
191
        ranges_header_value = self.headers.get('Range')
207
192
        if ranges_header_value is None or os.path.isdir(path):
208
193
            # Let the mother class handle most cases
209
 
            return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
 
194
            return SimpleHTTPRequestHandler.do_GET(self)
210
195
 
211
196
        try:
212
197
            # Always read in binary mode. Opening files in text
283
268
        return self._translate_path(path)
284
269
 
285
270
    def _translate_path(self, path):
286
 
        """Translate a /-separated PATH to the local filename syntax.
287
 
 
288
 
        Note that we're translating http URLs here, not file URLs.
289
 
        The URL root location is the server's startup directory.
290
 
        Components that mean special things to the local file system
291
 
        (e.g. drive or directory names) are ignored.  (XXX They should
292
 
        probably be diagnosed.)
293
 
 
294
 
        Override from python standard library to stop it calling os.getcwd()
295
 
        """
296
 
        # abandon query parameters
297
 
        path = urlparse.urlparse(path)[2]
298
 
        path = posixpath.normpath(urllib.unquote(path))
299
 
        path = path.decode('utf-8')
300
 
        words = path.split('/')
301
 
        words = filter(None, words)
302
 
        path = self._cwd
303
 
        for num, word in enumerate(words):
304
 
            if num == 0:
 
271
        return SimpleHTTPRequestHandler.translate_path(self, path)
 
272
 
 
273
    if sys.platform == 'win32':
 
274
        # On win32 you cannot access non-ascii filenames without
 
275
        # decoding them into unicode first.
 
276
        # However, under Linux, you can access bytestream paths
 
277
        # without any problems. If this function was always active
 
278
        # it would probably break tests when LANG=C was set
 
279
        def _translate_path(self, path):
 
280
            """Translate a /-separated PATH to the local filename syntax.
 
281
 
 
282
            For bzr, all url paths are considered to be utf8 paths.
 
283
            On Linux, you can access these paths directly over the bytestream
 
284
            request, but on win32, you must decode them, and access them
 
285
            as Unicode files.
 
286
            """
 
287
            # abandon query parameters
 
288
            path = urlparse.urlparse(path)[2]
 
289
            path = posixpath.normpath(urllib.unquote(path))
 
290
            path = path.decode('utf-8')
 
291
            words = path.split('/')
 
292
            words = filter(None, words)
 
293
            path = os.getcwdu()
 
294
            for word in words:
305
295
                drive, word = os.path.splitdrive(word)
306
 
            head, word = os.path.split(word)
307
 
            if word in (os.curdir, os.pardir): continue
308
 
            path = os.path.join(path, word)
309
 
        return path
310
 
 
311
 
 
312
 
class TestingHTTPServerMixin:
313
 
 
314
 
    def __init__(self, test_case_server):
 
296
                head, word = os.path.split(word)
 
297
                if word in (os.curdir, os.pardir): continue
 
298
                path = os.path.join(path, word)
 
299
            return path
 
300
 
 
301
 
 
302
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
 
303
 
 
304
    def __init__(self, server_address, RequestHandlerClass,
 
305
                 test_case_server):
 
306
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
 
307
                                           RequestHandlerClass)
315
308
        # test_case_server can be used to communicate between the
316
309
        # tests and the server (or the request handler and the
317
310
        # server), allowing dynamic behaviors to be defined from
318
311
        # the tests cases.
319
312
        self.test_case_server = test_case_server
320
 
        self._home_dir = test_case_server._home_dir
321
 
 
322
 
    def stop_server(self):
323
 
         """Called to clean-up the server.
324
 
 
325
 
         Since the server may be (surely is, even) in a blocking listen, we
326
 
         shutdown its socket before closing it.
327
 
         """
328
 
         # Note that is this executed as part of the implicit tear down in the
329
 
         # main thread while the server runs in its own thread. The clean way
330
 
         # to tear down the server is to instruct him to stop accepting
331
 
         # connections and wait for the current connection(s) to end
332
 
         # naturally. To end the connection naturally, the http transports
333
 
         # should close their socket when they do not need to talk to the
334
 
         # server anymore. This happens naturally during the garbage collection
335
 
         # phase of the test transport objetcs (the server clients), so we
336
 
         # don't have to worry about them.  So, for the server, we must tear
337
 
         # down here, from the main thread, when the test have ended.  Note
338
 
         # that since the server is in a blocking operation and since python
339
 
         # use select internally, shutting down the socket is reliable and
340
 
         # relatively clean.
341
 
         try:
342
 
             self.socket.shutdown(socket.SHUT_RDWR)
343
 
         except socket.error, e:
344
 
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
345
 
             # windows (occurs before the first connection attempt
346
 
             # vila--20071230)
347
 
 
348
 
             # 'Socket is not connected' can also occur on OSX, with a
349
 
             # "regular" ENOTCONN (when something went wrong during test case
350
 
             # setup leading to self.setUp() *not* being called but
351
 
             # self.stop_server() still being called -- vila20081106
352
 
             if not len(e.args) or e.args[0] not in (errno.ENOTCONN, 10057):
353
 
                 raise
354
 
         # Let the server properly close the socket
355
 
         self.server_close()
356
 
 
357
 
 
358
 
class TestingHTTPServer(SocketServer.TCPServer, TestingHTTPServerMixin):
359
 
 
360
 
    def __init__(self, server_address, request_handler_class,
361
 
                 test_case_server):
362
 
        TestingHTTPServerMixin.__init__(self, test_case_server)
363
 
        SocketServer.TCPServer.__init__(self, server_address,
364
 
                                        request_handler_class)
365
 
 
366
 
 
367
 
class TestingThreadingHTTPServer(SocketServer.ThreadingTCPServer,
368
 
                                 TestingHTTPServerMixin):
369
 
    """A threading HTTP test server for HTTP 1.1.
370
 
 
371
 
    Since tests can initiate several concurrent connections to the same http
372
 
    server, we need an independent connection for each of them. We achieve that
373
 
    by spawning a new thread for each connection.
374
 
    """
375
 
 
376
 
    def __init__(self, server_address, request_handler_class,
377
 
                 test_case_server):
378
 
        TestingHTTPServerMixin.__init__(self, test_case_server)
379
 
        SocketServer.ThreadingTCPServer.__init__(self, server_address,
380
 
                                                 request_handler_class)
381
 
        # Decides how threads will act upon termination of the main
382
 
        # process. This is prophylactic as we should not leave the threads
383
 
        # lying around.
384
 
        self.daemon_threads = True
385
 
 
386
 
    def process_request_thread(self, request, client_address):
387
 
        SocketServer.ThreadingTCPServer.process_request_thread(
388
 
            self, request, client_address)
389
 
        # Under some circumstances (as in bug #383920), we need to force the
390
 
        # shutdown as python delays it until gc occur otherwise and the client
391
 
        # may hang.
392
 
        try:
393
 
            # The request process has been completed, the thread is about to
394
 
            # die, let's shutdown the socket if we can.
395
 
            request.shutdown(socket.SHUT_RDWR)
396
 
        except (socket.error, select.error), e:
397
 
            if e[0] in (errno.EBADF, errno.ENOTCONN):
398
 
                # Right, the socket is already down
399
 
                pass
400
 
            else:
401
 
                raise
402
 
 
403
 
 
404
 
class HttpServer(transport.Server):
 
313
 
 
314
 
 
315
class HttpServer(Server):
405
316
    """A test server for http transports.
406
317
 
407
318
    Subclasses can provide a specific request handler.
408
319
    """
409
320
 
410
 
    # The real servers depending on the protocol
411
 
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
412
 
                         'HTTP/1.1': TestingThreadingHTTPServer,
413
 
                         }
414
 
 
415
321
    # Whether or not we proxy the requests (see
416
322
    # TestingHTTPRequestHandler.translate_path).
417
323
    proxy_requests = False
419
325
    # used to form the url that connects to this server
420
326
    _url_protocol = 'http'
421
327
 
422
 
    def __init__(self, request_handler=TestingHTTPRequestHandler,
423
 
                 protocol_version=None):
424
 
        """Constructor.
425
 
 
426
 
        :param request_handler: a class that will be instantiated to handle an
427
 
            http connection (one or several requests).
428
 
 
429
 
        :param protocol_version: if specified, will override the protocol
430
 
            version of the request handler.
431
 
        """
432
 
        transport.Server.__init__(self)
 
328
    # Subclasses can provide a specific request handler
 
329
    def __init__(self, request_handler=TestingHTTPRequestHandler):
 
330
        Server.__init__(self)
433
331
        self.request_handler = request_handler
434
332
        self.host = 'localhost'
435
333
        self.port = 0
436
334
        self._httpd = None
437
 
        self.protocol_version = protocol_version
438
 
        # Allows tests to verify number of GET requests issued
439
 
        self.GET_request_nb = 0
440
 
 
441
 
    def create_httpd(self, serv_cls, rhandler_cls):
442
 
        return serv_cls((self.host, self.port), self.request_handler, self)
443
 
 
444
 
    def __repr__(self):
445
 
        return "%s(%s:%s)" % \
446
 
            (self.__class__.__name__, self.host, self.port)
447
335
 
448
336
    def _get_httpd(self):
449
337
        if self._httpd is None:
450
 
            rhandler = self.request_handler
451
 
            # Depending on the protocol version, we will create the approriate
452
 
            # server
453
 
            if self.protocol_version is None:
454
 
                # Use the request handler one
455
 
                proto_vers = rhandler.protocol_version
456
 
            else:
457
 
                # Use our own, it will be used to override the request handler
458
 
                # one too.
459
 
                proto_vers = self.protocol_version
460
 
            # Create the appropriate server for the required protocol
461
 
            serv_cls = self.http_server_class.get(proto_vers, None)
462
 
            if serv_cls is None:
463
 
                raise httplib.UnknownProtocol(proto_vers)
464
 
            else:
465
 
                self._httpd = self.create_httpd(serv_cls, rhandler)
466
 
            self.host, self.port = self._httpd.socket.getsockname()
 
338
            self._httpd = TestingHTTPServer((self.host, self.port),
 
339
                                            self.request_handler,
 
340
                                            self)
 
341
            host, self.port = self._httpd.socket.getsockname()
467
342
        return self._httpd
468
343
 
469
344
    def _http_start(self):
470
 
        """Server thread main entry point. """
471
 
        self._http_running = False
472
 
        try:
473
 
            try:
474
 
                httpd = self._get_httpd()
475
 
                self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
476
 
                                                       self.host, self.port)
477
 
                self._http_running = True
478
 
            except:
479
 
                # Whatever goes wrong, we save the exception for the main
480
 
                # thread. Note that since we are running in a thread, no signal
481
 
                # can be received, so we don't care about KeyboardInterrupt.
482
 
                self._http_exception = sys.exc_info()
483
 
        finally:
484
 
            # Release the lock or the main thread will block and the whole
485
 
            # process will hang.
486
 
            self._http_starting.release()
 
345
        httpd = self._get_httpd()
 
346
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
347
                                               self.host,
 
348
                                               self.port)
 
349
        httpd.socket.settimeout(0.1)
 
350
        self._http_starting.release()
487
351
 
488
 
        # From now on, exceptions are taken care of by the
489
 
        # SocketServer.BaseServer or the request handler.
490
352
        while self._http_running:
491
353
            try:
492
 
                # Really an HTTP connection but the python framework is generic
493
 
                # and call them requests
494
354
                httpd.handle_request()
495
355
            except socket.timeout:
496
356
                pass
497
 
            except (socket.error, select.error), e:
498
 
                if (e[0] == errno.EBADF
499
 
                    or (sys.platform == 'win32' and e[0] == 10038)):
500
 
                    # Starting with python-2.6, handle_request may raise socket
501
 
                    # or select exceptions when the server is shut down (as we
502
 
                    # do).
503
 
                    # 10038 = WSAENOTSOCK
504
 
                    # http://msdn.microsoft.com/en-us/library/ms740668%28VS.85%29.aspx
505
 
                    pass
506
 
                else:
507
 
                    raise
508
357
 
509
358
    def _get_remote_url(self, path):
510
359
        path_parts = path.split(os.path.sep)
522
371
        """Capture Server log output."""
523
372
        self.logs.append(format % args)
524
373
 
525
 
    def start_server(self, backing_transport_server=None):
526
 
        """See bzrlib.transport.Server.start_server.
527
 
 
 
374
    def setUp(self, backing_transport_server=None):
 
375
        """See bzrlib.transport.Server.setUp.
 
376
        
528
377
        :param backing_transport_server: The transport that requests over this
529
378
            protocol should be forwarded to. Note that this is currently not
530
379
            supported for HTTP.
531
380
        """
532
381
        # XXX: TODO: make the server back onto vfs_server rather than local
533
382
        # disk.
534
 
        if not (backing_transport_server is None
535
 
                or isinstance(backing_transport_server,
536
 
                              test_server.LocalURLServer)):
537
 
            raise AssertionError(
538
 
                "HTTPServer currently assumes local transport, got %s" % \
539
 
                backing_transport_server)
 
383
        assert backing_transport_server is None or \
 
384
            isinstance(backing_transport_server, LocalURLServer), \
 
385
            "HTTPServer currently assumes local transport, got %s" % \
 
386
            backing_transport_server
540
387
        self._home_dir = os.getcwdu()
541
388
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
389
        self._http_starting = threading.Lock()
 
390
        self._http_starting.acquire()
 
391
        self._http_running = True
542
392
        self._http_base_url = None
543
 
 
544
 
        # Create the server thread
545
 
        self._http_starting = threading.Lock()
546
 
        self._http_starting.acquire()
547
393
        self._http_thread = threading.Thread(target=self._http_start)
548
394
        self._http_thread.setDaemon(True)
549
 
        self._http_exception = None
550
395
        self._http_thread.start()
551
 
 
552
396
        # Wait for the server thread to start (i.e release the lock)
553
397
        self._http_starting.acquire()
554
 
 
555
 
        if self._http_exception is not None:
556
 
            # Something went wrong during server start
557
 
            exc_class, exc_value, exc_tb = self._http_exception
558
 
            raise exc_class, exc_value, exc_tb
559
398
        self._http_starting.release()
560
399
        self.logs = []
561
400
 
562
 
    def stop_server(self):
563
 
        self._httpd.stop_server()
 
401
    def tearDown(self):
 
402
        """See bzrlib.transport.Server.tearDown."""
 
403
        self._httpd.server_close()
564
404
        self._http_running = False
565
 
        # We don't need to 'self._http_thread.join()' here since the thread is
566
 
        # a daemonic one and will be garbage collected anyway. Joining just
567
 
        # slows us down for no added benefit.
 
405
        self._http_thread.join()
568
406
 
569
407
    def get_url(self):
570
408
        """See bzrlib.transport.Server.get_url."""
574
412
        """See bzrlib.transport.Server.get_bogus_url."""
575
413
        # this is chosen to try to prevent trouble with proxies, weird dns,
576
414
        # etc
577
 
        return self._url_protocol + '://127.0.0.1:1/'
 
415
        return 'http://127.0.0.1:1/'
578
416
 
579
417
 
580
418
class HttpServer_urllib(HttpServer):