+ async_spawn_and_throw

Author: EdmondDantes

async_API.c

@@ -885,6 +885,7 @@ void async_api_register(void)
 		async_scheduler_coroutine_enqueue,
 		async_coroutine_resume,
 		async_coroutine_cancel,
+		async_spawn_and_throw,
 		graceful_shutdown,
 		get_coroutines,
 		add_microtask,

coroutine.c

@@ -379,26 +379,28 @@ static zend_result finally_handlers_iterator_handler(async_iterator_t *iterator,
 	return SUCCESS;
 }
 
-static void finally_handlers_iterator_dtor(zend_async_microtask_t *microtask)
+static void finally_handlers_iterator_dtor(zend_async_iterator_t *zend_iterator)
 {
-	async_iterator_t * iterator = (async_iterator_t *) microtask;
+	async_iterator_t * iterator = (async_iterator_t *) zend_iterator;
 
-	if (iterator->extended_data != NULL) {
-		coroutine_finally_handlers_context_t *context = (coroutine_finally_handlers_context_t *) iterator->extended_data;
-		
-		// Throw CompositeException if any exceptions were collected
-		if (context->composite_exception != NULL) {
-			zend_throw_exception_internal(context->composite_exception);
-			context->composite_exception = NULL;
-		}
-		
-		// Release coroutine reference
-		OBJ_RELEASE(&context->coroutine->std);
-		
-		// Free the context
-		efree(context);
-		iterator->extended_data = NULL;
+	if (UNEXPECTED(iterator->extended_data == NULL)) {
+		return;
 	}
+
+	coroutine_finally_handlers_context_t *context = iterator->extended_data;
+
+	// Throw CompositeException if any exceptions were collected
+	if (context->composite_exception != NULL) {
+		zend_throw_exception_internal(context->composite_exception);
+		context->composite_exception = NULL;
+	}
+
+	// Release coroutine reference
+	OBJ_RELEASE(&context->coroutine->std);
+
+	// Free the context
+	efree(context);
+	iterator->extended_data = NULL;
 }
 
 static void async_coroutine_call_finally_handlers(async_coroutine_t *coroutine)
@@ -407,6 +409,12 @@ static void async_coroutine_call_finally_handlers(async_coroutine_t *coroutine)
 		return;
 	}
 
+	// Create a special child scope for finally handlers
+	zend_async_scope_t *child_scope = ZEND_ASYNC_NEW_SCOPE(coroutine->coroutine.scope);
+	if (UNEXPECTED(child_scope == NULL)) {
+		return;
+	}
+
 	zval handlers;
 	ZVAL_ARR(&handlers, coroutine->finally_handlers);
 	coroutine->finally_handlers = NULL;
@@ -416,7 +424,7 @@ static void async_coroutine_call_finally_handlers(async_coroutine_t *coroutine)
 		NULL,
 		NULL,
 		finally_handlers_iterator_handler,
-		coroutine->coroutine.scope,
+		child_scope,
 		0,
 		0,
 		0

exceptions.c

@@ -20,6 +20,7 @@
 #include "php.h"
 
 #include "exceptions_arginfo.h"
+#include "zend_common.h"
 
 zend_class_entry * async_ce_async_exception = NULL;
 zend_class_entry * async_ce_cancellation_exception = NULL;
@@ -197,4 +198,80 @@ ZEND_API ZEND_COLD void async_composite_exception_add_exception(zend_object *com
 	} else if (transfer) {
 		OBJ_RELEASE(exception);
 	}
