Synnefo » snf-ganeti

    return serializer.LoadJson(data)

  """Waits for a condition to occur on the socket.

  @type sock: socket

  @param sock: Wait for events on this socket

  @type event: int

    # Poller object expects milliseconds

    timeout *= 1000

  poller.register(sock, event)

  try:

    while True:

    poller.unregister(sock)

  """Wrapper around socket functions.

  This function abstracts error handling for socket operations, especially

  for the complicated interaction with OpenSSL.

  @type sock: socket

  @param sock: Socket for the operation

  @type op: int

      else:

        wait_for_event = event_poll

      if event is None:

        raise HttpSocketTimeout()

      raise

  """Closes the connection.

  @type sock: socket

  @param sock: Socket to be shut down

  @type close_timeout: float

                for peer

  """

  #print msgreader.peer_will_close, force

  if msgreader and msgreader.peer_will_close and not force:

    # Wait for peer to close

    try:

      # Check whether it's actually closed

        return

    except (socket.error, HttpError, HttpSocketTimeout):

      # Ignore errors at this stage

  # Close the connection from our side

  try:

    # We don't care about the return value, see NOTES in SSL_shutdown(3).

                    write_timeout)

  except HttpSocketTimeout:

    raise HttpError("Timeout while shutting down connection")

      raise HttpError("Error while shutting down connection: %s" % err)

  """Shakes peer's hands.

  @type sock: socket

  @param sock: Socket to be shut down

  @type write_timeout: float

  """

  try:

  except HttpSocketTimeout:

    raise HttpError("Timeout during SSL handshake")

  except socket.error, err:

    buf = self._FormatMessage()

    pos = 0

    end = len(buf)

    while pos < end:

      # Send only SOCK_BUF_SIZE bytes at a time

      data = buf[pos:(pos + SOCK_BUF_SIZE)]

      # Remove sent bytes

      pos += sent

    self.sock = sock

    self.msg = msg

    self.start_line_buffer = None

    self.header_buffer = StringIO()

    self.body_buffer = StringIO()

    while self.parser_status != self.PS_COMPLETE:

      # TODO: Don't read more than necessary (Content-Length), otherwise

      # data might be lost and/or an error could occur

      if data:

        buf += data

    http.HttpBase.__init__(self)

    self.request = req

    try:

      # TODO: Implement connection caching/keep-alive

      self.sock = self._CreateSocket(req.ssl_params,

      finally:

        # TODO: Keep-alive is not supported, always close connection

        force_close = True

      self.sock.close()

      self.sock = None

    if not connected:

      # Wait for connection

      if event is None:

        raise http.HttpError("Timeout while connecting to server")

    if self.using_ssl:

      self.sock.set_connect_state()

      try:

      except http.HttpSessionHandshakeUnexpectedEOF:

        raise http.HttpError("Server closed connection during SSL handshake")

    self.sock = sock

    self.client_addr = client_addr

    self.request_msg = http.HttpMessage()

    self.response_msg = http.HttpMessage()

        if self.server.using_ssl:

          self.sock.set_accept_state()

          try:

          except http.HttpSessionHandshakeUnexpectedEOF:

            # Ignore rest

            return

          # Try to send a response

          self._SendResponse()

      finally:

                                request_msg_reader, force_close)

      self.sock.close()