Swoole

https://github.com/swoole/swoole-src
Admin
Swoole is a high-performance, event-driven, asynchronous, and coroutine-based concurrency library...
Tokens:35,668
Snippets:264
Trust Score:9.6
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Compile and install Swoole from source

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Standard commands to compile and install the extension after cloning the source.

```shell
phpize && \
./configure && \
make && make install
```

--------------------------------

### Define installation targets

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Specifies installation paths for the Swoole extension, library files, and header files.

```cmake
INSTALL(TARGETS ext-swoole LIBRARY DESTINATION ${PHP_EXTENSION_DIR})
INSTALL(TARGETS lib-swoole LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
INSTALL(FILES ${HEAD_FILES} DESTINATION include/swoole)
INSTALL(FILES ${HEAD_WAPPER_FILES} DESTINATION include/swoole/wrapper)
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.h DESTINATION include/swoole)
```

--------------------------------

### Compile Swoole from source

Source: https://github.com/swoole/swoole-src/wiki/Installing

Clone the Swoole repository, then run phpize, configure, and make to build and install the extension. After installation, add 'extension=swoole.so' to your php.ini.

```shell
git clone https://github.com/swoole/swoole-src.git
cd swoole-src
phpize
./configure
make && make install
```

--------------------------------

### Build ext-swoole

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Commands to build and install the PHP extension ext-swoole. After installation, add 'extension=swoole.so' to php.ini.

```shell
cd swoole-src
phpize
./configure ${options}
make -j$(nproc)
make install
```

--------------------------------

### Install Swoole via PECL

Source: https://github.com/swoole/swoole-src/wiki/Installing

Use the PECL command to install Swoole. This is an alternative to compiling from source.

```shell
pecl install swoole
```

--------------------------------

### Create and start a Swoole Server with event handlers

Source: https://github.com/swoole/swoole-src/wiki/Classes

Creates a Swoole TCP server on 127.0.0.1:9501 with 8 worker processes and daemon mode enabled. Registers connect, receive, and close event handlers; the receive handler sends a response and closes the connection. Call start() to begin serving.

```php
use Swoole\Server;

$serv = new Server('127.0.0.1', 9501);
$serv->set(array(
    'worker_num' => 8,   //工作进程数量
    'daemonize' => true, //是否作为守护进程
));
$serv->on('connect', function ($serv, $fd){
    echo "Client:Connect.\n";
});
$serv->on('receive', function ($serv, $fd, $from_id, $data) {
    $serv->send($fd, 'Swoole: '.$data);
    $serv->close($fd);
});
$serv->on('close', function ($serv, $fd) {
    echo "Client: Close.\n";
});
$serv->start();
```

--------------------------------

### Install swoole_async extension

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Steps to install the separate swoole_async extension required for async clients and APIs since version 4.3.0.

```shell
git clone https://github.com/swoole/ext-async.git
cd ext-async
phpize
./configure
make -j 4
sudo make install
```

--------------------------------

### Coroutine Client Examples

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Demonstrates automatic coroutine scheduling for HTTP, WebSocket, HTTP2, and TCP clients.

```php
go(function () {
    // http
    $http_client = new Swoole\Coroutine\Http\Client('127.0.0.1', 9501);
    assert($http_client->post('/', 'Swoole Http'));
    var_dump($http_client->body);
    // websocket
    $http_client->upgrade('/');
    $http_client->push('Swoole Websocket');
    var_dump($http_client->recv()->data);
});
go(function () {
    // http2
    $http2_client = new Swoole\Coroutine\Http2\Client('localhost', 9501);
    $http2_client->connect();
    $http2_request = new Swoole\Http2\Request;
    $http2_request->method = 'POST';
    $http2_request->data = 'Swoole Http2';
    $http2_client->send($http2_request);
    $http2_response = $http2_client->recv();
    var_dump($http2_response->data);
});
go(function () use ($tcp_options) {
    // tcp
    $tcp_client = new Swoole\Coroutine\Client(SWOOLE_TCP);
    $tcp_client->set($tcp_options);
    $tcp_client->connect('127.0.0.1', 9502);
    $tcp_client->send(tcp_pack('Swoole Tcp'));
    var_dump(tcp_unpack($tcp_client->recv()));
});
```

--------------------------------

### Create an HTTP server with Swoole

Source: https://github.com/swoole/swoole-src/blob/master/README.md

This example creates an HTTP server on 127.0.0.1:9501. It sets the hook_flags to SWOOLE_HOOK_ALL to enable coroutine hooks for all supported functions. In the request handler, it uses Co::join to run two coroutines concurrently that fetch content from google.com and taobao.com, then returns the results as JSON.

```php
$http = new Swoole\Http\Server('127.0.0.1', 9501);
$http->set(['hook_flags' => SWOOLE_HOOK_ALL]);

$http->on('request', function ($request, $response) {
    $result = [];
    Co::join([
        go(function () use (&$result) {
            $result['google'] = file_get_contents("https://www.google.com/");
        }),
        go(function () use (&$result) {
            $result['taobao'] = file_get_contents("https://www.taobao.com/");
        })
    ]);
    $response->end(json_encode($result));
});

$http->start();
```

--------------------------------

