def render(self, request):
self._session_id = request.getHeader('x-apple-session-id')
if self._session_id == None:
self._session_id = 'dummy'
else:
self._protocolHandler.sessionID = self._session_id
request.responseHeaders.removeHeader('Content-Type')
request.responseHeaders.removeHeader('Server')
Resource.render(self, request)
return 1
def render(self, request):
self._session_id = request.getHeader('x-apple-session-id')
if self._session_id == None:
self._session_id = 'dummy'
else:
self._protocolHandler.sessionID = self._session_id
request.responseHeaders.removeHeader('Content-Type')
request.responseHeaders.removeHeader('Server')
Resource.render(self, request)
return 1
def render(self, request):
# For proxied requests, we have to override getClientIP to return
# the proper IP address.
if request.requestHeaders.hasHeader(b'x-forwarded-for'):
client_ip = request.requestHeaders.getRawHeaders(
b"x-forwarded-for", [b"-"])[0].split(b",")[0].strip()
request.getClientIP = lambda: client_ip
# Add a few properties to the request object that are used to
# return additional information for the request_buffer debugging
# tool
request._zaction = {
"metrics": [],
"maps": [],
"events": []
}
result = TwistedResource.render(self, request)
# log any requests that generated error responses
# this will only get us the code, but the detailed response bodies
# will be in the /health logs.
if request.code >= 400:
timestamp = datetimeToLogString(reactor.seconds())
log.error(combinedLogFormatter(timestamp, request))
if not request.uri.startswith("/health"):
self.site.request_buffer.store_request(request, result)
return result
def render(self, request):
try:
return Resource.render(self, request)
except UnsupportedMethod, e:
Logr.debug("(%s) unhandled method %s",
self.service.serviceType, request.method)
raise e
def render(self, request):
try:
return Resource.render(self, request)
except BadOption as e:
self._write_error(request, 400, e)
self._log_stats(request, {}, error=self._format_error(400, e))
return b"\n"
def render(self, request):
session = get_current_session(request)
authresponse = self._checkAuth(request)
if authresponse != None:
return authresponse
else:
return Resource.render(self, request)
def render(self, request):
"Disable cache of renderable resources"
request.setHeader('Expires', 'Fri, 25 Nov 1966 08:22:00 EST')
request.setHeader("Cache-Control", "no-store, no-cache, must-revalidate")
request.setHeader("Pragma", "no-cache")
request.setHeader("X-XSS-Protection", "0")
return Resource.render(self, request)
def render(self, request):
try:
return Resource.render(self, request)
except UnsupportedMethod, e:
Logr.debug("(%s) unhandled method %s",
self.service.serviceType, request.method)
raise e
def render(self, request):
request.setHeader('Content-Type', 'application/json; charset=utf8')
user = request.getUser()
passwd = request.getPassword()
m = hashlib.sha256()
m.update(passwd)
if m.hexdigest() != settings.ADMIN_PASSWORD_SHA256:
request.setResponseCode(401)
return '"Authorisation required!"'
links = []
for c in self.children:
if isinstance(self.children[c], RestResource) and c != '':
links.append('</%s>; rel="%s"' % (c, c))
if len(links) > 0:
request.setHeader('Link', ", ".join(links))
self.path_or_id = self.get_path_id(request)
if request.method == 'POST' and self.path_or_id != '':
request.setResponseCode(405)
return '"Cannot call POST on a resource with an identifier"'
if (request.method == 'PUT'
or request.method == 'DELETE') and self.path_or_id == '':
request.setResponseCode(405)
return '"Cannot call PUT or DELETE without an identifier"'
return Resource.render(self, request)
def render(self, request):
try:
return Resource.render(self, request)
except:
log.err()
return """{"message": "We were unable to handle your api request.", "success": false}"""
def render(self, request):
request.initialize(self)
result = Resource.render(self, request)
if result == NOT_DONE_YET:
return result
request.finalize()
return result.encode("UTF-8")
def render(self, request):
"Disable cache of renderable resources"
request.setHeader('Expires', 'Fri, 25 Nov 1966 08:22:00 EST')
request.setHeader("Cache-Control", "no-store, no-cache, must-revalidate")
request.setHeader("Pragma", "no-cache")
request.setHeader("X-XSS-Protection", "0")
return Resource.render(self, request)
def render(self, *args, **kwargs):
ret = Resource.render(self, *args, **kwargs)
if ret is not NOT_DONE_YET:
ret = json.dumps(ret, indent=2) if not isinstance(ret, basestring) else ret
if not ret.endswith('\n'):
ret += '\n'
return ret
def render(self, request):
""" Invoke appropriate handler function.
This is where the incoming HTTP request first lands.
Dispatch the request to corresponding handler function based
on the request method (get/put/post/...).
"""
methodname, method = self._getMethod(request)
try:
if method:
d = defer.maybeDeferred(
self._executeHandler,
methodname,
method,
request)
d.addCallback(self._createResponse, request)
d.addErrback(self._errorResponse)
d.addCallback(self._prepareResponse, request)
return NOT_DONE_YET
else:
# let the base class handle 405
return ResourceBase.render(self, request)
finally:
self.log.info('"%s %s" %d' % (
request.method,
request.path,
request.code if method else 501))
def render(self, request):
try:
return Resource.render(self, request)
except BadOption as e:
self._write_error(request, 400, e)
self._log_stats(request, {}, error=self._format_error(400, e))
return b"\n"
def render(self, request):
request.setHeader('Content-Type', 'application/json; charset=utf8')
user = request.getUser()
passwd = request.getPassword()
m = hashlib.sha256()
m.update(passwd)
if m.hexdigest() != settings.ADMIN_PASSWORD_SHA256:
request.setResponseCode(401)
return '"Authorisation required!"'
links = []
for c in self.children:
if isinstance(self.children[c], RestResource) and c != '':
links.append('</%s>; rel="%s"' % (c, c))
if len(links) > 0:
request.setHeader('Link', ", ".join(links))
self.path_or_id = self.get_path_id(request)
if request.method == 'POST' and self.path_or_id != '':
request.setResponseCode(405)
return '"Cannot call POST on a resource with an identifier"'
if (request.method == 'PUT' or request.method == 'DELETE') and self.path_or_id == '':
request.setResponseCode(405)
return '"Cannot call PUT or DELETE without an identifier"'
return Resource.render(self, request)
def render(self, *args, **kwargs):
ret = Resource.render(self, *args, **kwargs)
if ret is not NOT_DONE_YET:
ret = json.dumps(
ret, indent=2) if not isinstance(ret, basestring) else ret
if not ret.endswith('\n'):
ret += '\n'
return ret
def render(self, request):
start = time.time()
try:
return Resource.render(self, request)
except Exception, e:
log.err(e)
request.content.reset()
log.err('Error: input: %s' % request.content.read())
def render(self, request):
self.request = request
user = self.request.getUser()
password = self.request.getPassword()
if user == self.root.api.username and password == self.root.api.password:
return Resource.render(self, request)
else:
request.setResponseCode(http.UNAUTHORIZED)
return json.dumps({'status': 'Unauthorized'})
def render(self, request):
session = get_current_session(request)
redirect_uri = self._authredirect(request)
if redirect_uri != None:
session.return_uri = request.uri
return redirect(request, redirect_uri)
else:
return Resource.render(self, request)
def render(self, request):
session = get_current_session(request)
redirect_uri = self._authredirect(request)
if redirect_uri != None:
session.return_uri = request.uri
return redirect(request, redirect_uri)
else:
return Resource.render(self, request)
def render(self, request):
try:
request.setHeader('Content-Type', 'text/xml')
return Resource.render(self, request)
except UnsupportedMethod, e:
log.msg("unsupported: (%s) %s" %
(self.service.serviceType, request.method),
loglevel=logging.DEBUG)
raise e
def render(self, request):
try:
request.setHeader('Content-Type', 'text/xml')
return Resource.render(self, request)
except UnsupportedMethod, e:
log.msg("unsupported: (%s) %s" % (
self.service.serviceType,
request.method),
loglevel=logging.DEBUG)
raise e
def render(self, request):
if self.cors:
request.setHeader('Access-Control-Allow-Origin', '*')
request.setHeader('Access-Control-Allow-Methods', 'PUT, GET, POST, DELETE, OPTIONS')
request.setHeader('Access-Control-Allow-Headers', 'authorization, content-type')
if request.method != "OPTIONS" or not self.cors:
return Resource.render(self, request)
else:
return ""
def render(self, request):
# assert(isinstance(request, (server.Request)))
# assert(isinstance(request.site, AuthenticatedSite))
self.request = request
request.user = request.site.check_authentication(request)
request.user = None
if not self.check_permissions():
return self.access_forbidden(request)
return Resource.render(self, request)
def render(self, request):
request.setResponseCode(200)
request.setHeader('Content-Type', 'application/json')
try:
return Resource.render(self, request)
except IOError as ex:
if ex.errno == errno.ENOENT:
return NoResource().render(request)
else:
raise
except ErrorPage as ex:
return ex.render(request)
def make_real_webserver(self):
"""
Construct a real webserver to test actual connectivity.
"""
root = Resource()
root.isLeaf = True
root.render = lambda r: self._render_request(r)
site_factory = Site(root)
webserver = yield reactor.listenTCP(
0, site_factory, interface='127.0.0.1')
self.add_cleanup(webserver.loseConnection)
addr = webserver.getHost()
url = "http://%s:%s/" % (addr.host, addr.port)
returnValue(url)
def make_real_webserver(self):
"""
Construct a real webserver to test actual connectivity.
"""
root = Resource()
root.isLeaf = True
root.render = lambda r: self._render_request(r)
site_factory = Site(root)
webserver = yield reactor.listenTCP(
0, site_factory, interface='127.0.0.1')
self.add_cleanup(webserver.loseConnection)
addr = webserver.getHost()
url = "http://%s:%s/" % (addr.host, addr.port)
returnValue(url)
def render(self, request):
"""Process request
@type request: twisted.web.http.Request"""
# Import here to prevent circular import
from management_portal.auth.decorators import NotAllowed, NotLoggedIn
try:
return Resource.render(self, request)
except NotLoggedIn:
myTmp = self.redirectRelative(request,
'/login?next=' + request.path)
request.setResponseCode(http.UNAUTHORIZED)
return myTmp
except NotAllowed:
return self.redirectRelative(request, '/')
def render(self, request):
# type: (Request) -> Union[int, bytes]
"""
Before we render this request as normal, parse parameters, and add them to the request! Also, catch any errors
during parameter parsing, and show them appropriately.
:param request: Twisted request object
:return: Byte string or NOT_DONE_YET - see IResource.render
"""
try:
request.url_args = self.parse_args(request)
except Exception:
self.handle_exception(request)
return NOT_DONE_YET
else:
return Resource.render(self, request)
def render(self, request):
from twisted.web2 import http_headers
head = http_headers.Headers(handler=http_headers.DefaultHTTPHandler)
head.setRawHeaders('Accept', (request.getHeader('Accept'),))
accept = head.getHeader('Accept')
accept = sorted([(mime, prio) for mime, prio in accept.iteritems()], key=lambda x: -x[1])
if self.plugin.flat_urls.hasURL('/'):
urls = self.plugin.flat_urls.getURL('/')
for ctype, weight in accept:
ctype = '%s/%s' % (ctype.mediaType, ctype.mediaSubtype)
if ctype in urls:
request.raw_content_type = ctype
return self.plugin.flat_urls[('/', ctype)].render(request)
return Resource.render(self, request)
def render(self, request):
request.setResponseCode(200)
request.setHeader('Content-Type', 'application/json')
try:
return Resource.render(self, request)
except IOError as ex:
if ex.errno == errno.ENOENT:
if request.is_ajax():
return SlydJsonNoResource().render(request)
else:
return NoResource().render(request)
else:
raise
except ErrorPage as ex:
if request.is_ajax():
ex = SlydJsonErrorPage(ex.code, ex.brief, ex.detail)
return ex.render(request)
def render(self, request):
request.setResponseCode(200)
request.setHeader('Content-Type', 'application/json')
try:
return Resource.render(self, request)
except IOError as ex:
if ex.errno == errno.ENOENT:
if request.is_ajax():
return SlydJsonNoResource().render(request)
else:
return NoResource().render(request)
else:
raise
except ErrorPage as ex:
if request.is_ajax():
ex = SlydJsonErrorPage(ex.code, ex.brief, ex.detail)
return ex.render(request)
def render(self, request):
request.setHeader(b"content-type", b"application/json")
token = request.args.get('access_token')
if token:
token = token[0]
if not token:
log.info("No access token")
request.setResponseCode(401)
return '{"errcode": "twisted.unauthorized"}'
elif token != self.api.token_hs:
log.info("Wrong token: {got!r} != {expected!r}",
got=token,
expected=self.api.token_hs)
request.setResponseCode(403)
return '{"errcode": "M_FORBIDDEN"}'
else:
return Resource.render(self, request)
def render(self, request):
""" Check for HTTP basic auth, and pass to normal rendering if accepted """
try:
self.projectName = request.site.buildbot_service.parent.projectName
except:
self.projectName = ""
if self.userpass is not None:
if request.getUser() != self.userpass[0] or request.getPassword() != self.userpass[1]:
realm = "%s buildbot tryserver" % self.projectName
request.setHeader('WWW-Authenticate',
'Basic Realm="%s"' % realm)
errpage = ErrorPage(http.UNAUTHORIZED,
"Unauthorized",
"401 Authentication required")
return errpage.render(request)
return Resource.render(self, request)
def render(self, request):
self.request = request
user = self.request.getUser().decode()
password = self.request.getPassword().decode()
if user == self.root.api.username and password == self.root.api.password:
if self.require_init and (not self.root.api.initialized):
request.setResponseCode(
http.SERVICE_UNAVAILABLE,
message='Gateway not Initialized'.encode())
return json.dumps(False).encode()
else:
try:
return Resource.render(self, request)
except Exception as exc:
traceback.print_exc()
self.root.api.check_exception_halt(exc, self)
else:
request.setResponseCode(http.UNAUTHORIZED)
return json.dumps({'status': 'Unauthorized'}).encode()
def render(self, request):
try:
id = getPlatypusCookie(request)
except CookieError:
print "There was a cookie issue"
try:
redirect_number = int(request.args["redirect"][0])
except:
redirect_number = 1
print "Redirect number ",
print int(redirect_number)
if redirect_number < 6:
print "Setting cookie"
setPlatypusCookie(request)
url = str(request.uri)
url = self.appendToURL(url, {"redirect":str(redirect_number)})
print "Redirect url is ",
print str(url)
redirectTo(url, request)
request.finish()
return NOT_DONE_YET # though we are
else:
request.write("<h2> You're request couldn't be completed.")
request.finish()
return NOT_DONE_YET# though we are
else:
try:
return Resource.render(self, request)
except:
log.err()
return "<html> <body><h2>Sorry we could not process your request.</h2></body> </html>"
'''
def render(self, request):
request.setHeader('Server', self.factory.banner)
return Resource.render(self, request)
def render(self, request):
log.msg('control ressource: %s' % request)
return Resource.render(self, request)
def render(self, *args, **kwargs):
self.startTime = time.time()
return Resource.render(self, *args, **kwargs)
def render(self, request):
request.setHeader('Server', self.factory.banner)
return Resource.render(self, request)
def render(self,request):
request.setHeader('Access-Control-Allow-Origin', '*')
request.setHeader("Access-Control-Allow-Methods","*")
request.setHeader("Access-Control-Allow-Headers","Content-Type,*")
return Resource.render(self,request)
def render(self, request):
try:
return Resource.render(self, request)
except BadRequest as e:
request.setResponseCode(400)
return str(e) + "\n"
def render(self, request):
request.setHeader('Server', self.factory.banner)
request.setResponseCode(int(self.error_code))
return Resource.render(self, request)
def render(self, request):
request.setHeader('access-control-allow-origin', request.getHeader('origin'))
request.setHeader('access-control-allow-credentials', 'true')
return Resource.render(self, request)
def render(self, request):
log.msg('control ressource: %s' % request)
return Resource.render(self, request)
def render(self, *args, **kwargs):
self.startTime = time.time()
return Resource.render(self, *args, **kwargs)
def render(self, request):
try:
return Resource.render(self, request)
except BadOption as e:
return self._write_error(request, 400, e)
def do_render(info):
Resource.render(self, request)
def render(self, request):
request.setHeader('Server', self.factory.banner)
request.setResponseCode(int(self.error_code))
return Resource.render(self, request)
def render(self, request):
result = Resource.render(self, request)
result.addCallback(self.finishRequest, request)
return NOT_DONE_YET
def render(self, request):
try:
return Resource.render(self, request)
except BadOption as e:
request.setResponseCode(400)
return str(e) + "\n"
def render(self, request):
try:
return Resource.render(self, request)
except BadOption as e:
return self._write_error(request, 400, e)
