google_appengine/google/appengine/dist/httplib.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17 """Copyright 2008 Python Software Foundation, Ian Bicking, and Google."""
  18
  19 import mimetools
  20 import StringIO
  21 import sys
  22
  23
  24 CONTINUE = 100
  25 SWITCHING_PROTOCOLS = 101
  26 PROCESSING  = 102
  27 OK = 200
  28 CREATED = 201
  29 ACCEPTED = 202
  30 NON_AUTHORITATIVE_INFORMATION = 203
  31 NO_CONTENT = 204
  32 RESET_CONTENT = 205
  33 PARTIAL_CONTENT = 206
  34 MULTI_STATUS = 207
  35 IM_USED = 226
  36 MULTIPLE_CHOICES = 300
  37 MOVED_PERMANENTLY = 301
  38 FOUND = 302
  39 SEE_OTHER = 303
  40 NOT_MODIFIED = 304
  41 USE_PROXY = 305
  42 TEMPORARY_REDIRECT = 307
  43 BAD_REQUEST = 400
  44 UNAUTHORIZED = 401
  45 PAYMENT_REQUIRED = 402
  46 FORBIDDEN = 403
  47 NOT_FOUND = 404
  48 METHOD_NOT_ALLOWED = 405
  49 NOT_ACCEPTABLE = 406
  50 PROXY_AUTHENTICATION_REQUIRED = 407
  51 REQUEST_TIMEOUT = 408
  52 CONFLICT = 409
  53 GONE = 410
  54 LENGTH_REQUIRED = 411
  55 PRECONDITION_FAILED = 412
  56 REQUEST_ENTITY_TOO_LARGE = 413
  57 REQUEST_URI_TOO_LONG = 414
  58 UNSUPPORTED_MEDIA_TYPE = 415
  59 REQUESTED_RANGE_NOT_SATISFIABLE = 416
  60 EXPECTATION_FAILED = 417
  61 UNPROCESSABLE_ENTITY = 422
  62 LOCKED = 423
  63 FAILED_DEPENDENCY = 424
  64 UPGRADE_REQUIRED = 426
  65 INTERNAL_SERVER_ERROR = 500
  66 NOT_IMPLEMENTED = 501
  67 BAD_GATEWAY = 502
  68 SERVICE_UNAVAILABLE = 503
  69 GATEWAY_TIMEOUT = 504
  70 HTTP_VERSION_NOT_SUPPORTED = 505
  71 INSUFFICIENT_STORAGE = 507
  72 NOT_EXTENDED = 510
  73
  74 responses = {
  75   100: 'Continue',
  76   101: 'Switching Protocols',
  77
  78   200: 'OK',
  79   201: 'Created',
  80   202: 'Accepted',
  81   203: 'Non-Authoritative Information',
  82   204: 'No Content',
  83   205: 'Reset Content',
  84   206: 'Partial Content',
  85
  86   300: 'Multiple Choices',
  87   301: 'Moved Permanently',
  88   302: 'Found',
  89   303: 'See Other',
  90   304: 'Not Modified',
  91   305: 'Use Proxy',
  92   306: '(Unused)',
  93   307: 'Temporary Redirect',
  94
  95   400: 'Bad Request',
  96   401: 'Unauthorized',
  97   402: 'Payment Required',
  98   403: 'Forbidden',
  99   404: 'Not Found',
 100   405: 'Method Not Allowed',
 101   406: 'Not Acceptable',
 102   407: 'Proxy Authentication Required',
 103   408: 'Request Timeout',
 104   409: 'Conflict',
 105   410: 'Gone',
 106   411: 'Length Required',
 107   412: 'Precondition Failed',
 108   413: 'Request Entity Too Large',
 109   414: 'Request-URI Too Long',
 110   415: 'Unsupported Media Type',
 111   416: 'Requested Range Not Satisfiable',
 112   417: 'Expectation Failed',
 113
 114   500: 'Internal Server Error',
 115   501: 'Not Implemented',
 116   502: 'Bad Gateway',
 117   503: 'Service Unavailable',
 118   504: 'Gateway Timeout',
 119   505: 'HTTP Version Not Supported',
 120 }
 121
 122 HTTP_PORT = 80
 123 HTTPS_PORT = 443
 124
 125
 126
 127
 128
 129 class HTTPConnection:
 130
 131
 132   protocol = 'http'
 133   default_port = HTTP_PORT
 134   _allow_truncated = True
 135   _follow_redirects = False
 136
 137   def __init__(self, host, port=None, strict=False, timeout=None):
 138     from google.appengine.api import urlfetch
 139     self._fetch = urlfetch.fetch
 140     self._method_map = {
 141       'GET': urlfetch.GET,
 142       'POST': urlfetch.POST,
 143       'HEAD': urlfetch.HEAD,
 144       'PUT': urlfetch.PUT,
 145       'DELETE': urlfetch.DELETE,
 146     }
 147     self.host = host
 148     self.port = port
 149     self._method = self._url = None
 150     self._body = ''
 151     self.headers = []
 152
 153   def connect(self):
 154     pass
 155
 156   def request(self, method, url, body=None, headers=None):
 157     self._method = method
 158     self._url = url
 159     try:
 160       self._body = body.read()
 161     except AttributeError:
 162       self._body = body
 163     if headers is None:
 164       headers = []
 165     elif hasattr(headers, 'items'):
 166       headers = headers.items()
 167     self.headers = headers
 168
 169   def putrequest(self, request, selector, skip_host=False, skip_accept_encoding=False):
 170     self._method = request
 171     self._url = selector
 172
 173   def putheader(self, header, *lines):
 174     line = '\r\n\t'.join([str(line) for line in lines])
 175     self.headers.append((header, line))
 176
 177   def endheaders(self):
 178     pass
 179
 180   def set_debuglevel(self, level=None):
 181     pass
 182
 183   def send(self, data):
 184     self._body += data
 185
 186   def getresponse(self):
 187     if self.port and self.port != self.default_port:
 188         host = '%s:%s' % (self.host, self.port)
 189     else:
 190         host = self.host
 191     if not self._url.startswith(self.protocol):
 192       url = '%s://%s%s' % (self.protocol, host, self._url)
 193     else:
 194       url = self._url
 195     headers = dict(self.headers)
 196
 197     try:
 198       method = self._method_map[self._method.upper()]
 199     except KeyError:
 200       raise ValueError("%r is an unrecognized HTTP method" % self._method)
 201
 202     response = self._fetch(url, self._body, method, headers,
 203                            self._allow_truncated, self._follow_redirects)
 204     return HTTPResponse(response)
 205
 206   def close(self):
 207       pass
 208
 209
 210 class HTTPSConnection(HTTPConnection):
 211
 212     protocol = 'https'
 213     default_port = HTTPS_PORT
 214
 215     def __init__(self, host, port=None, key_file=None, cert_file=None,
 216                  strict=False, timeout=None):
 217         if key_file is not None or cert_file is not None:
 218             raise NotImplementedError(
 219                 "key_file and cert_file arguments are not implemented")
 220         HTTPConnection.__init__(self, host, port=port, strict=strict,
 221                                 timeout=timeout)
 222
 223
 224 class HTTPResponse(object):
 225
 226   def __init__(self, fetch_response):
 227     self._fetch_response = fetch_response
 228     self.fp = StringIO.StringIO(fetch_response.content)
 229
 230   def __getattr__(self, attr):
 231     return getattr(self.fp, attr)
 232
 233   def getheader(self, name, default=None):
 234     return self._fetch_response.headers.get(name, default)
 235
 236   def getheaders(self):
 237     return self._fetch_response.headers.items()
 238
 239   @property
 240   def msg(self):
 241     msg = mimetools.Message(StringIO.StringIO(''))
 242     for name, value in self._fetch_response.headers.items():
 243       msg[name] = str(value)
 244     return msg
 245
 246   version = 11
 247
 248   @property
 249   def status(self):
 250     return self._fetch_response.status_code
 251
 252   @property
 253   def reason(self):
 254     return responses.get(self._fetch_response.status_code, 'Unknown')
 255
 256
 257 class HTTP:
 258   "Compatibility class with httplib.py from 1.5."
 259
 260   _http_vsn = 11
 261   _http_vsn_str = 'HTTP/1.1'
 262
 263   debuglevel = 0
 264
 265   _connection_class = HTTPConnection
 266
 267   def __init__(self, host='', port=None, strict=None):
 268     "Provide a default host, since the superclass requires one."
 269
 270     if port == 0:
 271       port = None
 272
 273     self._setup(self._connection_class(host, port, strict))
 274
 275   def _setup(self, conn):
 276     self._conn = conn
 277
 278     self.send = conn.send
 279     self.putrequest = conn.putrequest
 280     self.endheaders = conn.endheaders
 281     self.set_debuglevel = conn.set_debuglevel
 282
 283     conn._http_vsn = self._http_vsn
 284     conn._http_vsn_str = self._http_vsn_str
 285
 286     self.file = None
 287
 288   def connect(self, host=None, port=None):
 289     "Accept arguments to set the host/port, since the superclass doesn't."
 290     self.__init__(host, port)
 291
 292   def getfile(self):
 293     "Provide a getfile, since the superclass' does not use this concept."
 294     return self.file
 295
 296   def putheader(self, header, *values):
 297     "The superclass allows only one value argument."
 298     self._conn.putheader(header, '\r\n\t'.join([str(v) for v in values]))
 299
 300   def getreply(self):
 301     """Compat definition since superclass does not define it.
 302
 303     Returns a tuple consisting of:
 304     - server status code (e.g. '200' if all goes well)
 305     - server "reason" corresponding to status code
 306     - any RFC822 headers in the response from the server
 307     """
 308     response = self._conn.getresponse()
 309
 310     self.headers = response.msg
 311     self.file = response.fp
 312     return response.status, response.reason, response.msg
 313
 314   def close(self):
 315     self._conn.close()
 316
 317     self.file = None
 318
 319
 320 class HTTPS(HTTP):
 321   """Compatibility with 1.5 httplib interface
 322
 323   Python 1.5.2 did not have an HTTPS class, but it defined an
 324   interface for sending http requests that is also useful for
 325   https.
 326   """
 327
 328   _connection_class = HTTPSConnection
 329
 330   def __init__(self, host='', port=None, key_file=None, cert_file=None,
 331                strict=None):
 332     if key_file is not None or cert_file is not None:
 333       raise NotImplementedError(
 334           "key_file and cert_file arguments are not implemented")
 335
 336
 337     if port == 0:
 338       port = None
 339     self._setup(self._connection_class(host, port, key_file,
 340                                        cert_file, strict))
 341
 342     self.key_file = key_file
 343     self.cert_file = cert_file
 344
 345
 346 class HTTPException(Exception):
 347   pass
 348
 349 class NotConnected(HTTPException):
 350   pass
 351
 352 class InvalidURL(HTTPException):
 353   pass
 354
 355 class UnknownProtocol(HTTPException):
 356   def __init__(self, version):
 357     self.version = version
 358     HTTPException.__init__(self, version)
 359
 360 class UnknownTransferEncoding(HTTPException):
 361   pass
 362
 363 class UnimplementedFileMode(HTTPException):
 364   pass
 365
 366 class IncompleteRead(HTTPException):
 367   def __init__(self, partial):
 368     self.partial = partial
 369     HTTPException.__init__(self, partial)
 370
 371 class ImproperConnectionState(HTTPException):
 372   pass
 373
 374 class CannotSendRequest(ImproperConnectionState):
 375   pass
 376
 377 class CannotSendHeader(ImproperConnectionState):
 378   pass
 379
 380 class ResponseNotReady(ImproperConnectionState):
 381   pass
 382
 383 class BadStatusLine(HTTPException):
 384   def __init__(self, line):
 385     self.line = line
 386     HTTPException.__init__(self, line)
 387
 388 error = HTTPException