redis_pool: rename binding->pool, drop unused wrapper; English test comments

Refactor: rename the binding's owning-pool field rp -> pool, and remove the
dead 'wrapper' field (getPool() is unimplemented; the async pool can mint its
own PHP wrapper on demand via ZEND_ASYNC_NEW_POOL_OBJ). Update the struct in
TRUE_ASYNC_POOL.md to match.

Translate all code comments in tests/async (.phpt + helper) and the README to
English.

Author: EdmondDantes

TRUE_ASYNC_POOL.md

@@ -102,7 +102,7 @@ Mirror `pdo_pool_binding_t` / the `pdo_dbh_t` pool fields.
 /* Per-coroutine binding. Analogue of pdo_pool_binding_t. */
 typedef struct {
     zend_async_event_callback_t event;  /* coroutine-finalize callback */
-    redis_async_pool *rp;               /* owning pool, NULL once destroyed */
+    redis_async_pool *pool;             /* owning pool, NULL once destroyed */
     RedisSock        *conn;             /* checked-out conn, or NULL */
     zend_ulong        coro_key;
     bool              has_coro_callback;
@@ -113,7 +113,6 @@ struct _redis_async_pool {
     zend_async_pool_t *async_pool;      /* physical RedisSock resources */
     HashTable         *bindings;        /* coro_key -> redis_pool_binding_t* */
     HashTable         *opts;            /* dup'd ctor options; factory replays */
-    zend_object       *wrapper;         /* PHP pool wrapper (getPool()), lazy */
     long               db_default;      /* configured DB; drift pins the conn */
     uint32_t           mux_reserve;     /* connections reserved for multiplexing */
 };

redis_pool.c

@@ -29,17 +29,16 @@ extern zend_class_entry *redis_exception_ce;
  */
 typedef struct {
 	zend_async_event_callback_t event;  /* must be first for the callback cast */
-	redis_async_pool *rp;               /* owning pool, NULL once destroyed */
+	redis_async_pool *pool;             /* owning pool, NULL once destroyed */
 	RedisSock   *conn;                  /* checked-out conn, NULL if released */
-	zend_ulong   coro_key;              /* key in rp->bindings */
+	zend_ulong   coro_key;              /* key in pool->bindings */
 	bool         has_coro_callback;     /* registered with the coroutine event */
 } redis_pool_binding_t;
 
 struct _redis_async_pool {
 	zend_async_pool_t *async_pool;      /* physical RedisSock resources */
 	HashTable         *bindings;        /* coro_key -> redis_pool_binding_t* */
 	HashTable         *opts;            /* dup'd ctor options; factory re-applies */
-	zend_object       *wrapper;         /* PHP pool wrapper (getPool()), lazy */
 	long               db_default;      /* configured DB; drift pins the conn */
 	uint32_t           mux_reserve;     /* connections reserved for multiplexing */
 };
@@ -205,19 +204,19 @@ static void redis_pool_binding_on_coroutine_finish(
 	redis_pool_binding_t *binding = (redis_pool_binding_t *)callback;
 
 	/* Pool already destroyed — nothing to do. */
-	if (binding->rp == NULL) {
+	if (binding->pool == NULL) {
 		return;
 	}
 
 	if (binding->conn != NULL) {
 		zval conn_zval;
 		ZVAL_PTR(&conn_zval, binding->conn);
-		ZEND_ASYNC_POOL_RELEASE(binding->rp->async_pool, &conn_zval);
+		ZEND_ASYNC_POOL_RELEASE(binding->pool->async_pool, &conn_zval);
 		binding->conn = NULL;
 	}
 
-	if (binding->rp->bindings != NULL) {
-		zend_hash_index_del(binding->rp->bindings, binding->coro_key);
+	if (binding->pool->bindings != NULL) {
+		zend_hash_index_del(binding->pool->bindings, binding->coro_key);
 	}
 }
 
@@ -300,7 +299,6 @@ int redis_pool_create(redis_object *redis, HashTable *opts)
 	rp->opts = zend_array_dup(opts);
 	rp->db_default = redis->sock ? redis->sock->dbNumber : 0;
 	rp->mux_reserve = (uint32_t)mux;
-	rp->wrapper = NULL;
 
 	redis->pool = rp;
 	return SUCCESS;
@@ -329,7 +327,7 @@ void redis_pool_destroy(redis_object *redis)
 				efree(binding);
 			} else {
 				/* Coroutine callback will no-op; dispose frees the binding. */
-				binding->rp = NULL;
+				binding->pool = NULL;
 			}
 		} ZEND_HASH_FOREACH_END();
 
@@ -338,11 +336,6 @@ void redis_pool_destroy(redis_object *redis)
 		rp->bindings = NULL;
 	}
 