### Run core-tests

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Commands to start dependency services, run all tests, run specific test cases with a filter, and list all tests.

```shell
# run all dependency services
cd core-tests
docker compose up -d
# run all tests
./bin/core-tests
# run some test cases
./bin/core-tests --gtest_filter=server.*
# list all tests
./bin/core_tests --gtest_list_tests
```

--------------------------------

### Build googletest

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Commands to download and install googletest v1.15.2, required for building core tests.

```shell
wget https://github.com/google/googletest/releases/download/v1.15.2/googletest-1.15.2.tar.gz
tar zxf googletest-1.15.2.tar.gz
cd googletest-1.15.2
mkdir ./build && cd ./build
cmake ..
make -j
sudo make install
```

--------------------------------

### Concurrency with Swoole coroutines

Source: https://github.com/swoole/swoole-src/blob/master/README.md

This example demonstrates concurrent coroutine execution using Co\run and Co\go. It runs four coroutines: one continuously reads from a TCP client connection, one serves a TCP server that sends the current time, one subscribes to a Redis channel, and one publishes messages to that channel every 2 seconds. This shows how Swoole can handle multiple concurrent I/O operations.

```php
Co\run(function() {
    Co\go(function() {
        while(1) {
            sleep(1);
            $fp = stream_socket_client("tcp://127.0.0.1:8000", $errno, $errstr, 30);
            echo fread($fp, 8192), PHP_EOL;
        }
    });

    Co\go(function() {
        $fp = stream_socket_server("tcp://0.0.0.0:8000", $errno, $errstr, STREAM_SERVER_BIND | STREAM_SERVER_LISTEN);
        while(1) {
            $conn = stream_socket_accept($fp);
            fwrite($conn, 'The local time is ' . date('n/j/Y g:i a'));
        }
    });

    Co\go(function() {
        $redis = new Redis();
        $redis->connect('127.0.0.1', 6379);
        while(true) {
            $redis->subscribe(['test'], function ($instance, $channelName, $message) {
                echo 'New redis message: '.$channelName, "==>", $message, PHP_EOL;
            });
        }
    });

    Co\go(function() {
        $redis = new Redis();
        $redis->connect('127.0.0.1', 6379);
        $count = 0;
        while(true) {
            sleep(2);
            $redis->publish('test','hello, world, count='.$count++);
        }
    });
});
```

--------------------------------

### Running PHP Tests

Source: https://github.com/swoole/swoole-src/blob/master/CLAUDE.md

Commands to execute PHP tests using the run-tests.php script. Requires the Swoole extension to be installed.

```bash
# Run all tests
php run-tests.php tests/

# Run a single test
php run-tests.php tests/swoole_coroutine/array.phpt

# Run a specific test directory
php run-tests.php tests/swoole_http_server/
```

--------------------------------

### Enable Coroutine Runtime Hooks

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Call Swoole\Runtime::enableCoroutine() at the start of a script to convert synchronous socket operations into asynchronous IO. This example demonstrates concurrent Redis operations.

```php
Swoole\Runtime::enableCoroutine();
$s = microtime(true);
Co\run(function() {
    for ($c = 100; $c--;) {
        go(function () {
            ($redis = new Redis)->connect('127.0.0.1', 6379);
            for ($n = 100; $n--;) {
                assert($redis->get('awesome') === 'swoole');
            }
        });
    }
});
echo 'use ' . (microtime(true) - $s) . ' s';
```

--------------------------------

### PHP Code Style Fixer

Source: https://github.com/swoole/swoole-src/blob/master/CLAUDE.md

Commands to install and run the PHP code style fixer.

```bash
composer install -d tests/include/lib  # install php-cs-fixer
./php-cs-fix                           # fix code style
```

--------------------------------

### Set Maximum Idle Buffer

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Example of setting the maximum idle buffer size to zero to allow unlimited buffer growth for large payloads.

```c
context->reader->maxbuf = 0;
```

--------------------------------

### Run Swoole via Docker

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Use this command to quickly verify a Swoole installation by running the php --ri swoole command inside the phpswoole/swoole Docker container. The --rm flag removes the container after execution.

```bash
docker run --rm phpswoole/swoole "php --ri swoole"
```

--------------------------------

### Worker Abnormal Exit Warning

Source: https://github.com/swoole/swoole-src/blob/master/docs/ISSUE.md

Example of a warning message indicating a worker process has exited abnormally.

```shell
WARNING	Worker::report_error(): worker(pid=%d, id=%d) abnormal exit, status=0, signal=11
```

--------------------------------

### Mixed Server Implementation

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Initializes a Swoole server handling HTTP, WebSocket, and TCP protocols on a single event loop.

```php
$server = new Swoole\WebSocket\Server('127.0.0.1', 9501, SWOOLE_BASE);
$server->set(['open_http2_protocol' => true]);
// http && http2
$server->on('request', function (Swoole\Http\Request $request, Swoole\Http\Response $response) {
    $response->end('Hello ' . $request->rawcontent());
});
// websocket
$server->on('message', function (Swoole\WebSocket\Server $server, Swoole\WebSocket\Frame $frame) {
    $server->push($frame->fd, 'Hello ' . $frame->data);
});
// tcp
$tcp_server = $server->listen('127.0.0.1', 9502, SWOOLE_TCP);
$tcp_server->set($tcp_options);
$tcp_server->on('receive', function (Swoole\Server $server, int $fd, int $reactor_id, string $data) {
    $server->send($fd, tcp_pack('Hello ' . tcp_unpack($data)));
});
$server->start();
```

