def consume(self, event):
# type: (Mapping[str, Any]) -> None
server_meta = event['server_meta']
environ = {
'REQUEST_METHOD': 'SOCKET',
'SCRIPT_NAME': '',
'PATH_INFO': '/json/messages',
'SERVER_NAME': '127.0.0.1',
'SERVER_PORT': 9993,
'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0',
'wsgi.version': (1, 0),
'wsgi.input': StringIO(),
'wsgi.errors': sys.stderr,
'wsgi.multithread': False,
'wsgi.multiprocess': True,
'wsgi.run_once': False,
'zulip.emulated_method': 'POST'
}
if 'socket_user_agent' in event['request']:
environ['HTTP_USER_AGENT'] = event['request']['socket_user_agent']
del event['request']['socket_user_agent']
# We're mostly using a WSGIRequest for convenience
environ.update(server_meta['request_environ'])
request = WSGIRequest(environ)
# Note: If we ever support non-POST methods, we'll need to change this.
request._post = event['request']
request.csrf_processing_done = True
user_profile = get_user_profile_by_id(server_meta['user_id'])
request._cached_user = user_profile
resp = self.handler.get_response(request)
server_meta['time_request_finished'] = time.time()
server_meta['worker_log_data'] = request._log_data
resp_content = resp.content.decode('utf-8')
response_data = ujson.loads(resp_content)
if response_data['result'] == 'error':
check_and_send_restart_signal()
result = {
'response': response_data,
'req_id': event['req_id'],
'server_meta': server_meta
}
redis_key = req_redis_key(event['req_id'])
self.redis_client.hmset(redis_key, {
'status': 'complete',
'response': resp_content
})
# Since this sends back to Tornado, we can't use
# call_consume_in_tests here.
queue_json_publish(server_meta['return_queue'], result, lambda e: None)
def consume(self, event):
# type: (Mapping[str, Any]) -> None
server_meta = event['server_meta']
environ = {
'REQUEST_METHOD': 'SOCKET',
'SCRIPT_NAME': '',
'PATH_INFO': '/json/messages',
'SERVER_NAME': '127.0.0.1',
'SERVER_PORT': 9993,
'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0',
'wsgi.version': (1, 0),
'wsgi.input': StringIO(),
'wsgi.errors': sys.stderr,
'wsgi.multithread': False,
'wsgi.multiprocess': True,
'wsgi.run_once': False,
'zulip.emulated_method': 'POST'
}
if 'socket_user_agent' in event['request']:
environ['HTTP_USER_AGENT'] = event['request']['socket_user_agent']
del event['request']['socket_user_agent']
# We're mostly using a WSGIRequest for convenience
environ.update(server_meta['request_environ'])
request = WSGIRequest(environ)
# Note: If we ever support non-POST methods, we'll need to change this.
request._post = event['request']
request.csrf_processing_done = True
user_profile = get_user_profile_by_id(server_meta['user_id'])
request._cached_user = user_profile
resp = self.handler.get_response(request)
server_meta['time_request_finished'] = time.time()
server_meta['worker_log_data'] = request._log_data
resp_content = resp.content.decode('utf-8')
response_data = ujson.loads(resp_content)
if response_data['result'] == 'error':
check_and_send_restart_signal()
result = {'response': response_data, 'req_id': event['req_id'],
'server_meta': server_meta}
redis_key = req_redis_key(event['req_id'])
self.redis_client.hmset(redis_key, {'status': 'complete',
'response': resp_content})
# Since this sends back to Tornado, we can't use
# call_consume_in_tests here.
queue_json_publish(server_meta['return_queue'], result, lambda e: None)
def get_request(self, path=None, language=None, post_data=None, enforce_csrf_checks=False):
if not path:
path = self.get_pages_root()
if not language:
language = settings.LANGUAGES[0][0]
parsed_path = urlparse(path)
host = parsed_path.netloc or "testserver"
port = 80
if ":" in host:
host, port = host.split(":", 1)
environ = {
"HTTP_COOKIE": self.client.cookies,
"PATH_INFO": parsed_path.path,
"QUERY_STRING": parsed_path.query,
"REMOTE_ADDR": "127.0.0.1",
"REQUEST_METHOD": "GET",
"SCRIPT_NAME": "",
"SERVER_NAME": host,
"SERVER_PORT": port,
"SERVER_PROTOCOL": "HTTP/1.1",
"wsgi.version": (1, 0),
"wsgi.url_scheme": "http",
"wsgi.errors": self.client.errors,
"wsgi.multiprocess": True,
"wsgi.multithread": False,
"wsgi.run_once": False,
"wsgi.input": "",
}
if post_data:
post_data = encode_multipart(BOUNDARY, post_data)
environ.update(
{
"CONTENT_LENGTH": len(post_data),
"CONTENT_TYPE": MULTIPART_CONTENT,
"REQUEST_METHOD": "POST",
"wsgi.input": FakePayload(post_data),
}
)
request = WSGIRequest(environ)
request.session = self.client.session
request.user = getattr(self, "user", AnonymousUser())
request.LANGUAGE_CODE = language
if not enforce_csrf_checks:
request.csrf_processing_done = True
return request
def consume(self, event):
# type: (Mapping[str, Any]) -> None
server_meta = event['server_meta']
environ = {
'REQUEST_METHOD': 'SOCKET',
'SCRIPT_NAME': '',
'PATH_INFO': '/json/messages',
'SERVER_NAME': 'localhost',
'SERVER_PORT': 9993,
'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0',
'wsgi.version': (1, 0),
'wsgi.input': StringIO(),
'wsgi.errors': sys.stderr,
'wsgi.multithread': False,
'wsgi.multiprocess': True,
'wsgi.run_once': False,
'zulip.emulated_method': 'POST'
}
# We're mostly using a WSGIRequest for convenience
environ.update(server_meta['request_environ'])
request = WSGIRequest(environ)
request._request = event['request']
request.csrf_processing_done = True
user_profile = get_user_profile_by_id(server_meta['user_id'])
request._cached_user = user_profile
resp = self.handler.get_response(request)
server_meta['time_request_finished'] = time.time()
server_meta['worker_log_data'] = request._log_data
resp_content = resp.content.decode('utf-8')
result = {
'response': ujson.loads(resp_content),
'req_id': event['req_id'],
'server_meta': server_meta
}
redis_key = req_redis_key(event['req_id'])
self.redis_client.hmset(redis_key, {
'status': 'complete',
'response': resp_content
})
queue_json_publish(server_meta['return_queue'], result, lambda e: None)
def consume(self, event):
# type: (Mapping[str, Any]) -> None
server_meta = event['server_meta']
environ = {'REQUEST_METHOD': 'SOCKET',
'SCRIPT_NAME': '',
'PATH_INFO': '/json/messages',
'SERVER_NAME': 'localhost',
'SERVER_PORT': 9993,
'SERVER_PROTOCOL': 'ZULIP_SOCKET/1.0',
'wsgi.version': (1, 0),
'wsgi.input': StringIO(),
'wsgi.errors': sys.stderr,
'wsgi.multithread': False,
'wsgi.multiprocess': True,
'wsgi.run_once': False,
'zulip.emulated_method': 'POST'}
# We're mostly using a WSGIRequest for convenience
environ.update(server_meta['request_environ'])
request = WSGIRequest(environ)
request._request = event['request']
request.csrf_processing_done = True
user_profile = get_user_profile_by_id(server_meta['user_id'])
request._cached_user = user_profile
resp = self.handler.get_response(request)
server_meta['time_request_finished'] = time.time()
server_meta['worker_log_data'] = request._log_data
resp_content = resp.content.decode('utf-8')
result = {'response': ujson.loads(resp_content), 'req_id': event['req_id'],
'server_meta': server_meta}
redis_key = req_redis_key(event['req_id'])
self.redis_client.hmset(redis_key, {'status': 'complete',
'response': resp_content});
queue_json_publish(server_meta['return_queue'], result, lambda e: None)
def consume(self, event):
server_meta = event["server_meta"]
environ = {
"REQUEST_METHOD": "SOCKET",
"SCRIPT_NAME": "",
"PATH_INFO": "/json/messages",
"SERVER_NAME": "localhost",
"SERVER_PORT": 9993,
"SERVER_PROTOCOL": "ZULIP_SOCKET/1.0",
"wsgi.version": (1, 0),
"wsgi.input": StringIO(),
"wsgi.errors": sys.stderr,
"wsgi.multithread": False,
"wsgi.multiprocess": True,
"wsgi.run_once": False,
"zulip.emulated_method": "POST",
}
# We're mostly using a WSGIRequest for convenience
environ.update(server_meta["request_environ"])
request = WSGIRequest(environ)
request._request = event["request"]
request.csrf_processing_done = True
user_profile = get_user_profile_by_id(server_meta["user_id"])
request._cached_user = user_profile
resp = self.handler.get_response(request)
server_meta["time_request_finished"] = time.time()
server_meta["worker_log_data"] = request._log_data
resp_content = resp.content
result = {"response": ujson.loads(resp_content), "req_id": event["req_id"], "server_meta": server_meta}
redis_key = req_redis_key(event["req_id"])
self.redis_client.hmset(redis_key, {"status": "complete", "response": resp_content})
queue_json_publish(server_meta["return_queue"], result, lambda e: None)