+}
+
+static void exception_coroutine_finally_callback(
+	zend_async_event_t *event,
+	zend_async_event_callback_t *callback,
+	void * result,
+	zend_object *exception
+)
+{
+	zend_coroutine_t *coroutine = (zend_coroutine_t *) event;
+
+	if (coroutine->extended_data != NULL) {
+		zend_object *exception_obj = coroutine->extended_data;
+		coroutine->extended_data = NULL;
+		zend_throw_exception_internal(exception_obj);
+	}
+}
+
+static void exception_coroutine_entry(void)
+{
+	zend_coroutine_t *coroutine = ZEND_ASYNC_CURRENT_COROUTINE;
+
+	if (UNEXPECTED(coroutine == NULL || coroutine->extended_data == NULL)) {
+		return;
+	}
+
+	zend_object *exception = coroutine->extended_data;
+	coroutine->extended_data = NULL;
+
+	zend_throw_exception_internal(exception);
+}
+
+bool async_spawn_and_throw(zend_object *exception, zend_async_scope_t *scope, int32_t priority)
+{
+	bool need_new_scope = false;
+
+	if (scope == NULL) {
+		scope = ZEND_ASYNC_CURRENT_SCOPE;
+	}
+
+	if (ZEND_ASYNC_SCOPE_IS_CANCELLED(scope) || ZEND_ASYNC_SCOPE_IS_CLOSED(scope)) {
+		scope = scope->parent_scope;
+		need_new_scope = true;
+	}
+
+	if (scope == NULL || ZEND_ASYNC_SCOPE_IS_CLOSED(scope)) {
+		async_warning("To throw an exception in a coroutine, "
+				"the Scope must be active or have a parent that is not closed.");
+		return false;
+	}
+
+	if (need_new_scope) {
+		scope = ZEND_ASYNC_NEW_SCOPE(scope);
+		if (UNEXPECTED(scope == NULL)) {
+			async_warning("Failed to create a new Scope for throwing an exception in a coroutine.");
+			return false;
+		}
+	}
+
+	zend_coroutine_t *coroutine = ZEND_ASYNC_SPAWN_WITH_SCOPE_EX(scope, priority);
+	if (UNEXPECTED(coroutine == NULL)) {
+		async_warning("Failed to spawn a coroutine for throwing an exception.");
+		return false;
+	}
+
+	coroutine->event.add_callback(&coroutine->event, ZEND_ASYNC_EVENT_CALLBACK(exception_coroutine_finally_callback));
+	if (UNEXPECTED(EG(exception))) {
+		coroutine->event.dispose(&coroutine->event);
+		return false;
+	}
+
+	coroutine->internal_entry = exception_coroutine_entry;
+	coroutine->extended_data = exception;
+	GC_ADDREF(exception);
+
+	return true;
 }

exceptions.h

@@ -18,6 +18,7 @@
 
 #include <zend_portability.h>
 #include <zend_property_hooks.h>
+#include <Zend/zend_async_API.h>
 
 BEGIN_EXTERN_C()
 
@@ -38,6 +39,7 @@ ZEND_API ZEND_COLD zend_object * async_throw_timeout(const char *format, const z
 ZEND_API ZEND_COLD zend_object * async_throw_poll(const char *format, ...);
 ZEND_API ZEND_COLD zend_object * async_new_composite_exception(void);
 ZEND_API void async_composite_exception_add_exception(zend_object *composite, zend_object *exception, bool transfer);
+bool async_spawn_and_throw(zend_object *exception, zend_async_scope_t *scope, int32_t priority);
 
 END_EXTERN_C()
 

iterator.c

@@ -70,7 +70,7 @@ void iterator_dtor(zend_async_microtask_t *microtask)
 		// Call the extended destructor if it exists
 		ASYNC_ITERATOR_DTOR extended_dtor = iterator->extended_dtor;
 		iterator->extended_dtor = NULL;
-		extended_dtor(microtask);
+		extended_dtor((zend_async_iterator_t *)iterator);
 	}
 
 	// Free hash iterator if it was allocated

iterator.h

@@ -42,25 +42,17 @@ async_iterator_t * async_iterator_new(
 	size_t iterator_size
 );
 