--------------------------------

### Configure libpq dependency

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Configures libpq by either using a defined directory or pkg_check_modules, then links it to ext-swoole.

```cmake
if (DEFINED libpq_dir)
    include_directories(BEFORE ${libpq_dir}/include)
    link_directories(${libpq_dir}/lib)
else()
    pkg_check_modules(LIBPQ REQUIRED libpq)
    target_include_directories(ext-swoole PRIVATE ${LIBPQ_INCLUDE_DIRS})
endif()

target_link_libraries(ext-swoole swoole pq curl)
```

--------------------------------

### Configure test_server executable

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Compiles the test_server executable from the specified source file and links it against the lib-swoole library and pthread.

```cmake
set(TEST_SRC_LIST examples/cpp/test_server.cc)
add_executable(test_server ${TEST_SRC_LIST})
add_dependencies(test_server lib-swoole)
target_link_libraries(test_server swoole pthread)
```

--------------------------------

### Developer Build with ASAN

Source: https://github.com/swoole/swoole-src/blob/master/CLAUDE.md

Build configuration optimized for development with AddressSanitizer and additional warnings enabled.

```bash
phpize && ./configure --enable-swoole-dev --enable-debug-log --enable-sockets --enable-mysqlnd --enable-swoole-curl
```

--------------------------------

### Establish a secure WebSocket connection

Source: https://github.com/swoole/swoole-src/blob/master/examples/ssl/websocket_client.html

This snippet demonstrates how to initialize a WebSocket connection to a wss:// URL and define event handlers for open, close, message, and error events.

```javascript
var wsServer = 'wss://localhost:9502'; var websocket = new WebSocket(wsServer); websocket.onopen = function (evt) { console.log("Connected to WebSocket server."); }; websocket.onclose = function (evt) { console.log("Disconnected"); }; websocket.onmessage = function (evt) { console.log('Retrieved data from server: ' + evt.data); }; websocket.onerror = function (evt, e) { console.log('Error occured: ' + evt.data); };
```

--------------------------------

### Traditional PHP Extension Build

Source: https://github.com/swoole/swoole-src/blob/master/CLAUDE.md

Standard build process for production use of the Swoole extension.

```bash
phpize && ./configure [flags] && make -j$(nproc) && make install
```

--------------------------------

### Build libswoole.so

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Commands to build the libswoole shared library from the swoole-src directory.

```shell
cd swoole-src
cmake .
make -j$(nproc) lib-swoole
```

--------------------------------

### Simple pipeline with redisAppendCommand and redisGetReply

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Pipelines two commands and reads their replies in order. Results in a single write(2) and a single read(2) call. Each redisGetReply retrieves the next reply.

```c
redisReply *reply;
redisAppendCommand(context,"SET foo bar");
redisAppendCommand(context,"GET foo");
redisGetReply(context,&reply); // reply for SET
freeReplyObject(reply);
redisGetReply(context,&reply); // reply for GET
freeReplyObject(reply);
```

--------------------------------

### Build core-tests

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Command to build the core-tests target.

```shell
make -j$(nproc) core-tests
```

--------------------------------

### Enable Core Dump

Source: https://github.com/swoole/swoole-src/blob/master/docs/ISSUE.md

Command to set the core file size limit to unlimited to allow core dump generation.

```shell
ulimit -c unlimited
```

--------------------------------

### Running Core C++ Tests

Source: https://github.com/swoole/swoole-src/blob/master/CLAUDE.md

Commands to execute Google Test binaries after a CMake build.

```bash
mkdir -p build && cd build && cmake .. && make -j$(nproc)
./core-tests                           # run all
./core-tests --gtest_filter="Server.*" # run subset
```

--------------------------------

### Configure co executable

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Compiles the co executable from the specified source file and links it against the lib-swoole library.

```cmake
set(TEST_SRC_LIST examples/cpp/co.cc)
add_executable(co ${TEST_SRC_LIST})
add_dependencies(co lib-swoole)
target_link_libraries(co swoole)
```

--------------------------------

### Configure ext-swoole library

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Collects source files for the ext-swoole library, including third-party dependencies, and configures the shared library build properties.

```cmake
file(GLOB ext_cxx_files ext-src/*.cc)
set(ext_src_list  ${ext_cxx_files}
        thirdparty/php/curl/interface.cc
        thirdparty/php/curl/multi.cc
        thirdparty/php84/curl/interface.cc
	    thirdparty/php84/curl/multi.cc	
	    thirdparty/php/sockets/multicast.cc
        thirdparty/php/sockets/sendrecvmsg.cc
        thirdparty/php/sockets/conversions.cc
        thirdparty/php/sockets/sockaddr_conv.cc
        thirdparty/php/standard/proc_open.cc
        thirdparty/php/standard/var_decoder.cc
	    thirdparty/nghttp2/nghttp2_hd.c
        thirdparty/nghttp2/nghttp2_rcbuf.c
        thirdparty/nghttp2/nghttp2_helper.c
        thirdparty/nghttp2/nghttp2_buf.c
        thirdparty/nghttp2/nghttp2_mem.c
        thirdparty/nghttp2/nghttp2_hd_huffman.c
        thirdparty/nghttp2/nghttp2_hd_huffman_data.c
    )
add_library(ext-swoole SHARED ${ext_src_list})
set_target_properties(ext-swoole PROPERTIES PREFIX "")
set_target_properties(ext-swoole PROPERTIES OUTPUT_NAME "swoole")
add_dependencies(ext-swoole lib-swoole)
```

