← 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-04-10 18:30:32 UTC
  • mto: This revision was merged to the branch mainline in revision 2403.
  • Revision ID: john@arbash-meinel.com-20070410183032-rw4d3kpb8f9cesfw
We don't need to extract ancestry_b until we after we've checked for existence.
It seems to make sense to check 'b in ancestry_a' first, though we might consider checking
a in ancestry_b first.
b in a is merging something which has already been merged.
a in b is merging something which has merged you.
And 'a in b' may actually be more common.
The timing difference is fairly small, though.

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
 
    """Handles one request.
45
 
 
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.
50
 
    """
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
 
44
class TestingHTTPRequestHandler(SimpleHTTPRequestHandler):
64
45
 
65
46
    def log_message(self, format, *args):
66
47
        tcs = self.server.test_case_server
74
55
    def handle_one_request(self):
75
56
        """Handle a single HTTP request.
76
57
 
77
 
        We catch all socket errors occurring when the client close the
78
 
        connection early to avoid polluting the test results.
 
58
        You normally don't need to override this method; see the class
 
59
        __doc__ string for information on how to handle specific HTTP
 
60
        commands such as GET and POST.
 
61
 
79
62
        """
80
 
        try:
81
 
            SimpleHTTPServer.SimpleHTTPRequestHandler.handle_one_request(self)
82
 
        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.
 
63
        for i in xrange(1,11): # Don't try more than 10 times
 
64
            try:
 
65
                self.raw_requestline = self.rfile.readline()
 
66
            except socket.error, e:
 
67
                if e.args[0] in (errno.EAGAIN, errno.EWOULDBLOCK):
 
68
                    # omitted for now because some tests look at the log of
 
69
                    # the server and expect to see no errors.  see recent
 
70
                    # email thread. -- mbp 20051021. 
 
71
                    ## self.log_message('EAGAIN (%d) while reading from raw_requestline' % i)
 
72
                    time.sleep(0.01)
 
73
                    continue
 
74
                raise
 
75
            else:
 
76
                break
 
77
        if not self.raw_requestline:
86
78
            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
 
79
            return
 
80
        if not self.parse_request(): # An error code has been sent, just exit
 
81
            return
 
82
        mname = 'do_' + self.command
 
83
        if getattr(self, mname, None) is None:
 
84
            self.send_error(501, "Unsupported method (%r)" % self.command)
 
85
            return
 
86
        method = getattr(self, mname)
 
87
        method()
91
88
 
92
89
    _range_regexp = re.compile(r'^(?P<start>\d+)-(?P<end>\d+)$')
93
90
    _tail_regexp = re.compile(r'^-(?P<tail>\d+)$')
125
122
                    return 0, []
126
123
        return tail, ranges
127
124
 
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
125
    def send_range_content(self, file, start, length):
149
126
        file.seek(start)
150
127
        self.wfile.write(file.read(length))
165
142
    def get_multiple_ranges(self, file, file_size, ranges):
166
143
        self.send_response(206)
167
144
        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)
 
145
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
146
        self.send_header("Content-Type",
 
147
                         "multipart/byteranges; boundary=%s" % boundary)
184
148
        self.end_headers()
185
 
 
186
 
        # Send the multipart body
187
149
        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))
 
150
            self.wfile.write("--%s\r\n" % boundary)
 
151
            self.send_header("Content-type", 'application/octet-stream')
 
152
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
 
153
                                                                  end,
 
154
                                                                  file_size))
192
155
            self.end_headers()
193
156
            self.send_range_content(file, start, end - start + 1)
194
 
        # Final boundary
195
 
        self.wfile.write(boundary_line)
 
157
            self.wfile.write("--%s\r\n" % boundary)
196
158
 
197
159
    def do_GET(self):
198
160
        """Serve a GET request.
199
161
 
200
162
        Handles the Range header.
201
163
        """
202
 
        # Update statistics
203
 
        self.server.test_case_server.GET_request_nb += 1
