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)