README

 _                               _  _____ 
| |                             | |/ ____|
| |     __ _ _ __ __ ___   _____| | (___  
| |    / _` | '__/ _` \ \ / / _ \ |\___ \ 
| |___| (_| | | | (_| |\ V /  __/ |____) |
|______\__,_|_|  \__,_| \_/ \___|_|_____/ 
                                           

🚀 LaravelS 是 一个现成的适配器，在 Swoole 和 Laravel/Lumen 之间。

请 关注 此存储库以获取最新更新。

中文文档

目录

• 特性
• 要求
• 安装
• 运行
• 部署
• 与 Nginx 合作（推荐）
• 与 Apache 合作
• 启用 WebSocket 服务器
• 监听事件
  • 系统事件
  • 自定义异步事件
• 异步任务队列
• 毫秒级定时任务
• 修改代码后自动重载
• 在项目中获取 SwooleServer 实例
• 使用 SwooleTable
• 多端口混合协议
• 协程
• 自定义进程
• 其他特性
• 重要提示
• 用户和案例
• 替代方案
• 赞助商
• 许可证

特性

• 内置 Http/WebSocket 服务器

• 多端口混合协议

• 自定义进程

• 内存驻留

• 异步事件监听

• 异步任务队列

• 毫秒级定时任务

• 优雅重载

• 修改代码后自动重载

• 支持 Laravel/Lumen，兼容性好

• 简单 & 现成

要求

安装

1. 通过 Composer(packagist) 安装包。

composer require "hhxsv5/laravel-s:~3.7.0" -vvv
# Make sure that your composer.lock file is under the VCS

2. 注册服务提供者（选择以下两种之一）。

• Laravel: 在 config/app.php 文件中，Laravel 5.5+ 支持自动发现包，您应跳过此步骤

  'providers' => [
      //...
      Hhxsv5\LaravelS\Illuminate\LaravelSServiceProvider::class,
  ],

• Lumen: 在 bootstrap/app.php 文件中

  $app->register(Hhxsv5\LaravelS\Illuminate\LaravelSServiceProvider::class);

3. 发布配置和二进制文件。

升级 LaravelS 后，您需要重新发布；点击 此处 查看每个版本的变更说明。

php artisan laravels publish
# Configuration: config/laravels.php
# Binary: bin/laravels bin/fswatch bin/inotify

4. 修改 config/laravels.php: listen_ip, listen_port，参考 设置。

运行

请在运行前仔细阅读提示，重要提示(重要)。

• 命令: php bin/laravels {start|stop|restart|reload|info|help}。

• 运行时 文件：start 将自动执行 artisan laravels config 并生成这些文件，开发者通常不需要注意它们，建议将它们添加到 .gitignore。

部署

建议通过 Supervisord 监控主进程，前提是不带选项 -d 并将 swoole.daemonize 设置为 false。

[program:laravel-s-test]
directory=/var/wwww/laravel-s-test
command=/usr/local/bin/php bin/laravels start -i
numprocs=1
autostart=true
autorestart=true
startretries=3
user=www-data
redirect_stderr=true
stdout_logfile=/var/log/supervisor/%(program_name)s.log

与 Nginx 合作（推荐）

示例.

gzip on;
gzip_min_length 1024;
gzip_comp_level 2;
gzip_types text/plain text/css text/javascript application/json application/javascript application/x-javascript application/xml application/x-httpd-php image/jpeg image/gif image/png font/ttf font/otf image/svg+xml;
gzip_vary on;
gzip_disable "msie6";
upstream swoole {
    # Connect IP:Port
    server 127.0.0.1:5200 weight=5 max_fails=3 fail_timeout=30s;
    # Connect UnixSocket Stream file, tips: put the socket file in the /dev/shm directory to get better performance
    #server unix:/yourpath/laravel-s-test/storage/laravels.sock weight=5 max_fails=3 fail_timeout=30s;
    #server 192.168.1.1:5200 weight=3 max_fails=3 fail_timeout=30s;
    #server 192.168.1.2:5200 backup;
    keepalive 16;
}
server {
    listen 80;
    # Don't forget to bind the host
    server_name laravels.com;
    root /yourpath/laravel-s-test/public;
    access_log /yourpath/log/nginx/$server_name.access.log  main;
    autoindex off;
    index index.html index.htm;
    # Nginx handles the static resources(recommend enabling gzip), LaravelS handles the dynamic resource.
    location / {
        try_files $uri @laravels;
    }
    # Response 404 directly when request the PHP file, to avoid exposing public/*.php
    #location ~* \.php$ {
    #    return 404;
    #}
    location @laravels {
        # proxy_connect_timeout 60s;
        # proxy_send_timeout 60s;
        # proxy_read_timeout 120s;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Real-PORT $remote_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header Scheme $scheme;
        proxy_set_header Server-Protocol $server_protocol;
        proxy_set_header Server-Name $server_name;
        proxy_set_header Server-Addr $server_addr;
        proxy_set_header Server-Port $server_port;
        # "swoole" is the upstream
        proxy_pass http://swoole;
    }
}

与 Apache 合作

LoadModule proxy_module /yourpath/modules/mod_proxy.so
LoadModule proxy_balancer_module /yourpath/modules/mod_proxy_balancer.so
LoadModule lbmethod_byrequests_module /yourpath/modules/mod_lbmethod_byrequests.so
LoadModule proxy_http_module /yourpath/modules/mod_proxy_http.so
LoadModule slotmem_shm_module /yourpath/modules/mod_slotmem_shm.so
LoadModule rewrite_module /yourpath/modules/mod_rewrite.so
LoadModule remoteip_module /yourpath/modules/mod_remoteip.so
LoadModule deflate_module /yourpath/modules/mod_deflate.so

<IfModule deflate_module>
    SetOutputFilter DEFLATE
    DeflateCompressionLevel 2
    AddOutputFilterByType DEFLATE text/html text/plain text/css text/javascript application/json application/javascript application/x-javascript application/xml application/x-httpd-php image/jpeg image/gif image/png font/ttf font/otf image/svg+xml
</IfModule>

<VirtualHost *:80>
    # Don't forget to bind the host
    ServerName www.laravels.com
    ServerAdmin hhxsv5@sina.com

    DocumentRoot /yourpath/laravel-s-test/public;
    DirectoryIndex index.html index.htm
    <Directory "/">
        AllowOverride None
        Require all granted
    </Directory>

    RemoteIPHeader X-Forwarded-For

    ProxyRequests Off
    ProxyPreserveHost On
    <Proxy balancer://laravels>  
        BalancerMember http://192.168.1.1:5200 loadfactor=7
        #BalancerMember http://192.168.1.2:5200 loadfactor=3
        #BalancerMember http://192.168.1.3:5200 loadfactor=1 status=+H
        ProxySet lbmethod=byrequests
    </Proxy>
    #ProxyPass / balancer://laravels/
    #ProxyPassReverse / balancer://laravels/

    # Apache handles the static resources, LaravelS handles the dynamic resource.
    RewriteEngine On
    RewriteCond %{DOCUMENT_ROOT}%{REQUEST_FILENAME} !-d
    RewriteCond %{DOCUMENT_ROOT}%{REQUEST_FILENAME} !-f
    RewriteRule ^/(.*)$ balancer://laravels/%{REQUEST_URI} [P,L]

    ErrorLog ${APACHE_LOG_DIR}/www.laravels.com.error.log
    CustomLog ${APACHE_LOG_DIR}/www.laravels.com.access.log combined
</VirtualHost>

启用 WebSocket 服务器

WebSocket 服务器监听地址与 Http 服务器相同。

1. 创建 WebSocket 处理器类，并实现接口 WebSocketHandlerInterface。实例在启动时自动创建，您无需手动创建。

namespace App\Services;
use Hhxsv5\LaravelS\Swoole\WebSocketHandlerInterface;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;
use Swoole\WebSocket\Server;
/**
 * @see https://www.swoole.co.uk/docs/modules/swoole-websocket-server
 */
class WebSocketService implements WebSocketHandlerInterface
{
    // Declare constructor without parameters
    public function __construct()
    {
    }
    public function onOpen(Server $server, Request $request)
    {
        // Before the onOpen event is triggered, the HTTP request to establish the WebSocket has passed the Laravel route, 
        // so Laravel's Request, Auth information is readable, and Session is readable and writable, but only in the onOpen event.
        // \Log::info('New WebSocket connection', [$request->fd, request()->all(), session()->getId(), session('xxx'), session(['yyy' => time()])]);
        $server->push($request->fd, 'Welcome to LaravelS');
        // throw new \Exception('an exception');// all exceptions will be ignored, then record them into Swoole log, you need to try/catch them
    }
    public function onMessage(Server $server, Frame $frame)
    {
        // \Log::info('Received message', [$frame->fd, $frame->data, $frame->opcode, $frame->finish]);
        $server->push($frame->fd, date('Y-m-d H:i:s'));
        // throw new \Exception('an exception');// all exceptions will be ignored, then record them into Swoole log, you need to try/catch them
    }
    public function onClose(Server $server, $fd, $reactorId)
    {
        // throw new \Exception('an exception');// all exceptions will be ignored, then record them into Swoole log, you need to try/catch them
    }
}

2. 修改 config/laravels.php。

// ...
'websocket'      => [
    'enable'  => true, // Here is true
    'handler' => \App\Services\WebSocketService::class,
],
'swoole'         => [
    //...
    // Must set dispatch_mode in (2, 4, 5), see https://www.swoole.co.uk/docs/modules/swoole-server/configuration
    'dispatch_mode' => 2,
    //...
],
// ...

3. 使用 SwooleTable 绑定 FD & UserId，可选，Swoole Table 示例。您还可以使用其他全局存储服务，如 Redis/Memcached/MySQL，但请注意，多个 Swoole 服务器 之间的 FD 可能会发生冲突。

4. 与 Nginx 合作（推荐）

参考 WebSocket 代理

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}
upstream swoole {
    # Connect IP:Port
    server 127.0.0.1:5200 weight=5 max_fails=3 fail_timeout=30s;
    # Connect UnixSocket Stream file, tips: put the socket file in the /dev/shm directory to get better performance
    #server unix:/yourpath/laravel-s-test/storage/laravels.sock weight=5 max_fails=3 fail_timeout=30s;
    #server 192.168.1.1:5200 weight=3 max_fails=3 fail_timeout=30s;
    #server 192.168.1.2:5200 backup;
    keepalive 16;
}
server {
    listen 80;
    # Don't forget to bind the host
    server_name laravels.com;
    root /yourpath/laravel-s-test/public;
    access_log /yourpath/log/nginx/$server_name.access.log  main;
    autoindex off;
    index index.html index.htm;
    # Nginx handles the static resources(recommend enabling gzip), LaravelS handles the dynamic resource.
    location / {
        try_files $uri @laravels;
    }
    # Response 404 directly when request the PHP file, to avoid exposing public/*.php
    #location ~* \.php$ {
    #    return 404;
    #}
    # Http and WebSocket are concomitant, Nginx identifies them by "location"
    # !!! The location of WebSocket is "/ws"
    # Javascript: var ws = new WebSocket("ws://laravels.com/ws");
    location =/ws {
        # proxy_connect_timeout 60s;
        # proxy_send_timeout 60s;
        # proxy_read_timeout: Nginx will close the connection if the proxied server does not send data to Nginx in 60 seconds; At the same time, this close behavior is also affected by heartbeat setting of Swoole.
        # proxy_read_timeout 60s;
        proxy_http_version 1.1;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Real-PORT $remote_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header Scheme $scheme;
        proxy_set_header Server-Protocol $server_protocol;
        proxy_set_header Server-Name $server_name;
        proxy_set_header Server-Addr $server_addr;
        proxy_set_header Server-Port $server_port;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_pass http://swoole;
    }
    location @laravels {
        # proxy_connect_timeout 60s;
        # proxy_send_timeout 60s;
        # proxy_read_timeout 60s;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Real-PORT $remote_port;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header Scheme $scheme;
        proxy_set_header Server-Protocol $server_protocol;
        proxy_set_header Server-Name $server_name;
        proxy_set_header Server-Addr $server_addr;
        proxy_set_header Server-Port $server_port;
        proxy_pass http://swoole;
    }
}

5. 心跳设置

• Swoole 的心跳设置

  // config/laravels.php
  'swoole' => [
      //...
      // All connections are traversed every 60 seconds. If a connection does not send any data to the server within 600 seconds, the connection will be forced to close.
      'heartbeat_idle_time'      => 600,
      'heartbeat_check_interval' => 60,
      //...
  ],

• Nginx 的代理读取超时

  # Nginx will close the connection if the proxied server does not send data to Nginx in 60 seconds
  proxy_read_timeout 60s;

6. 控制器中的推送数据

namespace App\Http\Controllers;
class TestController extends Controller
{
    public function push()
    {
        $fd = 1; // Find fd by userId from a map [userId=>fd].
        /**@var \Swoole\WebSocket\Server $swoole */
        $swoole = app('swoole');
        $success = $swoole->push($fd, 'Push data to fd#1 in Controller');
        var_dump($success);
    }
}

监听事件

系统事件

通常，您可以重置/销毁一些 global/static 变量，或更改当前的 Request/Response 对象。

• laravels.received_request 在 LaravelS 将 Swoole\Http\Request 解析为 Illuminate\Http\Request 之后，在 Laravel 的 Kernel 处理此请求之前。

  // Edit file `app/Providers/EventServiceProvider.php`, add the following code into method `boot`
  // If no variable $events, you can also call Facade \Event::listen(). 
  $events->listen('laravels.received_request', function (\Illuminate\Http\Request $req, $app) {
      $req->query->set('get_key', 'hhxsv5');// Change query of request
      $req->request->set('post_key', 'hhxsv5'); // Change post of request
  });

• laravels.generated_response 在 Laravel 的 Kernel 处理完请求之后，在 LaravelS 将 Illuminate\Http\Response 解析为 Swoole\Http\Response 之前。

  // Edit file `app/Providers/EventServiceProvider.php`, add the following code into method `boot`
  // If no variable $events, you can also call Facade \Event::listen(). 
  $events->listen('laravels.generated_response', function (\Illuminate\Http\Request $req, \Symfony\Component\HttpFoundation\Response $rsp, $app) {
      $rsp->headers->set('header-key', 'hhxsv5');// Change header of response
  });

自定义异步事件

此功能依赖于 Swoole 的 AsyncTask，您需要首先在 config/laravels.php 中设置 swoole.task_worker_num。异步事件处理的性能受 Swoole 任务进程的数量影响，您需要适当地设置 task_worker_num。

1. 创建事件类。

use Hhxsv5\LaravelS\Swoole\Task\Event;
class TestEvent extends Event
{
    protected $listeners = [
        // Listener list
        TestListener1::class,
        // TestListener2::class,
    ];
    private $data;
    public function __construct($data)
    {
        $this->data = $data;
    }
    public function getData()
    {
        return $this->data;
    }
}

2. 创建监听器类。

use Hhxsv5\LaravelS\Swoole\Task\Task;
use Hhxsv5\LaravelS\Swoole\Task\Listener;
class TestListener1 extends Listener
{
    /**
     * @var TestEvent
     */
    protected $event;
    
    public function handle()
    {
        \Log::info(__CLASS__ . ':handle start', [$this->event->getData()]);
        sleep(2);// Simulate the slow codes
        // Deliver task in CronJob, but NOT support callback finish() of task.
        // Note: Modify task_ipc_mode to 1 or 2 in config/laravels.php, see https://www.swoole.co.uk/docs/modules/swoole-server/configuration
        $ret = Task::deliver(new TestTask('task data'));
        var_dump($ret);
        // throw new \Exception('an exception');// all exceptions will be ignored, then record them into Swoole log, you need to try/catch them
    }
}

3. 触发事件。

// Create instance of event and fire it, "fire" is asynchronous.
use Hhxsv5\LaravelS\Swoole\Task\Event;
$event = new TestEvent('event data');
// $event->delay(10); // Delay 10 seconds to fire event
// $event->setTries(3); // When an error occurs, try 3 times in total
$success = Event::fire($event);
var_dump($success);// Return true if sucess, otherwise false

异步任务队列

此功能依赖于 Swoole 的 AsyncTask，您需要首先在 config/laravels.php 中设置 swoole.task_worker_num。任务处理的性能受 Swoole 任务进程的数量影响，您需要适当地设置 task_worker_num。

1. 创建任务类。

use Hhxsv5\LaravelS\Swoole\Task\Task;
class TestTask extends Task
{
    private $data;
    private $result;
    public function __construct($data)
    {
        $this->data = $data;
    }
    // The logic of task handling, run in task process, CAN NOT deliver task
    public function handle()
    {
        \Log::info(__CLASS__ . ':handle start', [$this->data]);
        sleep(2);// Simulate the slow codes
        // throw new \Exception('an exception');// all exceptions will be ignored, then record them into Swoole log, you need to try/catch them
        $this->result = 'the result of ' . $this->data;
    }
    // Optional, finish event, the logic of after task handling, run in worker process, CAN deliver task 
    public function finish()
    {
        \Log::info(__CLASS__ . ':finish start', [$this->result]);
        Task::deliver(new TestTask2('task2 data')); // Deliver the other task
    }
}

2. 发送任务。

// Create instance of TestTask and deliver it, "deliver" is asynchronous.
use Hhxsv5\LaravelS\Swoole\Task\Task;
$task = new TestTask('task data');
// $task->delay(3);// delay 3 seconds to deliver task
// $task->setTries(3); // When an error occurs, try 3 times in total
$ret = Task::deliver($task);
var_dump($ret);// Return true if sucess, otherwise false

毫秒级定时任务

基于 Swoole 的毫秒级定时器 的 cron 作业包装器，替代 Linux 的 Crontab。

1. 创建 cron 作业类。

namespace App\Jobs\Timer;
use App\Tasks\TestTask;
use Swoole\Coroutine;
use Hhxsv5\LaravelS\Swoole\Task\Task;
use Hhxsv5\LaravelS\Swoole\Timer\CronJob;
class TestCronJob extends CronJob
{
    protected $i = 0;
    // !!! The `interval` and `isImmediate` of cron job can be configured in two ways(pick one of two): one is to overload the corresponding method, and the other is to pass parameters when registering cron job.
    // --- Override the corresponding method to return the configuration: begin
    public function interval()
    {
        return 1000;// Run every 1000ms
    }
    public function isImmediate()
    {
        return false;// Whether to trigger `run` immediately after setting up
    }
    // --- Override the corresponding method to return the configuration: end
    public function run()
    {
        \Log::info(__METHOD__, ['start', $this->i, microtime(true)]);
        // do something
        // sleep(1); // Swoole < 2.1
        Coroutine::sleep(1); // Swoole>=2.1 Coroutine will be automatically created for run().
        $this->i++;
        \Log::info(__METHOD__, ['end', $this->i, microtime(true)]);

        if ($this->i >= 10) { // Run 10 times only
            \Log::info(__METHOD__, ['stop', $this->i, microtime(true)]);
            $this->stop(); // Stop this cron job
            // Deliver task in CronJob, but NOT support callback finish() of task.
            // Note: Modify task_ipc_mode to 1 or 2 in config/laravels.php, see https://www.swoole.co.uk/docs/modules/swoole-server/configuration
            $ret = Task::deliver(new TestTask('task data'));
            var_dump($ret);
        }
        // throw new \Exception('an exception');// all exceptions will be ignored, then record them into Swoole log, you need to try/catch them
    }
}

2. 注册 cron 作业。

// Register cron jobs in file "config/laravels.php"
[
    // ...
    'timer'          => [
        'enable' => true, // Enable Timer
        'jobs'   => [ // The list of cron job
            // Enable LaravelScheduleJob to run `php artisan schedule:run` every 1 minute, replace Linux Crontab
            // \Hhxsv5\LaravelS\Illuminate\LaravelScheduleJob::class,
            // Two ways to configure parameters:
            // [\App\Jobs\Timer\TestCronJob::class, [1000, true]], // Pass in parameters when registering
            \App\Jobs\Timer\TestCronJob::class, // Override the corresponding method to return the configuration
        ],
        'max_wait_time' => 5, // Max waiting time of reloading
    ],
    // ...
];

注意：构建服务器集群时将启动多个定时器，因此您需要确保只启动一个定时器以避免重复运行任务。

4. LaravelS v3.4.0 开始支持热重启 [重新加载] Timer 进程。在 LaravelS 收到 SIGUSR1 信号后，它将等待 max_wait_time（默认 5）秒以结束进程，然后 Manager 进程将再次拉起 Timer 进程。

5. 如果您只需要使用 分钟级 定时任务，建议启用 Hhxsv5\LaravelS\Illuminate\LaravelScheduleJob 而不是 Linux Crontab，这样您可以遵循 Laravel 任务调度 的编码习惯并配置 Kernel。

// app/Console/Kernel.php
protected function schedule(Schedule $schedule)
{
    // runInBackground() will start a new child process to execute the task. This is asynchronous and will not affect the execution timing of other tasks.
    $schedule->command(TestCommand::class)->runInBackground()->everyMinute();
}

修改代码后自动重载

• 通过 inotify，仅支持 Linux。

  1. 安装 inotify 扩展。

  2. 在 设置 中打开开关。

  注意：请仅在 Linux 中修改文件以接收文件更改事件。建议使用最新的 Docker。 Vagrant 解决方案。

• 通过 fswatch，支持 OS X/Linux/Windows。

  1. 安装 fswatch。

  2. 在项目根目录中运行命令。

  # Watch current directory
  ./bin/fswatch
  # Watch app directory
  ./bin/fswatch ./app

• 通过 inotifywait，支持 Linux。

  1. 安装 inotify-tools。

  2. 在项目根目录中运行命令。

  # Watch current directory
  ./bin/inotify
  # Watch app directory
  ./bin/inotify ./app

• 当上述方法不起作用时，最终的解决方案是设置 max_request=1,worker_num=1，这样 Worker 进程在处理完请求后将重新启动。此方法的速度非常慢，因此仅适用于开发环境。

在您的项目中获取 SwooleServer 的实例

/**
 * $swoole is the instance of `Swoole\WebSocket\Server` if enable WebSocket server, otherwise `Swoole\Http\Server`
 * @var \Swoole\WebSocket\Server|\Swoole\Http\Server $swoole
 */
$swoole = app('swoole');
var_dump($swoole->stats());// Singleton

使用 SwooleTable

1. 定义表，支持多个。

所有定义的表将在 Swoole 启动之前创建。

// in file "config/laravels.php"
[
    // ...
    'swoole_tables'  => [
        // Scene：bind UserId & FD in WebSocket
        'ws' => [// The Key is table name, will add suffix "Table" to avoid naming conflicts. Here defined a table named "wsTable"
            'size'   => 102400,// The max size
            'column' => [// Define the columns
                ['name' => 'value', 'type' => \Swoole\Table::TYPE_INT, 'size' => 8],
            ],
        ],
        //...Define the other tables
    ],
    // ...
];

2. 访问 Table：所有表实例都将绑定到 SwooleServer，通过 app('swoole')->xxxTable 访问。

namespace App\Services;
use Hhxsv5\LaravelS\Swoole\WebsocketHandlerInterface;
use Swoole\Http\Request;
use Swoole\WebSocket\Frame;
use Swoole\WebSocket\Server;
class WebSocketService implements WebSocketHandlerInterface
{
    /**@var \Swoole\Table $wsTable */
    private $wsTable;
    public function __construct()
    {
        $this->wsTable = app('swoole')->wsTable;
    }
    // Scene：bind UserId & FD in WebSocket
    public function onOpen(Server $server, Request $request)
    {
        // var_dump(app('swoole') === $server);// The same instance
        /**
         * Get the currently logged in user
         * This feature requires that the path to establish a WebSocket connection go through middleware such as Authenticate.
         * E.g:
         * Browser side: var ws = new WebSocket("ws://127.0.0.1:5200/ws");
         * Then the /ws route in Laravel needs to add the middleware like Authenticate.
         */
        // $user = Auth::user();
        // $userId = $user ? $user->id : 0; // 0 means a guest user who is not logged in
        $userId = mt_rand(1000, 10000);
        $this->wsTable->set('uid:' . $userId, ['value' => $request->fd]);// Bind map uid to fd
        $this->wsTable->set('fd:' . $request->fd, ['value' => $userId]);// Bind map fd to uid
        $server->push($request->fd, "Welcome to LaravelS #{$request->fd}");
    }
    public function onMessage(Server $server, Frame $frame)
    {
        // Broadcast
        foreach ($this->wsTable as $key => $row) {
            if (strpos($key, 'uid:') === 0 && $server->isEstablished($row['value'])) {
                $content = sprintf('Broadcast: new message "%s" from #%d', $frame->data, $frame->fd);
                $server->push($row['value'], $content);
            }
        }
    }
    public function onClose(Server $server, $fd, $reactorId)
    {
        $uid = $this->wsTable->get('fd:' . $fd);
        if ($uid !== false) {
            $this->wsTable->del('uid:' . $uid['value']); // Unbind uid map
        }
        $this->wsTable->del('fd:' . $fd);// Unbind fd map
        $server->push($fd, "Goodbye #{$fd}");
    }
}

多端口混合协议

有关更多信息，请参阅 Swoole 服务器添加监听器

为了让我们的主服务器支持更多协议而不仅仅是 Http 和 WebSocket，我们在 LaravelS 中引入了 Swoole 的 多端口混合协议 功能，并将其命名为 Socket。现在，您可以在 Laravel 上轻松构建 TCP/UDP 应用程序。

1. 创建套接字处理类，并扩展 Hhxsv5\LaravelS\Swoole\Socket\{TcpSocket|UdpSocket|Http|WebSocket}。

   namespace App\Sockets;
   use Hhxsv5\LaravelS\Swoole\Socket\TcpSocket;
   use Swoole\Server;
   class TestTcpSocket extends TcpSocket
   {
       public function onConnect(Server $server, $fd, $reactorId)
       {
           \Log::info('New TCP connection', [$fd]);
           $server->send($fd, 'Welcome to LaravelS.');
       }
       public function onReceive(Server $server, $fd, $reactorId, $data)
       {
           \Log::info('Received data', [$fd, $data]);
           $server->send($fd, 'LaravelS: ' . $data);
           if ($data === "quit\r\n") {
               $server->send($fd, 'LaravelS: bye' . PHP_EOL);
               $server->close($fd);
           }
       }
       public function onClose(Server $server, $fd, $reactorId)
       {
           \Log::info('Close TCP connection', [$fd]);
           $server->send($fd, 'Goodbye');
       }
   }

   这些 Socket 连接与您的 HTTP/WebSocket 连接共享相同的 worker 进程。因此，如果您想传递任务、使用 SwooleTable，甚至是 Laravel 组件如 DB、Eloquent 等，这都不会有任何问题。同时，您可以通过成员属性 swoolePort 直接访问 Swoole\Server\Port 对象。

   public function onReceive(Server $server, $fd, $reactorId, $data)
   {
       $port = $this->swoolePort; // Get the `Swoole\Server\Port` object
   }

   namespace App\Http\Controllers;
   class TestController extends Controller
   {
       public function test()
       {
           /**@var \Swoole\Http\Server $swoole */
           $swoole = app('swoole');
           // $swoole->ports: Traverse all Port objects, https://www.swoole.co.uk/docs/modules/swoole-server/multiple-ports
           $port = $swoole->ports[0]; // Get the `Swoole\Server\Port` object
           // $fd = 1; // The FD of onReceive/onMessage in Port
           // $swoole->send($fd, 'Send tcp message from controller to port client');
           // $swoole->push($fd, 'Send websocket message from controller to port client');
       }
   }

2. 注册套接字。

   // Edit `config/laravels.php`
   //...
   'sockets' => [
       [
           'host'     => '127.0.0.1',
           'port'     => 5291,
           'type'     => SWOOLE_SOCK_TCP,// Socket type: SWOOLE_SOCK_TCP/SWOOLE_SOCK_TCP6/SWOOLE_SOCK_UDP/SWOOLE_SOCK_UDP6/SWOOLE_UNIX_DGRAM/SWOOLE_UNIX_STREAM
           'settings' => [// Swoole settings：https://www.swoole.co.uk/docs/modules/swoole-server-methods#swoole_server-addlistener
               'open_eof_check' => true,
               'package_eof'    => "\r\n",
           ],
           'handler'  => \App\Sockets\TestTcpSocket::class,
           'enable'   => true, // whether to enable, default true
       ],
   ],

   关于心跳配置，它只能在 主服务器 上设置，不能在 Socket 上配置，但 Socket 会继承 主服务器 的心跳配置。

   对于 TCP 套接字，当 Swoole 的 dispatch_mode 为 1/3 时，onConnect 和 onClose 事件将被阻塞，因此如果您想解除这两个事件的阻塞，请将 dispatch_mode 设置为 2/4/5。

   'swoole' => [
       //...
       'dispatch_mode' => 2,
       //...
   ];

3. 测试。

• TCP: telnet 127.0.0.1 5291

• UDP: [Linux] echo "Hello LaravelS" > /dev/udp/127.0.0.1/5292

1. 注册其他协议的示例。

   • UDP

   'sockets' => [
       [
           'host'     => '0.0.0.0',
           'port'     => 5292,
           'type'     => SWOOLE_SOCK_UDP,
           'settings' => [
               'open_eof_check' => true,
               'package_eof'    => "\r\n",
           ],
           'handler'  => \App\Sockets\TestUdpSocket::class,
       ],
   ],

   • Http

   'sockets' => [
       [
           'host'     => '0.0.0.0',
           'port'     => 5293,
           'type'     => SWOOLE_SOCK_TCP,
           'settings' => [
               'open_http_protocol' => true,
           ],
           'handler'  => \App\Sockets\TestHttp::class,
       ],
   ],

   • WebSocket: 主服务器必须 启用 WebSocket，即将 websocket.enable 设置为 true。

   'sockets' => [
       [
           'host'     => '0.0.0.0',
           'port'     => 5294,
           'type'     => SWOOLE_SOCK_TCP,
           'settings' => [
               'open_http_protocol'      => true,
               'open_websocket_protocol' => true,
           ],
           'handler'  => \App\Sockets\TestWebSocket::class,
       ],
   ],

协程

Swoole 协程

• 警告：协程中代码执行的顺序是随机的。请求级别的数据应由协程 ID 进行隔离。然而，Laravel/Lumen 中有许多单例和静态属性，不同请求之间的数据会相互影响，这是 不安全的。例如，数据库连接是一个单例，相同的数据库连接共享相同的 PDO 资源。这在同步阻塞模式下是正常的，但在异步协程模式下不适用。每个查询都需要创建不同的连接并维护不同连接的 IO 状态，这需要一个连接池。因此，不要启用协程，只有自定义进程可以使用协程。

• 启用协程，默认禁用。

  // Edit `config/laravels.php`
  [
      //...
      'swoole' => [
          //...
          'enable_coroutine' => true
       ],
  ]

• 协程客户端: 需要 Swoole>=2.0。

• 运行时协程: 需要 Swoole>=4.1.0，并启用它。

  // Edit `config/laravels.php`
  [
      //...
      'enable_coroutine_runtime' => true
      //...
  ]

自定义进程

支持开发者创建用于监控、报告或其他特殊任务的专用工作进程。参考 addProcess。

1. 创建进程类，实现 CustomProcessInterface。

   namespace App\Processes;
   use App\Tasks\TestTask;
   use Hhxsv5\LaravelS\Swoole\Process\CustomProcessInterface;
   use Hhxsv5\LaravelS\Swoole\Task\Task;
   use Swoole\Coroutine;
   use Swoole\Http\Server;
   use Swoole\Process;
   class TestProcess implements CustomProcessInterface
   {
       /**
        * @var bool Quit tag for Reload updates
        */
       private static $quit = false;
   
       public static function callback(Server $swoole, Process $process)
       {
           // The callback method cannot exit. Once exited, Manager process will automatically create the process 
           while (!self::$quit) {
               \Log::info('Test process: running');
               // sleep(1); // Swoole < 2.1
               Coroutine::sleep(1); // Swoole>=2.1: Coroutine & Runtime will be automatically enabled for callback().
                // Deliver task in custom process, but NOT support callback finish() of task.
               // Note: Modify task_ipc_mode to 1 or 2 in config/laravels.php, see https://www.swoole.co.uk/docs/modules/swoole-server/configuration
               $ret = Task::deliver(new TestTask('task data'));
               var_dump($ret);
               // The upper layer will catch the exception thrown in the callback and record it in the Swoole log, and then this process will exit. The Manager process will re-create the process after 3 seconds, so developers need to try / catch to catch the exception by themselves to avoid frequent process creation.
               // throw new \Exception('an exception');
           }
       }
       // Requirements: LaravelS >= v3.4.0 & callback() must be async non-blocking program.
       public static function onReload(Server $swoole, Process $process)
       {
           // Stop the process...
           // Then end process
           \Log::info('Test process: reloading');
           self::$quit = true;
           // $process->exit(0); // Force exit process
       }
   }

2. 注册 TestProcess。

   // Edit `config/laravels.php`
   // ...
   'processes' => [
       'test' => [ // Key name is process name
           'class'    => \App\Processes\TestProcess::class,
           'redirect' => false, // Whether redirect stdin/stdout, true or false
           'pipe'     => 0,     // The type of pipeline, 0: no pipeline 1: SOCK_STREAM 2: SOCK_DGRAM
           'enable'   => true,  // Whether to enable, default true
           //'queue'    => [ // Enable message queue as inter-process communication, configure empty array means use default parameters
           //    'msg_key'  => 0,    // The key of the message queue. Default: ftok(__FILE__, 1).
           //    'mode'     => 2,    // Communication mode, default is 2, which means contention mode
           //    'capacity' => 8192, // The length of a single message, is limited by the operating system kernel parameters. The default is 8192, and the maximum is 65536
           //],
       ],
   ],

3. 注意：回调()不能退出。如果退出，Manager 进程将重新创建进程。

4. 示例：向自定义进程写入数据。

   // config/laravels.php
   'processes' => [
       'test' => [
           'class'    => \App\Processes\TestProcess::class,
           'redirect' => false,
           'pipe'     => 1,
       ],
   ],

   // app/Processes/TestProcess.php
   public static function callback(Server $swoole, Process $process)
   {
       while ($data = $process->read()) {
           \Log::info('TestProcess: read data', [$data]);
           $process->write('TestProcess: ' . $data);
       }
   }

   // app/Http/Controllers/TestController.php
   public function testProcessWrite()
   {
       /**@var \Swoole\Process $process */
       $process = app('swoole')->customProcesses['test'];
       $process->write('TestController: write data' . time());
       var_dump($pushProcess->read());
   }

其他特性

配置 Swoole 的事件回调函数

支持的事件

1. 创建一个事件类以实现相应的接口。

namespace App\Events;
use Hhxsv5\LaravelS\Swoole\Events\ServerStartInterface;
use Swoole\Atomic;
use Swoole\Http\Server;
class ServerStartEvent implements ServerStartInterface
{
    public function __construct()
    {
    }
    public function handle(Server $server)
    {
        // Initialize a global counter (available across processes)
        $server->atomicCount = new Atomic(2233);

        // Invoked in controller: app('swoole')->atomicCount->get();
    }
}

namespace App\Events;
use Hhxsv5\LaravelS\Swoole\Events\WorkerStartInterface;
use Swoole\Http\Server;
class WorkerStartEvent implements WorkerStartInterface
{
    public function __construct()
    {
    }
    public function handle(Server $server, $workerId)
    {
        // Initialize a database connection pool
        // DatabaseConnectionPool::init();
    }
}

2. 配置。

// Edit `config/laravels.php`
'event_handlers' => [
    'ServerStart' => \App\Events\ServerStartEvent::class,
    'WorkerStart' => \App\Events\WorkerStartEvent::class,
],

重要提示

• 单例问题

  • 在 FPM 模式下，单例实例将在每个请求中实例化和回收，请求开始=>实例化实例=>请求结束=>回收实例。

  • 在 Swoole 服务器上，所有单例实例都将驻留在内存中，其生命周期与 FPM 不同，请求开始=>实例化实例=>请求结束=>不回收单例实例。因此，需要开发者在每个请求中维护单例实例的状态。

  • 常见解决方案

    1. 编写一个 XxxCleaner 类来清理单例对象状态。此类实现接口 Hhxsv5\LaravelS\Illuminate\Cleaners\CleanerInterface，然后将其注册到 laravels.php 中的 cleaners。

    2. 通过 Middleware 重置单例实例的状态。

    3. 重新注册 ServiceProvider，将 XxxServiceProvider 添加到 laravels.php 文件中的 register_providers。这样，每个请求都会重新初始化单例实例 参考。

  • LaravelS 内置了一些 清理器。

• 已知问题：包含已知问题和解决方案的包。

• 调试方法：日志记录，Laravel Dump Server（Laravel 5.7 默认已集成）。

• 应从 Illuminate\Http\Request 对象获取所有请求信息，$_ENV 可读，$_SERVER 部分可读，禁止使用 $_GET/$_POST/$_FILES/$_COOKIE/$_REQUEST/$_SESSION/$GLOBALS。

  public function form(\Illuminate\Http\Request $request)
  {
      $name = $request->input('name');
      $all = $request->all();
      $sessionId = $request->cookie('sessionId');
      $photo = $request->file('photo');
      // Call getContent() to get the raw POST body, instead of file_get_contents('php://input')
      $rawContent = $request->getContent();
      //...
  }

• 通过 Illuminate\Http\Response 对象进行响应，兼容 echo/vardump()/print_r()，禁止使用 dd()/exit()/die()/header()/setcookie()/http_response_code() 函数。

  public function json()
  {
      return response()->json(['time' => time()])->header('header1', 'value1')->withCookie('c1', 'v1');
  }

• 各种 单例连接 将是 内存驻留 的，建议启用 持久连接。

1. 数据库连接，它将在断开连接后立即自动重新连接。

   // config/database.php
   //...
   'connections' => [
       'my_conn' => [
           'driver'    => 'mysql',
           'host'      => env('DB_MY_CONN_HOST', 'localhost'),
           'port'      => env('DB_MY_CONN_PORT', 3306),
           'database'  => env('DB_MY_CONN_DATABASE', 'forge'),
           'username'  => env('DB_MY_CONN_USERNAME', 'forge'),
           'password'  => env('DB_MY_CONN_PASSWORD', ''),
           'charset'   => 'utf8mb4',
           'collation' => 'utf8mb4_unicode_ci',
           'prefix'    => '',
           'strict'    => false,
           'options'   => [
               // Enable persistent connection
               \PDO::ATTR_PERSISTENT => true,
           ],
       ],
       //...
   ],
   //...

2. Redis 连接，它将在断开连接后不会立即自动重新连接，并且会抛出关于丢失连接的异常，下一次重新连接。您需要在每次操作 Redis 之前确保正确执行 SELECT DB。

   // config/database.php
   'redis' => [
           'client' => env('REDIS_CLIENT', 'phpredis'), // It is recommended to use phpredis for better performance.
           'default' => [
               'host'       => env('REDIS_HOST', 'localhost'),
               'password'   => env('REDIS_PASSWORD', null),
               'port'       => env('REDIS_PORT', 6379),
               'database'   => 0,
               'persistent' => true, // Enable persistent connection
           ],
       ],
   //...

• 全局、静态变量需要手动销毁（重置）。

• 无限地向 静态/全局变量追加元素会导致 OOM（内存不足）。

  class Test
  {
      public static $array = [];
      public static $string = '';
  }
  
  // Controller
  public function test(Request $req)
  {
      // Out of Memory
      Test::$array[] = $req->input('param1');
      Test::$string .= $req->input('param2');
  }

• Linux 内核参数调整

• 压力测试

替代方案

赞助商

许可证

MIT