PHP code example of sidalex / swoole-app

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

sidalex / swoole-app example snippets

declare(strict_types=1);
t_contents('./config.json'));

$app = new \Sidalex\SwooleApp\Application($config);
$server = $app->createServer();
$server->start();

$config = json_decode(file_get_contents('./config.json'));

$config = new stdClass();
$config->notFoundController = 'appNameSpaceMyApp\MyNotFoundController';
$config->controllers = [
'appNameSpaseMyApp\MyFirstControllerNamespace',
'appNameSpaseMyApp\MySecondControllerNamespace',
'appNameSpaseMyApp\MyThreeControllerNamespace',
];
$config->CyclicJobs =[
'appNameSpaseMyApp\MyFirstCyclicJobsClass',
'appNameSpaseMyApp\MySecondCyclicJobsClass',
'appNameSpaseMyApp\MyThreeCyclicJobsClass',
];

object(stdClass) {
  ["DEBUG"] => true
  ["DB"] => object(stdClass) {
    ["HOST"] => "localhost"
    ["PORT"] => 3306
  }
}

$app = new \Sidalex\SwooleApp\Application($config);
$server = $app->createServer(); // Uses configured host/port/mode
$server->start();

use Sidalex\SwooleApp\Classes\Validators\ConfigValidatorInterface;

