mirror of
https://github.com/python/cpython.git
synced 2024-12-05 15:54:17 +08:00
3449 lines
87 KiB
C
3449 lines
87 KiB
C
#include "Python.h"
|
|
#include "pycore_pyerrors.h" // _PyErr_ClearExcState()
|
|
#include <stddef.h> // offsetof()
|
|
|
|
|
|
/*[clinic input]
|
|
module _asyncio
|
|
[clinic start generated code]*/
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=8fd17862aa989c69]*/
|
|
|
|
|
|
/* identifiers used from some functions */
|
|
_Py_IDENTIFIER(__asyncio_running_event_loop__);
|
|
_Py_IDENTIFIER(_asyncio_future_blocking);
|
|
_Py_IDENTIFIER(add_done_callback);
|
|
_Py_IDENTIFIER(call_soon);
|
|
_Py_IDENTIFIER(cancel);
|
|
_Py_IDENTIFIER(get_event_loop);
|
|
_Py_IDENTIFIER(throw);
|
|
|
|
|
|
/* State of the _asyncio module */
|
|
static PyObject *asyncio_mod;
|
|
static PyObject *traceback_extract_stack;
|
|
static PyObject *asyncio_get_event_loop_policy;
|
|
static PyObject *asyncio_future_repr_info_func;
|
|
static PyObject *asyncio_iscoroutine_func;
|
|
static PyObject *asyncio_task_get_stack_func;
|
|
static PyObject *asyncio_task_print_stack_func;
|
|
static PyObject *asyncio_task_repr_info_func;
|
|
static PyObject *asyncio_InvalidStateError;
|
|
static PyObject *asyncio_CancelledError;
|
|
static PyObject *context_kwname;
|
|
static int module_initialized;
|
|
|
|
static PyObject *cached_running_holder;
|
|
static volatile uint64_t cached_running_holder_tsid;
|
|
|
|
/* Counter for autogenerated Task names */
|
|
static uint64_t task_name_counter = 0;
|
|
|
|
/* WeakSet containing all alive tasks. */
|
|
static PyObject *all_tasks;
|
|
|
|
/* Dictionary containing tasks that are currently active in
|
|
all running event loops. {EventLoop: Task} */
|
|
static PyObject *current_tasks;
|
|
|
|
/* An isinstance type cache for the 'is_coroutine()' function. */
|
|
static PyObject *iscoroutine_typecache;
|
|
|
|
|
|
typedef enum {
|
|
STATE_PENDING,
|
|
STATE_CANCELLED,
|
|
STATE_FINISHED
|
|
} fut_state;
|
|
|
|
#define FutureObj_HEAD(prefix) \
|
|
PyObject_HEAD \
|
|
PyObject *prefix##_loop; \
|
|
PyObject *prefix##_callback0; \
|
|
PyObject *prefix##_context0; \
|
|
PyObject *prefix##_callbacks; \
|
|
PyObject *prefix##_exception; \
|
|
PyObject *prefix##_result; \
|
|
PyObject *prefix##_source_tb; \
|
|
PyObject *prefix##_cancel_msg; \
|
|
fut_state prefix##_state; \
|
|
int prefix##_log_tb; \
|
|
int prefix##_blocking; \
|
|
PyObject *dict; \
|
|
PyObject *prefix##_weakreflist; \
|
|
_PyErr_StackItem prefix##_cancelled_exc_state;
|
|
|
|
typedef struct {
|
|
FutureObj_HEAD(fut)
|
|
} FutureObj;
|
|
|
|
typedef struct {
|
|
FutureObj_HEAD(task)
|
|
PyObject *task_fut_waiter;
|
|
PyObject *task_coro;
|
|
PyObject *task_name;
|
|
PyObject *task_context;
|
|
int task_must_cancel;
|
|
int task_log_destroy_pending;
|
|
} TaskObj;
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
TaskObj *sw_task;
|
|
PyObject *sw_arg;
|
|
} TaskStepMethWrapper;
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *rl_loop;
|
|
#if defined(HAVE_GETPID) && !defined(MS_WINDOWS)
|
|
pid_t rl_pid;
|
|
#endif
|
|
} PyRunningLoopHolder;
|
|
|
|
|
|
static PyTypeObject FutureType;
|
|
static PyTypeObject TaskType;
|
|
static PyTypeObject PyRunningLoopHolder_Type;
|
|
|
|
|
|
#define Future_CheckExact(obj) Py_IS_TYPE(obj, &FutureType)
|
|
#define Task_CheckExact(obj) Py_IS_TYPE(obj, &TaskType)
|
|
|
|
#define Future_Check(obj) PyObject_TypeCheck(obj, &FutureType)
|
|
#define Task_Check(obj) PyObject_TypeCheck(obj, &TaskType)
|
|
|
|
#include "clinic/_asynciomodule.c.h"
|
|
|
|
|
|
/*[clinic input]
|
|
class _asyncio.Future "FutureObj *" "&Future_Type"
|
|
[clinic start generated code]*/
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=00d3e4abca711e0f]*/
|
|
|
|
|
|
/* Get FutureIter from Future */
|
|
static PyObject * future_new_iter(PyObject *);
|
|
|
|
static PyRunningLoopHolder * new_running_loop_holder(PyObject *);
|
|
|
|
|
|
static int
|
|
_is_coroutine(PyObject *coro)
|
|
{
|
|
/* 'coro' is not a native coroutine, call asyncio.iscoroutine()
|
|
to check if it's another coroutine flavour.
|
|
|
|
Do this check after 'future_init()'; in case we need to raise
|
|
an error, __del__ needs a properly initialized object.
|
|
*/
|
|
PyObject *res = PyObject_CallOneArg(asyncio_iscoroutine_func, coro);
|
|
if (res == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
int is_res_true = PyObject_IsTrue(res);
|
|
Py_DECREF(res);
|
|
if (is_res_true <= 0) {
|
|
return is_res_true;
|
|
}
|
|
|
|
if (PySet_GET_SIZE(iscoroutine_typecache) < 100) {
|
|
/* Just in case we don't want to cache more than 100
|
|
positive types. That shouldn't ever happen, unless
|
|
someone stressing the system on purpose.
|
|
*/
|
|
if (PySet_Add(iscoroutine_typecache, (PyObject*) Py_TYPE(coro))) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
static inline int
|
|
is_coroutine(PyObject *coro)
|
|
{
|
|
if (PyCoro_CheckExact(coro)) {
|
|
return 1;
|
|
}
|
|
|
|
/* Check if `type(coro)` is in the cache.
|
|
Caching makes is_coroutine() function almost as fast as
|
|
PyCoro_CheckExact() for non-native coroutine-like objects
|
|
(like coroutines compiled with Cython).
|
|
|
|
asyncio.iscoroutine() has its own type caching mechanism.
|
|
This cache allows us to avoid the cost of even calling
|
|
a pure-Python function in 99.9% cases.
|
|
*/
|
|
int has_it = PySet_Contains(
|
|
iscoroutine_typecache, (PyObject*) Py_TYPE(coro));
|
|
if (has_it == 0) {
|
|
/* type(coro) is not in iscoroutine_typecache */
|
|
return _is_coroutine(coro);
|
|
}
|
|
|
|
/* either an error has occurred or
|
|
type(coro) is in iscoroutine_typecache
|
|
*/
|
|
return has_it;
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
get_future_loop(PyObject *fut)
|
|
{
|
|
/* Implementation of `asyncio.futures._get_loop` */
|
|
|
|
_Py_IDENTIFIER(get_loop);
|
|
_Py_IDENTIFIER(_loop);
|
|
PyObject *getloop;
|
|
|
|
if (Future_CheckExact(fut) || Task_CheckExact(fut)) {
|
|
PyObject *loop = ((FutureObj *)fut)->fut_loop;
|
|
Py_INCREF(loop);
|
|
return loop;
|
|
}
|
|
|
|
if (_PyObject_LookupAttrId(fut, &PyId_get_loop, &getloop) < 0) {
|
|
return NULL;
|
|
}
|
|
if (getloop != NULL) {
|
|
PyObject *res = PyObject_CallNoArgs(getloop);
|
|
Py_DECREF(getloop);
|
|
return res;
|
|
}
|
|
|
|
return _PyObject_GetAttrId(fut, &PyId__loop);
|
|
}
|
|
|
|
|
|
static int
|
|
get_running_loop(PyObject **loop)
|
|
{
|
|
PyObject *rl;
|
|
|
|
PyThreadState *ts = PyThreadState_Get();
|
|
uint64_t ts_id = PyThreadState_GetID(ts);
|
|
if (ts_id == cached_running_holder_tsid && cached_running_holder != NULL) {
|
|
// Fast path, check the cache.
|
|
rl = cached_running_holder; // borrowed
|
|
}
|
|
else {
|
|
PyObject *ts_dict = _PyThreadState_GetDict(ts); // borrowed
|
|
if (ts_dict == NULL) {
|
|
goto not_found;
|
|
}
|
|
|
|
rl = _PyDict_GetItemIdWithError(
|
|
ts_dict, &PyId___asyncio_running_event_loop__); // borrowed
|
|
if (rl == NULL) {
|
|
if (PyErr_Occurred()) {
|
|
goto error;
|
|
}
|
|
else {
|
|
goto not_found;
|
|
}
|
|
}
|
|
|
|
cached_running_holder = rl; // borrowed
|
|
cached_running_holder_tsid = ts_id;
|
|
}
|
|
|
|
assert(Py_IS_TYPE(rl, &PyRunningLoopHolder_Type));
|
|
PyObject *running_loop = ((PyRunningLoopHolder *)rl)->rl_loop;
|
|
|
|
if (running_loop == Py_None) {
|
|
goto not_found;
|
|
}
|
|
|
|
#if defined(HAVE_GETPID) && !defined(MS_WINDOWS)
|
|
/* On Windows there is no getpid, but there is also no os.fork(),
|
|
so there is no need for this check.
|
|
*/
|
|
if (getpid() != ((PyRunningLoopHolder *)rl)->rl_pid) {
|
|
goto not_found;
|
|
}
|
|
#endif
|
|
|
|
Py_INCREF(running_loop);
|
|
*loop = running_loop;
|
|
return 0;
|
|
|
|
not_found:
|
|
*loop = NULL;
|
|
return 0;
|
|
|
|
error:
|
|
*loop = NULL;
|
|
return -1;
|
|
}
|
|
|
|
|
|
static int
|
|
set_running_loop(PyObject *loop)
|
|
{
|
|
PyObject *ts_dict = NULL;
|
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
|
if (tstate != NULL) {
|
|
ts_dict = _PyThreadState_GetDict(tstate); // borrowed
|
|
}
|
|
|
|
if (ts_dict == NULL) {
|
|
PyErr_SetString(
|
|
PyExc_RuntimeError, "thread-local storage is not available");
|
|
return -1;
|
|
}
|
|
|
|
PyRunningLoopHolder *rl = new_running_loop_holder(loop);
|
|
if (rl == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
if (_PyDict_SetItemId(
|
|
ts_dict, &PyId___asyncio_running_event_loop__, (PyObject *)rl) < 0)
|
|
{
|
|
Py_DECREF(rl); // will cleanup loop & current_pid
|
|
return -1;
|
|
}
|
|
Py_DECREF(rl);
|
|
|
|
cached_running_holder = (PyObject *)rl;
|
|
cached_running_holder_tsid = PyThreadState_GetID(tstate);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static PyObject *
|
|
get_event_loop(void)
|
|
{
|
|
PyObject *loop;
|
|
PyObject *policy;
|
|
|
|
if (get_running_loop(&loop)) {
|
|
return NULL;
|
|
}
|
|
if (loop != NULL) {
|
|
return loop;
|
|
}
|
|
|
|
policy = PyObject_CallNoArgs(asyncio_get_event_loop_policy);
|
|
if (policy == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
loop = _PyObject_CallMethodIdNoArgs(policy, &PyId_get_event_loop);
|
|
Py_DECREF(policy);
|
|
return loop;
|
|
}
|
|
|
|
|
|
static int
|
|
call_soon(PyObject *loop, PyObject *func, PyObject *arg, PyObject *ctx)
|
|
{
|
|
PyObject *handle;
|
|
PyObject *stack[3];
|
|
Py_ssize_t nargs;
|
|
|
|
if (ctx == NULL) {
|
|
handle = _PyObject_CallMethodIdObjArgs(
|
|
loop, &PyId_call_soon, func, arg, NULL);
|
|
}
|
|
else {
|
|
/* Use FASTCALL to pass a keyword-only argument to call_soon */
|
|
|
|
PyObject *callable = _PyObject_GetAttrId(loop, &PyId_call_soon);
|
|
if (callable == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
/* All refs in 'stack' are borrowed. */
|
|
nargs = 1;
|
|
stack[0] = func;
|
|
if (arg != NULL) {
|
|
stack[1] = arg;
|
|
nargs++;
|
|
}
|
|
stack[nargs] = (PyObject *)ctx;
|
|
|
|
handle = PyObject_Vectorcall(callable, stack, nargs, context_kwname);
|
|
Py_DECREF(callable);
|
|
}
|
|
|
|
if (handle == NULL) {
|
|
return -1;
|
|
}
|
|
Py_DECREF(handle);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static inline int
|
|
future_is_alive(FutureObj *fut)
|
|
{
|
|
return fut->fut_loop != NULL;
|
|
}
|
|
|
|
|
|
static inline int
|
|
future_ensure_alive(FutureObj *fut)
|
|
{
|
|
if (!future_is_alive(fut)) {
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"Future object is not initialized.");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
#define ENSURE_FUTURE_ALIVE(fut) \
|
|
do { \
|
|
assert(Future_Check(fut) || Task_Check(fut)); \
|
|
if (future_ensure_alive((FutureObj*)fut)) { \
|
|
return NULL; \
|
|
} \
|
|
} while(0);
|
|
|
|
|
|
static int
|
|
future_schedule_callbacks(FutureObj *fut)
|
|
{
|
|
Py_ssize_t len;
|
|
Py_ssize_t i;
|
|
|
|
if (fut->fut_callback0 != NULL) {
|
|
/* There's a 1st callback */
|
|
|
|
int ret = call_soon(
|
|
fut->fut_loop, fut->fut_callback0,
|
|
(PyObject *)fut, fut->fut_context0);
|
|
|
|
Py_CLEAR(fut->fut_callback0);
|
|
Py_CLEAR(fut->fut_context0);
|
|
if (ret) {
|
|
/* If an error occurs in pure-Python implementation,
|
|
all callbacks are cleared. */
|
|
Py_CLEAR(fut->fut_callbacks);
|
|
return ret;
|
|
}
|
|
|
|
/* we called the first callback, now try calling
|
|
callbacks from the 'fut_callbacks' list. */
|
|
}
|
|
|
|
if (fut->fut_callbacks == NULL) {
|
|
/* No more callbacks, return. */
|
|
return 0;
|
|
}
|
|
|
|
len = PyList_GET_SIZE(fut->fut_callbacks);
|
|
if (len == 0) {
|
|
/* The list of callbacks was empty; clear it and return. */
|
|
Py_CLEAR(fut->fut_callbacks);
|
|
return 0;
|
|
}
|
|
|
|
for (i = 0; i < len; i++) {
|
|
PyObject *cb_tup = PyList_GET_ITEM(fut->fut_callbacks, i);
|
|
PyObject *cb = PyTuple_GET_ITEM(cb_tup, 0);
|
|
PyObject *ctx = PyTuple_GET_ITEM(cb_tup, 1);
|
|
|
|
if (call_soon(fut->fut_loop, cb, (PyObject *)fut, ctx)) {
|
|
/* If an error occurs in pure-Python implementation,
|
|
all callbacks are cleared. */
|
|
Py_CLEAR(fut->fut_callbacks);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
Py_CLEAR(fut->fut_callbacks);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
future_init(FutureObj *fut, PyObject *loop)
|
|
{
|
|
PyObject *res;
|
|
int is_true;
|
|
_Py_IDENTIFIER(get_debug);
|
|
|
|
// Same to FutureObj_clear() but not clearing fut->dict
|
|
Py_CLEAR(fut->fut_loop);
|
|
Py_CLEAR(fut->fut_callback0);
|
|
Py_CLEAR(fut->fut_context0);
|
|
Py_CLEAR(fut->fut_callbacks);
|
|
Py_CLEAR(fut->fut_result);
|
|
Py_CLEAR(fut->fut_exception);
|
|
Py_CLEAR(fut->fut_source_tb);
|
|
Py_CLEAR(fut->fut_cancel_msg);
|
|
_PyErr_ClearExcState(&fut->fut_cancelled_exc_state);
|
|
|
|
fut->fut_state = STATE_PENDING;
|
|
fut->fut_log_tb = 0;
|
|
fut->fut_blocking = 0;
|
|
|
|
if (loop == Py_None) {
|
|
loop = get_event_loop();
|
|
if (loop == NULL) {
|
|
return -1;
|
|
}
|
|
}
|
|
else {
|
|
Py_INCREF(loop);
|
|
}
|
|
fut->fut_loop = loop;
|
|
|
|
res = _PyObject_CallMethodIdNoArgs(fut->fut_loop, &PyId_get_debug);
|
|
if (res == NULL) {
|
|
return -1;
|
|
}
|
|
is_true = PyObject_IsTrue(res);
|
|
Py_DECREF(res);
|
|
if (is_true < 0) {
|
|
return -1;
|
|
}
|
|
if (is_true && !_Py_IsFinalizing()) {
|
|
/* Only try to capture the traceback if the interpreter is not being
|
|
finalized. The original motivation to add a `_Py_IsFinalizing()`
|
|
call was to prevent SIGSEGV when a Future is created in a __del__
|
|
method, which is called during the interpreter shutdown and the
|
|
traceback module is already unloaded.
|
|
*/
|
|
fut->fut_source_tb = PyObject_CallNoArgs(traceback_extract_stack);
|
|
if (fut->fut_source_tb == NULL) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
future_set_result(FutureObj *fut, PyObject *res)
|
|
{
|
|
if (future_ensure_alive(fut)) {
|
|
return NULL;
|
|
}
|
|
|
|
if (fut->fut_state != STATE_PENDING) {
|
|
PyErr_SetString(asyncio_InvalidStateError, "invalid state");
|
|
return NULL;
|
|
}
|
|
|
|
assert(!fut->fut_result);
|
|
Py_INCREF(res);
|
|
fut->fut_result = res;
|
|
fut->fut_state = STATE_FINISHED;
|
|
|
|
if (future_schedule_callbacks(fut) == -1) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
future_set_exception(FutureObj *fut, PyObject *exc)
|
|
{
|
|
PyObject *exc_val = NULL;
|
|
|
|
if (fut->fut_state != STATE_PENDING) {
|
|
PyErr_SetString(asyncio_InvalidStateError, "invalid state");
|
|
return NULL;
|
|
}
|
|
|
|
if (PyExceptionClass_Check(exc)) {
|
|
exc_val = PyObject_CallNoArgs(exc);
|
|
if (exc_val == NULL) {
|
|
return NULL;
|
|
}
|
|
if (fut->fut_state != STATE_PENDING) {
|
|
Py_DECREF(exc_val);
|
|
PyErr_SetString(asyncio_InvalidStateError, "invalid state");
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
exc_val = exc;
|
|
Py_INCREF(exc_val);
|
|
}
|
|
if (!PyExceptionInstance_Check(exc_val)) {
|
|
Py_DECREF(exc_val);
|
|
PyErr_SetString(PyExc_TypeError, "invalid exception object");
|
|
return NULL;
|
|
}
|
|
if (Py_IS_TYPE(exc_val, (PyTypeObject *)PyExc_StopIteration)) {
|
|
Py_DECREF(exc_val);
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"StopIteration interacts badly with generators "
|
|
"and cannot be raised into a Future");
|
|
return NULL;
|
|
}
|
|
|
|
assert(!fut->fut_exception);
|
|
fut->fut_exception = exc_val;
|
|
fut->fut_state = STATE_FINISHED;
|
|
|
|
if (future_schedule_callbacks(fut) == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
fut->fut_log_tb = 1;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
create_cancelled_error(PyObject *msg)
|
|
{
|
|
PyObject *exc;
|
|
if (msg == NULL || msg == Py_None) {
|
|
exc = PyObject_CallNoArgs(asyncio_CancelledError);
|
|
} else {
|
|
exc = PyObject_CallOneArg(asyncio_CancelledError, msg);
|
|
}
|
|
return exc;
|
|
}
|
|
|
|
static void
|
|
future_set_cancelled_error(FutureObj *fut)
|
|
{
|
|
PyObject *exc = create_cancelled_error(fut->fut_cancel_msg);
|
|
PyErr_SetObject(asyncio_CancelledError, exc);
|
|
Py_DECREF(exc);
|
|
|
|
_PyErr_ChainStackItem(&fut->fut_cancelled_exc_state);
|
|
}
|
|
|
|
static int
|
|
future_get_result(FutureObj *fut, PyObject **result)
|
|
{
|
|
if (fut->fut_state == STATE_CANCELLED) {
|
|
future_set_cancelled_error(fut);
|
|
return -1;
|
|
}
|
|
|
|
if (fut->fut_state != STATE_FINISHED) {
|
|
PyErr_SetString(asyncio_InvalidStateError, "Result is not set.");
|
|
return -1;
|
|
}
|
|
|
|
fut->fut_log_tb = 0;
|
|
if (fut->fut_exception != NULL) {
|
|
Py_INCREF(fut->fut_exception);
|
|
*result = fut->fut_exception;
|
|
return 1;
|
|
}
|
|
|
|
Py_INCREF(fut->fut_result);
|
|
*result = fut->fut_result;
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
future_add_done_callback(FutureObj *fut, PyObject *arg, PyObject *ctx)
|
|
{
|
|
if (!future_is_alive(fut)) {
|
|
PyErr_SetString(PyExc_RuntimeError, "uninitialized Future object");
|
|
return NULL;
|
|
}
|
|
|
|
if (fut->fut_state != STATE_PENDING) {
|
|
/* The future is done/cancelled, so schedule the callback
|
|
right away. */
|
|
if (call_soon(fut->fut_loop, arg, (PyObject*) fut, ctx)) {
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
/* The future is pending, add a callback.
|
|
|
|
Callbacks in the future object are stored as follows:
|
|
|
|
callback0 -- a pointer to the first callback
|
|
callbacks -- a list of 2nd, 3rd, ... callbacks
|
|
|
|
Invariants:
|
|
|
|
* callbacks != NULL:
|
|
There are some callbacks in in the list. Just
|
|
add the new callback to it.
|
|
|
|
* callbacks == NULL and callback0 == NULL:
|
|
This is the first callback. Set it to callback0.
|
|
|
|
* callbacks == NULL and callback0 != NULL:
|
|
This is a second callback. Initialize callbacks
|
|
with a new list and add the new callback to it.
|
|
*/
|
|
|
|
if (fut->fut_callbacks == NULL && fut->fut_callback0 == NULL) {
|
|
Py_INCREF(arg);
|
|
fut->fut_callback0 = arg;
|
|
Py_INCREF(ctx);
|
|
fut->fut_context0 = ctx;
|
|
}
|
|
else {
|
|
PyObject *tup = PyTuple_New(2);
|
|
if (tup == NULL) {
|
|
return NULL;
|
|
}
|
|
Py_INCREF(arg);
|
|
PyTuple_SET_ITEM(tup, 0, arg);
|
|
Py_INCREF(ctx);
|
|
PyTuple_SET_ITEM(tup, 1, (PyObject *)ctx);
|
|
|
|
if (fut->fut_callbacks != NULL) {
|
|
int err = PyList_Append(fut->fut_callbacks, tup);
|
|
if (err) {
|
|
Py_DECREF(tup);
|
|
return NULL;
|
|
}
|
|
Py_DECREF(tup);
|
|
}
|
|
else {
|
|
fut->fut_callbacks = PyList_New(1);
|
|
if (fut->fut_callbacks == NULL) {
|
|
Py_DECREF(tup);
|
|
return NULL;
|
|
}
|
|
|
|
PyList_SET_ITEM(fut->fut_callbacks, 0, tup); /* borrow */
|
|
}
|
|
}
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
future_cancel(FutureObj *fut, PyObject *msg)
|
|
{
|
|
fut->fut_log_tb = 0;
|
|
|
|
if (fut->fut_state != STATE_PENDING) {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
fut->fut_state = STATE_CANCELLED;
|
|
|
|
Py_XINCREF(msg);
|
|
Py_XSETREF(fut->fut_cancel_msg, msg);
|
|
|
|
if (future_schedule_callbacks(fut) == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
Py_RETURN_TRUE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.__init__
|
|
|
|
*
|
|
loop: object = None
|
|
|
|
This class is *almost* compatible with concurrent.futures.Future.
|
|
|
|
Differences:
|
|
|
|
- result() and exception() do not take a timeout argument and
|
|
raise an exception when the future isn't done yet.
|
|
|
|
- Callbacks registered with add_done_callback() are always called
|
|
via the event loop's call_soon_threadsafe().
|
|
|
|
- This class is not compatible with the wait() and as_completed()
|
|
methods in the concurrent.futures package.
|
|
[clinic start generated code]*/
|
|
|
|
static int
|
|
_asyncio_Future___init___impl(FutureObj *self, PyObject *loop)
|
|
/*[clinic end generated code: output=9ed75799eaccb5d6 input=89af317082bc0bf8]*/
|
|
|
|
{
|
|
return future_init(self, loop);
|
|
}
|
|
|
|
static int
|
|
FutureObj_clear(FutureObj *fut)
|
|
{
|
|
Py_CLEAR(fut->fut_loop);
|
|
Py_CLEAR(fut->fut_callback0);
|
|
Py_CLEAR(fut->fut_context0);
|
|
Py_CLEAR(fut->fut_callbacks);
|
|
Py_CLEAR(fut->fut_result);
|
|
Py_CLEAR(fut->fut_exception);
|
|
Py_CLEAR(fut->fut_source_tb);
|
|
Py_CLEAR(fut->fut_cancel_msg);
|
|
_PyErr_ClearExcState(&fut->fut_cancelled_exc_state);
|
|
Py_CLEAR(fut->dict);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
FutureObj_traverse(FutureObj *fut, visitproc visit, void *arg)
|
|
{
|
|
Py_VISIT(fut->fut_loop);
|
|
Py_VISIT(fut->fut_callback0);
|
|
Py_VISIT(fut->fut_context0);
|
|
Py_VISIT(fut->fut_callbacks);
|
|
Py_VISIT(fut->fut_result);
|
|
Py_VISIT(fut->fut_exception);
|
|
Py_VISIT(fut->fut_source_tb);
|
|
Py_VISIT(fut->fut_cancel_msg);
|
|
Py_VISIT(fut->dict);
|
|
|
|
_PyErr_StackItem *exc_state = &fut->fut_cancelled_exc_state;
|
|
Py_VISIT(exc_state->exc_type);
|
|
Py_VISIT(exc_state->exc_value);
|
|
Py_VISIT(exc_state->exc_traceback);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.result
|
|
|
|
Return the result this future represents.
|
|
|
|
If the future has been cancelled, raises CancelledError. If the
|
|
future's result isn't yet available, raises InvalidStateError. If
|
|
the future is done and has an exception set, this exception is raised.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_result_impl(FutureObj *self)
|
|
/*[clinic end generated code: output=f35f940936a4b1e5 input=49ecf9cf5ec50dc5]*/
|
|
{
|
|
PyObject *result;
|
|
|
|
if (!future_is_alive(self)) {
|
|
PyErr_SetString(asyncio_InvalidStateError,
|
|
"Future object is not initialized.");
|
|
return NULL;
|
|
}
|
|
|
|
int res = future_get_result(self, &result);
|
|
|
|
if (res == -1) {
|
|
return NULL;
|
|
}
|
|
|
|
if (res == 0) {
|
|
return result;
|
|
}
|
|
|
|
assert(res == 1);
|
|
|
|
PyErr_SetObject(PyExceptionInstance_Class(result), result);
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.exception
|
|
|
|
Return the exception that was set on this future.
|
|
|
|
The exception (or None if no exception was set) is returned only if
|
|
the future is done. If the future has been cancelled, raises
|
|
CancelledError. If the future isn't done yet, raises
|
|
InvalidStateError.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_exception_impl(FutureObj *self)
|
|
/*[clinic end generated code: output=88b20d4f855e0710 input=733547a70c841c68]*/
|
|
{
|
|
if (!future_is_alive(self)) {
|
|
PyErr_SetString(asyncio_InvalidStateError,
|
|
"Future object is not initialized.");
|
|
return NULL;
|
|
}
|
|
|
|
if (self->fut_state == STATE_CANCELLED) {
|
|
future_set_cancelled_error(self);
|
|
return NULL;
|
|
}
|
|
|
|
if (self->fut_state != STATE_FINISHED) {
|
|
PyErr_SetString(asyncio_InvalidStateError, "Exception is not set.");
|
|
return NULL;
|
|
}
|
|
|
|
if (self->fut_exception != NULL) {
|
|
self->fut_log_tb = 0;
|
|
Py_INCREF(self->fut_exception);
|
|
return self->fut_exception;
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.set_result
|
|
|
|
result: object
|
|
/
|
|
|
|
Mark the future done and set its result.
|
|
|
|
If the future is already done when this method is called, raises
|
|
InvalidStateError.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_set_result(FutureObj *self, PyObject *result)
|
|
/*[clinic end generated code: output=1ec2e6bcccd6f2ce input=8b75172c2a7b05f1]*/
|
|
{
|
|
ENSURE_FUTURE_ALIVE(self)
|
|
return future_set_result(self, result);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.set_exception
|
|
|
|
exception: object
|
|
/
|
|
|
|
Mark the future done and set an exception.
|
|
|
|
If the future is already done when this method is called, raises
|
|
InvalidStateError.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_set_exception(FutureObj *self, PyObject *exception)
|
|
/*[clinic end generated code: output=f1c1b0cd321be360 input=e45b7d7aa71cc66d]*/
|
|
{
|
|
ENSURE_FUTURE_ALIVE(self)
|
|
return future_set_exception(self, exception);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.add_done_callback
|
|
|
|
fn: object
|
|
/
|
|
*
|
|
context: object = NULL
|
|
|
|
Add a callback to be run when the future becomes done.
|
|
|
|
The callback is called with a single argument - the future object. If
|
|
the future is already done when this is called, the callback is
|
|
scheduled with call_soon.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_add_done_callback_impl(FutureObj *self, PyObject *fn,
|
|
PyObject *context)
|
|
/*[clinic end generated code: output=7ce635bbc9554c1e input=15ab0693a96e9533]*/
|
|
{
|
|
if (context == NULL) {
|
|
context = PyContext_CopyCurrent();
|
|
if (context == NULL) {
|
|
return NULL;
|
|
}
|
|
PyObject *res = future_add_done_callback(self, fn, context);
|
|
Py_DECREF(context);
|
|
return res;
|
|
}
|
|
return future_add_done_callback(self, fn, context);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.remove_done_callback
|
|
|
|
fn: object
|
|
/
|
|
|
|
Remove all instances of a callback from the "call when done" list.
|
|
|
|
Returns the number of callbacks removed.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_remove_done_callback(FutureObj *self, PyObject *fn)
|
|
/*[clinic end generated code: output=5ab1fb52b24ef31f input=0a43280a149d505b]*/
|
|
{
|
|
PyObject *newlist;
|
|
Py_ssize_t len, i, j=0;
|
|
Py_ssize_t cleared_callback0 = 0;
|
|
|
|
ENSURE_FUTURE_ALIVE(self)
|
|
|
|
if (self->fut_callback0 != NULL) {
|
|
int cmp = PyObject_RichCompareBool(self->fut_callback0, fn, Py_EQ);
|
|
if (cmp == -1) {
|
|
return NULL;
|
|
}
|
|
if (cmp == 1) {
|
|
/* callback0 == fn */
|
|
Py_CLEAR(self->fut_callback0);
|
|
Py_CLEAR(self->fut_context0);
|
|
cleared_callback0 = 1;
|
|
}
|
|
}
|
|
|
|
if (self->fut_callbacks == NULL) {
|
|
return PyLong_FromSsize_t(cleared_callback0);
|
|
}
|
|
|
|
len = PyList_GET_SIZE(self->fut_callbacks);
|
|
if (len == 0) {
|
|
Py_CLEAR(self->fut_callbacks);
|
|
return PyLong_FromSsize_t(cleared_callback0);
|
|
}
|
|
|
|
if (len == 1) {
|
|
PyObject *cb_tup = PyList_GET_ITEM(self->fut_callbacks, 0);
|
|
int cmp = PyObject_RichCompareBool(
|
|
PyTuple_GET_ITEM(cb_tup, 0), fn, Py_EQ);
|
|
if (cmp == -1) {
|
|
return NULL;
|
|
}
|
|
if (cmp == 1) {
|
|
/* callbacks[0] == fn */
|
|
Py_CLEAR(self->fut_callbacks);
|
|
return PyLong_FromSsize_t(1 + cleared_callback0);
|
|
}
|
|
/* callbacks[0] != fn and len(callbacks) == 1 */
|
|
return PyLong_FromSsize_t(cleared_callback0);
|
|
}
|
|
|
|
newlist = PyList_New(len);
|
|
if (newlist == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < PyList_GET_SIZE(self->fut_callbacks); i++) {
|
|
int ret;
|
|
PyObject *item = PyList_GET_ITEM(self->fut_callbacks, i);
|
|
Py_INCREF(item);
|
|
ret = PyObject_RichCompareBool(PyTuple_GET_ITEM(item, 0), fn, Py_EQ);
|
|
if (ret == 0) {
|
|
if (j < len) {
|
|
PyList_SET_ITEM(newlist, j, item);
|
|
j++;
|
|
continue;
|
|
}
|
|
ret = PyList_Append(newlist, item);
|
|
}
|
|
Py_DECREF(item);
|
|
if (ret < 0) {
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
if (j == 0) {
|
|
Py_CLEAR(self->fut_callbacks);
|
|
Py_DECREF(newlist);
|
|
return PyLong_FromSsize_t(len + cleared_callback0);
|
|
}
|
|
|
|
if (j < len) {
|
|
Py_SET_SIZE(newlist, j);
|
|
}
|
|
j = PyList_GET_SIZE(newlist);
|
|
len = PyList_GET_SIZE(self->fut_callbacks);
|
|
if (j != len) {
|
|
if (PyList_SetSlice(self->fut_callbacks, 0, len, newlist) < 0) {
|
|
goto fail;
|
|
}
|
|
}
|
|
Py_DECREF(newlist);
|
|
return PyLong_FromSsize_t(len - j + cleared_callback0);
|
|
|
|
fail:
|
|
Py_DECREF(newlist);
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.cancel
|
|
|
|
msg: object = None
|
|
|
|
Cancel the future and schedule callbacks.
|
|
|
|
If the future is already done or cancelled, return False. Otherwise,
|
|
change the future's state to cancelled, schedule the callbacks and
|
|
return True.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_cancel_impl(FutureObj *self, PyObject *msg)
|
|
/*[clinic end generated code: output=3edebbc668e5aba3 input=925eb545251f2c5a]*/
|
|
{
|
|
ENSURE_FUTURE_ALIVE(self)
|
|
return future_cancel(self, msg);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.cancelled
|
|
|
|
Return True if the future was cancelled.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_cancelled_impl(FutureObj *self)
|
|
/*[clinic end generated code: output=145197ced586357d input=943ab8b7b7b17e45]*/
|
|
{
|
|
if (future_is_alive(self) && self->fut_state == STATE_CANCELLED) {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
else {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.done
|
|
|
|
Return True if the future is done.
|
|
|
|
Done means either that a result / exception are available, or that the
|
|
future was cancelled.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_done_impl(FutureObj *self)
|
|
/*[clinic end generated code: output=244c5ac351145096 input=28d7b23fdb65d2ac]*/
|
|
{
|
|
if (!future_is_alive(self) || self->fut_state == STATE_PENDING) {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
else {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future.get_loop
|
|
|
|
Return the event loop the Future is bound to.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future_get_loop_impl(FutureObj *self)
|
|
/*[clinic end generated code: output=119b6ea0c9816c3f input=cba48c2136c79d1f]*/
|
|
{
|
|
ENSURE_FUTURE_ALIVE(self)
|
|
Py_INCREF(self->fut_loop);
|
|
return self->fut_loop;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_blocking(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
if (future_is_alive(fut) && fut->fut_blocking) {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
else {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
static int
|
|
FutureObj_set_blocking(FutureObj *fut, PyObject *val, void *Py_UNUSED(ignored))
|
|
{
|
|
if (future_ensure_alive(fut)) {
|
|
return -1;
|
|
}
|
|
if (val == NULL) {
|
|
PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
|
|
return -1;
|
|
}
|
|
|
|
int is_true = PyObject_IsTrue(val);
|
|
if (is_true < 0) {
|
|
return -1;
|
|
}
|
|
fut->fut_blocking = is_true;
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_log_traceback(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
ENSURE_FUTURE_ALIVE(fut)
|
|
if (fut->fut_log_tb) {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
else {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
static int
|
|
FutureObj_set_log_traceback(FutureObj *fut, PyObject *val, void *Py_UNUSED(ignored))
|
|
{
|
|
if (val == NULL) {
|
|
PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
|
|
return -1;
|
|
}
|
|
int is_true = PyObject_IsTrue(val);
|
|
if (is_true < 0) {
|
|
return -1;
|
|
}
|
|
if (is_true) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"_log_traceback can only be set to False");
|
|
return -1;
|
|
}
|
|
fut->fut_log_tb = is_true;
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_loop(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
if (!future_is_alive(fut)) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
Py_INCREF(fut->fut_loop);
|
|
return fut->fut_loop;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_callbacks(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
Py_ssize_t i;
|
|
|
|
ENSURE_FUTURE_ALIVE(fut)
|
|
|
|
if (fut->fut_callback0 == NULL) {
|
|
if (fut->fut_callbacks == NULL) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
Py_INCREF(fut->fut_callbacks);
|
|
return fut->fut_callbacks;
|
|
}
|
|
|
|
Py_ssize_t len = 1;
|
|
if (fut->fut_callbacks != NULL) {
|
|
len += PyList_GET_SIZE(fut->fut_callbacks);
|
|
}
|
|
|
|
|
|
PyObject *new_list = PyList_New(len);
|
|
if (new_list == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *tup0 = PyTuple_New(2);
|
|
if (tup0 == NULL) {
|
|
Py_DECREF(new_list);
|
|
return NULL;
|
|
}
|
|
|
|
Py_INCREF(fut->fut_callback0);
|
|
PyTuple_SET_ITEM(tup0, 0, fut->fut_callback0);
|
|
assert(fut->fut_context0 != NULL);
|
|
Py_INCREF(fut->fut_context0);
|
|
PyTuple_SET_ITEM(tup0, 1, (PyObject *)fut->fut_context0);
|
|
|
|
PyList_SET_ITEM(new_list, 0, tup0);
|
|
|
|
if (fut->fut_callbacks != NULL) {
|
|
for (i = 0; i < PyList_GET_SIZE(fut->fut_callbacks); i++) {
|
|
PyObject *cb = PyList_GET_ITEM(fut->fut_callbacks, i);
|
|
Py_INCREF(cb);
|
|
PyList_SET_ITEM(new_list, i + 1, cb);
|
|
}
|
|
}
|
|
|
|
return new_list;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_result(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
ENSURE_FUTURE_ALIVE(fut)
|
|
if (fut->fut_result == NULL) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
Py_INCREF(fut->fut_result);
|
|
return fut->fut_result;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_exception(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
ENSURE_FUTURE_ALIVE(fut)
|
|
if (fut->fut_exception == NULL) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
Py_INCREF(fut->fut_exception);
|
|
return fut->fut_exception;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_source_traceback(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
if (!future_is_alive(fut) || fut->fut_source_tb == NULL) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
Py_INCREF(fut->fut_source_tb);
|
|
return fut->fut_source_tb;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_cancel_message(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
if (fut->fut_cancel_msg == NULL) {
|
|
Py_RETURN_NONE;
|
|
}
|
|
Py_INCREF(fut->fut_cancel_msg);
|
|
return fut->fut_cancel_msg;
|
|
}
|
|
|
|
static int
|
|
FutureObj_set_cancel_message(FutureObj *fut, PyObject *msg,
|
|
void *Py_UNUSED(ignored))
|
|
{
|
|
if (msg == NULL) {
|
|
PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
|
|
return -1;
|
|
}
|
|
Py_INCREF(msg);
|
|
Py_XSETREF(fut->fut_cancel_msg, msg);
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_get_state(FutureObj *fut, void *Py_UNUSED(ignored))
|
|
{
|
|
_Py_IDENTIFIER(PENDING);
|
|
_Py_IDENTIFIER(CANCELLED);
|
|
_Py_IDENTIFIER(FINISHED);
|
|
PyObject *ret = NULL;
|
|
|
|
ENSURE_FUTURE_ALIVE(fut)
|
|
|
|
switch (fut->fut_state) {
|
|
case STATE_PENDING:
|
|
ret = _PyUnicode_FromId(&PyId_PENDING);
|
|
break;
|
|
case STATE_CANCELLED:
|
|
ret = _PyUnicode_FromId(&PyId_CANCELLED);
|
|
break;
|
|
case STATE_FINISHED:
|
|
ret = _PyUnicode_FromId(&PyId_FINISHED);
|
|
break;
|
|
default:
|
|
assert (0);
|
|
}
|
|
Py_XINCREF(ret);
|
|
return ret;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future._make_cancelled_error
|
|
|
|
Create the CancelledError to raise if the Future is cancelled.
|
|
|
|
This should only be called once when handling a cancellation since
|
|
it erases the context exception value.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future__make_cancelled_error_impl(FutureObj *self)
|
|
/*[clinic end generated code: output=a5df276f6c1213de input=ac6effe4ba795ecc]*/
|
|
{
|
|
PyObject *exc = create_cancelled_error(self->fut_cancel_msg);
|
|
_PyErr_StackItem *exc_state = &self->fut_cancelled_exc_state;
|
|
/* Transfer ownership of exc_value from exc_state to exc since we are
|
|
done with it. */
|
|
PyException_SetContext(exc, exc_state->exc_value);
|
|
exc_state->exc_value = NULL;
|
|
|
|
return exc;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Future._repr_info
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Future__repr_info_impl(FutureObj *self)
|
|
/*[clinic end generated code: output=fa69e901bd176cfb input=f21504d8e2ae1ca2]*/
|
|
{
|
|
return PyObject_CallOneArg(asyncio_future_repr_info_func, (PyObject *)self);
|
|
}
|
|
|
|
static PyObject *
|
|
FutureObj_repr(FutureObj *fut)
|
|
{
|
|
_Py_IDENTIFIER(_repr_info);
|
|
|
|
ENSURE_FUTURE_ALIVE(fut)
|
|
|
|
PyObject *rinfo = _PyObject_CallMethodIdNoArgs((PyObject*)fut,
|
|
&PyId__repr_info);
|
|
if (rinfo == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *rinfo_s = PyUnicode_Join(NULL, rinfo);
|
|
Py_DECREF(rinfo);
|
|
if (rinfo_s == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *rstr = PyUnicode_FromFormat("<%s %U>",
|
|
_PyType_Name(Py_TYPE(fut)), rinfo_s);
|
|
Py_DECREF(rinfo_s);
|
|
return rstr;
|
|
}
|
|
|
|
static void
|
|
FutureObj_finalize(FutureObj *fut)
|
|
{
|
|
_Py_IDENTIFIER(call_exception_handler);
|
|
_Py_IDENTIFIER(message);
|
|
_Py_IDENTIFIER(exception);
|
|
_Py_IDENTIFIER(future);
|
|
_Py_IDENTIFIER(source_traceback);
|
|
|
|
PyObject *error_type, *error_value, *error_traceback;
|
|
PyObject *context;
|
|
PyObject *message = NULL;
|
|
PyObject *func;
|
|
|
|
if (!fut->fut_log_tb) {
|
|
return;
|
|
}
|
|
assert(fut->fut_exception != NULL);
|
|
fut->fut_log_tb = 0;
|
|
|
|
/* Save the current exception, if any. */
|
|
PyErr_Fetch(&error_type, &error_value, &error_traceback);
|
|
|
|
context = PyDict_New();
|
|
if (context == NULL) {
|
|
goto finally;
|
|
}
|
|
|
|
message = PyUnicode_FromFormat(
|
|
"%s exception was never retrieved", _PyType_Name(Py_TYPE(fut)));
|
|
if (message == NULL) {
|
|
goto finally;
|
|
}
|
|
|
|
if (_PyDict_SetItemId(context, &PyId_message, message) < 0 ||
|
|
_PyDict_SetItemId(context, &PyId_exception, fut->fut_exception) < 0 ||
|
|
_PyDict_SetItemId(context, &PyId_future, (PyObject*)fut) < 0) {
|
|
goto finally;
|
|
}
|
|
if (fut->fut_source_tb != NULL) {
|
|
if (_PyDict_SetItemId(context, &PyId_source_traceback,
|
|
fut->fut_source_tb) < 0) {
|
|
goto finally;
|
|
}
|
|
}
|
|
|
|
func = _PyObject_GetAttrId(fut->fut_loop, &PyId_call_exception_handler);
|
|
if (func != NULL) {
|
|
PyObject *res = PyObject_CallOneArg(func, context);
|
|
if (res == NULL) {
|
|
PyErr_WriteUnraisable(func);
|
|
}
|
|
else {
|
|
Py_DECREF(res);
|
|
}
|
|
Py_DECREF(func);
|
|
}
|
|
|
|
finally:
|
|
Py_XDECREF(context);
|
|
Py_XDECREF(message);
|
|
|
|
/* Restore the saved exception. */
|
|
PyErr_Restore(error_type, error_value, error_traceback);
|
|
}
|
|
|
|
static PyObject *
|
|
future_cls_getitem(PyObject *cls, PyObject *type)
|
|
{
|
|
Py_INCREF(cls);
|
|
return cls;
|
|
}
|
|
|
|
static PyAsyncMethods FutureType_as_async = {
|
|
(unaryfunc)future_new_iter, /* am_await */
|
|
0, /* am_aiter */
|
|
0, /* am_anext */
|
|
0, /* am_send */
|
|
};
|
|
|
|
static PyMethodDef FutureType_methods[] = {
|
|
_ASYNCIO_FUTURE_RESULT_METHODDEF
|
|
_ASYNCIO_FUTURE_EXCEPTION_METHODDEF
|
|
_ASYNCIO_FUTURE_SET_RESULT_METHODDEF
|
|
_ASYNCIO_FUTURE_SET_EXCEPTION_METHODDEF
|
|
_ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF
|
|
_ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF
|
|
_ASYNCIO_FUTURE_CANCEL_METHODDEF
|
|
_ASYNCIO_FUTURE_CANCELLED_METHODDEF
|
|
_ASYNCIO_FUTURE_DONE_METHODDEF
|
|
_ASYNCIO_FUTURE_GET_LOOP_METHODDEF
|
|
_ASYNCIO_FUTURE__MAKE_CANCELLED_ERROR_METHODDEF
|
|
_ASYNCIO_FUTURE__REPR_INFO_METHODDEF
|
|
{"__class_getitem__", future_cls_getitem, METH_O|METH_CLASS, NULL},
|
|
{NULL, NULL} /* Sentinel */
|
|
};
|
|
|
|
#define FUTURE_COMMON_GETSETLIST \
|
|
{"_state", (getter)FutureObj_get_state, NULL, NULL}, \
|
|
{"_asyncio_future_blocking", (getter)FutureObj_get_blocking, \
|
|
(setter)FutureObj_set_blocking, NULL}, \
|
|
{"_loop", (getter)FutureObj_get_loop, NULL, NULL}, \
|
|
{"_callbacks", (getter)FutureObj_get_callbacks, NULL, NULL}, \
|
|
{"_result", (getter)FutureObj_get_result, NULL, NULL}, \
|
|
{"_exception", (getter)FutureObj_get_exception, NULL, NULL}, \
|
|
{"_log_traceback", (getter)FutureObj_get_log_traceback, \
|
|
(setter)FutureObj_set_log_traceback, NULL}, \
|
|
{"_source_traceback", (getter)FutureObj_get_source_traceback, \
|
|
NULL, NULL}, \
|
|
{"_cancel_message", (getter)FutureObj_get_cancel_message, \
|
|
(setter)FutureObj_set_cancel_message, NULL},
|
|
|
|
static PyGetSetDef FutureType_getsetlist[] = {
|
|
FUTURE_COMMON_GETSETLIST
|
|
{NULL} /* Sentinel */
|
|
};
|
|
|
|
static void FutureObj_dealloc(PyObject *self);
|
|
|
|
static PyTypeObject FutureType = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"_asyncio.Future",
|
|
sizeof(FutureObj), /* tp_basicsize */
|
|
.tp_dealloc = FutureObj_dealloc,
|
|
.tp_as_async = &FutureType_as_async,
|
|
.tp_repr = (reprfunc)FutureObj_repr,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
|
|
.tp_doc = _asyncio_Future___init____doc__,
|
|
.tp_traverse = (traverseproc)FutureObj_traverse,
|
|
.tp_clear = (inquiry)FutureObj_clear,
|
|
.tp_weaklistoffset = offsetof(FutureObj, fut_weakreflist),
|
|
.tp_iter = (getiterfunc)future_new_iter,
|
|
.tp_methods = FutureType_methods,
|
|
.tp_getset = FutureType_getsetlist,
|
|
.tp_dictoffset = offsetof(FutureObj, dict),
|
|
.tp_init = (initproc)_asyncio_Future___init__,
|
|
.tp_new = PyType_GenericNew,
|
|
.tp_finalize = (destructor)FutureObj_finalize,
|
|
};
|
|
|
|
static void
|
|
FutureObj_dealloc(PyObject *self)
|
|
{
|
|
FutureObj *fut = (FutureObj *)self;
|
|
|
|
if (Future_CheckExact(fut)) {
|
|
/* When fut is subclass of Future, finalizer is called from
|
|
* subtype_dealloc.
|
|
*/
|
|
if (PyObject_CallFinalizerFromDealloc(self) < 0) {
|
|
// resurrected.
|
|
return;
|
|
}
|
|
}
|
|
|
|
PyObject_GC_UnTrack(self);
|
|
|
|
if (fut->fut_weakreflist != NULL) {
|
|
PyObject_ClearWeakRefs(self);
|
|
}
|
|
|
|
(void)FutureObj_clear(fut);
|
|
Py_TYPE(fut)->tp_free(fut);
|
|
}
|
|
|
|
|
|
/*********************** Future Iterator **************************/
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
FutureObj *future;
|
|
} futureiterobject;
|
|
|
|
|
|
#define FI_FREELIST_MAXLEN 255
|
|
static futureiterobject *fi_freelist = NULL;
|
|
static Py_ssize_t fi_freelist_len = 0;
|
|
|
|
|
|
static void
|
|
FutureIter_dealloc(futureiterobject *it)
|
|
{
|
|
PyObject_GC_UnTrack(it);
|
|
Py_CLEAR(it->future);
|
|
|
|
if (fi_freelist_len < FI_FREELIST_MAXLEN) {
|
|
fi_freelist_len++;
|
|
it->future = (FutureObj*) fi_freelist;
|
|
fi_freelist = it;
|
|
}
|
|
else {
|
|
PyObject_GC_Del(it);
|
|
}
|
|
}
|
|
|
|
static PySendResult
|
|
FutureIter_am_send(futureiterobject *it,
|
|
PyObject *Py_UNUSED(arg),
|
|
PyObject **result)
|
|
{
|
|
/* arg is unused, see the comment on FutureIter_send for clarification */
|
|
|
|
PyObject *res;
|
|
FutureObj *fut = it->future;
|
|
|
|
*result = NULL;
|
|
if (fut == NULL) {
|
|
return PYGEN_ERROR;
|
|
}
|
|
|
|
if (fut->fut_state == STATE_PENDING) {
|
|
if (!fut->fut_blocking) {
|
|
fut->fut_blocking = 1;
|
|
Py_INCREF(fut);
|
|
*result = (PyObject *)fut;
|
|
return PYGEN_NEXT;
|
|
}
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"await wasn't used with future");
|
|
return PYGEN_ERROR;
|
|
}
|
|
|
|
it->future = NULL;
|
|
res = _asyncio_Future_result_impl(fut);
|
|
if (res != NULL) {
|
|
Py_DECREF(fut);
|
|
*result = res;
|
|
return PYGEN_RETURN;
|
|
}
|
|
|
|
Py_DECREF(fut);
|
|
return PYGEN_ERROR;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureIter_iternext(futureiterobject *it)
|
|
{
|
|
PyObject *result;
|
|
switch (FutureIter_am_send(it, Py_None, &result)) {
|
|
case PYGEN_RETURN:
|
|
(void)_PyGen_SetStopIterationValue(result);
|
|
Py_DECREF(result);
|
|
return NULL;
|
|
case PYGEN_NEXT:
|
|
return result;
|
|
case PYGEN_ERROR:
|
|
return NULL;
|
|
default:
|
|
Py_UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
static PyObject *
|
|
FutureIter_send(futureiterobject *self, PyObject *unused)
|
|
{
|
|
/* Future.__iter__ doesn't care about values that are pushed to the
|
|
* generator, it just returns self.result().
|
|
*/
|
|
return FutureIter_iternext(self);
|
|
}
|
|
|
|
static PyObject *
|
|
FutureIter_throw(futureiterobject *self, PyObject *args)
|
|
{
|
|
PyObject *type, *val = NULL, *tb = NULL;
|
|
if (!PyArg_ParseTuple(args, "O|OO", &type, &val, &tb))
|
|
return NULL;
|
|
|
|
if (val == Py_None) {
|
|
val = NULL;
|
|
}
|
|
if (tb == Py_None) {
|
|
tb = NULL;
|
|
} else if (tb != NULL && !PyTraceBack_Check(tb)) {
|
|
PyErr_SetString(PyExc_TypeError, "throw() third argument must be a traceback");
|
|
return NULL;
|
|
}
|
|
|
|
Py_INCREF(type);
|
|
Py_XINCREF(val);
|
|
Py_XINCREF(tb);
|
|
|
|
if (PyExceptionClass_Check(type)) {
|
|
PyErr_NormalizeException(&type, &val, &tb);
|
|
/* No need to call PyException_SetTraceback since we'll be calling
|
|
PyErr_Restore for `type`, `val`, and `tb`. */
|
|
} else if (PyExceptionInstance_Check(type)) {
|
|
if (val) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"instance exception may not have a separate value");
|
|
goto fail;
|
|
}
|
|
val = type;
|
|
type = PyExceptionInstance_Class(type);
|
|
Py_INCREF(type);
|
|
if (tb == NULL)
|
|
tb = PyException_GetTraceback(val);
|
|
} else {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"exceptions must be classes deriving BaseException or "
|
|
"instances of such a class");
|
|
goto fail;
|
|
}
|
|
|
|
Py_CLEAR(self->future);
|
|
|
|
PyErr_Restore(type, val, tb);
|
|
|
|
return NULL;
|
|
|
|
fail:
|
|
Py_DECREF(type);
|
|
Py_XDECREF(val);
|
|
Py_XDECREF(tb);
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *
|
|
FutureIter_close(futureiterobject *self, PyObject *arg)
|
|
{
|
|
Py_CLEAR(self->future);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static int
|
|
FutureIter_traverse(futureiterobject *it, visitproc visit, void *arg)
|
|
{
|
|
Py_VISIT(it->future);
|
|
return 0;
|
|
}
|
|
|
|
static PyMethodDef FutureIter_methods[] = {
|
|
{"send", (PyCFunction)FutureIter_send, METH_O, NULL},
|
|
{"throw", (PyCFunction)FutureIter_throw, METH_VARARGS, NULL},
|
|
{"close", (PyCFunction)FutureIter_close, METH_NOARGS, NULL},
|
|
{NULL, NULL} /* Sentinel */
|
|
};
|
|
|
|
static PyAsyncMethods FutureIterType_as_async = {
|
|
0, /* am_await */
|
|
0, /* am_aiter */
|
|
0, /* am_anext */
|
|
(sendfunc)FutureIter_am_send, /* am_send */
|
|
};
|
|
|
|
|
|
static PyTypeObject FutureIterType = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"_asyncio.FutureIter",
|
|
.tp_basicsize = sizeof(futureiterobject),
|
|
.tp_itemsize = 0,
|
|
.tp_dealloc = (destructor)FutureIter_dealloc,
|
|
.tp_as_async = &FutureIterType_as_async,
|
|
.tp_getattro = PyObject_GenericGetAttr,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
|
|
Py_TPFLAGS_HAVE_AM_SEND,
|
|
.tp_traverse = (traverseproc)FutureIter_traverse,
|
|
.tp_iter = PyObject_SelfIter,
|
|
.tp_iternext = (iternextfunc)FutureIter_iternext,
|
|
.tp_methods = FutureIter_methods,
|
|
};
|
|
|
|
static PyObject *
|
|
future_new_iter(PyObject *fut)
|
|
{
|
|
futureiterobject *it;
|
|
|
|
if (!PyObject_TypeCheck(fut, &FutureType)) {
|
|
PyErr_BadInternalCall();
|
|
return NULL;
|
|
}
|
|
|
|
ENSURE_FUTURE_ALIVE(fut)
|
|
|
|
if (fi_freelist_len) {
|
|
fi_freelist_len--;
|
|
it = fi_freelist;
|
|
fi_freelist = (futureiterobject*) it->future;
|
|
it->future = NULL;
|
|
_Py_NewReference((PyObject*) it);
|
|
}
|
|
else {
|
|
it = PyObject_GC_New(futureiterobject, &FutureIterType);
|
|
if (it == NULL) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
Py_INCREF(fut);
|
|
it->future = (FutureObj*)fut;
|
|
PyObject_GC_Track(it);
|
|
return (PyObject*)it;
|
|
}
|
|
|
|
|
|
/*********************** Task **************************/
|
|
|
|
|
|
/*[clinic input]
|
|
class _asyncio.Task "TaskObj *" "&Task_Type"
|
|
[clinic start generated code]*/
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=719dcef0fcc03b37]*/
|
|
|
|
static int task_call_step_soon(TaskObj *, PyObject *);
|
|
static PyObject * task_wakeup(TaskObj *, PyObject *);
|
|
static PyObject * task_step(TaskObj *, PyObject *);
|
|
|
|
/* ----- Task._step wrapper */
|
|
|
|
static int
|
|
TaskStepMethWrapper_clear(TaskStepMethWrapper *o)
|
|
{
|
|
Py_CLEAR(o->sw_task);
|
|
Py_CLEAR(o->sw_arg);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
TaskStepMethWrapper_dealloc(TaskStepMethWrapper *o)
|
|
{
|
|
PyObject_GC_UnTrack(o);
|
|
(void)TaskStepMethWrapper_clear(o);
|
|
Py_TYPE(o)->tp_free(o);
|
|
}
|
|
|
|
static PyObject *
|
|
TaskStepMethWrapper_call(TaskStepMethWrapper *o,
|
|
PyObject *args, PyObject *kwds)
|
|
{
|
|
if (kwds != NULL && PyDict_GET_SIZE(kwds) != 0) {
|
|
PyErr_SetString(PyExc_TypeError, "function takes no keyword arguments");
|
|
return NULL;
|
|
}
|
|
if (args != NULL && PyTuple_GET_SIZE(args) != 0) {
|
|
PyErr_SetString(PyExc_TypeError, "function takes no positional arguments");
|
|
return NULL;
|
|
}
|
|
return task_step(o->sw_task, o->sw_arg);
|
|
}
|
|
|
|
static int
|
|
TaskStepMethWrapper_traverse(TaskStepMethWrapper *o,
|
|
visitproc visit, void *arg)
|
|
{
|
|
Py_VISIT(o->sw_task);
|
|
Py_VISIT(o->sw_arg);
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
TaskStepMethWrapper_get___self__(TaskStepMethWrapper *o, void *Py_UNUSED(ignored))
|
|
{
|
|
if (o->sw_task) {
|
|
Py_INCREF(o->sw_task);
|
|
return (PyObject*)o->sw_task;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyGetSetDef TaskStepMethWrapper_getsetlist[] = {
|
|
{"__self__", (getter)TaskStepMethWrapper_get___self__, NULL, NULL},
|
|
{NULL} /* Sentinel */
|
|
};
|
|
|
|
static PyTypeObject TaskStepMethWrapper_Type = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"TaskStepMethWrapper",
|
|
.tp_basicsize = sizeof(TaskStepMethWrapper),
|
|
.tp_itemsize = 0,
|
|
.tp_getset = TaskStepMethWrapper_getsetlist,
|
|
.tp_dealloc = (destructor)TaskStepMethWrapper_dealloc,
|
|
.tp_call = (ternaryfunc)TaskStepMethWrapper_call,
|
|
.tp_getattro = PyObject_GenericGetAttr,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
|
|
.tp_traverse = (traverseproc)TaskStepMethWrapper_traverse,
|
|
.tp_clear = (inquiry)TaskStepMethWrapper_clear,
|
|
};
|
|
|
|
static PyObject *
|
|
TaskStepMethWrapper_new(TaskObj *task, PyObject *arg)
|
|
{
|
|
TaskStepMethWrapper *o;
|
|
o = PyObject_GC_New(TaskStepMethWrapper, &TaskStepMethWrapper_Type);
|
|
if (o == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
Py_INCREF(task);
|
|
o->sw_task = task;
|
|
|
|
Py_XINCREF(arg);
|
|
o->sw_arg = arg;
|
|
|
|
PyObject_GC_Track(o);
|
|
return (PyObject*) o;
|
|
}
|
|
|
|
/* ----- Task._wakeup implementation */
|
|
|
|
static PyMethodDef TaskWakeupDef = {
|
|
"task_wakeup",
|
|
(PyCFunction)task_wakeup,
|
|
METH_O,
|
|
NULL
|
|
};
|
|
|
|
/* ----- Task introspection helpers */
|
|
|
|
static int
|
|
register_task(PyObject *task)
|
|
{
|
|
_Py_IDENTIFIER(add);
|
|
|
|
PyObject *res = _PyObject_CallMethodIdOneArg(all_tasks,
|
|
&PyId_add, task);
|
|
if (res == NULL) {
|
|
return -1;
|
|
}
|
|
Py_DECREF(res);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
unregister_task(PyObject *task)
|
|
{
|
|
_Py_IDENTIFIER(discard);
|
|
|
|
PyObject *res = _PyObject_CallMethodIdOneArg(all_tasks,
|
|
&PyId_discard, task);
|
|
if (res == NULL) {
|
|
return -1;
|
|
}
|
|
Py_DECREF(res);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
enter_task(PyObject *loop, PyObject *task)
|
|
{
|
|
PyObject *item;
|
|
Py_hash_t hash;
|
|
hash = PyObject_Hash(loop);
|
|
if (hash == -1) {
|
|
return -1;
|
|
}
|
|
item = _PyDict_GetItem_KnownHash(current_tasks, loop, hash);
|
|
if (item != NULL) {
|
|
Py_INCREF(item);
|
|
PyErr_Format(
|
|
PyExc_RuntimeError,
|
|
"Cannot enter into task %R while another " \
|
|
"task %R is being executed.",
|
|
task, item, NULL);
|
|
Py_DECREF(item);
|
|
return -1;
|
|
}
|
|
if (PyErr_Occurred()) {
|
|
return -1;
|
|
}
|
|
return _PyDict_SetItem_KnownHash(current_tasks, loop, task, hash);
|
|
}
|
|
|
|
|
|
static int
|
|
leave_task(PyObject *loop, PyObject *task)
|
|
/*[clinic end generated code: output=0ebf6db4b858fb41 input=51296a46313d1ad8]*/
|
|
{
|
|
PyObject *item;
|
|
Py_hash_t hash;
|
|
hash = PyObject_Hash(loop);
|
|
if (hash == -1) {
|
|
return -1;
|
|
}
|
|
item = _PyDict_GetItem_KnownHash(current_tasks, loop, hash);
|
|
if (item != task) {
|
|
if (item == NULL) {
|
|
/* Not entered, replace with None */
|
|
item = Py_None;
|
|
}
|
|
PyErr_Format(
|
|
PyExc_RuntimeError,
|
|
"Leaving task %R does not match the current task %R.",
|
|
task, item, NULL);
|
|
return -1;
|
|
}
|
|
return _PyDict_DelItem_KnownHash(current_tasks, loop, hash);
|
|
}
|
|
|
|
/* ----- Task */
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.__init__
|
|
|
|
coro: object
|
|
*
|
|
loop: object = None
|
|
name: object = None
|
|
|
|
A coroutine wrapped in a Future.
|
|
[clinic start generated code]*/
|
|
|
|
static int
|
|
_asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop,
|
|
PyObject *name)
|
|
/*[clinic end generated code: output=88b12b83d570df50 input=352a3137fe60091d]*/
|
|
{
|
|
if (future_init((FutureObj*)self, loop)) {
|
|
return -1;
|
|
}
|
|
|
|
int is_coro = is_coroutine(coro);
|
|
if (is_coro == -1) {
|
|
return -1;
|
|
}
|
|
if (is_coro == 0) {
|
|
self->task_log_destroy_pending = 0;
|
|
PyErr_Format(PyExc_TypeError,
|
|
"a coroutine was expected, got %R",
|
|
coro, NULL);
|
|
return -1;
|
|
}
|
|
|
|
Py_XSETREF(self->task_context, PyContext_CopyCurrent());
|
|
if (self->task_context == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
Py_CLEAR(self->task_fut_waiter);
|
|
self->task_must_cancel = 0;
|
|
self->task_log_destroy_pending = 1;
|
|
Py_INCREF(coro);
|
|
Py_XSETREF(self->task_coro, coro);
|
|
|
|
if (name == Py_None) {
|
|
name = PyUnicode_FromFormat("Task-%" PRIu64, ++task_name_counter);
|
|
} else if (!PyUnicode_CheckExact(name)) {
|
|
name = PyObject_Str(name);
|
|
} else {
|
|
Py_INCREF(name);
|
|
}
|
|
Py_XSETREF(self->task_name, name);
|
|
if (self->task_name == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
if (task_call_step_soon(self, NULL)) {
|
|
return -1;
|
|
}
|
|
return register_task((PyObject*)self);
|
|
}
|
|
|
|
static int
|
|
TaskObj_clear(TaskObj *task)
|
|
{
|
|
(void)FutureObj_clear((FutureObj*) task);
|
|
Py_CLEAR(task->task_context);
|
|
Py_CLEAR(task->task_coro);
|
|
Py_CLEAR(task->task_name);
|
|
Py_CLEAR(task->task_fut_waiter);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
TaskObj_traverse(TaskObj *task, visitproc visit, void *arg)
|
|
{
|
|
Py_VISIT(task->task_context);
|
|
Py_VISIT(task->task_coro);
|
|
Py_VISIT(task->task_name);
|
|
Py_VISIT(task->task_fut_waiter);
|
|
(void)FutureObj_traverse((FutureObj*) task, visit, arg);
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
TaskObj_get_log_destroy_pending(TaskObj *task, void *Py_UNUSED(ignored))
|
|
{
|
|
if (task->task_log_destroy_pending) {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
else {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
static int
|
|
TaskObj_set_log_destroy_pending(TaskObj *task, PyObject *val, void *Py_UNUSED(ignored))
|
|
{
|
|
if (val == NULL) {
|
|
PyErr_SetString(PyExc_AttributeError, "cannot delete attribute");
|
|
return -1;
|
|
}
|
|
int is_true = PyObject_IsTrue(val);
|
|
if (is_true < 0) {
|
|
return -1;
|
|
}
|
|
task->task_log_destroy_pending = is_true;
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
TaskObj_get_must_cancel(TaskObj *task, void *Py_UNUSED(ignored))
|
|
{
|
|
if (task->task_must_cancel) {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
else {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
}
|
|
|
|
static PyObject *
|
|
TaskObj_get_coro(TaskObj *task, void *Py_UNUSED(ignored))
|
|
{
|
|
if (task->task_coro) {
|
|
Py_INCREF(task->task_coro);
|
|
return task->task_coro;
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
TaskObj_get_fut_waiter(TaskObj *task, void *Py_UNUSED(ignored))
|
|
{
|
|
if (task->task_fut_waiter) {
|
|
Py_INCREF(task->task_fut_waiter);
|
|
return task->task_fut_waiter;
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task._make_cancelled_error
|
|
|
|
Create the CancelledError to raise if the Task is cancelled.
|
|
|
|
This should only be called once when handling a cancellation since
|
|
it erases the context exception value.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task__make_cancelled_error_impl(TaskObj *self)
|
|
/*[clinic end generated code: output=55a819e8b4276fab input=52c0e32de8e2f840]*/
|
|
{
|
|
FutureObj *fut = (FutureObj*)self;
|
|
return _asyncio_Future__make_cancelled_error_impl(fut);
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task._repr_info
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task__repr_info_impl(TaskObj *self)
|
|
/*[clinic end generated code: output=6a490eb66d5ba34b input=3c6d051ed3ddec8b]*/
|
|
{
|
|
return PyObject_CallOneArg(asyncio_task_repr_info_func, (PyObject *)self);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.cancel
|
|
|
|
msg: object = None
|
|
|
|
Request that this task cancel itself.
|
|
|
|
This arranges for a CancelledError to be thrown into the
|
|
wrapped coroutine on the next cycle through the event loop.
|
|
The coroutine then has a chance to clean up or even deny
|
|
the request using try/except/finally.
|
|
|
|
Unlike Future.cancel, this does not guarantee that the
|
|
task will be cancelled: the exception might be caught and
|
|
acted upon, delaying cancellation of the task or preventing
|
|
cancellation completely. The task may also return a value or
|
|
raise a different exception.
|
|
|
|
Immediately after this method is called, Task.cancelled() will
|
|
not return True (unless the task was already cancelled). A
|
|
task will be marked as cancelled when the wrapped coroutine
|
|
terminates with a CancelledError exception (even if cancel()
|
|
was not called).
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_cancel_impl(TaskObj *self, PyObject *msg)
|
|
/*[clinic end generated code: output=c66b60d41c74f9f1 input=f4ff8e8ffc5f1c00]*/
|
|
{
|
|
self->task_log_tb = 0;
|
|
|
|
if (self->task_state != STATE_PENDING) {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
if (self->task_fut_waiter) {
|
|
PyObject *res;
|
|
int is_true;
|
|
|
|
res = _PyObject_CallMethodIdOneArg(self->task_fut_waiter,
|
|
&PyId_cancel, msg);
|
|
if (res == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
is_true = PyObject_IsTrue(res);
|
|
Py_DECREF(res);
|
|
if (is_true < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
if (is_true) {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
}
|
|
|
|
self->task_must_cancel = 1;
|
|
Py_XINCREF(msg);
|
|
Py_XSETREF(self->task_cancel_msg, msg);
|
|
Py_RETURN_TRUE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.get_stack
|
|
|
|
*
|
|
limit: object = None
|
|
|
|
Return the list of stack frames for this task's coroutine.
|
|
|
|
If the coroutine is not done, this returns the stack where it is
|
|
suspended. If the coroutine has completed successfully or was
|
|
cancelled, this returns an empty list. If the coroutine was
|
|
terminated by an exception, this returns the list of traceback
|
|
frames.
|
|
|
|
The frames are always ordered from oldest to newest.
|
|
|
|
The optional limit gives the maximum number of frames to
|
|
return; by default all available frames are returned. Its
|
|
meaning differs depending on whether a stack or a traceback is
|
|
returned: the newest frames of a stack are returned, but the
|
|
oldest frames of a traceback are returned. (This matches the
|
|
behavior of the traceback module.)
|
|
|
|
For reasons beyond our control, only one stack frame is
|
|
returned for a suspended coroutine.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_get_stack_impl(TaskObj *self, PyObject *limit)
|
|
/*[clinic end generated code: output=c9aeeeebd1e18118 input=05b323d42b809b90]*/
|
|
{
|
|
return PyObject_CallFunctionObjArgs(
|
|
asyncio_task_get_stack_func, self, limit, NULL);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.print_stack
|
|
|
|
*
|
|
limit: object = None
|
|
file: object = None
|
|
|
|
Print the stack or traceback for this task's coroutine.
|
|
|
|
This produces output similar to that of the traceback module,
|
|
for the frames retrieved by get_stack(). The limit argument
|
|
is passed to get_stack(). The file argument is an I/O stream
|
|
to which the output is written; by default output is written
|
|
to sys.stderr.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_print_stack_impl(TaskObj *self, PyObject *limit,
|
|
PyObject *file)
|
|
/*[clinic end generated code: output=7339e10314cd3f4d input=1a0352913b7fcd92]*/
|
|
{
|
|
return PyObject_CallFunctionObjArgs(
|
|
asyncio_task_print_stack_func, self, limit, file, NULL);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.set_result
|
|
|
|
result: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_set_result(TaskObj *self, PyObject *result)
|
|
/*[clinic end generated code: output=1dcae308bfcba318 input=9d1a00c07be41bab]*/
|
|
{
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"Task does not support set_result operation");
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.set_exception
|
|
|
|
exception: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_set_exception(TaskObj *self, PyObject *exception)
|
|
/*[clinic end generated code: output=bc377fc28067303d input=9a8f65c83dcf893a]*/
|
|
{
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"Task does not support set_exception operation");
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.get_coro
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_get_coro_impl(TaskObj *self)
|
|
/*[clinic end generated code: output=bcac27c8cc6c8073 input=d2e8606c42a7b403]*/
|
|
{
|
|
Py_INCREF(self->task_coro);
|
|
return self->task_coro;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.get_name
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_get_name_impl(TaskObj *self)
|
|
/*[clinic end generated code: output=0ecf1570c3b37a8f input=a4a6595d12f4f0f8]*/
|
|
{
|
|
if (self->task_name) {
|
|
Py_INCREF(self->task_name);
|
|
return self->task_name;
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.Task.set_name
|
|
|
|
value: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_Task_set_name(TaskObj *self, PyObject *value)
|
|
/*[clinic end generated code: output=138a8d51e32057d6 input=a8359b6e65f8fd31]*/
|
|
{
|
|
if (!PyUnicode_CheckExact(value)) {
|
|
value = PyObject_Str(value);
|
|
if (value == NULL) {
|
|
return NULL;
|
|
}
|
|
} else {
|
|
Py_INCREF(value);
|
|
}
|
|
|
|
Py_XSETREF(self->task_name, value);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static void
|
|
TaskObj_finalize(TaskObj *task)
|
|
{
|
|
_Py_IDENTIFIER(call_exception_handler);
|
|
_Py_IDENTIFIER(task);
|
|
_Py_IDENTIFIER(message);
|
|
_Py_IDENTIFIER(source_traceback);
|
|
|
|
PyObject *context;
|
|
PyObject *message = NULL;
|
|
PyObject *func;
|
|
PyObject *error_type, *error_value, *error_traceback;
|
|
|
|
if (task->task_state != STATE_PENDING || !task->task_log_destroy_pending) {
|
|
goto done;
|
|
}
|
|
|
|
/* Save the current exception, if any. */
|
|
PyErr_Fetch(&error_type, &error_value, &error_traceback);
|
|
|
|
context = PyDict_New();
|
|
if (context == NULL) {
|
|
goto finally;
|
|
}
|
|
|
|
message = PyUnicode_FromString("Task was destroyed but it is pending!");
|
|
if (message == NULL) {
|
|
goto finally;
|
|
}
|
|
|
|
if (_PyDict_SetItemId(context, &PyId_message, message) < 0 ||
|
|
_PyDict_SetItemId(context, &PyId_task, (PyObject*)task) < 0)
|
|
{
|
|
goto finally;
|
|
}
|
|
|
|
if (task->task_source_tb != NULL) {
|
|
if (_PyDict_SetItemId(context, &PyId_source_traceback,
|
|
task->task_source_tb) < 0)
|
|
{
|
|
goto finally;
|
|
}
|
|
}
|
|
|
|
func = _PyObject_GetAttrId(task->task_loop, &PyId_call_exception_handler);
|
|
if (func != NULL) {
|
|
PyObject *res = PyObject_CallOneArg(func, context);
|
|
if (res == NULL) {
|
|
PyErr_WriteUnraisable(func);
|
|
}
|
|
else {
|
|
Py_DECREF(res);
|
|
}
|
|
Py_DECREF(func);
|
|
}
|
|
|
|
finally:
|
|
Py_XDECREF(context);
|
|
Py_XDECREF(message);
|
|
|
|
/* Restore the saved exception. */
|
|
PyErr_Restore(error_type, error_value, error_traceback);
|
|
|
|
done:
|
|
FutureObj_finalize((FutureObj*)task);
|
|
}
|
|
|
|
static PyObject *
|
|
task_cls_getitem(PyObject *cls, PyObject *type)
|
|
{
|
|
Py_INCREF(cls);
|
|
return cls;
|
|
}
|
|
|
|
static void TaskObj_dealloc(PyObject *); /* Needs Task_CheckExact */
|
|
|
|
static PyMethodDef TaskType_methods[] = {
|
|
_ASYNCIO_FUTURE_RESULT_METHODDEF
|
|
_ASYNCIO_FUTURE_EXCEPTION_METHODDEF
|
|
_ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF
|
|
_ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF
|
|
_ASYNCIO_FUTURE_CANCELLED_METHODDEF
|
|
_ASYNCIO_FUTURE_DONE_METHODDEF
|
|
_ASYNCIO_TASK_SET_RESULT_METHODDEF
|
|
_ASYNCIO_TASK_SET_EXCEPTION_METHODDEF
|
|
_ASYNCIO_TASK_CANCEL_METHODDEF
|
|
_ASYNCIO_TASK_GET_STACK_METHODDEF
|
|
_ASYNCIO_TASK_PRINT_STACK_METHODDEF
|
|
_ASYNCIO_TASK__MAKE_CANCELLED_ERROR_METHODDEF
|
|
_ASYNCIO_TASK__REPR_INFO_METHODDEF
|
|
_ASYNCIO_TASK_GET_NAME_METHODDEF
|
|
_ASYNCIO_TASK_SET_NAME_METHODDEF
|
|
_ASYNCIO_TASK_GET_CORO_METHODDEF
|
|
{"__class_getitem__", task_cls_getitem, METH_O|METH_CLASS, NULL},
|
|
{NULL, NULL} /* Sentinel */
|
|
};
|
|
|
|
static PyGetSetDef TaskType_getsetlist[] = {
|
|
FUTURE_COMMON_GETSETLIST
|
|
{"_log_destroy_pending", (getter)TaskObj_get_log_destroy_pending,
|
|
(setter)TaskObj_set_log_destroy_pending, NULL},
|
|
{"_must_cancel", (getter)TaskObj_get_must_cancel, NULL, NULL},
|
|
{"_coro", (getter)TaskObj_get_coro, NULL, NULL},
|
|
{"_fut_waiter", (getter)TaskObj_get_fut_waiter, NULL, NULL},
|
|
{NULL} /* Sentinel */
|
|
};
|
|
|
|
static PyTypeObject TaskType = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"_asyncio.Task",
|
|
sizeof(TaskObj), /* tp_basicsize */
|
|
.tp_base = &FutureType,
|
|
.tp_dealloc = TaskObj_dealloc,
|
|
.tp_as_async = &FutureType_as_async,
|
|
.tp_repr = (reprfunc)FutureObj_repr,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
|
|
.tp_doc = _asyncio_Task___init____doc__,
|
|
.tp_traverse = (traverseproc)TaskObj_traverse,
|
|
.tp_clear = (inquiry)TaskObj_clear,
|
|
.tp_weaklistoffset = offsetof(TaskObj, task_weakreflist),
|
|
.tp_iter = (getiterfunc)future_new_iter,
|
|
.tp_methods = TaskType_methods,
|
|
.tp_getset = TaskType_getsetlist,
|
|
.tp_dictoffset = offsetof(TaskObj, dict),
|
|
.tp_init = (initproc)_asyncio_Task___init__,
|
|
.tp_new = PyType_GenericNew,
|
|
.tp_finalize = (destructor)TaskObj_finalize,
|
|
};
|
|
|
|
static void
|
|
TaskObj_dealloc(PyObject *self)
|
|
{
|
|
TaskObj *task = (TaskObj *)self;
|
|
|
|
if (Task_CheckExact(self)) {
|
|
/* When fut is subclass of Task, finalizer is called from
|
|
* subtype_dealloc.
|
|
*/
|
|
if (PyObject_CallFinalizerFromDealloc(self) < 0) {
|
|
// resurrected.
|
|
return;
|
|
}
|
|
}
|
|
|
|
PyObject_GC_UnTrack(self);
|
|
|
|
if (task->task_weakreflist != NULL) {
|
|
PyObject_ClearWeakRefs(self);
|
|
}
|
|
|
|
(void)TaskObj_clear(task);
|
|
Py_TYPE(task)->tp_free(task);
|
|
}
|
|
|
|
static int
|
|
task_call_step_soon(TaskObj *task, PyObject *arg)
|
|
{
|
|
PyObject *cb = TaskStepMethWrapper_new(task, arg);
|
|
if (cb == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
int ret = call_soon(task->task_loop, cb, NULL, task->task_context);
|
|
Py_DECREF(cb);
|
|
return ret;
|
|
}
|
|
|
|
static PyObject *
|
|
task_set_error_soon(TaskObj *task, PyObject *et, const char *format, ...)
|
|
{
|
|
PyObject* msg;
|
|
|
|
va_list vargs;
|
|
#ifdef HAVE_STDARG_PROTOTYPES
|
|
va_start(vargs, format);
|
|
#else
|
|
va_start(vargs);
|
|
#endif
|
|
msg = PyUnicode_FromFormatV(format, vargs);
|
|
va_end(vargs);
|
|
|
|
if (msg == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *e = PyObject_CallOneArg(et, msg);
|
|
Py_DECREF(msg);
|
|
if (e == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (task_call_step_soon(task, e) == -1) {
|
|
Py_DECREF(e);
|
|
return NULL;
|
|
}
|
|
|
|
Py_DECREF(e);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static inline int
|
|
gen_status_from_result(PyObject **result)
|
|
{
|
|
if (*result != NULL) {
|
|
return PYGEN_NEXT;
|
|
}
|
|
if (_PyGen_FetchStopIterationValue(result) == 0) {
|
|
return PYGEN_RETURN;
|
|
}
|
|
|
|
assert(PyErr_Occurred());
|
|
return PYGEN_ERROR;
|
|
}
|
|
|
|
static PyObject *
|
|
task_step_impl(TaskObj *task, PyObject *exc)
|
|
{
|
|
int res;
|
|
int clear_exc = 0;
|
|
PyObject *result = NULL;
|
|
PyObject *coro;
|
|
PyObject *o;
|
|
|
|
if (task->task_state != STATE_PENDING) {
|
|
PyErr_Format(asyncio_InvalidStateError,
|
|
"_step(): already done: %R %R",
|
|
task,
|
|
exc ? exc : Py_None);
|
|
goto fail;
|
|
}
|
|
|
|
if (task->task_must_cancel) {
|
|
assert(exc != Py_None);
|
|
|
|
if (exc) {
|
|
/* Check if exc is a CancelledError */
|
|
res = PyObject_IsInstance(exc, asyncio_CancelledError);
|
|
if (res == -1) {
|
|
/* An error occurred, abort */
|
|
goto fail;
|
|
}
|
|
if (res == 0) {
|
|
/* exc is not CancelledError; reset it to NULL */
|
|
exc = NULL;
|
|
}
|
|
}
|
|
|
|
if (!exc) {
|
|
/* exc was not a CancelledError */
|
|
exc = create_cancelled_error(task->task_cancel_msg);
|
|
|
|
if (!exc) {
|
|
goto fail;
|
|
}
|
|
clear_exc = 1;
|
|
}
|
|
|
|
task->task_must_cancel = 0;
|
|
}
|
|
|
|
Py_CLEAR(task->task_fut_waiter);
|
|
|
|
coro = task->task_coro;
|
|
if (coro == NULL) {
|
|
PyErr_SetString(PyExc_RuntimeError, "uninitialized Task object");
|
|
if (clear_exc) {
|
|
/* We created 'exc' during this call */
|
|
Py_DECREF(exc);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int gen_status = PYGEN_ERROR;
|
|
if (exc == NULL) {
|
|
gen_status = PyIter_Send(coro, Py_None, &result);
|
|
}
|
|
else {
|
|
result = _PyObject_CallMethodIdOneArg(coro, &PyId_throw, exc);
|
|
gen_status = gen_status_from_result(&result);
|
|
if (clear_exc) {
|
|
/* We created 'exc' during this call */
|
|
Py_DECREF(exc);
|
|
}
|
|
}
|
|
|
|
if (gen_status == PYGEN_RETURN || gen_status == PYGEN_ERROR) {
|
|
PyObject *et, *ev, *tb;
|
|
|
|
if (result != NULL) {
|
|
/* The error is StopIteration and that means that
|
|
the underlying coroutine has resolved */
|
|
|
|
PyObject *res;
|
|
if (task->task_must_cancel) {
|
|
// Task is cancelled right before coro stops.
|
|
task->task_must_cancel = 0;
|
|
res = future_cancel((FutureObj*)task, task->task_cancel_msg);
|
|
}
|
|
else {
|
|
res = future_set_result((FutureObj*)task, result);
|
|
}
|
|
|
|
Py_DECREF(result);
|
|
|
|
if (res == NULL) {
|
|
return NULL;
|
|
}
|
|
Py_DECREF(res);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
if (PyErr_ExceptionMatches(asyncio_CancelledError)) {
|
|
/* CancelledError */
|
|
PyErr_Fetch(&et, &ev, &tb);
|
|
|
|
FutureObj *fut = (FutureObj*)task;
|
|
_PyErr_StackItem *exc_state = &fut->fut_cancelled_exc_state;
|
|
exc_state->exc_type = et;
|
|
exc_state->exc_value = ev;
|
|
exc_state->exc_traceback = tb;
|
|
|
|
return future_cancel(fut, NULL);
|
|
}
|
|
|
|
/* Some other exception; pop it and call Task.set_exception() */
|
|
PyErr_Fetch(&et, &ev, &tb);
|
|
|
|
assert(et);
|
|
if (!ev || !PyObject_TypeCheck(ev, (PyTypeObject *) et)) {
|
|
PyErr_NormalizeException(&et, &ev, &tb);
|
|
}
|
|
if (tb != NULL) {
|
|
PyException_SetTraceback(ev, tb);
|
|
}
|
|
o = future_set_exception((FutureObj*)task, ev);
|
|
if (!o) {
|
|
/* An exception in Task.set_exception() */
|
|
Py_DECREF(et);
|
|
Py_XDECREF(tb);
|
|
Py_XDECREF(ev);
|
|
goto fail;
|
|
}
|
|
assert(o == Py_None);
|
|
Py_DECREF(o);
|
|
|
|
if (PyErr_GivenExceptionMatches(et, PyExc_KeyboardInterrupt) ||
|
|
PyErr_GivenExceptionMatches(et, PyExc_SystemExit))
|
|
{
|
|
/* We've got a KeyboardInterrupt or a SystemError; re-raise it */
|
|
PyErr_Restore(et, ev, tb);
|
|
goto fail;
|
|
}
|
|
|
|
Py_DECREF(et);
|
|
Py_XDECREF(tb);
|
|
Py_XDECREF(ev);
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
if (result == (PyObject*)task) {
|
|
/* We have a task that wants to await on itself */
|
|
goto self_await;
|
|
}
|
|
|
|
/* Check if `result` is FutureObj or TaskObj (and not a subclass) */
|
|
if (Future_CheckExact(result) || Task_CheckExact(result)) {
|
|
PyObject *wrapper;
|
|
PyObject *res;
|
|
FutureObj *fut = (FutureObj*)result;
|
|
|
|
/* Check if `result` future is attached to a different loop */
|
|
if (fut->fut_loop != task->task_loop) {
|
|
goto different_loop;
|
|
}
|
|
|
|
if (!fut->fut_blocking) {
|
|
goto yield_insteadof_yf;
|
|
}
|
|
|
|
fut->fut_blocking = 0;
|
|
|
|
/* result.add_done_callback(task._wakeup) */
|
|
wrapper = PyCFunction_New(&TaskWakeupDef, (PyObject *)task);
|
|
if (wrapper == NULL) {
|
|
goto fail;
|
|
}
|
|
res = future_add_done_callback(
|
|
(FutureObj*)result, wrapper, task->task_context);
|
|
Py_DECREF(wrapper);
|
|
if (res == NULL) {
|
|
goto fail;
|
|
}
|
|
Py_DECREF(res);
|
|
|
|
/* task._fut_waiter = result */
|
|
task->task_fut_waiter = result; /* no incref is necessary */
|
|
|
|
if (task->task_must_cancel) {
|
|
PyObject *r;
|
|
int is_true;
|
|
r = _PyObject_CallMethodIdOneArg(result, &PyId_cancel,
|
|
task->task_cancel_msg);
|
|
if (r == NULL) {
|
|
return NULL;
|
|
}
|
|
is_true = PyObject_IsTrue(r);
|
|
Py_DECREF(r);
|
|
if (is_true < 0) {
|
|
return NULL;
|
|
}
|
|
else if (is_true) {
|
|
task->task_must_cancel = 0;
|
|
}
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/* Check if `result` is None */
|
|
if (result == Py_None) {
|
|
/* Bare yield relinquishes control for one event loop iteration. */
|
|
if (task_call_step_soon(task, NULL)) {
|
|
goto fail;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/* Check if `result` is a Future-compatible object */
|
|
if (_PyObject_LookupAttrId(result, &PyId__asyncio_future_blocking, &o) < 0) {
|
|
goto fail;
|
|
}
|
|
if (o != NULL && o != Py_None) {
|
|
/* `result` is a Future-compatible object */
|
|
PyObject *wrapper;
|
|
PyObject *res;
|
|
|
|
int blocking = PyObject_IsTrue(o);
|
|
Py_DECREF(o);
|
|
if (blocking < 0) {
|
|
goto fail;
|
|
}
|
|
|
|
/* Check if `result` future is attached to a different loop */
|
|
PyObject *oloop = get_future_loop(result);
|
|
if (oloop == NULL) {
|
|
goto fail;
|
|
}
|
|
if (oloop != task->task_loop) {
|
|
Py_DECREF(oloop);
|
|
goto different_loop;
|
|
}
|
|
Py_DECREF(oloop);
|
|
|
|
if (!blocking) {
|
|
goto yield_insteadof_yf;
|
|
}
|
|
|
|
/* result._asyncio_future_blocking = False */
|
|
if (_PyObject_SetAttrId(
|
|
result, &PyId__asyncio_future_blocking, Py_False) == -1) {
|
|
goto fail;
|
|
}
|
|
|
|
wrapper = PyCFunction_New(&TaskWakeupDef, (PyObject *)task);
|
|
if (wrapper == NULL) {
|
|
goto fail;
|
|
}
|
|
|
|
/* result.add_done_callback(task._wakeup) */
|
|
PyObject *add_cb = _PyObject_GetAttrId(
|
|
result, &PyId_add_done_callback);
|
|
if (add_cb == NULL) {
|
|
Py_DECREF(wrapper);
|
|
goto fail;
|
|
}
|
|
PyObject *stack[2];
|
|
stack[0] = wrapper;
|
|
stack[1] = (PyObject *)task->task_context;
|
|
res = PyObject_Vectorcall(add_cb, stack, 1, context_kwname);
|
|
Py_DECREF(add_cb);
|
|
Py_DECREF(wrapper);
|
|
if (res == NULL) {
|
|
goto fail;
|
|
}
|
|
Py_DECREF(res);
|
|
|
|
/* task._fut_waiter = result */
|
|
task->task_fut_waiter = result; /* no incref is necessary */
|
|
|
|
if (task->task_must_cancel) {
|
|
PyObject *r;
|
|
int is_true;
|
|
r = _PyObject_CallMethodIdOneArg(result, &PyId_cancel,
|
|
task->task_cancel_msg);
|
|
if (r == NULL) {
|
|
return NULL;
|
|
}
|
|
is_true = PyObject_IsTrue(r);
|
|
Py_DECREF(r);
|
|
if (is_true < 0) {
|
|
return NULL;
|
|
}
|
|
else if (is_true) {
|
|
task->task_must_cancel = 0;
|
|
}
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
Py_XDECREF(o);
|
|
/* Check if `result` is a generator */
|
|
res = PyObject_IsInstance(result, (PyObject*)&PyGen_Type);
|
|
if (res < 0) {
|
|
goto fail;
|
|
}
|
|
if (res) {
|
|
/* `result` is a generator */
|
|
o = task_set_error_soon(
|
|
task, PyExc_RuntimeError,
|
|
"yield was used instead of yield from for "
|
|
"generator in task %R with %R", task, result);
|
|
Py_DECREF(result);
|
|
return o;
|
|
}
|
|
|
|
/* The `result` is none of the above */
|
|
o = task_set_error_soon(
|
|
task, PyExc_RuntimeError, "Task got bad yield: %R", result);
|
|
Py_DECREF(result);
|
|
return o;
|
|
|
|
self_await:
|
|
o = task_set_error_soon(
|
|
task, PyExc_RuntimeError,
|
|
"Task cannot await on itself: %R", task);
|
|
Py_DECREF(result);
|
|
return o;
|
|
|
|
yield_insteadof_yf:
|
|
o = task_set_error_soon(
|
|
task, PyExc_RuntimeError,
|
|
"yield was used instead of yield from "
|
|
"in task %R with %R",
|
|
task, result);
|
|
Py_DECREF(result);
|
|
return o;
|
|
|
|
different_loop:
|
|
o = task_set_error_soon(
|
|
task, PyExc_RuntimeError,
|
|
"Task %R got Future %R attached to a different loop",
|
|
task, result);
|
|
Py_DECREF(result);
|
|
return o;
|
|
|
|
fail:
|
|
Py_XDECREF(result);
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *
|
|
task_step(TaskObj *task, PyObject *exc)
|
|
{
|
|
PyObject *res;
|
|
|
|
if (enter_task(task->task_loop, (PyObject*)task) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
res = task_step_impl(task, exc);
|
|
|
|
if (res == NULL) {
|
|
PyObject *et, *ev, *tb;
|
|
PyErr_Fetch(&et, &ev, &tb);
|
|
leave_task(task->task_loop, (PyObject*)task);
|
|
_PyErr_ChainExceptions(et, ev, tb);
|
|
return NULL;
|
|
}
|
|
else {
|
|
if (leave_task(task->task_loop, (PyObject*)task) < 0) {
|
|
Py_DECREF(res);
|
|
return NULL;
|
|
}
|
|
else {
|
|
return res;
|
|
}
|
|
}
|
|
}
|
|
|
|
static PyObject *
|
|
task_wakeup(TaskObj *task, PyObject *o)
|
|
{
|
|
PyObject *et, *ev, *tb;
|
|
PyObject *result;
|
|
assert(o);
|
|
|
|
if (Future_CheckExact(o) || Task_CheckExact(o)) {
|
|
PyObject *fut_result = NULL;
|
|
int res = future_get_result((FutureObj*)o, &fut_result);
|
|
|
|
switch(res) {
|
|
case -1:
|
|
assert(fut_result == NULL);
|
|
break; /* exception raised */
|
|
case 0:
|
|
Py_DECREF(fut_result);
|
|
return task_step(task, NULL);
|
|
default:
|
|
assert(res == 1);
|
|
result = task_step(task, fut_result);
|
|
Py_DECREF(fut_result);
|
|
return result;
|
|
}
|
|
}
|
|
else {
|
|
PyObject *fut_result = PyObject_CallMethod(o, "result", NULL);
|
|
if (fut_result != NULL) {
|
|
Py_DECREF(fut_result);
|
|
return task_step(task, NULL);
|
|
}
|
|
/* exception raised */
|
|
}
|
|
|
|
PyErr_Fetch(&et, &ev, &tb);
|
|
if (!ev || !PyObject_TypeCheck(ev, (PyTypeObject *) et)) {
|
|
PyErr_NormalizeException(&et, &ev, &tb);
|
|
}
|
|
|
|
result = task_step(task, ev);
|
|
|
|
Py_DECREF(et);
|
|
Py_XDECREF(tb);
|
|
Py_XDECREF(ev);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*********************** Functions **************************/
|
|
|
|
|
|
/*[clinic input]
|
|
_asyncio._get_running_loop
|
|
|
|
Return the running event loop or None.
|
|
|
|
This is a low-level function intended to be used by event loops.
|
|
This function is thread-specific.
|
|
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio__get_running_loop_impl(PyObject *module)
|
|
/*[clinic end generated code: output=b4390af721411a0a input=0a21627e25a4bd43]*/
|
|
{
|
|
PyObject *loop;
|
|
if (get_running_loop(&loop)) {
|
|
return NULL;
|
|
}
|
|
if (loop == NULL) {
|
|
/* There's no currently running event loop */
|
|
Py_RETURN_NONE;
|
|
}
|
|
return loop;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio._set_running_loop
|
|
loop: 'O'
|
|
/
|
|
|
|
Set the running event loop.
|
|
|
|
This is a low-level function intended to be used by event loops.
|
|
This function is thread-specific.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio__set_running_loop(PyObject *module, PyObject *loop)
|
|
/*[clinic end generated code: output=ae56bf7a28ca189a input=4c9720233d606604]*/
|
|
{
|
|
if (set_running_loop(loop)) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.get_event_loop
|
|
|
|
Return an asyncio event loop.
|
|
|
|
When called from a coroutine or a callback (e.g. scheduled with
|
|
call_soon or similar API), this function will always return the
|
|
running event loop.
|
|
|
|
If there is no running event loop set, the function will return
|
|
the result of `get_event_loop_policy().get_event_loop()` call.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_get_event_loop_impl(PyObject *module)
|
|
/*[clinic end generated code: output=2a2d8b2f824c648b input=9364bf2916c8655d]*/
|
|
{
|
|
return get_event_loop();
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio.get_running_loop
|
|
|
|
Return the running event loop. Raise a RuntimeError if there is none.
|
|
|
|
This function is thread-specific.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio_get_running_loop_impl(PyObject *module)
|
|
/*[clinic end generated code: output=c247b5f9e529530e input=2a3bf02ba39f173d]*/
|
|
{
|
|
PyObject *loop;
|
|
if (get_running_loop(&loop)) {
|
|
return NULL;
|
|
}
|
|
if (loop == NULL) {
|
|
/* There's no currently running event loop */
|
|
PyErr_SetString(
|
|
PyExc_RuntimeError, "no running event loop");
|
|
}
|
|
return loop;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_asyncio._register_task
|
|
|
|
task: object
|
|
|
|
Register a new task in asyncio as executed by loop.
|
|
|
|
Returns None.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio__register_task_impl(PyObject *module, PyObject *task)
|
|
/*[clinic end generated code: output=8672dadd69a7d4e2 input=21075aaea14dfbad]*/
|
|
{
|
|
if (register_task(task) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_asyncio._unregister_task
|
|
|
|
task: object
|
|
|
|
Unregister a task.
|
|
|
|
Returns None.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio__unregister_task_impl(PyObject *module, PyObject *task)
|
|
/*[clinic end generated code: output=6e5585706d568a46 input=28fb98c3975f7bdc]*/
|
|
{
|
|
if (unregister_task(task) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_asyncio._enter_task
|
|
|
|
loop: object
|
|
task: object
|
|
|
|
Enter into task execution or resume suspended task.
|
|
|
|
Task belongs to loop.
|
|
|
|
Returns None.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio__enter_task_impl(PyObject *module, PyObject *loop, PyObject *task)
|
|
/*[clinic end generated code: output=a22611c858035b73 input=de1b06dca70d8737]*/
|
|
{
|
|
if (enter_task(loop, task) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_asyncio._leave_task
|
|
|
|
loop: object
|
|
task: object
|
|
|
|
Leave task execution or suspend a task.
|
|
|
|
Task belongs to loop.
|
|
|
|
Returns None.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task)
|
|
/*[clinic end generated code: output=0ebf6db4b858fb41 input=51296a46313d1ad8]*/
|
|
{
|
|
if (leave_task(loop, task) < 0) {
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*********************** PyRunningLoopHolder ********************/
|
|
|
|
|
|
static PyRunningLoopHolder *
|
|
new_running_loop_holder(PyObject *loop)
|
|
{
|
|
PyRunningLoopHolder *rl = PyObject_New(
|
|
PyRunningLoopHolder, &PyRunningLoopHolder_Type);
|
|
if (rl == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(HAVE_GETPID) && !defined(MS_WINDOWS)
|
|
rl->rl_pid = getpid();
|
|
#endif
|
|
|
|
Py_INCREF(loop);
|
|
rl->rl_loop = loop;
|
|
|
|
return rl;
|
|
}
|
|
|
|
|
|
static void
|
|
PyRunningLoopHolder_tp_dealloc(PyRunningLoopHolder *rl)
|
|
{
|
|
Py_CLEAR(rl->rl_loop);
|
|
PyObject_Free(rl);
|
|
}
|
|
|
|
|
|
static PyTypeObject PyRunningLoopHolder_Type = {
|
|
PyVarObject_HEAD_INIT(NULL, 0)
|
|
"_RunningLoopHolder",
|
|
sizeof(PyRunningLoopHolder),
|
|
.tp_getattro = PyObject_GenericGetAttr,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT,
|
|
.tp_dealloc = (destructor)PyRunningLoopHolder_tp_dealloc,
|
|
};
|
|
|
|
|
|
/*********************** Module **************************/
|
|
|
|
|
|
static void
|
|
module_free_freelists(void)
|
|
{
|
|
PyObject *next;
|
|
PyObject *current;
|
|
|
|
next = (PyObject*) fi_freelist;
|
|
while (next != NULL) {
|
|
assert(fi_freelist_len > 0);
|
|
fi_freelist_len--;
|
|
|
|
current = next;
|
|
next = (PyObject*) ((futureiterobject*) current)->future;
|
|
PyObject_GC_Del(current);
|
|
}
|
|
assert(fi_freelist_len == 0);
|
|
fi_freelist = NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
module_free(void *m)
|
|
{
|
|
Py_CLEAR(asyncio_mod);
|
|
Py_CLEAR(traceback_extract_stack);
|
|
Py_CLEAR(asyncio_future_repr_info_func);
|
|
Py_CLEAR(asyncio_get_event_loop_policy);
|
|
Py_CLEAR(asyncio_iscoroutine_func);
|
|
Py_CLEAR(asyncio_task_get_stack_func);
|
|
Py_CLEAR(asyncio_task_print_stack_func);
|
|
Py_CLEAR(asyncio_task_repr_info_func);
|
|
Py_CLEAR(asyncio_InvalidStateError);
|
|
Py_CLEAR(asyncio_CancelledError);
|
|
|
|
Py_CLEAR(all_tasks);
|
|
Py_CLEAR(current_tasks);
|
|
Py_CLEAR(iscoroutine_typecache);
|
|
|
|
Py_CLEAR(context_kwname);
|
|
|
|
module_free_freelists();
|
|
|
|
module_initialized = 0;
|
|
}
|
|
|
|
static int
|
|
module_init(void)
|
|
{
|
|
PyObject *module = NULL;
|
|
|
|
asyncio_mod = PyImport_ImportModule("asyncio");
|
|
if (asyncio_mod == NULL) {
|
|
goto fail;
|
|
}
|
|
if (module_initialized != 0) {
|
|
return 0;
|
|
}
|
|
else {
|
|
module_initialized = 1;
|
|
}
|
|
|
|
current_tasks = PyDict_New();
|
|
if (current_tasks == NULL) {
|
|
goto fail;
|
|
}
|
|
|
|
iscoroutine_typecache = PySet_New(NULL);
|
|
if (iscoroutine_typecache == NULL) {
|
|
goto fail;
|
|
}
|
|
|
|
|
|
context_kwname = Py_BuildValue("(s)", "context");
|
|
if (context_kwname == NULL) {
|
|
goto fail;
|
|
}
|
|
|
|
#define WITH_MOD(NAME) \
|
|
Py_CLEAR(module); \
|
|
module = PyImport_ImportModule(NAME); \
|
|
if (module == NULL) { \
|
|
goto fail; \
|
|
}
|
|
|
|
#define GET_MOD_ATTR(VAR, NAME) \
|
|
VAR = PyObject_GetAttrString(module, NAME); \
|
|
if (VAR == NULL) { \
|
|
goto fail; \
|
|
}
|
|
|
|
WITH_MOD("asyncio.events")
|
|
GET_MOD_ATTR(asyncio_get_event_loop_policy, "get_event_loop_policy")
|
|
|
|
WITH_MOD("asyncio.base_futures")
|
|
GET_MOD_ATTR(asyncio_future_repr_info_func, "_future_repr_info")
|
|
|
|
WITH_MOD("asyncio.exceptions")
|
|
GET_MOD_ATTR(asyncio_InvalidStateError, "InvalidStateError")
|
|
GET_MOD_ATTR(asyncio_CancelledError, "CancelledError")
|
|
|
|
WITH_MOD("asyncio.base_tasks")
|
|
GET_MOD_ATTR(asyncio_task_repr_info_func, "_task_repr_info")
|
|
GET_MOD_ATTR(asyncio_task_get_stack_func, "_task_get_stack")
|
|
GET_MOD_ATTR(asyncio_task_print_stack_func, "_task_print_stack")
|
|
|
|
WITH_MOD("asyncio.coroutines")
|
|
GET_MOD_ATTR(asyncio_iscoroutine_func, "iscoroutine")
|
|
|
|
WITH_MOD("traceback")
|
|
GET_MOD_ATTR(traceback_extract_stack, "extract_stack")
|
|
|
|
PyObject *weak_set;
|
|
WITH_MOD("weakref")
|
|
GET_MOD_ATTR(weak_set, "WeakSet");
|
|
all_tasks = PyObject_CallNoArgs(weak_set);
|
|
Py_CLEAR(weak_set);
|
|
if (all_tasks == NULL) {
|
|
goto fail;
|
|
}
|
|
|
|
Py_DECREF(module);
|
|
return 0;
|
|
|
|
fail:
|
|
Py_CLEAR(module);
|
|
module_free(NULL);
|
|
return -1;
|
|
|
|
#undef WITH_MOD
|
|
#undef GET_MOD_ATTR
|
|
}
|
|
|
|
PyDoc_STRVAR(module_doc, "Accelerator module for asyncio");
|
|
|
|
static PyMethodDef asyncio_methods[] = {
|
|
_ASYNCIO_GET_EVENT_LOOP_METHODDEF
|
|
_ASYNCIO_GET_RUNNING_LOOP_METHODDEF
|
|
_ASYNCIO__GET_RUNNING_LOOP_METHODDEF
|
|
_ASYNCIO__SET_RUNNING_LOOP_METHODDEF
|
|
_ASYNCIO__REGISTER_TASK_METHODDEF
|
|
_ASYNCIO__UNREGISTER_TASK_METHODDEF
|
|
_ASYNCIO__ENTER_TASK_METHODDEF
|
|
_ASYNCIO__LEAVE_TASK_METHODDEF
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static struct PyModuleDef _asynciomodule = {
|
|
PyModuleDef_HEAD_INIT, /* m_base */
|
|
"_asyncio", /* m_name */
|
|
module_doc, /* m_doc */
|
|
-1, /* m_size */
|
|
asyncio_methods, /* m_methods */
|
|
NULL, /* m_slots */
|
|
NULL, /* m_traverse */
|
|
NULL, /* m_clear */
|
|
(freefunc)module_free /* m_free */
|
|
};
|
|
|
|
|
|
PyMODINIT_FUNC
|
|
PyInit__asyncio(void)
|
|
{
|
|
if (module_init() < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyType_Ready(&FutureIterType) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyType_Ready(&TaskStepMethWrapper_Type) < 0) {
|
|
return NULL;
|
|
}
|
|
if (PyType_Ready(&PyRunningLoopHolder_Type) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *m = PyModule_Create(&_asynciomodule);
|
|
if (m == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* FutureType and TaskType are made ready by PyModule_AddType() calls below. */
|
|
if (PyModule_AddType(m, &FutureType) < 0) {
|
|
Py_DECREF(m);
|
|
return NULL;
|
|
}
|
|
|
|
if (PyModule_AddType(m, &TaskType) < 0) {
|
|
Py_DECREF(m);
|
|
return NULL;
|
|
}
|
|
|
|
Py_INCREF(all_tasks);
|
|
if (PyModule_AddObject(m, "_all_tasks", all_tasks) < 0) {
|
|
Py_DECREF(all_tasks);
|
|
Py_DECREF(m);
|
|
return NULL;
|
|
}
|
|
|
|
Py_INCREF(current_tasks);
|
|
if (PyModule_AddObject(m, "_current_tasks", current_tasks) < 0) {
|
|
Py_DECREF(current_tasks);
|
|
Py_DECREF(m);
|
|
return NULL;
|
|
}
|
|
|
|
return m;
|
|
}
|