-	if (rp->wrapper != NULL) {
-		OBJ_RELEASE(rp->wrapper);
-		rp->wrapper = NULL;
-	}
-
 	if (rp->async_pool != NULL) {
 		ZEND_ASYNC_POOL_CLOSE(rp->async_pool);
 		ZEND_ASYNC_EVENT_RELEASE(&rp->async_pool->event);
@@ -397,7 +390,7 @@ RedisSock *redis_pool_acquire_conn(redis_object *redis, int no_throw)
 	binding->event.callback = redis_pool_binding_on_coroutine_finish;
 	binding->event.dispose = redis_pool_binding_dispose;
 	binding->event.ref_count = 1;
-	binding->rp = rp;
+	binding->pool = rp;
 	binding->conn = Z_PTR(resource);
 	binding->coro_key = coro_key;
 

tests/async/001-pool_construct.phpt

@@ -13,7 +13,7 @@ $redis = AsyncRedisPoolTest::poolFactory(max: 4);
 $pool  = $redis->getPool();
 
 echo "Has pool: " . ($pool !== null ? "yes" : "no") . "\n";
-echo "Count: "  . $pool->count() . "\n";      // ещё ничего не выдано
+echo "Count: "  . $pool->count() . "\n";      // nothing handed out yet
 echo "Idle: "   . $pool->idleCount() . "\n";
 echo "Active: " . $pool->activeCount() . "\n";
 echo "Done\n";

tests/async/003-pool_concurrent_coroutines.phpt

@@ -14,8 +14,8 @@ use function Async\await;
 
 $redis = AsyncRedisPoolTest::poolFactory(max: 4);
 
-/* Инвариант (chaos-стиль): при любой интерливинге каждая корутина читает
- * именно своё значение — общий $redis не перемешивает ответы. */
+/* Invariant (chaos-style): under any interleaving each coroutine reads its own
+ * value — the shared $redis never mixes up replies. */
 $N = 8;
 $coros = [];
 for ($i = 0; $i < $N; $i++) {

tests/async/004-pool_backpressure.phpt

@@ -12,24 +12,24 @@ require_once __DIR__ . '/inc/async_redis_pool_test.inc';
 use function Async\spawn;
 use function Async\await;
 
-/* Порт ext/async/tests/pool/029: при max=1 второй потребитель обязан
- * запарковаться, пока первый держит соединение (в транзакции — пиннинг). */
+/* Port of ext/async/tests/pool/029: with max=1 the second consumer must park
+ * while the first holds the connection (pinned by the transaction). */
 $redis = AsyncRedisPoolTest::poolFactory(max: 1);
 $k = AsyncRedisPoolTest::key('bp');
 
 $c2Blocked = false;
 
 $c1 = spawn(function() use ($redis, $k) {
-    $redis->multi();              // пиннит единственное соединение
+    $redis->multi();              // pins the only connection
     $redis->set($k, '1');
     \Async\suspend();
     \Async\suspend();
-    $redis->exec();               // отпускает соединение в пул
+    $redis->exec();               // releases the connection back to the pool
 });
 
 $c2 = spawn(function() use ($redis, $k, &$c2Blocked) {
     $c2Blocked = ($redis->getPool()->idleCount() === 0);
-    $v = $redis->get($k);         // ждёт, пока c1 не освободит conn
+    $v = $redis->get($k);         // waits until c1 frees the conn
     $redis->del($k);
     return $v;
 });

tests/async/005-pool_transaction_pins.phpt

@@ -20,7 +20,7 @@ $co = spawn(function() use ($redis, $k) {
     $redis->set($k, 'a');
     $redis->append($k, 'b');
     $redis->get($k);
-    $res = $redis->exec();        // транзакция атомарна на одном соединении
+    $res = $redis->exec();        // transaction is atomic on a single connection
     $redis->del($k);
     return $res;
 });

tests/async/006-pool_concurrent_multi_isolation.phpt

@@ -12,16 +12,16 @@ require_once __DIR__ . '/inc/async_redis_pool_test.inc';
 use function Async\spawn;
 use function Async\await;
 
-/* Две корутины ведут транзакции параллельно. Каждая пиннит СВОЁ физическое
- * соединение (нужно max>=2), команды не перемешиваются между транзакциями. */
+/* Two coroutines run transactions in parallel. Each pins its OWN physical
+ * connection (needs max>=2); commands do not interleave between transactions. */
 $redis = AsyncRedisPoolTest::poolFactory(max: 2);
 
 $mk = function(string $tag) use ($redis) {
     return function() use ($redis, $tag) {
         $k = AsyncRedisPoolTest::key("iso:$tag");
         $redis->multi();
         $redis->set($k, $tag);
-        \Async\suspend();              // отдаём управление другой корутине
+        \Async\suspend();              // yield to the other coroutine
         $redis->append($k, $tag);
         $out = $redis->exec();
         $v = $redis->get($k);
@@ -36,8 +36,8 @@ $b = spawn($mk('B'));
 $va = await($a);
 $vb = await($b);
 
-echo "A: $va\n";   // должно быть "AA", не перемешано с B
-echo "B: $vb\n";   // должно быть "BB"
+echo "A: $va\n";   // must be "AA", not mixed with B
+echo "B: $vb\n";   // must be "BB"
 echo "Done\n";
 ?>
 --EXPECT--

tests/async/README.md

@@ -1,22 +1,22 @@
 # TrueAsync pool tests
 
-Тесты пула соединений phpredis под TrueAsync. Формат — `.phpt` (как
-`php-src/ext/async/tests`), корутины через `Async\spawn` / `Async\await`.
-НЕ синхронный `tests/TestRedis.php`.
+Tests for the phpredis connection pool under TrueAsync. Format: `.phpt` (like
+`php-src/ext/async/tests`), coroutines via `Async\spawn` / `Async\await`. NOT the
+synchronous `tests/TestRedis.php` framework.
 
-Статус: **исполняемая спецификация**. Фича из `TRUE_ASYNC_POOL.md` ещё не
-реализована — пока тесты падают/скипаются. По мере реализации Stage 1/2 должны
-зеленеть.
+Status: **executable specification**. Tests that depend on already-implemented
+behaviour pass; those depending on not-yet-implemented parts (e.g. `getPool()`)
+fail until those land.
 
-## Запуск
+## Running
 
-Нужен build php-src с `--enable-zts` и подключённым TrueAsync-реактором +
-собранный phpredis против него, и живой Redis (по умолчанию `127.0.0.1:6379`,
-переопределяется `REDIS_TEST_HOST` / `REDIS_TEST_PORT`).
+Needs a php-src build with `--enable-zts` and the TrueAsync reactor, phpredis
+built against it, and a live Redis (default `127.0.0.1:6379`, overridable via
+`REDIS_TEST_HOST` / `REDIS_TEST_PORT`).
 
 ```sh
 REDIS_TEST_HOST=127.0.0.1 REDIS_TEST_PORT=6379 \
   php run-tests.php -p $(which php) tests/async
 ```
 
-Хелпер `inc/async_redis_pool_test.inc` даёт `skipIf*` и `poolFactory()`.
+The helper `inc/async_redis_pool_test.inc` provides `skipIf*` and `poolFactory()`.

tests/async/inc/async_redis_pool_test.inc

@@ -1,5 +1,5 @@
 <?php
-/* Хелпер для async pool тестов phpredis. По образцу
+/* Helper for phpredis async pool tests. Modeled on
  * php-src/ext/async/tests/pdo_mysql/inc/async_pdo_mysql_test.inc */
 
 use function Async\spawn;
@@ -10,21 +10,21 @@ class AsyncRedisPoolTest
     static function host(): string { return getenv('REDIS_TEST_HOST') ?: '127.0.0.1'; }
     static function port(): int    { return (int)(getenv('REDIS_TEST_PORT') ?: 6379); }
 
-    /* Скип, если TrueAsync-рантайм недоступен. */
+    /* Skip if the TrueAsync runtime is unavailable. */
     static function skipIfNoAsync(): void {
         if (!function_exists('Async\\spawn')) {
             die("skip TrueAsync runtime not available\n");
         }
     }
 
-    /* Скип, если расширение redis не загружено. */
+    /* Skip if the redis extension is not loaded. */
     static function skipIfNoRedis(): void {
         if (!extension_loaded('redis')) {
             die("skip redis extension not loaded\n");
         }
     }
 
-    /* Скип, если живой Redis недоступен. */
+    /* Skip if no live Redis server is reachable. */
     static function skipIfNoServer(): void {
         $r = new Redis();
         if (!@$r->connect(self::host(), self::port(), 1.0)) {
@@ -39,7 +39,7 @@ class AsyncRedisPoolTest
         self::skipIfNoServer();
     }
 
-    /* Pool-enabled Redis (template-режим). Конфиг пула — см. TRUE_ASYNC_POOL.md §6. */
+    /* Pool-enabled Redis (template mode). Pool config — see TRUE_ASYNC_POOL.md §6. */
     static function poolFactory(int $max = 4, int $mux = 0, int $min = 0): Redis {
         return new Redis([
             'host' => self::host(),
@@ -53,7 +53,7 @@ class AsyncRedisPoolTest
         ]);
     }
 
-    /* Уникальный префикс ключей, чтобы тесты не топтали друг друга. */
+    /* Unique key prefix so tests do not clobber each other. */
     static function key(string $name): string {
         return 'phpredis:async:test:' . $name;
     }