Vega strike Python Modules doc: HTTPConnection Class Reference

All Data Structures Namespaces Files Functions Variables

Inheritance diagram for HTTPConnection:

Public Member Functions
def	__init__

def	set_debuglevel

def	connect

def	close

def	send

def	putrequest

def	putheader

def	endheaders

def	request

def	getresponse

Data Fields
	sock

	host

	port

	debuglevel

Static Public Attributes
	response_class = HTTPResponse

	default_port = HTTP_PORT

int	auto_open = 1

int	debuglevel = 0

Detailed Description

Definition at line 329 of file httplib.py.

Constructor & Destructor Documentation

def __init__	(	self,
		host,
		port = `None`
	)

Definition at line 339 of file httplib.py.

 
     def __init__(self, host, port=None):
         self.sock = None
         self.__response = None
         self.__state = _CS_IDLE
 
         self._set_hostport(host, port)

Member Function Documentation

def close ( self)

Close the connection to the HTTP server.

Definition at line 381 of file httplib.py.

References HTTPConnection.__response, HTTPConnection.__state, FTP.sock, and HTTPConnection.sock.

 
     def close(self):
         """Close the connection to the HTTP server."""
         if self.sock:
             self.sock.close()   # close it manually... there may be other refs
             self.sock = None
         if self.__response:
             self.__response.close()
             self.__response = None
         self.__state = _CS_IDLE

def connect ( self)

Connect to the host and port specified in __init__.

Definition at line 360 of file httplib.py.

References HTTPResponse.debuglevel, HTTPConnection.debuglevel, FTP.host, HTTPConnection.host, FTP.port, HTTPConnection.port, FTP.sock, HTTPConnection.sock, and socket.socket().

 
     def connect(self):
         """Connect to the host and port specified in __init__."""
         msg = "getaddrinfo returns an empty list"
         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
             af, socktype, proto, canonname, sa = res
             try:
                 self.sock = socket.socket(af, socktype, proto)
                 if self.debuglevel > 0:
                     print "connect: (%s, %s)" % (self.host, self.port)
                 self.sock.connect(sa)
             except socket.error, msg:
                 if self.debuglevel > 0:
                     print 'connect fail:', (self.host, self.port)
                 if self.sock:
                     self.sock.close()
                 self.sock = None
                 continue
             break
         if not self.sock:
             raise socket.error, msg

def endheaders ( self)

Indicate that the last header line has been sent to the server.

Definition at line 523 of file httplib.py.

References HTTPConnection.__state, HTTPConnection.send(), dispatcher_with_send.send(), file_wrapper.send(), and HTTP.send.

 
     def endheaders(self):
         """Indicate that the last header line has been sent to the server."""
 
         if self.__state == _CS_REQ_STARTED:
             self.__state = _CS_REQ_SENT
         else:
             raise CannotSendHeader()
 
         self.send('\r\n')

def getresponse ( self)

Definition at line 564 of file httplib.py.

References HTTPConnection.__response, HTTPConnection.__state, Chunk.close(), openrsrc.close(), _Hqxcoderengine.close(), FileInput.close(), _Rlecoderengine.close(), HTTPResponse.close(), BinHex.close(), GzipFile.close(), _Hqxdecoderengine.close(), Aifc_read.close(), _Rledecoderengine.close(), HTTPConnection.close(), HexBin.close(), file_wrapper.close(), FTP.close(), HTTPResponse.debuglevel, HTTPConnection.debuglevel, HTTPConnection.response_class, FTP.sock, and HTTPConnection.sock.

 
     def getresponse(self):
         "Get the response from the server."
 
         # check if a prior response has been completed
         if self.__response and self.__response.isclosed():
             self.__response = None
 
         #
         # if a prior response exists, then it must be completed (otherwise, we
         # cannot read this response's header to determine the connection-close
         # behavior)
         #
         # note: if a prior response existed, but was connection-close, then the
         # socket and response were made independent of this HTTPConnection
         # object since a new request requires that we open a whole new
         # connection
         #
         # this means the prior response had one of two states:
         #   1) will_close: this connection was reset and the prior socket and
         #                  response operate independently
         #   2) persistent: the response was retained and we await its
         #                  isclosed() status to become true.
         #
         if self.__state != _CS_REQ_SENT or self.__response:
             raise ResponseNotReady()
 
         if self.debuglevel > 0:
             response = self.response_class(self.sock, self.debuglevel)
         else:
             response = self.response_class(self.sock)
 
         response.begin()
         self.__state = _CS_IDLE
 
         if response.will_close:
             # this effectively passes the connection to the response
             self.close()
         else:
             # remember this, so we can tell when it is complete
             self.__response = response
 
         return response
 