204
164
 
205
165
        path = self.translate_path(self.path)
206
166
        ranges_header_value = self.headers.get('Range')
207
167
        if ranges_header_value is None or os.path.isdir(path):
208
168
            # Let the mother class handle most cases
209
 
            return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
 
169
            return SimpleHTTPRequestHandler.do_GET(self)
210
170
 
211
171
        try:
212
172
            # Always read in binary mode. Opening files in text
259
219
            self.get_multiple_ranges(file, file_size, ranges)
260
220
        file.close()
261
221
 
262
 
    def translate_path(self, path):
263
 
        """Translate a /-separated PATH to the local filename syntax.
264
 
 
265
 
        If the server requires it, proxy the path before the usual translation
266
 
        """
267
 
        if self.server.test_case_server.proxy_requests:
268
 
            # We need to act as a proxy and accept absolute urls,
269
 
            # which SimpleHTTPRequestHandler (parent) is not
270
 
            # ready for. So we just drop the protocol://host:port
271
 
            # part in front of the request-url (because we know
272
 
            # we would not forward the request to *another*
273
 
            # proxy).
274
 
 
275
 
            # So we do what SimpleHTTPRequestHandler.translate_path
276
 
            # do beginning with python 2.4.3: abandon query
277
 
            # parameters, scheme, host port, etc (which ensure we
278
 
            # provide the right behaviour on all python versions).
 
222
    if sys.platform == 'win32':
 
223
        # On win32 you cannot access non-ascii filenames without
 
224
        # decoding them into unicode first.
 
225
        # However, under Linux, you can access bytestream paths
 
226
        # without any problems. If this function was always active
 
227
        # it would probably break tests when LANG=C was set
 
228
        def translate_path(self, path):
 
229
            """Translate a /-separated PATH to the local filename syntax.
 
230
 
 
231
            For bzr, all url paths are considered to be utf8 paths.
 
232
            On Linux, you can access these paths directly over the bytestream
 
233
            request, but on win32, you must decode them, and access them
 
234
            as Unicode files.
 
235
            """
 
236
            # abandon query parameters
279
237
            path = urlparse.urlparse(path)[2]
280
 
            # And now, we can apply *our* trick to proxy files
281
 
            path += '-proxied'
282
 
 
283
 
        return self._translate_path(path)
284
 
 
285
 
    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:
 
238
            path = posixpath.normpath(urllib.unquote(path))
 
239
            path = path.decode('utf-8')
 
240
            words = path.split('/')
 
241
            words = filter(None, words)
 
242
            path = os.getcwdu()
 
243
            for word in words:
305
244
                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):
 
245
                head, word = os.path.split(word)
 
246
                if word in (os.curdir, os.pardir): continue
 
247
                path = os.path.join(path, word)
 
248
            return path
 
249
 
 
250
 
 
251
class TestingHTTPServer(BaseHTTPServer.HTTPServer):
 
252
 
 
253
    def __init__(self, server_address, RequestHandlerClass,
 
254
                 test_case_server):
 
255
        BaseHTTPServer.HTTPServer.__init__(self, server_address,
 
256
                                           RequestHandlerClass)
315
257
        # test_case_server can be used to communicate between the
316
258
        # tests and the server (or the request handler and the
317
259
        # server), allowing dynamic behaviors to be defined from
318
260
        # the tests cases.
319
261
        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):
 
262
 
 
263
 
 
264
class HttpServer(Server):
405
265
    """A test server for http transports.
406
266
 
407
267
    Subclasses can provide a specific request handler.
408
268
    """
409
269
 
410
 
    # The real servers depending on the protocol
411
 
    http_server_class = {'HTTP/1.0': TestingHTTPServer,
412
 
                         'HTTP/1.1': TestingThreadingHTTPServer,
413
 
                         }
414
 
 
415
 
    # Whether or not we proxy the requests (see
416
 
    # TestingHTTPRequestHandler.translate_path).
417
 
    proxy_requests = False
