$db = new swoole_mysql();
$server = ['host' => '192.168.56.102'];

$db->connect($server, function ($db, $r) {
    if ($r === false) {
        die($db->connect_error);
    }

    echo "Connected to DB";
});

$db = new swoole_mysql();
$server = array('host' => '192.168.56.102');

$db->connect($server, function ($db, $r) {
    if ($r === false) { die( $db->connect_error); }

    $sql = 'show tables';

    $db->query($sql, function(swoole_mysql $db, $r) {
        if ($r === false){
            var_dump($db->error, $db->errno);
        } elseif ($r === true ){
            var_dump($db->affected_rows, $db->insert_id);
        }
        var_dump($r);
        $db->close();
    });
});

echo "main start\n";
go(function () {
    echo "coro ".co::getcid()." start\n";
});
echo "end\n";

/*
main start
coro 1 start
end
*/

echo "main start\n";
go(function () {
    echo "coro ".co::getcid()." start\n";
    co::sleep(.1); //switch at this point
    echo "coro ".co::getcid()." end\n";
});

go(function () {
    echo "coro ".co::getcid()." start\n";
    echo "coro ".co::getcid()." end\n";
});
echo "end\n";

$mysql = new Swoole\Coroutine\MySQL();
$mysql->connect([
    'host' => '127.0.0.1',
    'user' => 'user',
]);
$mysql->setDefer();
$mysql->query('select sleep(1)');

// ...

$result = $mysql->recv();

Swoole\Runtime::enableCoroutine();

go(function () {
    $redis = new redis;
    $retval = $redis->connect("127.0.0.1", 6379);
    var_dump($retval, $redis->getLastError());
    var_dump($redis->get("key"));
    var_dump($redis->set("key", "value2"));
    var_dump($redis->get("key"));
    $redis->close();
});

swoole:
    http_server:
        port: 9501
        host: 0.0.0.0
        running_mode: process
        settings:
            reactor_count: 2
            worker_count: 4

/**
 * {@inheritdoc}
 *
 * @throws \Exception
 */
public function handle(SwooleRequest $request, SwooleResponse $response): void
{
    $httpFoundationRequest = $this->requestFactory->make($request);
    $httpFoundationResponse = $this->kernel->handle($httpFoundationRequest);
    $this->responseProcessor->process($httpFoundationResponse, $response);

    if ($this->kernel instanceof TerminableInterface) {
        $this->kernel->terminate($httpFoundationRequest, $httpFoundationResponse);
    }
}

<?php
/**
 * Provides a way to reset an object to its initial state.
 *
 * When calling the "reset()" method on an object, it should be put back to its
 * initial state. This usually means clearing any internal buffers and forwarding
 * the call to internal dependencies. All properties of the object should be put
 * back to the same state it had when it was first ready to use.
 *
 * This method could be called, for example, to recycle objects that are used as
 * services, so that they can be used to handle several requests in the same
 * process loop (note that we advise making your services stateless instead of
 * implementing this interface when possible.)
 */
interface ResetInterface
{
    public function reset();
}

abstract class Kernel implements KernelInterface, RebootableInterface, TerminableInterface 
{    
    /**
     * {@inheritdoc}
     */
    public function boot()
    {
        if (true === $this->booted) {
            if (!$this->requestStackSize && $this->resetServices) {
                if ($this->container->has('services_resetter')) {
                    $this->container->get('services_resetter')->reset();
                }
                $this->resetServices = false;
                if ($this->debug) {
                    $this->startTime = microtime(true);
                }
            }

            return;
        }
     
        // ...
        $this->booted = true;
    }

/**
 * https://roadrunner.dev/docs/integrations-symfony
 */
while ($req = $psr7->acceptRequest()) {
    try {
        $request = $httpFoundationFactory->createRequest($req);
        $response = $kernel->handle($request);
        $psr7->respond($diactorosFactory->createResponse($response));
        $kernel->terminate($request, $response);
        $kernel->reboot(null);
    } catch (\Throwable $e) {
        $psr7->getWorker()->error((string)$e);
    }
}

public function reboot($warmupDir) {
    $this->shutdown();
    $this->warmupDir = $warmupDir;
    $this->boot();
}

public function shutdown() {
    if (false === $this->booted) {
        return;
    }

    $this->booted = false;
    foreach ($this->getBundles() as $bundle) {
        $bundle->shutdown();
        $bundle->setContainer(null);
    }

    $this->container = null;
    $this->requestStackSize = 0;
    $this->resetServices = false;
}

namespace K911\Swoole\Bridge\Doctrine\ORM;

final class EntityManagerHandler implements RequestHandlerInterface
{
    /**
     * {@inheritdoc}
     */
    public function handle(Request $request, Response $response): void
    {
        if (!$this->connection->ping()) {
            $this->connection->close();
            $this->connection->connect();
        }

        $this->decorated->handle($request, $response);

        $this->entityManager->clear();
    }
}

<?php

$serv = new swoole_server("127.0.0.1", 9501);
$serv->set(array(
    'worker_num' => 4,    
    'max_request' => 1000,  
    'dispatch_mode'=>3,
));

spec:
  containers:
  - name: liveness
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 5
    readinessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 5
    

<?php
namespace Liip\Monitor\Check;
class RabbitMQCheck extends Check {
    /**
     * {@inheritdoc}
     * @see \Liip\MonitorBundle\Check\CheckInterface::check()
     */
    public function check() {
        try {
            $conn = new AMQPConnection(
                $this->host,
                $this->port,
                $this->user,
                $this->password,
                $this->vhost
            );
            $ch = $conn->channel();
            $result = $this->buildResult('OK', CheckResult::OK);
        } catch (\Exception $e) {
            $result = $this->buildResult($e->getMessage(), CheckResult::CRITICAL);
        }

        return $result;
    }
}

<?php
namespace ZendDiagnostics\Check;
class RabbitMQ extends AbstractCheck {
    /**
     * @see \ZendDiagnostics\Check\CheckInterface::check()
     * @return Failure|Success
     */
    public function check()
    {
        if (! class_exists('PhpAmqpLib\Connection\AMQPConnection')) {
            return new Failure('PhpAmqpLib is not installed');
        }

        $conn = new AMQPConnection(
            $this->host,
            $this->port,
            $this->user,
            $this->password,
            $this->vhost
        );

        $conn->channel();

        return new Success();
    }
}