def putheader	(	self,
		header,
		value
	)

Send a request header line to the server.

For example: h.putheader('Accept', 'text/html')

Definition at line 512 of file httplib.py.

References HTTPConnection.__state, HTTPConnection.send(), dispatcher_with_send.send(), file_wrapper.send(), and HTTP.send.

 
     def putheader(self, header, value):
         """Send a request header line to the server.
 
         For example: h.putheader('Accept', 'text/html')
         """
         if self.__state != _CS_REQ_STARTED:
             raise CannotSendHeader()
 
         str = '%s: %s\r\n' % (header, value)
         self.send(str)

def putrequest	(	self,
		method,
		url,
		skip_host = `0`
	)

Send a request to the server.

`method' specifies an HTTP request method, e.g. 'GET'.
`url' specifies the object being requested, e.g. '/index.html'.

Definition at line 413 of file httplib.py.

References HTTPConnection.__response, HTTPConnection.__state, HTTPConnection._http_vsn, HTTPConnection._http_vsn_str, HTTPConnection.auto_open, FTP.host, HTTPConnection.host, FTP.port, HTTPConnection.port, HTTPConnection.putheader(), HTTPConnection.send(), dispatcher_with_send.send(), file_wrapper.send(), HTTP.send, and urlparse.urlsplit().

 
     def putrequest(self, method, url, skip_host=0):
         """Send a request to the server.
 
         `method' specifies an HTTP request method, e.g. 'GET'.
         `url' specifies the object being requested, e.g. '/index.html'.
         """
 
         # check if a prior response has been completed
         if self.__response and self.__response.isclosed():
             self.__response = None
 
         #
         # in certain cases, we cannot issue another request on this connection.
         # this occurs when:
         #   1) we are in the process of sending a request.   (_CS_REQ_STARTED)
         #   2) a response to a previous request has signalled that it is going
         #      to close the connection upon completion.
         #   3) the headers for the previous response have not been read, thus
         #      we cannot determine whether point (2) is true.   (_CS_REQ_SENT)
         #
         # if there is no prior response, then we can request at will.
         #
         # if point (2) is true, then we will have passed the socket to the
         # response (effectively meaning, "there is no prior response"), and
         # will open a new one when a new request is made.
         #
         # Note: if a prior response exists, then we *can* start a new request.
         #       We are not allowed to begin fetching the response to this new
         #       request, however, until that prior response is complete.
         #
         if self.__state == _CS_IDLE:
             self.__state = _CS_REQ_STARTED
         else:
             raise CannotSendRequest()
 
         if not url:
             url = '/'
         str = '%s %s %s\r\n' % (method, url, self._http_vsn_str)
 
         try:
             self.send(str)
         except socket.error, v:
             # trap 'Broken pipe' if we're allowed to automatically reconnect
             if v[0] != 32 or not self.auto_open:
                 raise
             # try one more time (the socket was closed; this will reopen)
             self.send(str)
 
         if self._http_vsn == 11:
             # Issue some standard headers for better HTTP/1.1 compliance
 
             if not skip_host:
                 # this header is issued *only* for HTTP/1.1
                 # connections. more specifically, this means it is
                 # only issued when the client uses the new
                 # HTTPConnection() class. backwards-compat clients
                 # will be using HTTP/1.0 and those clients may be
                 # issuing this header themselves. we should NOT issue
                 # it twice; some web servers (such as Apache) barf
                 # when they see two Host: headers
 
                 # If we need a non-standard port,include it in the
                 # header.  If the request is going through a proxy,
                 # but the host of the actual URL, not the host of the
                 # proxy.
 
                 netloc = ''
                 if url.startswith('http'):
                     nil, netloc, nil, nil, nil = urlsplit(url)
 
                 if netloc:
                     self.putheader('Host', netloc)
                 elif self.port == HTTP_PORT:
                     self.putheader('Host', self.host)
                 else:
                     self.putheader('Host', "%s:%s" % (self.host, self.port))
 
             # note: we are assuming that clients will not attempt to set these
             #       headers since *this* library must deal with the
             #       consequences. this also means that when the supporting
             #       libraries are updated to recognize other forms, then this
             #       code should be changed (removed or updated).
 
             # we only want a Content-Encoding of "identity" since we don't
             # support encodings such as x-gzip or x-deflate.
             self.putheader('Accept-Encoding', 'identity')
 
             # we can accept "chunked" Transfer-Encodings, but no others
             # NOTE: no TE header implies *only* "chunked"
             #self.putheader('TE', 'chunked')
 
             # if TE is supplied in the header, then it must appear in a
             # Connection header.
             #self.putheader('Connection', 'TE')
 
         else:
             # For HTTP/1.0, the server will assume "not chunked"
             pass

