def _renderError(self, failure):
result = http.Response()
result.headers.setHeader(
'content-type',
http_headers.MimeType("text", "html", {"charset": "utf-8"}))
error = u'Unknown error'
try:
failure.raiseException()
except Exception as error:
error = forceUnicode(error)
result.stream = stream.IByteStream(
stream.IByteStream(error.encode('utf-8')))
return result
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 test_adapt(self):
fName = self.mktemp()
f = file(fName, "w")
f.write("test")
f.close()
for i in ("test", buffer("test"), file(fName)):
s = stream.IByteStream(i)
self.assertEquals(str(s.read()), "test")
self.assertEquals(s.read(), None)
def _generateResponse(self, result):
if not isinstance(result, http.Response):
result = http.Response()
result.code = responsecode.OK
result.headers.setHeader(
'content-type',
http_headers.MimeType("text", "html", {"charset": "utf-8"}))
result.stream = stream.IByteStream("")
return result
def _renderError(self, failure):
result = http.Response()
result.headers.setHeader(
'content-type',
http_headers.MimeType("text", "html", {"charset": "utf-8"}))
error = u'Unknown error'
try:
failure.raiseException()
except Exception as err:
error = {'class': err.__class__.__name__, 'message': unicode(err)}
error = toJson({"id": None, "result": None, "error": error})
result.stream = stream.IByteStream(error.encode('utf-8'))
return result
def _generateResponse(self, result):
logger.info(u"Creating interface page")
javascript = [
u"var currentParams = new Array();", u"var currentMethod = null;"
]
currentMethod = u''
if self._rpcs:
currentMethod = self._rpcs[0].getMethodName()
javascript.append(u"currentMethod = '%s';" % currentMethod)
for (index, param) in enumerate(self._rpcs[0].params):
javascript.append(u"currentParams[%d] = '%s';" %
(index, toJson(param)))
selectMethod = []
for method in self._callInterface:
methodName = method['name']
javascript.append(u"parameters['%s'] = new Array();" % methodName)
for (index, param) in enumerate(method['params']):
javascript.append(u"parameters['%s'][%s]='%s';" %
(methodName, index, param))
selected = u''
if method['name'] == currentMethod:
selected = u' selected="selected"'
selectMethod.append(u'<option%s>%s</option>' %
(selected, method['name']))
def wrapInDiv(obj):
return u'<div class="json">{0}</div>'.format(obj)
results = [u'<div id="result">']
if isinstance(result, failure.Failure):
error = u'Unknown error'
try:
result.raiseException()
except Exception as err:
error = {
'class': err.__class__.__name__,
'message': unicode(err)
}
error = toJson({"id": None, "result": None, "error": error})
results.append(wrapInDiv(objectToHtml(error)))
else:
for rpc in self._rpcs:
results.append(
wrapInDiv(objectToHtml(serialize(rpc.getResponse()))))
results.append(u'</div>')
html = interfacePage % {
'path': self.path,
'title': u'opsi interface page',
'javascript': u'\n'.join(javascript),
'select_path':
u'<option selected="selected">%s</option>' % self.path,
'select_method': u''.join(selectMethod),
'result': u''.join(results),
}
if not isinstance(result, http.Response):
result = http.Response()
result.code = responsecode.OK
result.stream = stream.IByteStream(html.encode('utf-8').strip())
return result
def _generateResponse(self, result):
invalidMime = False # For handling the invalid MIME type "gzip-application/json-rpc"
encoding = None
try:
if 'gzip' in self.request.headers.getHeader('Accept-Encoding'):
encoding = 'gzip'
elif 'deflate' in self.request.headers.getHeader(
'Accept-Encoding'):
encoding = 'deflate'
except Exception as error:
logger.debug2(
"Failed to get Accept-Encoding from request header: {0}".
format(error))
try:
if self.request.headers.getHeader('Accept'):
for accept in self.request.headers.getHeader('Accept').keys():
if accept.mediaType.startswith('gzip'):
invalidMime = True
encoding = 'gzip'
break
except Exception as error:
logger.error(u"Failed to get accepted mime types from header: {0}",
error)
response = [serialize(rpc.getResponse()) for rpc in self._rpcs]
if len(response) == 1:
response = response[0]
if not response:
response = None
if not isinstance(result, http.Response):
result = http.Response()
result.code = responsecode.OK
result.headers.setHeader(
'content-type',
http_headers.MimeType("application", "json", {"charset": "utf-8"}))
if invalidMime:
# The invalid requests expect the encoding set to
# gzip but the content is deflated.
result.headers.setHeader('content-encoding', ["gzip"])
result.headers.setHeader(
'content-type',
http_headers.MimeType("gzip-application", "json",
{"charset": "utf-8"}))
logger.debug(
u"Sending deflated data (backwards compatible - with content-encoding 'gzip')"
)
result.stream = stream.IByteStream(
deflateEncode(toJson(response).encode('utf-8')))
elif encoding == "deflate":
logger.debug(u"Sending deflated data")
result.headers.setHeader('content-encoding', [encoding])
result.stream = stream.IByteStream(
deflateEncode(toJson(response).encode('utf-8')))
elif encoding == "gzip":
logger.debug(u"Sending gzip compressed data")
result.headers.setHeader('content-encoding', [encoding])
result.stream = stream.IByteStream(
gzipEncode(toJson(response).encode('utf-8')))
else:
logger.debug(u"Sending plain data")
result.stream = stream.IByteStream(
toJson(response).encode('utf-8'))
return result