--------------------------------

### Connecting to Redis with error checking

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Creates a redisContext and checks the err field to verify the connection. If the context is NULL, memory allocation failed; otherwise, errstr contains the error description.

```c
redisContext *c = redisConnect("127.0.0.1", 6379);
if (c == NULL || c->err) {
    if (c) {
        printf("Error: %s\n", c->errstr);
        // handle error
    } else {
        printf("Can't allocate redis context\n");
    }
}
```

--------------------------------

### Git commit with workflow parameters --filter and --valgrind

Source: https://github.com/swoole/swoole-src/blob/master/docs/WORKFLOW-PARAMETERS.md

Use this shell command to trigger selected workflows via --filter and enable valgrind testing with --valgrind. The filter names must match the YAML filenames of the workflows. For --asan, replace --valgrind with --asan.

```shell
git commit -m "commit message --filter=[core][unit] --valgrind"
```

--------------------------------

### Sending a simple SET command

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Uses redisCommand with a format string to send a simple SET command. The reply variable is not shown but is the return value of redisCommand.

```c
reply = redisCommand(context, "SET foo bar");
```

--------------------------------

### Merge pdo_oci into Swoole source

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/pdo_oci/README.md

Clone the pdo_oci repository and use meld to merge it into the Swoole source tree.

```shell
git clone https://github.com/php/pecl-database-pdo_oci.git
meld soft/php/pecl-database-pdo_oci swoole-src/thirdparty/pdo_oci
```

--------------------------------

### Producer and Consumer Pattern with Channels

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Demonstrates coordinating multiple concurrent coroutines that push data into a single channel for processing.

```php
go(function () {
    // User: I need you to bring me some information back.
    // Channel: OK! I will be responsible for scheduling.
    $channel = new Swoole\Coroutine\Channel;
    go(function () use ($channel) {
        // Coroutine A: Ok! I will show you the github addr info
        $addr_info = Co::getaddrinfo('github.com');
        $channel->push(['A', json_encode($addr_info, JSON_PRETTY_PRINT)]);
    });
    go(function () use ($channel) {
        // Coroutine B: Ok! I will show you what your code look like
        $mirror = Co::readFile(__FILE__);
        $channel->push(['B', $mirror]);
    });
    go(function () use ($channel) {
        // Coroutine C: Ok! I will show you the date
        $channel->push(['C', date(DATE_W3C)]);
    });
    for ($i = 3; $i--;) {
        list($id, $data) = $channel->pop();
        echo "From {$id}:\n {$data}\n";
    }
    // User: Amazing, I got every information at earliest time!
});
```

--------------------------------

### redisCommandArgv prototype

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Issues a command with an array of arguments and optional lengths. Pass NULL for argvlen to use strlen on each argument; provide the full array for binary-safe arguments. Returns the same as redisCommand.

```c
void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
```

--------------------------------

### Configure core-tests executable

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Collects source files, defines the core-tests executable, and sets up include directories and link libraries.

```cmake
file(GLOB_RECURSE core_test_files core-tests/src/*.cpp thirdparty/llhttp/*.c)
add_executable(core-tests ${core_test_files})
add_dependencies(core-tests lib-swoole)
include_directories(BEFORE core-tests/include thirdparty thirdparty/hiredis thirdparty/llhttp/ ${GTEST_INCLUDE_DIRS} ${NGHTTP2_INCLUDE_DIR})
target_link_libraries(core-tests swoole pthread ssl crypto ${GTEST_BOTH_LIBRARIES} ${NGHTTP2_LIBRARIES})
```

--------------------------------

### Memory Detection with Valgrind

Source: https://github.com/swoole/swoole-src/blob/master/docs/ISSUE.md

Command to run a PHP script with Valgrind to detect memory issues, logging the output to a file.

```shell
USE_ZEND_ALLOC=0 valgrind --log-file=/tmp/valgrind.log php your_file.php
```

--------------------------------

### Enter the test container

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Command to enter the swoole container with an interactive shell. You can cancel the unit test with CTRL+C.

```shell
docker exec -it -e LINES=$(tput lines) -e COLUMNS=$(tput cols) swoole /bin/bash
```

--------------------------------

### Address Sanitizer Debugging with Docker

Source: https://github.com/swoole/swoole-src/blob/master/docs/ISSUE.md

Commands to pull and run the Swoole debug Docker image for memory detection without significant performance impact.

```shell
docker pull phpswoole/swoole:dev-debug
docker run -it --rm phpswoole/swoole:dev-debug /bin/bash
php your_file.php
```