def request	(	self,
		method,
		url,
		body = `None`,
		headers = `{}`
	)

Send a complete request to the server.

Definition at line 533 of file httplib.py.

References HTTPConnection._send_request(), HTTPConnection.auto_open, HTTPConnection.endheaders(), HTTP.endheaders, HTTPConnection.putheader(), HTTPConnection.putrequest(), HTTP.putrequest, HTTPConnection.send(), dispatcher_with_send.send(), file_wrapper.send(), HTTP.send, and locale.str().

 
     def request(self, method, url, body=None, headers={}):
         """Send a complete request to the server."""
 
         try:
             self._send_request(method, url, body, headers)
         except socket.error, v:
             # trap 'Broken pipe' if we're allowed to automatically reconnect
             if v[0] != 32 or not self.auto_open:
                 raise
             # try one more time
             self._send_request(method, url, body, headers)

def send	(	self,
		str
	)

Send `str' to the server.

Definition at line 391 of file httplib.py.

References HTTPConnection.auto_open, Chunk.close(), openrsrc.close(), _Hqxcoderengine.close(), FileInput.close(), _Rlecoderengine.close(), HTTPResponse.close(), BinHex.close(), GzipFile.close(), _Hqxdecoderengine.close(), Aifc_read.close(), _Rledecoderengine.close(), HTTPConnection.close(), HexBin.close(), file_wrapper.close(), FTP.close(), FTP.connect(), HTTPConnection.connect(), HTTPResponse.debuglevel, HTTPConnection.debuglevel, FTP.sock, and HTTPConnection.sock.

 
     def send(self, str):
         """Send `str' to the server."""
         if self.sock is None:
             if self.auto_open:
                 self.connect()
             else:
                 raise NotConnected()
 
         # send the data to the server. if we get a broken pipe, then close
         # the socket. we want to reconnect when somebody tries to send again.
         #
         # NOTE: we DO propagate the error, though, because we cannot simply
         #       ignore the error... the caller will know if they can retry.
         if self.debuglevel > 0:
             print "send:", repr(str)
         try:
             self.sock.sendall(str)
         except socket.error, v:
             if v[0] == 32:      # Broken pipe
                 self.close()
             raise

Public Member Functions

Data Fields

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation