def response_get_process(self, session: Dict, session_id: str, request: Request):
request.setResponseCode(OK)
if session is None:
session = {'auth': False}
yield self.cache_interface.set(session_id, session)
request.write(ujson.dumps(session).encode('utf-8'))
request.finish()
return None
def read_json_body(self, request: Request):
try:
result = ujson.loads(request.content.getvalue())
except ValueError:
request.setResponseCode(BAD_REQUEST)
request.write(ujson.dumps({'status': 'error', 'message': 'Invalid JSON'}).encode('utf-8'))
request.finish()
result = None
return result
def response_delete_process(self, session: Dict, session_id: str, request: Request):
if session is None or session.get('auth', False) is not True:
request.setResponseCode(UNAUTHORIZED)
request.write(ujson.dumps({'status': 'error', 'message': 'Unauthorized'}).encode('utf-8'))
else:
yield self.cache_interface.set(session_id, {'auth': False})
request.setResponseCode(OK)
request.write(ujson.dumps({'status': 'success'}).encode('utf-8'))
request.finish()
return None
def render_options(request: Request, verbs: str = 'GET, POST, OPTIONS') -> int:
"""Function to return OPTIONS request.
Most of the APIs only need it for GET, POST and OPTIONS, but verbs can be passed as parameter.
:param verbs: verbs to reply on render options
:type verbs: str
"""
from twisted.web import server
set_cors(request, verbs)
request.setHeader(b'content-type', b'application/json; charset=utf-8')
request.write(b'')
request.finish()
return server.NOT_DONE_YET
def _redirectOrJSON(result, request: http.Request, url: urlpath.URLPath, data):
try:
if request.getHeader('x-requested-with') == 'XMLHttpRequest':
request.write(json.dumps(data).encode('utf-8'))
if not request.notifyFinish().called:
request.finish()
return
except:
pass
request.redirect(str(url).encode('ascii'))
request.finish()
def response_post_process(self, session: Dict, session_id: str, request: Request):
body = self.read_json_body(request)
if session and session.get('auth', False) is True:
request.setResponseCode(OK)
request.write(ujson.dumps({'status': 'success'}).encode('utf-8'))
elif body and body.get('login') and body.get('password'):
password_hash = hashlib.md5(body.get('password').encode('utf-8')).hexdigest()
selector = Selector(Target.user, {'login': body.get('login'), 'password_hash': password_hash}, 1)
database_request = DataBasePackage(Method.select, selector=selector)
response = yield self.db_interface(database_request)
result = DataBaseResponse.deserialize(response)
if result.length == 0:
request.setResponseCode(UNAUTHORIZED)
request.write(ujson.dumps({'status': 'error', 'message': 'No match'}).encode('utf-8'))
else:
user = result.objects[0]
session = {'login': user.login, 'auth': True}
yield self.cache_interface.set(session_id, session)
request.write(ujson.dumps({'status': 'success'}).encode('utf-8'))
else:
request.setResponseCode(BAD_REQUEST)
request.write(ujson.dumps({'status': 'error', 'message': 'Invalid request'}).encode('utf-8'))
request.finish()
return None
def serverResponse(self, message):
"""
Writes a received HTTP response back out to the transport.
"""
# Write code
self.setResponseCode(message['status'])
# Write headers
for header, value in message.get("headers", {}):
self.setHeader(header.encode("utf8"), value.encode("utf8"))
# Write cookies
for cookie in message.get("cookies"):
self.cookies.append(cookie.encode("utf8"))
# Write out body
if "content" in message:
Request.write(self, message['content'].encode("utf8"))
self.finish()
def serverResponse(self, message):
"""
Writes a received HTTP response back out to the transport.
"""
# Write code
self.setResponseCode(message['status'])
# Write headers
for header, value in message.get("headers", {}):
self.setHeader(header.encode("utf8"), value.encode("utf8"))
# Write cookies
for cookie in message.get("cookies"):
self.cookies.append(cookie.encode("utf8"))
# Write out body
if "content" in message:
Request.write(self, message['content'].encode("utf8"))
self.finish()
def server_handler(request: http.Request) -> None:
request.setHeader("foo", "bar")
request.write("Woo-hoo".encode())
request.finish()
def server_handler(request: http.Request):
request.setHeader("foo", "bar")
request.write("my content".encode())
request.finish()
async def get(self, request: Request) -> None:
try:
if self.data is None:
await asyncio.wait_for(self.read_task, timeout=30)
if self.data is None:
request.setResponseCode(503)
request.write(b'Service temporarily unavailable')
return
raw_query = urlparse(request.uri).query
query = parse_qs(raw_query)
# Check for etag matching
if self.etag_base:
hasher = hashlib.sha256()
hasher.update(self.etag_base)
hasher.update(raw_query)
if request.setETag(hasher.hexdigest().encode('utf-8')):
# Etag matched; do not send a body
return
# decode query parameter
releases = None
if b'releases' in query:
releases = set(
self.release_aliases.get(release)
for release in sanitize_query_list(query[b'releases']))
releases &= self.releases
components = None
if b'components' in query:
components = sanitize_query_list(query[b'components'])
components &= self.components
architectures = None
if b'architectures' in query:
architectures = sanitize_query_list(query[b'architectures'])
architectures.add('all')
architectures &= self.architectures
# generate filtered results
def transform(item):
result = item.copy()
if releases is not None:
result['packages'] = [
package for package in result['packages']
if package['release'] in releases
]
if components is not None:
result['packages'] = [
package for package in result['packages']
if package['component'] in components
]
if architectures is not None:
result['packages'] = [
package for package in result['packages']
if package['architecture'] in architectures
]
return result, bool(result['packages'])
result = [
value for value, pred in map(transform, self.data) if pred
]
# deliver results
request.setHeader(b'content-type',
b'application/json; charset=utf-8')
request.write(simplejson.dumps(result).encode('utf-8'))
except Exception as e:
log.err(
"An exception occurred while handling request ({})".format(e))
request.setResponseCode(400)
request.write('Bad request'.encode('utf-8'))
finally:
request.finish()
def response_get_process(self, session: Dict, session_id: str, request: Request):
print(rerequest.path)
request.setResponseCode(OK)
request.write(b'test')
request.finish()
return None
def _delayed_render(request: TxRequest):
request.write(Data.NO_CONTENT_LENGTH)
request.finish()
def _delayed_render(request: TxRequest):
request.write(Data.DATALOSS)
request.finish()
async def _handle_dispatch(
self,
root_span: Span,
request: Request,
log: NotificationLoggerAdapter,
notif: Notification,
context: NotificationContext,
) -> None:
"""
Actually handle the dispatch of notifications to devices, sequentially
for simplicity.
root_span: the OpenTracing span
request: the Twisted Web Request
log: the logger to use
notif: the notification to dispatch
context: the context of the notification
"""
try:
rejected = []
for d in notif.devices:
NOTIFS_RECEIVED_DEVICE_PUSH_COUNTER.inc()
appid = d.app_id
found_pushkins = self.find_pushkins(appid)
if len(found_pushkins) == 0:
log.warning("Got notification for unknown app ID %s",
appid)
rejected.append(d.pushkey)
continue
if len(found_pushkins) > 1:
log.warning("Got notification for an ambiguous app ID %s",
appid)
rejected.append(d.pushkey)
continue
pushkin = found_pushkins[0]
log.debug("Sending push to pushkin %s for app ID %s",
pushkin.name, appid)
NOTIFS_BY_PUSHKIN.labels(pushkin.name).inc()
result = await pushkin.dispatch_notification(notif, d, context)
if not isinstance(result, list):
raise TypeError("Pushkin should return list.")
rejected += result
request.write(json.dumps({"rejected": rejected}).encode())
if rejected:
log.info(
"Successfully delivered notifications with %d rejected pushkeys",
len(rejected),
)
except NotificationDispatchException:
request.setResponseCode(502)
log.warning("Failed to dispatch notification.", exc_info=True)
except Exception:
request.setResponseCode(500)
log.error("Exception whilst dispatching notification.",
exc_info=True)
finally:
if not request._disconnected:
request.finish()
PUSHGATEWAY_HTTP_RESPONSES_COUNTER.labels(code=request.code).inc()
root_span.set_tag(tags.HTTP_STATUS_CODE, request.code)
req_time = time.perf_counter() - context.start_time
if req_time > 0:
# can be negative as perf_counter() may not be monotonic
NOTIFY_HANDLE_HISTOGRAM.labels(
code=request.code).observe(req_time)
if not 200 <= request.code < 300:
root_span.set_tag(tags.ERROR, True)
root_span.finish()
