def coroutine_to_deferred(c: Coroutine) -> Deferred:
"""Convert a coroutine to twisted Deferred."""
# see: https://twistedmatrix.com/trac/ticket/8748
# convert Coroutine to asyncio.Future
future = asyncio.ensure_future(c)
# convert asyncio.Future to Deferred
return Deferred.fromFuture(future)
def as_deferred(f):
'''
:param f:
:return:
'''
return Deferred.fromFuture(asyncio.ensure_future(f))
def transaction_exists_deferred(
self,
hash_bytes: bytes) -> Generator[None, protos.ExistsResponse, bool]:
self._check_connection()
request = protos.ExistsRequest(hash=hash_bytes)
result = yield Deferred.fromFuture(self._stub.Exists.future(request))
return result.exists
def _send(self, key, data):
print("Start storing key:'{}' in P2P-network".format(key))
fut = ensure_future(self.server.set(key, data))
d = Deferred.fromFuture(fut)
# from twisted.internet import reactor
# d.addTimeout(30, reactor, self.send_failed)
return d
def twisted_main(reactor):
handler = Handler()
rm = RandomMessageSocket()
rm.start_random_message_socket(handler.process_message)
# Call the python asyncio future using the twisted reactor
return Deferred.fromFuture(asyncio.ensure_future(handler.main()))
def defer(coroutine: typing.Union[typing.Coroutine, asyncio.Future]):
"""
Create a twisted Deferred from a coroutine or future and ensure it will run (call ensureDeferred on it).
:param coroutine: coroutine to defer.
"""
from twisted.internet.defer import ensureDeferred, Deferred
ensureDeferred(Deferred.fromFuture(asyncio.ensure_future(coroutine)))
def sleep(secs):
"""
Wrapper para usar asyncio.sleep com Twisted
:param int secs: por quantos segundos 'dormir'
:return: um Deferred que vai disparar em 'secs' segundos
"""
coroutine = asyncio.sleep(secs)
future = asyncio.ensure_future(coroutine)
return Deferred.fromFuture(future)
def deferred_from_coro(o) -> Any:
"""Converts a coroutine into a Deferred, or returns the object as is if it isn't a coroutine"""
if isinstance(o, Deferred):
return o
if asyncio.isfuture(o) or inspect.isawaitable(o):
if not is_asyncio_reactor_installed():
# wrapping the coroutine directly into a Deferred, this doesn't work correctly with coroutines
# that use asyncio, e.g. "await asyncio.sleep(1)"
return ensureDeferred(o)
else:
# wrapping the coroutine into a Future and then into a Deferred, this requires AsyncioSelectorReactor
return Deferred.fromFuture(asyncio.ensure_future(o))
return o
def as_deferred(d):
return Deferred.fromFuture(asyncio.ensure_future(d))
def get(self, key):
fut = ensure_future(self.server.get(key))
d = Deferred.fromFuture(fut)
return d
def as_deferred(self, f):
return Deferred.fromFuture(asyncio.ensure_future(f))
def _aio_as_deferred(f):
return Deferred.fromFuture(asyncio.ensure_future(f))
def as_deferred(*args, **kwargs):
return Deferred.fromFuture(asyncio.ensure_future(f(*args,**kwargs)))
def connect_p2p(self, bootstrap_address):
future = ensure_future(
self.server.bootstrap([(bootstrap_address, 8468)]))
d = Deferred.fromFuture(future)
return d
def as_deferred(f):
"""
transform a Twisted Deffered to an Asyncio Future
:param f: async function
"""
return Deferred.fromFuture(asyncio.ensure_future(f))
def as_deferred(f: Awaitable[Any]) -> Deferred:
"""Convert asyncio future to twisted deferred."""
return Deferred.fromFuture(asyncio.ensure_future(f))
def _force_deferred(coro: Coroutine) -> Deferred:
future = asyncio.ensure_future(coro)
return Deferred.fromFuture(future)
def wrapper(*args, **kwargs):
return Deferred.fromFuture(ensure_future(func(*args, **kwargs)))
def _render(self, request):
time_in = utils.now()
# if not self._check_headers(request):
# self._render_error(Failure(InvalidHeaderError()), request, None)
# return server.NOT_DONE_YET
session = request.getSession()
session_id = session.uid
finished_deferred = request.notifyFinish()
if self._use_authentication:
# if this is a new session, send a new secret and set the expiration
# otherwise, session.touch()
if self._initialize_session(session_id):
def expire_session():
self._unregister_user_session(session_id)
session.notifyOnExpire(expire_session)
message = "OK"
request.setResponseCode(200)
self._set_headers(request, message, True)
self._render_message(request, message)
return server.NOT_DONE_YET
else:
session.touch()
request.content.seek(0, 0)
content = request.content.read().decode()
try:
parsed = jsonrpclib.loads(content)
except json.JSONDecodeError:
log.warning("Unable to decode request json")
self._render_error(
JSONRPCError(None, code=JSONRPCError.CODE_PARSE_ERROR),
request, None)
return server.NOT_DONE_YET
request_id = None
try:
function_name = parsed.get('method')
args = parsed.get('params', {})
request_id = parsed.get('id', None)
token = parsed.pop('hmac', None)
except AttributeError as err:
log.warning(err)
self._render_error(
JSONRPCError(None, code=JSONRPCError.CODE_INVALID_REQUEST),
request, request_id)
return server.NOT_DONE_YET
reply_with_next_secret = False
if self._use_authentication:
try:
self._verify_token(session_id, parsed, token)
except InvalidAuthenticationToken as err:
log.warning("API validation failed")
self._render_error(
JSONRPCError.create_from_exception(
str(err),
code=JSONRPCError.CODE_AUTHENTICATION_ERROR,
traceback=format_exc()), request, request_id)
return server.NOT_DONE_YET
request.addCookie("TWISTED_SESSION", session_id)
self._update_session_secret(session_id)
reply_with_next_secret = True
try:
fn = self._get_jsonrpc_method(function_name)
except UnknownAPIMethodError as err:
log.warning('Failed to get function %s: %s', function_name, err)
self._render_error(
JSONRPCError(None, code=JSONRPCError.CODE_METHOD_NOT_FOUND),
request, request_id)
return server.NOT_DONE_YET
if args in (EMPTY_PARAMS, []):
_args, _kwargs = (), {}
elif isinstance(args, dict):
_args, _kwargs = (), args
elif len(args) == 1 and isinstance(args[0], dict):
# TODO: this is for backwards compatibility. Remove this once API and UI are updated
# TODO: also delete EMPTY_PARAMS then
_args, _kwargs = (), args[0]
elif len(args) == 2 and isinstance(args[0], list) and isinstance(
args[1], dict):
_args, _kwargs = args
else:
raise ValueError('invalid args format')
params_error, erroneous_params = self._check_params(fn, _args, _kwargs)
if params_error is not None:
params_error_message = '{} for {} command: {}'.format(
params_error, function_name, ', '.join(erroneous_params))
log.warning(params_error_message)
self._render_error(
JSONRPCError(params_error_message,
code=JSONRPCError.CODE_INVALID_PARAMS), request,
request_id)
return server.NOT_DONE_YET
try:
result = fn(self, *_args, **_kwargs)
if isinstance(result, Deferred):
d = result
elif isinstance(result, Failure):
d = defer.fail(result)
elif asyncio.iscoroutine(result):
d = Deferred.fromFuture(asyncio.ensure_future(result))
else:
d = defer.succeed(result)
except:
d = defer.fail(Failure(captureVars=Deferred.debug))
# finished_deferred will callback when the request is finished
# and errback if something went wrong. If the errback is
# called, cancel the deferred stack. This is to prevent
# request.finish() from being called on a closed request.
finished_deferred.addErrback(self._handle_dropped_request, d,
function_name)
d.addCallback(self._callback_render, request, request_id,
reply_with_next_secret)
d.addErrback(trap, ConnectionDone, ConnectionLost,
defer.CancelledError)
d.addErrback(self._render_error, request, request_id)
d.addBoth(lambda _: log.debug("%s took %f", function_name,
(utils.now() - time_in).total_seconds()))
return server.NOT_DONE_YET
def _aio_as_deferred(f):
return Deferred.fromFuture(asyncio.ensure_future(f))
def as_deferred(f: Future):
return Deferred.fromFuture(asyncio.ensure_future(f))
def as_deferred(f: Awaitable) -> Deferred:
return Deferred.fromFuture(asyncio.ensure_future(f))
def as_deferred(f):
"""Transform a Twisted Deffered to an Asyncio Future"""
return Deferred.fromFuture(asyncio.ensure_future(f))
def as_deferred(f: Union[asyncio.Future, Coroutine]):
return Deferred.fromFuture(asyncio.ensure_future(f))