--------------------------------

### CMake Build for Core Library

Source: https://github.com/swoole/swoole-src/blob/master/CLAUDE.md

Builds the core library and C++ tests without requiring a full PHP build.

```bash
mkdir -p build && cd build && cmake .. && make -j$(nproc)
```

--------------------------------

### Reply callback prototype

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Prototype for reply callbacks. The 'privdata' argument can carry arbitrary data from the command queue point.

```c
void(redisAsyncContext *c, void *reply, void *privdata);
```

--------------------------------

### Manage Timers with Coroutines

Source: https://github.com/swoole/swoole-src/blob/master/README.md

An alternative approach to timers using a coroutine loop with Co::sleep.

```php
go(function () {
    $i = 0;
    while (true) {
        Co::sleep(0.1);
        echo "📝 Do something...\n";
        if (++$i === 5) {
            echo "🛎 Done\n";
            break;
        }
    }
    echo "🎉 All right!\n";
});
```

--------------------------------

### Run PHP tests

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Command to run the automated test script that creates containers for multiple PHP environments and runs build and unit tests.

```shell
./scripts/route.sh
```

--------------------------------

### redisCommand

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Sends a command to Redis using a printf-like format. Supports %s for strings, %b for binary safe strings, and can be used with arguments anywhere in the command.

```APIDOC
## redisCommand

### Description
Sends a command to Redis using a printf-like format. Supports %s for strings, %b for binary safe strings, and can be used with arguments anywhere in the command.

### Function Signature
```c
void *redisCommand(redisContext *c, const char *format, ...);
```

### Parameters
- **c** (redisContext*) - Required - The context returned by redisConnect.
- **format** (const char*) - Required - A printf-style format string for the command.
- **...** - Optional - Arguments to be interpolated into the format string.

### Format Specifiers
- **%s** - Interpolates a string, using strlen to determine length.
- **%b** - Interpolates a binary safe string; requires a size_t length argument.

### Return Value
- **void*** - A pointer to a redisReply object on success, or NULL on error. On error, the context's err field is set and the context cannot be reused.

### Examples
```c
reply = redisCommand(context, "SET foo bar");
reply = redisCommand(context, "SET foo %s", value);
reply = redisCommand(context, "SET foo %b", value, (size_t) valuelen);
reply = redisCommand(context, "SET key:%s %s", myid, value);
```
```

--------------------------------

### Analyze Core Dump with GDB

Source: https://github.com/swoole/swoole-src/blob/master/docs/ISSUE.md

Commands to open a core dump file using GDB for post-mortem analysis.

```shell
gdb php core
gdb php /tmp/core.4596
```

--------------------------------

### View Call Stack in GDB

Source: https://github.com/swoole/swoole-src/blob/master/docs/ISSUE.md

Command to display the call stack information once inside the GDB environment.

```shell
(gdb) bt
```

--------------------------------

### Run PHP tests with special branch

Source: https://github.com/swoole/swoole-src/blob/master/docs/TESTS.md

Command to run the test script with a specific Swoole branch, e.g., 'alpine'.

```shell
SWOOLE_BRANCH=alpine ./scripts/route.sh
```

--------------------------------

### Configure lib-swoole library

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Defines the shared library lib-swoole, sets its output name and version, and links necessary dependencies including optional code coverage support.

```cmake
link_directories(${LIBRARY_OUTPUT_PATH})
add_library(lib-swoole SHARED ${SRC_LIST})
set_target_properties(lib-swoole PROPERTIES OUTPUT_NAME "swoole" VERSION ${SWOOLE_VERSION})
target_link_libraries(lib-swoole ${SWOOLE_LINK_LIBRARIES})

if (CODE_COVERAGE)
    target_link_libraries(lib-swoole coverage_config gcov)
endif(CODE_COVERAGE)
```

--------------------------------

### Issue commands with redisAsyncCommand and redisAsyncCommandArgv

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Both functions queue commands asynchronously. Return REDIS_OK on success, REDIS_ERR otherwise (e.g., when disconnecting).

```c
int redisAsyncCommand(
  redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,
  const char *format, ...);
int redisAsyncCommandArgv(
  redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,
  int argc, const char **argv, const size_t *argvlen);
```

--------------------------------

### redisAsyncCommand

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Issues a command to Redis asynchronously using a printf-style format. Requires a callback function that is called when the reply is received. Returns REDIS_OK when the command was successfully added to the output buffer, REDIS_ERR otherwise.

```APIDOC
## redisAsyncCommand

### Description
Issues a command to Redis asynchronously using a printf-style format. Requires a callback function that is called when the reply is received. Returns REDIS_OK when the command was successfully added to the output buffer, REDIS_ERR otherwise.

### Function Signature
```c
int redisAsyncCommand(
  redisAsyncContext *ac, redisCallbackFn *fn, void *privdata,
  const char *format, ...);