-#define ASYNC_ITERATOR_DTOR zend_async_microtask_handler_t
+#define ASYNC_ITERATOR_DTOR zend_async_iterator_method_t
 
 void async_iterator_run(async_iterator_t *iterator);
 void async_iterator_run_in_coroutine(async_iterator_t *iterator, int32_t priority);
 
 struct _async_iterator_t {
-	zend_async_microtask_t microtask;
-	void (*run)(zend_async_iterator_t *iterator);
-	void (*run_in_coroutine)(zend_async_iterator_t *iterator, int32_t priority);
+	ZEND_ASYNC_ITERATOR_FIELDS
 	/* The current state of the iterator. See async_iterator_state_t */
 	async_iterator_state_t state;
-	/* The maximum number of concurrent tasks that can be executed at the same time */
-	unsigned int concurrency;
 	/* The number of active coroutines that are currently executing */
 	unsigned int active_coroutines;
-	/* Priority for coroutines created by this iterator */
-	int32_t priority;
-	/* The coroutine scope */
-	zend_async_scope_t *scope;
 	/* The internal handler */
 	async_iterator_handler_t handler;
 	/* Callback and info / cache to be used when coroutine is started. */
@@ -72,10 +64,6 @@ struct _async_iterator_t {
 	uint32_t hash_iterator;
 	/* The iterator object, which may be NULL if there is no iterator. */
 	zend_object_iterator *zend_iterator;
-	/* NULLABLE. Custom data for the iterator, can be used to store additional information. */
-	void *extended_data;
-	/* NULLABLE. An additional destructor that will be called. */
-	ASYNC_ITERATOR_DTOR extended_dtor;
 };
 
 #endif //ITERATOR_H

scope.c

@@ -1402,24 +1402,26 @@ static zend_result scope_finally_handlers_iterator_handler(async_iterator_t *ite
 	return SUCCESS;
 }
 
-static void scope_finally_handlers_iterator_dtor(zend_async_microtask_t *microtask)
+static void scope_finally_handlers_iterator_dtor(zend_async_iterator_t *z_iterator)
 {
-	async_iterator_t *iterator = (async_iterator_t *) microtask;
+	async_iterator_t *iterator = (async_iterator_t *) z_iterator;
 
-	if (iterator->extended_data != NULL) {
-		scope_finally_handlers_context_t *context = (scope_finally_handlers_context_t *) iterator->extended_data;
-		
-		// Throw CompositeException if any exceptions were collected
-		if (context->composite_exception != NULL) {
-			zend_throw_exception_internal(context->composite_exception);
-			context->composite_exception = NULL;
-		}
-		
-		// Free the context
-		efree(context);
-		iterator->extended_data = NULL;
+	if (UNEXPECTED(iterator->extended_data == NULL)) {
+		return;
+	}
+
+	scope_finally_handlers_context_t *context = iterator->extended_data;
+
+	// Throw CompositeException if any exceptions were collected
+	if (context->composite_exception != NULL) {
+		zend_throw_exception_internal(context->composite_exception);
+		context->composite_exception = NULL;
 	}
 
+	// Free the context
+	efree(context);
+	iterator->extended_data = NULL;
+
 	//
 	// If everything is correct,
 	// the Scope will destroy itself as soon as the coroutine created within it completes execution.
@@ -1433,36 +1435,6 @@ static void async_scope_call_finally_handlers(async_scope_t *scope)
 		return;
 	}
 
-	if (false == ZEND_ASYNC_IS_ACTIVE) {
-		// Run handlers immediately if not in async context
-		zval *callable;
-		zval result, param;
-		ZVAL_UNDEF(&result);
-		if (scope->scope.scope_object) {
-			ZVAL_OBJ(&param, scope->scope.scope_object);
-		} else {
-			ZVAL_NULL(&param);
-		}
-
-		ZEND_HASH_FOREACH_VAL(scope->finally_handlers, callable) {
-
-			ZVAL_UNDEF(&result);
-
-			if (UNEXPECTED(call_user_function(NULL, NULL, callable, &result, 1, &param) == FAILURE)) {
-				zend_throw_error(NULL, "Failed to call finally handler in finished scope");
-				zval_ptr_dtor(&result);
-				return;
-			}
-
-			zval_ptr_dtor(&result);
-		} ZEND_HASH_FOREACH_END();
-
-		zend_array_destroy(scope->finally_handlers);
-		scope->finally_handlers = NULL;
-
-		return;
-	}
-
 	// Create special child scope for finally handlers
 	//
 	// We don't increase the reference count of the Scope