def input_stream(req):
"""Stream request handler"""
i = 0
# chunk must be read with extra method, uwsgi has own
chunk = uwsgi.chunked_read() if uwsgi else req.read_chunk()
while chunk:
log.info("chunk: %s", chunk)
if chunk != b'%d' % i:
raise HTTPException(state.HTTP_BAD_REQUEST)
chunk = uwsgi.chunked_read() if uwsgi else req.read_chunk()
i += 1
return EmptyResponse(state.HTTP_OK)
def handle(self) -> Union[Response, tuple]:
"""
Handle a FastRPC request, returns Flask response
"""
accept_cts = self._get_accepted_content_types()
if not accept_cts.intersection(self.allowed_content_types):
logging.warning('No supported content type requested: "%s"', accept_cts)
return 'Content types in Accept not supported', 400
if request.headers['Content-Type'] not in self.allowed_content_types:
logging.warning('Content-Type "%s" is not supported', request.headers['Content-Type'])
return 'Content-Type not supported', 400
if fastrpc:
if FRPC_CONTENT_TYPE == request.headers['Content-Type']:
# We will be loading binary data, which is sent through chunked transfer encoding - not very friendly.
# Werkzeug doesn't recognize the header, so the data should be in request.stream BUT
# since chunked transfer encoding isn't sending Content-Length header, as it does not make sense,
# werkzeug needs some kind of middleware that handles it. In ideal world, we could use stream
# because the middleware would set request.environ['wsgi.input_terminated'] - I found none that do that
# which means for now we'll be supporting just uwsgi until I figure out how to do with with the others
# like gunicorn etc. big TODO !
if uwsgi is None:
raise NotImplementedError("This application needs to be running on uWSGI, I'm sorry! TODO :) ")
request_data = uwsgi.chunked_read()
else:
request_data = request.data
args, method_name = fastrpc.loads(request_data)
else:
args, method_name = xmlrpc.loads(request.data)
logging.info('Calling method %s with args: %s', method_name, args)
return self._create_response(method_name, args, accept_cts)
def handle(self) -> Union[Response, tuple]:
"""
Handle a FastRPC request, returns Flask response
"""
accept_cts = self._get_accepted_content_types()
if not accept_cts.intersection(self.allowed_content_types):
logging.warning('No supported content type requested: "%s"', accept_cts)
return 'Content types in Accept not supported', 400
if request.headers['Content-Type'] not in self.allowed_content_types:
logging.warning('Content-Type "%s" is not supported', request.headers['Content-Type'])
return 'Content-Type not supported', 400
if fastrpc:
if FRPC_CONTENT_TYPE == request.headers['Content-Type']:
# We will be loading binary data, which is sent through chunked transfer encoding - not very friendly.
# Werkzeug doesn't recognize the header, so the data should be in request.stream BUT
# since chunked transfer encoding isn't sending Content-Length header, as it does not make sense,
# werkzeug needs some kind of middleware that handles it. In ideal world, we could use stream
# because the middleware would set request.environ['wsgi.input_terminated'] - I found none that do that
# which means for now we'll be supporting just uwsgi until I figure out how to do with with the others
# like gunicorn etc. big TODO !
if uwsgi is None:
raise NotImplementedError("This application needs to be running on uWSGI, I'm sorry! TODO :) ")
request_data = uwsgi.chunked_read()
else:
request_data = request.data
args, method_name = fastrpc.loads(request_data)
else:
args, method_name = xmlrpc.loads(request.data)
logging.info('Calling method %s with args: %s', method_name, args)
return self._create_response(method_name, args, accept_cts)
def __call__(self, environ, start_response):
if environ.get('HTTP_TRANSFER_ENCODING', '0') == 'chunked':
del environ['HTTP_TRANSFER_ENCODING']
uwsgi_way = True
try:
import uwsgi
except:
uwsgi_way = False
if uwsgi_way:
body = uwsgi.chunked_read()
if body:
content_length = len(body)
else:
input = environ.get('wsgi.input')
if input:
body = ''
size = int(input.readline(), 16)
while size > 0:
body += input.read(size + 2)
size = int(input.readline(), 16)
content_length = len(body) - 2 if body else 0
if body:
environ['body_copy'] = body
environ["HTTP_CONTENT_LENGTH"] = content_length
environ["CONTENT_LENGTH"] = content_length
environ['wsgi.input'] = StringIO(body)
app_iter = self.application(environ,
self._sr_callback(start_response))
return app_iter
def test_json(req):
"""Test GET / POST json"""
# numbers are complete list
data = req.json
if req.is_chunked_request:
raw = b''
# chunk must be read with extra method, uwsgi has own
chunk = uwsgi.chunked_read() if uwsgi else req.read_chunk()
while chunk:
raw += chunk
chunk = uwsgi.chunked_read() if uwsgi else req.read_chunk()
data = parse_json_request(raw, req.charset)
return JSONResponse(status_code=418,
message="I'm teapot :-)",
numbers=list(range(5)),
request=data)
def read_chunked(fp):
data = []
while True:
chunk = uwsgi.chunked_read()
if chunk == '':
break
data.append(chunk)
return ''.join(data)
def read_chunked(fp):
data = []
while True:
chunk = uwsgi.chunked_read()
if chunk == '':
break
data.append(chunk)
return ''.join(data)
def readinto(self, buf):
if not self._internal_buffer:
self._internal_buffer = uwsgi.chunked_read()
n = min(len(buf), len(self._internal_buffer))
if n > 0:
buf[:n] = self._internal_buffer[:n]
self._internal_buffer = self._internal_buffer[n:]
return n
def readinto(self, buf):
if not self._internal_buffer:
self._internal_buffer = uwsgi.chunked_read()
n = min(len(buf), len(self._internal_buffer))
if n > 0:
buf[:n] = self._internal_buffer[:n]
self._internal_buffer = self._internal_buffer[n:]
return n
def try_uwsgi_body_gen():
try:
import uwsgi
except Exception:
return
while True:
chunk = uwsgi.chunked_read()
_dbg("chunked_read -> {!r}".format(chunk))
if chunk is None or chunk == b'' or chunk == '':
return
yield chunk
def _write_get_lines():
encoding = pecan.request.headers.get('Transfer-Encoding', "").lower()
if encoding == "chunked":
if uwsgi is None:
api.abort(
501, {
"cause": "Not implemented error",
"reason": "This server is not running with uwsgi"
})
return encoding, uwsgi.chunked_read()
return None, pecan.request.body
def _write_get_lines():
encoding = pecan.request.headers.get('Transfer-Encoding', "").lower()
if encoding == "chunked":
# TODO(sileht): Support reading chunk without uwsgi when
# pecan.request.environ['wsgi.input_terminated'] is set.
# https://github.com/unbit/uwsgi/issues/1428
if uwsgi is None:
api.abort(
501, {"cause": "Not implemented error",
"reason": "This server is not running with uwsgi"})
return encoding, uwsgi.chunked_read()
return None, pecan.request.body
def _write_get_lines():
encoding = pecan.request.headers.get('Transfer-Encoding', "").lower()
if encoding == "chunked":
# TODO(sileht): Support reading chunk without uwsgi when
# pecan.request.environ['wsgi.input_terminated'] is set.
# https://github.com/unbit/uwsgi/issues/1428
if uwsgi is None:
api.abort(
501, {
"cause": "Not implemented error",
"reason": "This server is not running with uwsgi"
})
return encoding, uwsgi.chunked_read()
return None, pecan.request.body
def _chunked_read(self):
size = 0
try:
chunk = uwsgi.chunked_read()
old_pos = self._body.pos
self._body.write(chunk)
self._body.pos = old_pos
size = len(chunk)
if not size:
self._body.pos = 0
except IOError as e:
raise IOError(
"Error reading chunk, is --http-raw-body enabled? Error: {}".
format(e))
return size
def chunked_reader():
try:
# If we're running under uWSGI, use the uwsgi.chunked_read method
# to read chunked input.
import uwsgi # noqa
while True:
chunk = uwsgi.chunked_read()
if len(chunk) > 0:
yield chunk
else:
return
except ImportError:
# Otherwise try to read the wsgi input. This works in embedded Apache.
stream = flask.request.environ["wsgi.input"]
try:
while True:
yield stream.next()
except:
return
def chunked_reader():
try:
# If we're running under uWSGI, use the uwsgi.chunked_read method
# to read chunked input.
import uwsgi # noqa
while True:
chunk = uwsgi.chunked_read()
if len(chunk) > 0:
yield chunk
else:
return
except ImportError:
# Otherwise try to read the wsgi input. This works in embedded Apache.
stream = flask.request.environ["wsgi.input"]
try:
while True:
yield stream.next()
except Exception:
return
def read(self, length=None):
position = 0
if length == 0:
return b""
if length and length < 0:
length = None
response = []
while True:
data = uwsgi.chunked_read()
# Return everything if we reached the end of the file
if not data:
break
response.append(data)
# Return the data if we've reached the length
if length is not None:
position += len(data)
if position >= length:
break
return b''.join(response)
c_origin = ffi.new('char[]', origin)
c_proto = ffi.new('char[]', proto)
if lib.uwsgi_websocket_handshake(wsgi_req, c_key, len(key), c_origin, len(origin), c_proto, len(proto)) < 0:
raise IOError("unable to complete websocket handshake")
uwsgi.websocket_handshake = uwsgi_pypy_websocket_handshake
"""
uwsgi.websocket_send(msg)
"""
def uwsgi_pypy_websocket_send(msg):
wsgi_req = uwsgi_pypy_current_wsgi_req();
if lib.uwsgi_websocket_send(wsgi_req, ffi.new('char[]', msg), len(msg)) < 0:
raise IOError("unable to send websocket message")
uwsgi.websocket_send = uwsgi_pypy_websocket_send
"""
uwsgi.chunked_read(timeout=0)
"""
def uwsgi_pypy_chunked_read(timeout=0):
wsgi_req = uwsgi_pypy_current_wsgi_req();
rlen = ffi.new("size_t*")
chunk = lib.uwsgi_chunked_read(wsgi_req, rlen, timeout, 0)
if chunk == ffi.NULL:
raise IOError("unable to receive chunked part")
return ffi.string(chunk, rlen[0])
uwsgi.chunked_read = uwsgi_pypy_chunked_read
"""
uwsgi.chunked_read_nb()
"""
def uwsgi_pypy_chunked_read_nb():
def uwsgi_pypy_websocket_handshake(key, origin=''):
wsgi_req = uwsgi_pypy_current_wsgi_req();
if lib.uwsgi_websocket_handshake(wsgi_req, ffi.new('char[]', key), len(key), ffi.new('char[]',origin), len(origin)) < 0:
raise IOError("unable to complete websocket handshake")
uwsgi.websocket_handshake = uwsgi_pypy_websocket_handshake
"""
uwsgi.websocket_send(msg)
"""
def uwsgi_pypy_websocket_send(msg):
wsgi_req = uwsgi_pypy_current_wsgi_req();
if lib.uwsgi_websocket_send(wsgi_req, ffi.new('char[]', msg), len(msg)) < 0:
raise IOError("unable to send websocket message")
uwsgi.websocket_send = uwsgi_pypy_websocket_send
"""
uwsgi.chunked_read(timeout=0)
"""
def uwsgi_pypy_chunked_read(timeout=0):
wsgi_req = uwsgi_pypy_current_wsgi_req();
rlen = ffi.new("size_t*")
chunk = lib.uwsgi_chunked_read(wsgi_req, rlen, timeout, 0)
if chunk == ffi.NULL:
raise IOError("unable to receive chunked part")
return ffi.string(chunk, rlen[0])
uwsgi.chunked_read = uwsgi_pypy_chunked_read
"""
uwsgi.chunked_read_nb()
"""
def uwsgi_pypy_chunked_read_nb():