```

### Parameters
- **ac** (redisAsyncContext*) - Required - The asynchronous context.
- **fn** (redisCallbackFn*) - Required - The reply callback function. The callback prototype is: `void(redisAsyncContext *c, void *reply, void *privdata);`
- **privdata** (void*) - Optional - Arbitrary data passed to the callback.
- **format** (const char*) - Required - The command format string, similar to printf.
- **...** - Additional arguments for the format string.

### Return Value
- **int** - Returns `REDIS_OK` when the command was successfully added to the output buffer, `REDIS_ERR` otherwise (e.g., when the connection is being disconnected).

### Notes
- Commands are automatically pipelined due to the nature of an event loop.
- If the reply for a command with a NULL callback is read, it is immediately freed.
- When the callback is non-NULL, the memory is freed immediately following the callback; the reply is only valid for the duration of the callback.
- All pending callbacks are called with a NULL reply when the context encountered an error.
```

--------------------------------

### Zero-length WSABUF buffer for IOCP probes

Source: https://github.com/swoole/swoole-src/blob/master/docs/windows-iocp-curl.md

Defines a zero-length WSABUF buffer used for IOCP read and write probes. The buffer points to a dummy variable and has length zero, so no payload data is transferred.

```cpp
WSABUF buffer;
buffer.buf = &dummy;
buffer.len = 0;
```

--------------------------------

### Generate self-signed SSL certificate with OpenSSL

Source: https://github.com/swoole/swoole-src/blob/master/examples/ssl/gen_cert.md

Generates a self-signed SSL certificate for local development or testing. Run these commands in order to create a private key, a certificate signing request, and a certificate valid for 365 days.

```shell
openssl genrsa -out ssl.key 2048
openssl req -new -key ssl.key -out ssl.csr
openssl x509 -req -days 365 -in ssl.csr -signkey ssl.key -out ssl.crt
```

--------------------------------

### Mixed Server Protocol Configuration

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Defines helper functions and options for TCP packet packing and unpacking.

```php
function tcp_pack(string $data): string
{
    return pack('N', strlen($data)) . $data;
}
function tcp_unpack(string $data): string
{
    return substr($data, 4, unpack('N', substr($data, 0, 4))[1]);
}
$tcp_options = [
    'open_length_check' => true,
    'package_length_type' => 'N',
    'package_length_offset' => 0,
    'package_body_offset' => 4
];
```

--------------------------------

### Swoole Coroutine Performance Benchmark

Source: https://github.com/swoole/swoole-src/blob/master/README.md

This script enables the Swoole coroutine runtime and executes multiple concurrent tasks including sleep cycles, file operations, PDO/MySQLi database queries, and TCP/UDP server-client communication to measure performance.

```php
Swoole\Runtime::enableCoroutine();
$s = microtime(true);
Co\run(function() {
    // i just want to sleep...
    for ($c = 100; $c--;) {
        go(function () {
            for ($n = 100; $n--;) {
                usleep(1000);
            }
        });
    }

    // 10K file read and write
    for ($c = 100; $c--;) {
        go(function () use ($c) {
            $tmp_filename = "/tmp/test-{$c}.php";
            for ($n = 100; $n--;) {
                $self = file_get_contents(__FILE__);
                file_put_contents($tmp_filename, $self);
                assert(file_get_contents($tmp_filename) === $self);
            }
            unlink($tmp_filename);
        });
    }

    // 10K pdo and mysqli read
    for ($c = 50; $c--;) {
        go(function () {
            $pdo = new PDO('mysql:host=127.0.0.1;dbname=test;charset=utf8', 'root', 'root');
            $statement = $pdo->prepare('SELECT * FROM `user`');
            for ($n = 100; $n--;) {
                $statement->execute();
                assert(count($statement->fetchAll()) > 0);
            }
        });
    }
    for ($c = 50; $c--;) {
        go(function () {
            $mysqli = new Mysqli('127.0.0.1', 'root', 'root', 'test');
            $statement = $mysqli->prepare('SELECT `id` FROM `user`');
            for ($n = 100; $n--;) {
                $statement->bind_result($id);
                $statement->execute();
                $statement->fetch();
                assert($id > 0);
            }
        });
    }

    // php_stream tcp server & client with 12.8K requests in single process
    function tcp_pack(string $data): string
    {
        return pack('n', strlen($data)) . $data;
    }

    function tcp_length(string $head): int
    {
        return unpack('n', $head)[1];
    }

    go(function () {
        $ctx = stream_context_create(['socket' => ['so_reuseaddr' => true, 'backlog' => 128]]);
        $socket = stream_socket_server(
            'tcp://0.0.0.0:9502',
            $errno, $errstr, STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $ctx
        );
        if (!$socket) {
            echo "$errstr ($errno)\n";
        } else {
            $i = 0;
            while ($conn = stream_socket_accept($socket, 1)) {
                stream_set_timeout($conn, 5);
                for ($n = 100; $n--;) {
                    $data = fread($conn, tcp_length(fread($conn, 2)));
                    assert($data === "Hello Swoole Server #{$n}!");
                    fwrite($conn, tcp_pack("Hello Swoole Client #{$n}!"));
                }
                if (++$i === 128) {
                    fclose($socket);
                    break;
                }
            }
        }
    });
    for ($c = 128; $c--;) {
        go(function () {
            $fp = stream_socket_client("tcp://127.0.0.1:9502", $errno, $errstr, 1);
            if (!$fp) {
                echo "$errstr ($errno)\n";
            } else {
                stream_set_timeout($fp, 5);
                for ($n = 100; $n--;) {
                    fwrite($fp, tcp_pack("Hello Swoole Server #{$n}!"));
                    $data = fread($fp, tcp_length(fread($fp, 2)));
                    assert($data === "Hello Swoole Client #{$n}!");
                }
                fclose($fp);
            }
        });
    }

    // udp server & client with 12.8K requests in single process
    go(function () {
        $socket = new Swoole\Coroutine\Socket(AF_INET, SOCK_DGRAM, 0);
        $socket->bind('127.0.0.1', 9503);
        $client_map = [];
        for ($c = 128; $c--;) {
            for ($n = 0; $n < 100; $n++) {
                $recv = $socket->recvfrom($peer);
                $client_uid = "{$peer['address']}:{$peer['port']}";
                $id = $client_map[$client_uid] = ($client_map[$client_uid] ?? -1) + 1;
                assert($recv === "Client: Hello #{$id}!");
                $socket->sendto($peer['address'], $peer['port'], "Server: Hello #{$id}!");
            }
        }
        $socket->close();
    });
    for ($c = 128; $c--;) {
        go(function () {
            $fp = stream_socket_client("udp://127.0.0.1:9503", $errno, $errstr, 1);
            if (!$fp) {
                echo "$errstr ($errno)\n";
            } else {
                for ($n = 0; $n < 100; $n++) {
                    fwrite($fp, "Client: Hello #{$n}!");
                    $recv = fread($fp, 1024);
                    list($address, $port) = explode(':', (stream_socket_get_name($fp, true)));
                    assert($address === '127.0.0.1' && (int)$port === 9503);
                    assert($recv === "Server: Hello #{$n}!");
                }
                fclose($fp);
            }
        });
    }
});
echo 'use ' . (microtime(true) - $s) . ' s';
```

