source: ferringb/src_uri_checker/httpchecker.py @ marienz@gentoo.org-20060220170847-f0f633c8d1b80da6

# Copyright: 2004-2005 Brian Harring
# Author(s): Brian Harring (ferringb@gentoo.org)
# License: GPL2
# $Header: /home/cvsrep/pchecker/httpchecker.py,v 1.21 2005/09/25 23:38:03 bharring Exp $

"""http and https checkers."""

from twisted.web import http, error
from twisted.python import log, failure


class HTTPCheckerClient(http.HTTPClient):

        def connectionMade(self):
                """Initialize some vars and start the first check."""
                http.HTTPClient.connectionMade(self)
                self.count = 0
                # determine pipelining possibility after first check.
                self.max_piped = 1
                self.debug = False
                self._startCheck()

        def _startCheck(self):
                """Run a single check."""
                uri = self.factory.getUri()
                if uri is None:
                        # all done
                        self.transport.loseConnection()
                        return
                self.status = []
                self.sendCommand('HEAD', uri)
                self.sendHeader('Connection', 'Keep-Alive')
                self.sendHeader('Host', '%s:%d' % (
                                self.factory.host, self.factory.port))
                self.sendHeader('User-Agent', 'exp. SRC_URI checker')
                self.endHeaders()
                self.count += 1

        def lineReceived(self, line):
                """Extra error handling for HTTPClient's lineReceived."""
                if self.firstLine and len(line.split(None, 1)) < 2:
                        log.msg('ignoring a bogus firstLine (I hope) line %r' % line)
                elif not self.firstLine and line and ':' not in line:
                        log.msg('ignoring a bogus header (I hope) line %r' % line)
                else:
                        http.HTTPClient.lineReceived(self, line)

        def setRawMode(self):
                """Override and no-op.

                Normally HTTPClient switches to raw mode after receiving the
                header. Since we want to do some more requests we force it to
                stay in line mode.
                """

        def handleStatus(self, version, status, message):
                """Remember our status."""
                try:
                        status = int(status)
                except ValueError:
                        pass
                self.version, self.status, self.message = version, status, message

        def handleHeader(self, key, val):
                """Check if we can do keepalive if we do not know yet."""
                if self.count == 1:
                        # we don't know yet.
                        k = key.lower()
                        if k == "keep-alive":
                                # yay! let's figure out how many requests...
                                for t in val.strip(",").split():
                                        try:
                                                t = t.split("=")
                                                if t[0].lower() == "max":
                                                        self.max_piped = int(t[1])
                                                        break
                                        except (ValueError, IndexError):
                                                # if something is odd, disable pipelining.
                                                break
                        elif k == "connection" and val.lower() == "close":
                                self.max_piped = 0

        def handleEndHeaders(self, *arg):
                """Handle the received headers and do another request if possible."""
                if self.status == 200:
                        self.factory.uriSucceeded()
                else:
                        self.factory.uriFailed(failure.Failure(
                                        error.Error(self.status, self.message)))
                if self.max_piped > self.count:
                        # reset us for a new check and run it.
                        self.firstLine = 1
                        self.status = []
                        self._startCheck()
                else:
                        # request limit reached, drop the connection.
                        self.transport.loseConnection()

        def handleResponse(self, response):
                """Ignore the response."""