class DatabaseConfigValidator implements ConfigValidatorInterface
{
    public function validate(\stdClass $config): void
    {
        if (!isset($config->DB->HOST)) {
            throw new \RuntimeException("Database host 

if (!$builder->validate([DatabaseConfigValidator::class])) {
    $errors = $builder->getErrors();
    // Handle errors
}

Swoole\Server->task(Sidalex\SwooleApp\Classes\Tasks\Data\TaskDataInterface $data, int $dstWorkerId = -1, callable $finishCallback = null);

$result = Swoole\Server->taskwait((Sidalex\SwooleApp\Classes\Tasks\Data\TaskDataInterface $data, float $timeout = 0.5, int $dstWorkerId = -1) :TaskResulted

$taskData = new BasicTaskData('Sidalex\TestSwoole\Tasks\TestTaskExecutor', ['test' => 'test1']);

$taskResult = $this->server->taskwait($taskData);
var_export($taskResult->getResult());

$taskData = new BasicTaskData('Sidalex\TestSwoole\Tasks\TestTaskExecutor', ['test' => 'test1']);
        /**
         * @var $taskResult TaskResulted
         */
        $taskResult =  $this->server->taskwait($taskData);
        var_export($taskResult->getResult());

$taskData = new BasicTaskData('Sidalex\TestSwoole\Tasks\TestTaskExecutor', ['test' => 'test1']);
/**
* @var $taskResult TaskResulted
*/
$taskResult =  $this->server->taskwait($taskData);
var_export($taskResult->getResult());

$config = new stdClass();
$config->CyclicJobs =[
"Sidalex\TestSwoole\CyclicJobs\TestCyclicJobs",
];

{
"CyclicJobs": [
"Sidalex\\TestSwoole\\CyclicJobs\\TestCyclicJobs"
]
}

class MyCyclicJob implements CyclicJobsInterface
{
private $application;
private $server;

    public function __construct(Application $application, Server $server)
    {
        $this->application = $application;
        $this->server = $server;
    }

    public function getTimeSleepSecond(): float
    {
        // Returns the sleep time in seconds
        return 5.0;
    }

    public function runJob(): void
    {
        $arr = [1,2,3,4,5,6,7,8,9];
        foreach ($arr as $value){
            if($value % 3 == 0)
            {
                echo "example";
            }
        }
    }
}

$config = new \stdClass();
$config->globalMiddlewares = [
    // Simple string - middleware class
    'App\Middleware\AuthMiddleware',
    
    // Or array with class and options
    [
        'class' => 'App\Middleware\CorsMiddleware',
        'options' => ['origins' => ['https://example.com']]
    ]
];

use Sidalex\SwooleApp\Classes\Controllers\Route;
use Sidalex\SwooleApp\Classes\Middleware\Middleware;

#[Route(uri: '/api/protected', method: 'GET')]
#[Middleware(middlewareClass: 'App\Middleware\AuthMiddleware')]
#[Middleware(middlewareClass: 'App\Middleware\LogMiddleware', options: ['level' => 'info'])]
class ProtectedController extends AbstractController
{
    public function execute(): \Swoole\Http\Response
    {
        // Controller logic
    }
}

use Sidalex\SwooleApp\Classes\Middleware\MiddlewareInterface;
use Sidalex\SwooleApp\Application;

class AuthMiddleware implements MiddlewareInterface
{
    public function process(
        \Swoole\Http\Request $request,
        \Swoole\Http\Response $response,
        Application $application,
        callable $next
    ): \Swoole\Http\Response {
        // Authentication check
        if (!$this->isAuthenticated($request)) {
            $response->setStatusCode(401);
            $response->end('Unauthorized');
            return $response;
        }
        
        // Continue middleware chain
        return $next($request, $response);
    }
}

use Sidalex\SwooleApp\Classes\Middleware\ConfigurableMiddlewareInterface;

class CorsMiddleware implements ConfigurableMiddlewareInterface
{
    private array $options;
    
    public function __construct(array $options = [])
    {
        $this->options = $options;
    }
    
    public function process(/* ... */): \Swoole\Http\Response
    {
        // Use configuration options
        $allowedOrigins = $this->options['origins'] ?? ['*'];
        // ...
    }
}

use Sidalex\SwooleApp\Classes\Validators\MiddlewareConfigValidator;

$validators = [MiddlewareConfigValidator::class];
$app = new Application($config, $validators);

#[\Sidalex\SwooleApp\Classes\Controllers\Route(uri: '/api/{v1}/get_resume',method:"POST")]
class TestController extends AbstractController
{

use Sidalex\SwooleApp\Classes\Controllers\Route;

#[Route(uri: '/api/{v1}/get_resume',method:"POST")]
class TestController extends AbstractController
{

$this->response->setHeader('Content-Type', 'application/json');
$this->response->end(
                json_encode(
                 [
                     'status' => 'error',
                     'message' => 'collection '.$this->uri_params['collection_name'] . 'not found in collectionList',
                 ]
                )
            );

class NotFoundController implements ControllerInterface
{

    private \Swoole\Http\Request $request;
    private \Swoole\Http\Response $responce;
    /**
     * @var array|string[]
     */
    private array $uri_params;

    public function __construct(\Swoole\Http\Request $request, \Swoole\Http\Response $response, array $uri_params=[])
    {
        $this->request = $request;
        $this->responce = $response;
        $this->uri_params = $uri_params;
    }

    public function execute(): \Swoole\Http\Response
    {
        $this->responce->setStatusCode(404);
        $this->responce->setHeader('Content-Type', 'application/json');
        $this->responce->end(json_encode(
            [
                'codeStatus' => '404',
                'text' => 'Page not found'
            ]
        ));
        return $this->responce;
    }

    public function setApplication(Application $application, Server $server)
    {

    }
}

namespace YourApp\StateContainers;

use Sidalex\SwooleApp\Classes\Initiation\AbstractContainerInitiator;
use Sidalex\SwooleApp\Application;

class DatabaseConnectionContainer extends AbstractContainerInitiator
{
    protected string $key = 'database';

    public function init(Application $app): void
    {
        // Initialize your database connection here
        $config = $app->getConfig()->getContainer('database_config');
        
        $this->result = new \PDO(
            $config['dsn'],
            $config['username'],
            $config['password']
        );
    }
}

// In a controller:
$db = $this->application->getStateContainer()->getContainer('database');

// In a task executor:
$db = $this->app->getStateContainer()->getContainer('database');

// In a cyclic job:
$db = $this->application->getStateContainer()->getContainer('database');

$config = new \stdClass();
$config->events = [
    'workerStart' => [
        'before' => [
            // Closure handler
            0 => function(\Sidalex\SwooleApp\Application $app, \Swoole\Http\Server $server, int $workerId) {
                error_log("Worker {$workerId} starting");
            },
        ],
        'after' => [
            // Class method handler
            0 => [MyHandler::class, 'handle'],
        ],
    ],
    'request' => [
        'before' => [
            0 => [RequestLogger::class, 'log'],
        ],
    ],
];

// Logging worker start
class StartupLogger {
    public function handle(\Sidalex\SwooleApp\Application $app, \Swoole\Http\Server $server, int $workerId): void
    {
        $type = $server->taskworker ? 'Task Worker' : 'HTTP Worker';
        error_log("[{$type}] Worker #{$workerId} started");
    }
}

// Request validation
class RequestValidator {
    public function handle(\Sidalex\SwooleApp\Application $app, \Swoole\Http\Request $request, \Swoole\Http\Response $response): void
    {
        $uri = $request->server['request_uri'] ?? '/';
        if (str_starts_with($uri, '/admin') && !$this->hasAdminToken($request)) {
            $response->status(403);
            $response->end(json_encode(['error' => 'Forbidden']));
        }
    }

    private function hasAdminToken(\Swoole\Http\Request $request): bool
    {
        return isset($request->header['x-admin-token']);
    }
}

// Config
$config = new \stdClass();
$config->events = [
    'workerStart' => [
        'after' => [
            0 => [StartupLogger::class, 'handle'],
        ],
    ],
    'request' => [
        'before' => [
            0 => [RequestValidator::class, 'handle'],
        ],
    ],
];

$app = new \Sidalex\SwooleApp\Application($config);
$server = $app->createServer();
$server->start();

declare(strict_types=1);
t_contents('./config.json'));

$app = new \Sidalex\SwooleApp\Application($config);
$server = $app->createServer();
$server->start();

$config = json_decode(file_get_contents('./config.json'));

$config = new stdClass();
$config->notFoundController = 'appNameSpaceMyApp\MyNotFoundController';
$config->controllers = [
    'appNameSpaseMyApp\MyFirstControllerNamespace',
    'appNameSpaseMyApp\MySecondControllerNamespace',
    'appNameSpaseMyApp\MyThreeControllerNamespace',
];
$config->CyclicJobs =[
    'appNameSpaseMyApp\MyFirstCyclicJobsClass',
    'appNameSpaseMyApp\MySecondCyclicJobsClass',
    'appNameSpaseMyApp\MyThreeCyclicJobsClass',
];

object(stdClass) {
["DEBUG"] => true
["DB"] => object(stdClass) {
    ["HOST"] => "localhost"
    ["PORT"] => 3306
}
}

$app = new \Sidalex\SwooleApp\Application($config);
$server = $app->createServer(); // Использует настроенные host/port/mode
$server->start();

use Sidalex\SwooleApp\Classes\Validators\ConfigValidatorInterface;

class DatabaseConfigValidator implements ConfigValidatorInterface
{
    public function validate(\stdClass $config): void
    {
        if (!isset($config->DB->HOST)) {
            throw new \RuntimeException("Требуется хост базы данных");
        }
    }
}

if (!$builder->validate([DatabaseConfigValidator::class])) {
    $errors = $builder->getErrors();
    // Обработка ошибок
}

Swoole\Server->task(Sidalex\SwooleApp\Classes\Tasks\Data\TaskDataInterface $data, int $dstWorkerId = -1, callable $finishCallback = null)

$result = Swoole\Server->taskwait((Sidalex\SwooleApp\Classes\Tasks\Data\TaskDataInterface $data, float $timeout = 0.5, int $dstWorkerId = -1) :TaskResulted

#Sidalex\SwooleApp\Classes\Tasks\Data\BasicTaskData
$taskData = new BasicTaskData('Sidalex\TestSwoole\Tasks\TestTaskExecutor', ['test' => 'test1']);

$taskData = new BasicTaskData('Sidalex\TestSwoole\Tasks\TestTaskExecutor', ['test' => 'test1']);
        /**
         * @var $taskResult TaskResulted
         */
        $taskResult =  $this->server->taskwait($taskData);
        var_export($taskResult->getResult());

$taskData = new BasicTaskData('Sidalex\TestSwoole\Tasks\TestTaskExecutor', ['test' => 'test1']);
/**
* @var $taskResult TaskResulted
*/
$taskResult =  $this->server->taskwait($taskData);
var_export($taskResult->getResult());

$config = new stdClass();
$config->CyclicJobs = [
    "Sidalex\TestSwoole\CyclicJobs\TestCyclicJobs",
];

{
"CyclicJobs": [
    "Sidalex\\TestSwoole\\CyclicJobs\\TestCyclicJobs"
]
}

class MyCyclicJob implements CyclicJobsInterface
{
    private $application;
    private $server;

    public function __construct(Application $application, Server $server)
    {
        $this->application = $application;
        $this->server = $server;
    }

    public function getTimeSleepSecond(): float
    {
        // Возвращает время задержки в секундах
        return 5.0;
    }

    public function runJob(): void
    {
        $arr = [1,2,3,4,5,6,7,8,9];
        foreach ($arr as $value){
            if($value % 3 == 0)
            {
                echo "example";
            }
        }
    }
}

$config = new \stdClass();
$config->globalMiddlewares = [
    // Простая строка - класс Middleware
    'App\Middleware\AuthMiddleware',
    
    // Или массив с классом и опциями
    [
        'class' => 'App\Middleware\CorsMiddleware',
        'options' => ['origins' => ['https://example.com']]
    ]
];

use Sidalex\SwooleApp\Classes\Controllers\Route;
use Sidalex\SwooleApp\Classes\Middleware\Middleware;

#[Route(uri: '/api/protected', method: 'GET')]
#[Middleware(middlewareClass: 'App\Middleware\AuthMiddleware')]
#[Middleware(middlewareClass: 'App\Middleware\LogMiddleware', options: ['level' => 'info'])]
class ProtectedController extends AbstractController
{
    public function execute(): \Swoole\Http\Response
    {
        // Логика контроллера
    }
}

use Sidalex\SwooleApp\Classes\Middleware\MiddlewareInterface;
use Sidalex\SwooleApp\Application;

class AuthMiddleware implements MiddlewareInterface
{
    public function process(
        \Swoole\Http\Request $request,
        \Swoole\Http\Response $response,
        Application $application,
        callable $next
    ): \Swoole\Http\Response {
        // Проверка аутентификации
        if (!$this->isAuthenticated($request)) {
            $response->setStatusCode(401);
            $response->end('Unauthorized');
            return $response;
        }
        
        // Продолжение цепочки Middleware
        return $next($request, $response);
    }
}

use Sidalex\SwooleApp\Classes\Middleware\ConfigurableMiddlewareInterface;

class CorsMiddleware implements ConfigurableMiddlewareInterface
{
    private array $options;
    
    public function __construct(array $options = [])
    {
        $this->options = $options;
    }
    
    public function process(/* ... */): \Swoole\Http\Response
    {
        // Использование опций конфигурации
        $allowedOrigins = $this->options['origins'] ?? ['*'];
        // ...
    }
}

use Sidalex\SwooleApp\Classes\Validators\MiddlewareConfigValidator;

$validators = [MiddlewareConfigValidator::class];
$app = new Application($config, $validators);

#[\Sidalex\SwooleApp\Classes\Controllers\Route(uri: '/api/{v1}/get_resume',method:"POST")]
class TestController extends AbstractController
{

use Sidalex\SwooleApp\Classes\Controllers\Route;

#[Route(uri: '/api/{v1}/get_resume',method:"POST")]
class TestController extends AbstractController
{

$this->response->setHeader('Content-Type', 'application/json');
$this->response->end(
                json_encode(
                 [
                     'status' => 'error',
                     'message' => 'collection '.$this->uri_params['collection_name'] . 'not found in collectionList',
                 ]
                )
            );

$obj = json_decode($this->request->getContent());

class NotFoundController implements ControllerInterface
{

    private \Swoole\Http\Request $request;
    private \Swoole\Http\Response $responce;
    /**
     * @var array|string[]
     */
    private array $uri_params;

    public function __construct(\Swoole\Http\Request $request, \Swoole\Http\Response $response, array $uri_params=[])
    {
        $this->request = $request;
        $this->responce = $response;
        $this->uri_params = $uri_params;
    }

    public function execute(): \Swoole\Http\Response
    {
        $this->responce->setStatusCode(404);
        $this->responce->setHeader('Content-Type', 'application/json');
        $this->responce->end(json_encode(
            [
                'codeStatus' => '404',
                'text' => 'Page not found'
            ]
        ));
        return $this->responce;
    }

    public function setApplication(Application $application, Server $server)
    {

    }
}

namespace YourApp\StateContainers;

use Sidalex\SwooleApp\Classes\Initiation\AbstractContainerInitiator;

use Sidalex\SwooleApp\Application;

class DatabaseConnectionContainer extends AbstractContainerInitiator
{
protected string $key = 'database';

public function init(Application $app): void
{
// Инициализируйте здесь подключение к базе данных
$config = $app->getConfig()->getContainer('database_config');

$this->result = new \PDO(
$config['dsn'],
$config['username'],
$config['password']
);
}
}

// В контроллере:
$db = $this->application->getStateContainer()->getContainer('database');

// В исполнителе задач:
$db = $this->app->getStateContainer()->getContainer('database');

// В циклическом задании:
$db = $this->application->getStateContainer()->getContainer('database');

$config = new \stdClass();
$config->events = [
    'workerStart' => [
        'before' => [
            // Обработчик-замыкание
            0 => function(\Sidalex\SwooleApp\Application $app, \Swoole\Http\Server $server, int $workerId) {
                error_log("Worker {$workerId} starting");
            },
        ],
        'after' => [
            // Обработчик с методом класса
            0 => [MyHandler::class, 'handle'],
        ],
    ],
    'request' => [
        'before' => [
            0 => [RequestLogger::class, 'log'],
        ],
    ],
];

// Логирование старта воркера
class StartupLogger {
    public function handle(\Sidalex\SwooleApp\Application $app, \Swoole\Http\Server $server, int $workerId): void
    {
        $type = $server->taskworker ? 'Task Worker' : 'HTTP Worker';
        error_log("[{$type}] Worker #{$workerId} started");
    }
}

// Валидация запроса
class RequestValidator {
    public function handle(\Sidalex\SwooleApp\Application $app, \Swoole\Http\Request $request, \Swoole\Http\Response $response): void
    {
        $uri = $request->server['request_uri'] ?? '/';
        if (str_starts_with($uri, '/admin') && !$this->hasAdminToken($request)) {
            $response->status(403);
            $response->end(json_encode(['error' => 'Forbidden']));
        }
    }

    private function hasAdminToken(\Swoole\Http\Request $request): bool
    {
        return isset($request->header['x-admin-token']);
    }
}

// Конфиг
$config = new \stdClass();
$config->events = [
    'workerStart' => [
        'after' => [
            0 => [StartupLogger::class, 'handle'],
        ],
    ],
    'request' => [
        'before' => [
            0 => [RequestValidator::class, 'handle'],
        ],
    ],
];

$app = new \Sidalex\SwooleApp\Application($config);
$server = $app->createServer();
$server->start();

ini
SWOOLE_APP_DEBUG=true
SWOOLE_APP_DB__HOST=localhost
SWOOLE_APP_DB__PORT=3306

ini
SWOOLE_APP_SERVER_MODE=PROCESS
# или
SWOOLE_APP_SERVER_MODE=BASE

ini
SWOOLE_APP_SERVER_HOST=0.0.0.0
SWOOLE_APP_SERVER_PORT=9501