--------------------------------

### WSASend for write interest

Source: https://github.com/swoole/swoole-src/blob/master/docs/windows-iocp-curl.md

Submits a zero-length WSASend operation to register write interest on a socket. The completion packet triggers the IOCP dispatcher callback.

```cpp
WSASend(sockfd, &buffer, 1, &bytes, 0, &overlapped, nullptr);
```

--------------------------------

### SMProxy feature list (MySQL connection pool)

Source: https://github.com/swoole/swoole-src/wiki/Awesome

Lists the key features of SMProxy, a MySQL connection pool built on Swoole. Supports read/write splitting, SQL92, MySQL native protocol, multiple connections/databases/users, transactions, coroutine scheduling, HandshakeV10, and MySQL 5.6-5.7 compatibility.

```text
支持读写分离
支持数据库连接池，能够有效解决PHP带来的数据库连接瓶颈
支持SQL92标准
遵守Mysql原生协议，跨语言，跨平台的通用中间件代理。
支持多个数据库连接，多个数据库，多个用户，灵活搭配。
支持mysql事物
采用协程调度
支持 HandshakeV10 协议版本
完美兼容mysql5.6-5.7
兼容各大框架，无缝提升性能
```

--------------------------------

### WebSocket Client Connection and Event Handlers

Source: https://github.com/swoole/swoole-src/blob/master/examples/websocket/client.html

Creates a WebSocket connection to ws://127.0.0.1:9501 and defines handlers for open, close, message, and error events. Logs connection status and received data to the console.

```javascript
var wsServer = 'ws://127.0.0.1:9501';
var websocket = new WebSocket(wsServer);
websocket.onopen = function (evt) {
  console.log("Connected to WebSocket server.");
};
websocket.onclose = function (evt) {
  console.log("Disconnected");
};
websocket.onmessage = function (evt) {
  console.log('Retrieved data from server: ' + evt.data);
};
websocket.onerror = function (evt, e) {
  console.log('Error occured: ' + evt.data);
};
```

--------------------------------

### redisAppendCommand

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Formats and appends a command to the output buffer without waiting for a reply. Used for pipelining.

```APIDOC
## [C] redisAppendCommand

### Description
Formats a command and adds it to the output buffer without sending or waiting for a reply. Allows batching multiple commands.

### Function Signature
void redisAppendCommand(redisContext *c, const char *format, ...);

### Parameters
- **c** (redisContext *) - Required - The context of the connection.
- **format** (const char *) - Required - A printf-style format string.
- **...** - Optional - Arguments to the format string.

### Return Value
void.
```

--------------------------------

### redisCommandArgv

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Sends a command to Redis using an array of arguments with optional lengths. The return value has the same semantic as redisCommand.

```APIDOC
## [C] redisCommandArgv

### Description
Sends a command with an array of arguments to Redis. Similar to redisCommand, allows binary-safe arguments by providing lengths.

### Function Signature
void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);

### Parameters
- **c** (redisContext *) - Required - The context of the connection.
- **argc** (int) - Required - The number of arguments in argv.
- **argv** (const char **) - Required - An array of strings representing the command and its arguments.
- **argvlen** (const size_t *) - Optional - An array of lengths for each argument. If NULL, strlen() is used.

### Return Value
pointer to redisReply on success, NULL on failure. Same semantic as redisCommand.
```

--------------------------------

### redisAppendCommand and redisAppendCommandArgv prototypes

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Appends commands to the output buffer without reading a reply. Use with redisGetReply to pipeline commands. These are identical to the redisCommand family except they do not return a reply.

```c
void redisAppendCommand(redisContext *c, const char *format, ...);
void redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen);
```

--------------------------------

### Check for nghttp2 dependency

Source: https://github.com/swoole/swoole-src/blob/master/CMakeLists.txt

Uses pkg_check_modules to verify the presence of libnghttp2 and logs the result.

```cmake
pkg_check_modules(NGHTTP2 REQUIRED libnghttp2)
if (${NGHTTP2_FOUND})
    message(STATUS "Found nghttp2")
else()
    message(STATUS "Not found nghttp2")
endif()
```

--------------------------------

### MySQL Coroutine Concurrency

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Demonstrates executing 10,000 concurrent MySQL read requests using Swoole coroutines.

```php
$s = microtime(true);
Co\run(function() {
    for ($c = 100; $c--;) {
        go(function () {
            $mysql = new Swoole\Coroutine\MySQL;
            $mysql->connect([
                'host' => '127.0.0.1',
                'user' => 'root',
                'password' => 'root',
                'database' => 'test'
            ]);
            $statement = $mysql->prepare('SELECT * FROM `user`');
            for ($n = 100; $n--;) {
                $result = $statement->execute();
                assert(count($result) > 0);
            }
        });
    }
});
echo 'use ' . (microtime(true) - $s) . ' s';
```

--------------------------------

### Disconnect callback prototype

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Prototype for the disconnect callback. The 'status' argument is REDIS_OK for user-initiated disconnects and REDIS_ERR for errors. The context is freed after the callback.

```c
void(const redisAsyncContext *c, int status);
```

--------------------------------

### Implement a Redis Connection Pool with Channel

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Uses a Channel to manage a fixed number of Redis connections, allowing concurrent coroutines to safely share resources without exceeding connection limits.

```php
class RedisPool
{
    /**@var \Swoole\Coroutine\Channel */
    protected $pool;

    /**
     * RedisPool constructor.
     * @param int $size max connections
     */
    public function __construct(int $size = 100)
    {
        $this->pool = new \Swoole\Coroutine\Channel($size);
        for ($i = 0; $i < $size; $i++) {
            $redis = new \Swoole\Coroutine\Redis();
            $res = $redis->connect('127.0.0.1', 6379);
            if ($res == false) {
                throw new \RuntimeException("failed to connect redis server.");
            } else {
                $this->put($redis);
            }
        }
    }

    public function get(): \Swoole\Coroutine\Redis
    {
        return $this->pool->pop();
    }

    public function put(\Swoole\Coroutine\Redis $redis)
    {
        $this->pool->push($redis);
    }

    public function close(): void
    {
        $this->pool->close();
        $this->pool = null;
    }
}

go(function () {
    $pool = new RedisPool();
    // max concurrency num is more than max connections
    // but it's no problem, channel will help you with scheduling
    for ($c = 0; $c < 1000; $c++) {
        go(function () use ($pool, $c) {
            for ($n = 0; $n < 100; $n++) {
                $redis = $pool->get();
                assert($redis->set("awesome-{$c}-{$n}", 'swoole'));
                assert($redis->get("awesome-{$c}-{$n}") === 'swoole');
                assert($redis->delete("awesome-{$c}-{$n}"));
                $pool->put($redis);
            }
        });
    }
});
```

--------------------------------

### Using specifiers anywhere in an argument

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Shows that specifiers can be used anywhere within an argument, as arguments are separated by spaces.

```c
reply = redisCommand(context, "SET key:%s %s", myid, value);
```

--------------------------------

### Manage Timers with Swoole Timer

Source: https://github.com/swoole/swoole-src/blob/master/README.md

Uses tick and after methods to schedule recurring and one-time tasks.

```php
$id = Swoole\Timer::tick(100, function () {
    echo "⚙️ Do something...\n";
});
Swoole\Timer::after(500, function () use ($id) {
    Swoole\Timer::clear($id);
    echo "⏰ Done\n";
});
Swoole\Timer::after(1000, function () use ($id) {
    if (!Swoole\Timer::exists($id)) {
        echo "✅ All right!\n";
    }
});
```

--------------------------------

### Customizing reply objects

Source: https://github.com/swoole/swoole-src/blob/master/thirdparty/hiredis/README.md

Explains how to customize the functions responsible for creating redisReply instances by setting the 'fn' field on the redisReader struct.

```APIDOC
## Customizing Replies

### Description
The function `redisReaderGetReply` creates `redisReply` objects. To customize how replies are created, set the `fn` field on the `redisReader` struct. This should be done immediately after creating the `redisReader`.

### Usage
```c
reader->fn = custom_functions;
```

### Example
See [hiredis-rb](https://github.com/pietern/hiredis-rb/blob/master/ext/hiredis_ext/reader.c) for an example of customized reply object functions.

```

--------------------------------

### Inspect Code Segments in GDB

Source: https://github.com/swoole/swoole-src/blob/master/docs/ISSUE.md

Commands to view specific code segments corresponding to stack frame IDs.

```shell
(gdb)f 1
(gdb)f 0
```
Tokens:
Raw