Synnefo » snf-ganeti » ganeti-local

from ganeti import compat

def _HandleServerRequestInner(handler, req_msg):

class HttpResponder(object):

  # The default request version.  This only affects responses up until

  # the point where the request line is parsed, so it mainly decides what

  # the client gets back when sending a malformed request line.

  # Most web servers default to HTTP 0.9, i.e. don't send a status line.

  default_request_version = http.HTTP_0_9

  responses = BaseHTTPServer.BaseHTTPRequestHandler.responses

  def __init__(self, handler):

    """Initializes this class.

    """

    self._handler = handler

  def __call__(self, fn):

    """Handles a request.

    @type fn: callable

    @param fn: Callback for retrieving HTTP request, must return a tuple

      containing request message (L{http.HttpMessage}) and C{None} or the

      message reader (L{_HttpClientToServerMessageReader})

    """

    response_msg = http.HttpMessage()

    response_msg.start_line = \

      http.HttpServerToClientStartLine(version=self.default_request_version,

                                       code=None, reason=None)

    force_close = True

    try:

      (request_msg, req_msg_reader) = fn()

      response_msg.start_line.version = request_msg.start_line.version

      # RFC2616, 14.23: All Internet-based HTTP/1.1 servers MUST respond

      # with a 400 (Bad Request) status code to any HTTP/1.1 request

      # message which lacks a Host header field.

      if (request_msg.start_line.version == http.HTTP_1_1 and

          not (request_msg.headers and

               http.HTTP_HOST in request_msg.headers)):

        raise http.HttpBadRequest(message="Missing Host header")

      (response_msg.start_line.code, response_msg.headers,

       response_msg.body) = \

        _HandleServerRequestInner(self._handler, request_msg)

    except http.HttpException, err:

      self._SetError(self.responses, self._handler, response_msg, err)

    else:

      # Only wait for client to close if we didn't have any exception.

      force_close = False

    return (request_msg, req_msg_reader, force_close,

            self._Finalize(self.responses, response_msg))

  @staticmethod

  def _SetError(responses, handler, response_msg, err):

    """Sets the response code and body from a HttpException.

    @type err: HttpException

    @param err: Exception instance

    """

    try:

      (shortmsg, longmsg) = responses[err.code]

    except KeyError:

      shortmsg = longmsg = "Unknown"

    if err.message:

      message = err.message

    else:

      message = shortmsg

    values = {

      "code": err.code,

      "message": cgi.escape(message),

      "explain": longmsg,

      }

    (content_type, body) = handler.FormatErrorMessage(values)

    headers = {

      http.HTTP_CONTENT_TYPE: content_type,

      }

    if err.headers:

      headers.update(err.headers)

    response_msg.start_line.code = err.code

    response_msg.headers = headers

    response_msg.body = body

  @staticmethod

  def _Finalize(responses, msg):

    assert msg.start_line.reason is None

    if not msg.headers:

      msg.headers = {}

    msg.headers.update({

      # TODO: Keep-alive is not supported

      http.HTTP_CONNECTION: "close",

      http.HTTP_DATE: _DateTimeHeader(),

      http.HTTP_SERVER: http.HTTP_GANETI_VERSION,

      })

    # Get response reason based on code

    try:

      code_desc = responses[msg.start_line.code]

    except KeyError:

      reason = ""

    else:

      (reason, _) = code_desc

    msg.start_line.reason = reason

    return msg

    responder = HttpResponder(handler)

    sock.settimeout(None)

    sock.setblocking(0)

    request_msg_reader = None

    force_close = True

      # Block for closing connection

        if server.using_ssl:

          sock.set_accept_state()

            http.Handshake(sock, self.WRITE_TIMEOUT)

        (request_msg, request_msg_reader, force_close, response_msg) = \

          responder(compat.partial(self._ReadRequest, sock, self.READ_TIMEOUT))

        if response_msg:

          # HttpMessage.start_line can be of different types

          # pylint: disable=E1103

          logging.info("%s:%s %s %s", client_addr[0], client_addr[1],

                       request_msg.start_line, response_msg.start_line.code)

          self._SendResponse(sock, request_msg, response_msg,

                             self.WRITE_TIMEOUT)

      sock.close()

  @staticmethod

  def _ReadRequest(sock, timeout):

    msg = http.HttpMessage()

      reader = _HttpClientToServerMessageReader(sock, msg, timeout)

    return (msg, reader)

  @staticmethod

  def _SendResponse(sock, req_msg, msg, timeout):

      _HttpServerToClientMessageWriter(sock, req_msg, msg, timeout)