def test_seek_bigger_than_limit(self):
fp = BytesIO(bytes_("0123456789"))
i = static.FileIter(fp).app_iter_range(limit=1, seek=2)
# XXX: this should not return anything actually, since we are starting
# to read after the place we wanted to stop.
self.assertEqual(bytes_("23456789"), next(i))
self.assertRaises(StopIteration, next, i)
def test_multiple_reads(self):
fp = BytesIO(bytes_("012"))
i = static.FileIter(fp).app_iter_range(block_size=1)
self.assertEqual(bytes_("0"), next(i))
self.assertEqual(bytes_("1"), next(i))
self.assertEqual(bytes_("2"), next(i))
self.assertRaises(StopIteration, next, i)
def callfunction(self, *args, **kwargs):
return_type = funcdef.return_type
try:
args, kwargs = api_args.get_args(funcdef, args, kwargs,
pecan.request.params,
pecan.request.body,
pecan.request.content_type)
result = f(self, *args, **kwargs)
# NOTE: Support setting of status_code with default 201
pecan.response.status = funcdef.status_code
if isinstance(result, atypes.PassthruResponse):
pecan.response.status = result.status_code
# NOTE(lucasagomes): If the return code is 204
# (No Response) we have to make sure that we are not
# returning anything in the body response and the
# content-length is 0
if result.status_code == 204:
return_type = None
if callable(getattr(result.obj, 'read', None)):
# Stream the files-like data directly to the response
pecan.response.app_iter = static.FileIter(result.obj)
return_type = None
result = None
else:
result = result.obj
except Exception:
try:
exception_info = sys.exc_info()
orig_exception = exception_info[1]
orig_code = getattr(orig_exception, 'code', None)
data = format_exception(exception_info,
cfg.CONF.debug_tracebacks_in_api)
finally:
del exception_info
if orig_code and orig_code in http_client.responses:
pecan.response.status = orig_code
else:
pecan.response.status = 500
return data
if return_type is None:
pecan.request.pecan['content_type'] = None
pecan.response.content_type = None
return ''
return dict(datatype=return_type, result=result)
def vendor_passthru(ident, method, topic, data=None, driver_passthru=False):
"""Call a vendor passthru API extension.
Call the vendor passthru API extension and process the method response
to set the right return code for methods that are asynchronous or
synchronous; Attach the return value to the response object if it's
being served statically.
:param ident: The resource identification. For node's vendor passthru
this is the node's UUID, for driver's vendor passthru this is the
driver's name.
:param method: The vendor method name.
:param topic: The RPC topic.
:param data: The data passed to the vendor method. Defaults to None.
:param driver_passthru: Boolean value. Whether this is a node or
driver vendor passthru. Defaults to False.
:returns: A WSME response object to be returned by the API.
"""
if not method:
raise wsme.exc.ClientSideError(_("Method not specified"))
if data is None:
data = {}
http_method = pecan.request.method.upper()
params = (pecan.request.context, ident, method, http_method, data, topic)
if driver_passthru:
response = pecan.request.rpcapi.driver_vendor_passthru(*params)
else:
response = pecan.request.rpcapi.vendor_passthru(*params)
status_code = http_client.ACCEPTED if response['async'] else http_client.OK
return_value = response['return']
response_params = {'status_code': status_code}
# Attach the return value to the response object
if response.get('attach'):
if isinstance(return_value, six.text_type):
# If unicode, convert to bytes
return_value = return_value.encode('utf-8')
file_ = wsme.types.File(content=return_value)
pecan.response.app_iter = static.FileIter(file_.file)
# Since we've attached the return value to the response
# object the response body should now be empty.
return_value = None
response_params['return_type'] = None
return wsme.api.Response(return_value, **response_params)
def test_limit_is_zero(self):
fp = BytesIO(bytes_("0123456789"))
i = static.FileIter(fp).app_iter_range(limit=0)
self.assertRaises(StopIteration, next, i)
def test_limit_and_seek(self):
fp = BytesIO(bytes_("0123456789"))
i = static.FileIter(fp).app_iter_range(limit=4, seek=1)
self.assertEqual(bytes_("123"), next(i))
self.assertRaises(StopIteration, next, i)
def test_empty_file(self):
fp = BytesIO()
fi = static.FileIter(fp)
self.assertRaises(StopIteration, next, iter(fi))