def __init__(self, code=None, headers=None, stream=None):
"""
@param code: The HTTP status code for this Response
@type code: C{int}
@param headers: Headers to be sent to the client.
@type headers: C{dict}, L{OPSI.web2.http_headers.Headers}, or
C{None}
@param stream: Content body to send to the HTTP client
@type stream: L{OPSI.web2.stream.IByteStream}
"""
if code is not None:
self.code = int(code)
if headers is not None:
if isinstance(headers, dict):
headers = http_headers.Headers(headers)
self.headers=headers
else:
self.headers = http_headers.Headers()
if stream is not None:
self.stream = IByteStream(stream)
def testParsedAndRaw(self):
def parse(raw):
return parsedvalue(raw)
def generate(parsed):
return parsed.raw
rawvalue = ("value1", "value2")
rawvalue2 = ("value3", "value4")
handler = HeaderHandler(parsers={'test': (parse, )},
generators={'test': (generate, )})
h = http_headers.Headers(handler=handler)
h.setRawHeaders("test", rawvalue)
self.assertEquals(h.getHeader("test"), parsedvalue(rawvalue))
h.setHeader("test", parsedvalue(rawvalue2))
self.assertEquals(h.getRawHeaders("test"), rawvalue2)
# Check the initializers
h = http_headers.Headers(rawHeaders={"test": rawvalue},
handler=handler)
self.assertEquals(h.getHeader("test"), parsedvalue(rawvalue))
h = http_headers.Headers({"test": parsedvalue(rawvalue2)},
handler=handler)
self.assertEquals(h.getRawHeaders("test"), rawvalue2)
def testIfMatch(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# Behavior with no ETag set, should be same as with an ETag
request.headers.setRawHeaders("If-Match", ('*', ))
self.checkPreconditions(request, response, True, responsecode.OK)
self.checkPreconditions(request,
response,
False,
responsecode.PRECONDITION_FAILED,
entityExists=False)
# Ask for tag, but no etag set.
request.headers.setRawHeaders("If-Match", ('"frob"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
## Actually set the ETag header
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
# behavior of entityExists
request.headers.setRawHeaders("If-Match", ('*', ))
self.checkPreconditions(request, response, True, responsecode.OK)
self.checkPreconditions(request,
response,
False,
responsecode.PRECONDITION_FAILED,
entityExists=False)
# tag matches
request.headers.setRawHeaders("If-Match", ('"frob", "foo"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# none match
request.headers.setRawHeaders("If-Match", ('"baz", "bob"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# Must only compare strong tags
out_headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
request.headers.setRawHeaders("If-Match", ('W/"foo"', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
def testIfModifiedSince(self):
if time.time() < 946771200:
raise "Your computer's clock is way wrong, this test will be invalid."
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# No Last-Modified => always succeed
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# Set output headers
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
# With a non-GET method
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
request.headers.setRawHeaders("If-Modified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# invalid date => header ignored
request.headers.setRawHeaders("If-Modified-Since",
('alalalalalalalalalala', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# date in the future => assume modified
request.headers.setHeader("If-Modified-Since", time.time() + 500)
self.checkPreconditions(request, response, True, responsecode.OK)
def getResponseFor(self,
root,
uri,
headers={},
method=None,
version=None,
prepath='',
content=None,
length=_unset):
if not isinstance(headers, http_headers.Headers):
headers = http_headers.Headers(headers)
if length is _unset:
if content is not None:
length = len(content)
else:
length = 0
if method is None:
method = self.method
if version is None:
version = self.version
cr = self.chanrequest(root, uri, length, headers, method, version,
prepath, content)
cr.request.process()
return cr.deferredFinish
def __init__(self, method, uri, headers, stream):
"""
@param method: The HTTP method to for this request, ex: 'GET', 'HEAD',
'POST', etc.
@type method: C{str}
@param uri: The URI of the resource to request, this may be absolute or
relative, however the interpretation of this URI is left up to the
remote server.
@type uri: C{str}
@param headers: Headers to be sent to the server. It is important to
note that this object does not create any implicit headers. So it
is up to the HTTP Client to add required headers such as 'Host'.
@type headers: C{dict}, L{OPSI.web2.http_headers.Headers}, or
C{None}
@param stream: Content body to send to the remote HTTP server.
@type stream: L{OPSI.web2.stream.IByteStream}
"""
self.method = method
self.uri = uri
if isinstance(headers, http_headers.Headers):
self.headers = headers
else:
self.headers = http_headers.Headers(headers or {})
if stream is not None:
self.stream = stream_mod.IByteStream(stream)
else:
self.stream = None
def __init__(self,
site,
method,
prepath,
uri,
length=None,
headers=None,
version=(1, 1),
content=None):
self.site = site
self.method = method
self.prepath = prepath
self.uri = uri
if headers is None:
headers = http_headers.Headers()
self.headers = headers
self.http_version = version
# Anything below here we do not pass as arguments
self.request = server.Request(self,
self.method,
self.uri,
self.http_version,
length,
self.headers,
site=self.site,
prepathuri=self.prepath)
if content is not None:
self.request.handleContentChunk(content)
self.request.handleContentComplete()
self.code = None
self.responseHeaders = None
self.data = ''
self.deferredFinish = defer.Deferred()
def testImmutable(self):
h = http_headers.Headers(
handler=HeaderHandler(parsers={}, generators={}))
h.makeImmutable()
self.assertRaises(AttributeError, h.setRawHeaders, "test", [1])
self.assertRaises(AttributeError, h.setHeader, "test", 1)
self.assertRaises(AttributeError, h.removeHeader, "test")
def testWithoutHeaders(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.removeHeader("ETag")
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
self.checkPreconditions(request, response, True, responsecode.OK)
def _abortWithError(self, errorcode, text=''):
"""Handle low level protocol errors."""
headers = http_headers.Headers()
headers.setHeader('content-length', len(text) + 1)
self.abortConnection(closeWrite=False)
self.writeHeaders(errorcode, headers)
self.write(text)
self.write("\n")
self.finish()
raise AbortedException
def testRaw(self):
rawvalue = ("value1", "value2")
h = http_headers.Headers(
handler=HeaderHandler(parsers={}, generators={}))
h.setRawHeaders("test", rawvalue)
self.assertEquals(h.hasHeader("test"), True)
self.assertEquals(h.getRawHeaders("test"), rawvalue)
self.assertEquals(list(h.getAllRawHeaders()), [('Test', rawvalue)])
self.assertEquals(h.getRawHeaders("foobar"), None)
h.removeHeader("test")
self.assertEquals(h.getRawHeaders("test"), None)
def testParsed(self):
parsed = parsedvalue(("value1", "value2"))
h = http_headers.Headers(
handler=HeaderHandler(parsers={}, generators={}))
h.setHeader("test", parsed)
self.assertEquals(h.hasHeader("test"), True)
self.assertEquals(h.getHeader("test"), parsed)
self.assertEquals(h.getHeader("foobar"), None)
h.removeHeader("test")
self.assertEquals(h.getHeader("test"), None)
def testIfRange(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
response = TestResponse()
self.assertEquals(http.checkIfRange(request, response), True)
request.headers.setRawHeaders("If-Range", ('"foo"', ))
self.assertEquals(http.checkIfRange(request, response), False)
response.headers.setHeader("ETag", http_headers.ETag('foo'))
self.assertEquals(http.checkIfRange(request, response), True)
request.headers.setRawHeaders("If-Range", ('"bar"', ))
response.headers.setHeader("ETag", http_headers.ETag('foo'))
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range", ('W/"foo"', ))
response.headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range", ('"foo"', ))
response.headers.removeHeader("ETag")
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range",
('Sun, 02 Jan 2000 00:00:00 GMT', ))
response.headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.assertEquals(http.checkIfRange(request, response), True)
request.headers.setRawHeaders("If-Range",
('Sun, 02 Jan 2000 00:00:01 GMT', ))
response.headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range",
('Sun, 01 Jan 2000 23:59:59 GMT', ))
response.headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range",
('Sun, 01 Jan 2000 23:59:59 GMT', ))
response.headers.removeHeader("Last-Modified")
self.assertEquals(http.checkIfRange(request, response), False)
request.headers.setRawHeaders("If-Range", ('jwerlqjL#$Y*KJAN', ))
self.assertEquals(http.checkIfRange(request, response), False)
def testIfUnmodifiedSince(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
# No Last-Modified => always fail.
request.headers.setRawHeaders("If-Unmodified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# Set output headers
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
request.headers.setRawHeaders("If-Unmodified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.setRawHeaders("If-Unmodified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# invalid date => header ignored
request.headers.setRawHeaders("If-Unmodified-Since",
('alalalalalalalalalala', ))
self.checkPreconditions(request, response, True, responsecode.OK)
def NotModifiedResponse(oldResponse=None):
if oldResponse is not None:
headers=http_headers.Headers()
for header in (
# Required from sec 10.3.5:
'date', 'etag', 'content-location', 'expires',
'cache-control', 'vary',
# Others:
'server', 'proxy-authenticate', 'www-authenticate', 'warning'):
value = oldResponse.headers.getRawHeaders(header)
if value is not None:
headers.setRawHeaders(header, value)
else:
headers = None
return Response(code=responsecode.NOT_MODIFIED, headers=headers)
def makeRequest(self, vars):
headers = http_headers.Headers()
http_vers = http.parseVersion(vars['SERVER_PROTOCOL'])
if http_vers[0] != 'http' or http_vers[1] > 1:
_abortWithError(
responsecode.INTERNAL_SERVER_ERROR,
"Twisted.web CGITransport: Unknown HTTP version: " %
vars['SERVER_PROTOCOL'])
secure = vars.get("HTTPS") in ("1", "on") # apache extension?
port = vars.get('SERVER_PORT') or 80
server_host = vars.get('SERVER_NAME') or vars.get(
'SERVER_ADDR') or 'localhost'
self.hostinfo = address.IPv4Address('TCP', server_host,
port), bool(secure)
self.remoteinfo = address.IPv4Address('TCP',
vars.get('REMOTE_ADDR', ''),
vars.get('REMOTE_PORT', 0))
uri = vars.get('REQUEST_URI') # apache extension?
if not uri:
qstr = vars.get('QUERY_STRING', '')
if qstr:
qstr = "?" + urllib.quote(qstr, safe="")
uri = urllib.quote(vars['SCRIPT_NAME']) + urllib.quote(
vars.get('PATH_INFO', '')) + qstr
for name, val in vars.iteritems():
if name.startswith('HTTP_'):
name = name[5:].replace('_', '-')
elif name == 'CONTENT_TYPE':
name = 'content-type'
else:
continue
headers.setRawHeaders(name, (val, ))
self._dataRemaining = int(vars.get('CONTENT_LENGTH', '0'))
self.request = self.requestFactory(self,
vars['REQUEST_METHOD'],
uri,
http_vers[1:3],
self._dataRemaining,
headers,
prepathuri=vars['SCRIPT_NAME'])
def __init__(self, site, method, uri, headers=None, content=None):
if not headers:
headers = http_headers.Headers(headers)
super(SimpleRequest, self).__init__(site=site,
chanRequest=None,
command=method,
path=uri,
version=self.clientproto,
contentLength=len(content or ''),
headers=headers)
self.stream = stream.MemoryStream(content or '')
self.remoteAddr = address.IPv4Address('TCP', '127.0.0.1', 0)
self._parseURL()
self.host = 'localhost'
self.port = 8080
def testNoResponse(self):
# Ensure that passing etag/lastModified arguments instead of response works.
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
request.method = "PUT"
request.headers.setRawHeaders("If-None-Match", ('"foo"', ))
self.checkPreconditions(request, None, True, responsecode.OK)
self.checkPreconditions(request,
None,
False,
responsecode.PRECONDITION_FAILED,
etag=http_headers.ETag('foo'),
lastModified=946771200)
# Make sure that, while you shoudn't do this, that it doesn't cause an error
request.method = "GET"
self.checkPreconditions(request,
None,
False,
responsecode.NOT_MODIFIED,
etag=http_headers.ETag('foo'))
def submitNext(_):
headers = http_headers.Headers(
headers={'Accept-Language': {
'en': 1.0
}},
rawHeaders={'X-My-Other-Header': ['socks']})
req = http.ClientRequest('GET', '/', headers, None)
cxn.server.data = ''
d = cxn.client.submitRequest(req, closeAfter=True)
self.assertReceived(cxn, 'GET / HTTP/1.1', [
'Connection: close', 'X-My-Other-Header: socks',
'Accept-Language: en'
])
self.writeLines(cxn, ('HTTP/1.1 200 OK', 'Content-Length: 0',
'Connection: close', '\r\n'))
return d
def __init__(self, channel):
self.inHeaders = http_headers.Headers()
self.channel = channel
def raw(d):
headers=http_headers.Headers()
for k,v in d.iteritems():
headers.setRawHeaders(k, [v])
return headers
def render(self, req):
return http.Response(responsecode.OK,
http_headers.Headers(
{'content-type': self.contentType()}),
stream=self.data)
def splitConnectionHeaders(self):
"""
Split off connection control headers from normal headers.
The normal headers are then passed on to user-level code, while the
connection headers are stashed in .connHeaders and used for things like
request/response framing.
This corresponds roughly with the HTTP RFC's description of 'hop-by-hop'
vs 'end-to-end' headers in RFC2616 S13.5.1, with the following
exceptions:
* proxy-authenticate and proxy-authorization are not treated as
connection headers.
* content-length is, as it is intimiately related with low-level HTTP
parsing, and is made available to user-level code via the stream
length, rather than a header value. (except for HEAD responses, in
which case it is NOT used by low-level HTTP parsing, and IS kept in
the normal headers.
"""
def move(name):
h = inHeaders.getRawHeaders(name, None)
if h is not None:
inHeaders.removeHeader(name)
connHeaders.setRawHeaders(name, h)
# NOTE: According to HTTP spec, we're supposed to eat the
# 'Proxy-Authenticate' and 'Proxy-Authorization' headers also, but that
# doesn't sound like a good idea to me, because it makes it impossible
# to have a non-authenticating transparent proxy in front of an
# authenticating proxy. An authenticating proxy can eat them itself.
#
# 'Proxy-Connection' is an undocumented HTTP 1.0 abomination.
connHeaderNames = [
'content-length', 'connection', 'keep-alive', 'te', 'trailers',
'transfer-encoding', 'upgrade', 'proxy-connection'
]
inHeaders = self.inHeaders
connHeaders = http_headers.Headers()
move('connection')
if self.version < (1, 1):
# Remove all headers mentioned in Connection, because a HTTP 1.0
# proxy might have erroneously forwarded it from a 1.1 client.
for name in connHeaders.getHeader('connection', ()):
if inHeaders.hasHeader(name):
inHeaders.removeHeader(name)
else:
# Otherwise, just add the headers listed to the list of those to move
connHeaderNames.extend(connHeaders.getHeader('connection', ()))
# If the request was HEAD, self.length has been set to 0 by
# HTTPClientRequest.submit; in this case, Content-Length should
# be treated as a response header, not a connection header.
# Note: this assumes the invariant that .length will always be None
# coming into this function, unless this is a HEAD request.
if self.length is not None:
connHeaderNames.remove('content-length')
for headername in connHeaderNames:
move(headername)
return connHeaders
def testIfNoneMatch(self):
request = http.Request(None, "GET", "/", "HTTP/1.1", 0,
http_headers.Headers())
out_headers = http_headers.Headers()
response = http.Response(responsecode.OK, out_headers, None)
request.headers.setRawHeaders("If-None-Match", ('"foo"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
out_headers.setHeader("ETag", http_headers.ETag('foo'))
out_headers.setHeader("Last-Modified",
946771200) # Sun, 02 Jan 2000 00:00:00 GMT
# behavior of entityExists
request.headers.setRawHeaders("If-None-Match", ('*', ))
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
self.checkPreconditions(request,
response,
True,
responsecode.OK,
entityExists=False)
# tag matches
request.headers.setRawHeaders("If-None-Match", ('"frob", "foo"', ))
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
# now with IMS, also:
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
request.method = "PUT"
self.checkPreconditions(request, response, False,
responsecode.PRECONDITION_FAILED)
request.method = "GET"
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
request.headers.setRawHeaders("If-Modified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.removeHeader("If-Modified-Since")
# none match
request.headers.setRawHeaders("If-None-Match", ('"baz", "bob"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
# now with IMS, also:
request.headers.setRawHeaders("If-Modified-Since",
('Mon, 03 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.setRawHeaders("If-Modified-Since",
('Sat, 01 Jan 2000 00:00:00 GMT', ))
self.checkPreconditions(request, response, True, responsecode.OK)
request.headers.removeHeader("If-Modified-Since")
# But if we have an error code already, ignore this header
response.code = responsecode.INTERNAL_SERVER_ERROR
self.checkPreconditions(request, response, True,
responsecode.INTERNAL_SERVER_ERROR)
response.code = responsecode.OK
# Weak tags okay for GET
out_headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
request.headers.setRawHeaders("If-None-Match", ('W/"foo"', ))
self.checkPreconditions(request, response, False,
responsecode.NOT_MODIFIED)
# Weak tags not okay for other methods
request.method = "PUT"
out_headers.setHeader("ETag", http_headers.ETag('foo', weak=True))
request.headers.setRawHeaders("If-None-Match", ('W/"foo"', ))
self.checkPreconditions(request, response, True, responsecode.OK)
def __init__(self):
self.headers = http_headers.Headers()
self.stream = stream.ProducerStream()
def _set(self, newheaders):
headers = http_headers.Headers()
for n, v in newheaders.items():
headers.setRawHeaders(n, (v, ))
newheaders = headers
getattr(self, where).headers = newheaders
def generateHeader(name, val):
head = http_headers.Headers(handler=http_headers.DefaultHTTPHandler)
head.setHeader(name, val)
return head.getRawHeaders(name)
