/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/http_server.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-08 21:56:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3773.
  • Revision ID: john@arbash-meinel.com-20081008215612-y9v94tqxreqoangx
Simplify the --raw mode.

I didn't realize, but the only node that is special cased is the 'root' node,
and to read it, you actually have to parse it directly, because the
compressed bytes start immediately after the end of the header, rather than
having any padding before the zlib bytes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/http_server.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
17
import errno
18
18
import httplib
31
31
import urlparse
32
32
 
33
33
from bzrlib import transport
34
 
from bzrlib.tests import test_server
35
34
from bzrlib.transport import local
36
35
 
37
36
 
 
37
class WebserverNotAvailable(Exception):
 
38
    pass
 
39
 
 
40
 
38
41
class BadWebserverPath(ValueError):
39
42
    def __str__(self):
40
43
        return 'path %s is not in %s' % self.args
138
141
            # common)
139
142
            self.send_response(301)
140
143
            self.send_header("Location", self.path + "/")
141
 
            # Indicates that the body is empty for HTTP/1.1 clients
 
144
            # Indicates that the body is empty for HTTP/1.1 clients 
142
145
            self.send_header('Content-Length', '0')
143
146
            self.end_headers()
144
147
            return None
178
181
            content_length += self._header_line_length(
179
182
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
180
183
            content_length += len('\r\n') # end headers
181
 
            content_length += end - start + 1
 
184
            content_length += end - start # + 1
182
185
        content_length += len(boundary_line)
183
186
        self.send_header('Content-length', content_length)
184
187
        self.end_headers()
319
322
        self.test_case_server = test_case_server
320
323
        self._home_dir = test_case_server._home_dir
321
324
 
322
 
    def stop_server(self):
 
325
    def tearDown(self):
323
326
         """Called to clean-up the server.
324
 
 
 
327
 
325
328
         Since the server may be (surely is, even) in a blocking listen, we
326
329
         shutdown its socket before closing it.
327
330
         """
344
347
             # WSAENOTCONN (10057) 'Socket is not connected' is harmless on
345
348
             # windows (occurs before the first connection attempt
346
349
             # 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):
 
350
             if not len(e.args) or e.args[0] != 10057:
353
351
                 raise
354
352
         # Let the server properly close the socket
355
353
         self.server_close()
383
381
        # lying around.
384
382
        self.daemon_threads = True
385
383
 
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
384
 
404
385
class HttpServer(transport.Server):
405
386
    """A test server for http transports.
438
419
        # Allows tests to verify number of GET requests issued
439
420
        self.GET_request_nb = 0
440
421
 
441
 
    def create_httpd(self, serv_cls, rhandler_cls):
442
 
        return serv_cls((self.host, self.port), self.request_handler, self)
443
 
 
444
422
    def __repr__(self):
445
423
        return "%s(%s:%s)" % \
446
424
            (self.__class__.__name__, self.host, self.port)
462
440
            if serv_cls is None:
463
441
                raise httplib.UnknownProtocol(proto_vers)
464
442
            else:
465
 
                self._httpd = self.create_httpd(serv_cls, rhandler)
466
 
            self.host, self.port = self._httpd.socket.getsockname()
 
443
                self._httpd = serv_cls((self.host, self.port), rhandler, self)
 
444
            host, self.port = self._httpd.socket.getsockname()
467
445
        return self._httpd
468
446
 
469
447
    def _http_start(self):
495
473
            except socket.timeout:
496
474
                pass
497
475
            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
 
476
               if e[0] == errno.EBADF:
 
477
                   # Starting with python-2.6, handle_request may raise socket
 
478
                   # or select exceptions when the server is shut down (as we
 
479
                   # do).
 
480
                   pass
 
481
               else:
 
482
                   raise
508
483
 
509
484
    def _get_remote_url(self, path):
510
485
        path_parts = path.split(os.path.sep)
522
497
        """Capture Server log output."""
523
498
        self.logs.append(format % args)
524
499
 
525
 
    def start_server(self, backing_transport_server=None):
526
 
        """See bzrlib.transport.Server.start_server.
527
 
 
 
500
    def setUp(self, backing_transport_server=None):
 
501
        """See bzrlib.transport.Server.setUp.
 
502
        
528
503
        :param backing_transport_server: The transport that requests over this
529
504
            protocol should be forwarded to. Note that this is currently not
530
505
            supported for HTTP.
531
506
        """
532
507
        # XXX: TODO: make the server back onto vfs_server rather than local
533
508
        # disk.
534
 
        if not (backing_transport_server is None
535
 
                or isinstance(backing_transport_server,
536
 
                              test_server.LocalURLServer)):
 
509
        if not (backing_transport_server is None or \
 
510
                isinstance(backing_transport_server, local.LocalURLServer)):
537
511
            raise AssertionError(
538
512
                "HTTPServer currently assumes local transport, got %s" % \
539
513
                backing_transport_server)
559
533
        self._http_starting.release()
560
534
        self.logs = []
561
535
 
562
 
    def stop_server(self):
563
 
        self._httpd.stop_server()
 
536
    def tearDown(self):
 
537
        """See bzrlib.transport.Server.tearDown."""
 
538
        self._httpd.tearDown()
564
539
        self._http_running = False
565
540
        # We don't need to 'self._http_thread.join()' here since the thread is
566
541
        # a daemonic one and will be garbage collected anyway. Joining just