418
 
 
419
270
    # used to form the url that connects to this server
420
271
    _url_protocol = 'http'
421
272
 
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)
 
273
    # Subclasses can provide a specific request handler
 
274
    def __init__(self, request_handler=TestingHTTPRequestHandler):
 
275
        Server.__init__(self)
433
276
        self.request_handler = request_handler
434
277
        self.host = 'localhost'
435
278
        self.port = 0
436
279
        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
280
 
448
281
    def _get_httpd(self):
449
282
        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()
 
283
            self._httpd = TestingHTTPServer((self.host, self.port),
 
284
                                            self.request_handler,
 
285
                                            self)
 
286
            host, self.port = self._httpd.socket.getsockname()
467
287
        return self._httpd
468
288
 
469
289
    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()
 
290
        httpd = self._get_httpd()
 
291
        self._http_base_url = '%s://%s:%s/' % (self._url_protocol,
 
292
                                               self.host,
 
293
                                               self.port)
 
294
        self._http_starting.release()
 
295
        httpd.socket.settimeout(0.1)
487
296
 
488
 
        # From now on, exceptions are taken care of by the
489
 
        # SocketServer.BaseServer or the request handler.
490
297
        while self._http_running:
491
298
            try:
492
 
                # Really an HTTP connection but the python framework is generic
493
 
                # and call them requests
494
299
                httpd.handle_request()
495
300
            except socket.timeout:
496
301
                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
302
 
509
303
    def _get_remote_url(self, path):
510
304
        path_parts = path.split(os.path.sep)
522
316
        """Capture Server log output."""
523
317
        self.logs.append(format % args)
524
318
 
525
 
    def start_server(self, backing_transport_server=None):
526
 
        """See bzrlib.transport.Server.start_server.
527
 
 
 
319
    def setUp(self, backing_transport_server=None):
 
320
        """See bzrlib.transport.Server.setUp.
 
321
        
528
322
        :param backing_transport_server: The transport that requests over this
529
323
            protocol should be forwarded to. Note that this is currently not
530
324
            supported for HTTP.
531
325
        """
532
326
        # XXX: TODO: make the server back onto vfs_server rather than local
533
327
        # 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)
 
328
        assert backing_transport_server is None or \
 
329
            isinstance(backing_transport_server, LocalURLServer), \
 
330
            "HTTPServer currently assumes local transport, got %s" % \
 
331
            backing_transport_server
540
332
        self._home_dir = os.getcwdu()
541
333
        self._local_path_parts = self._home_dir.split(os.path.sep)
 
334
        self._http_starting = threading.Lock()
 
335
        self._http_starting.acquire()
 
336
        self._http_running = True
542
337
        self._http_base_url = None
543
 
 
544
 
        # Create the server thread
545
 
        self._http_starting = threading.Lock()
546
 
        self._http_starting.acquire()
547
338
        self._http_thread = threading.Thread(target=self._http_start)
548
339
        self._http_thread.setDaemon(True)
549
 
        self._http_exception = None
550
340
        self._http_thread.start()
551
 
 
552
341
        # Wait for the server thread to start (i.e release the lock)
553
342
        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
343
        self._http_starting.release()
560
344
        self.logs = []
561
345
 
562
 
    def stop_server(self):
563
 
        self._httpd.stop_server()
 
346
    def tearDown(self):
 
347
        """See bzrlib.transport.Server.tearDown."""
564
348
        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.
 
349
        self._http_thread.join()
568
350
 
569
351
    def get_url(self):
570
352
        """See bzrlib.transport.Server.get_url."""
574
356
        """See bzrlib.transport.Server.get_bogus_url."""
575
357
        # this is chosen to try to prevent trouble with proxies, weird dns,
576
358
        # etc
577
 
        return self._url_protocol + '://127.0.0.1:1/'
 
359
        return 'http://127.0.0.1:1/'
578
360
 
579
361
 
580
362
class HttpServer_urllib(HttpServer):