在laravel下实现全双工的websocket开发 | laravel china 社区-大发黄金版app下载

php-fpm下的laravel

因为php-fpm的请求阅后即焚的特性，在php-fpm容器下，是无法建立一个长连接到任何服务器。
所以在php-fpm容器下，只能实现服务器主动下发消息到客户端，而客户端无法通过websocket协议上报数据到服务端。
大概的思路如下图：

其中的gateway server服务器可以用workerman的实现。http api server则是你的laravel代码。

octane下的laravel

是laravel官方出的、运行laravel代码的容器包。
该包的特性是：解决了php-fpm的请求阅后即焚的特性，让一些变量得以驻留在内存中被重复利用。
该包的意义是：

1. 官方亲自下场解决变量污染问题。在octane未出现之前，社区已经有很多基于swoole驱动laravel的包，这些三方包在解决常驻内存下框架的变量污染问题都上算不上尽善尽美，假设如果要动框架底层才能解决某一个变量的污染问题，这个时候第三方包就有点束手束脚了。
2. 官方引导社区走向常驻内存的时代。自octane之后，所有给larvel贡献composer包的作者，都会或多或少的考虑其作品在octane下是否有变量污染的问题。

该包的弱点是：该包虽然可以使用swoole作为底层驱动，但是其禁用了协程模式，依然无法建立一个长连接到任何服务器。

workerman下的laravel

既然octane解决了常驻内存下变量污染问题，又不支持建立一个长连接到任何服务器。
那我就用workerman驱动octane，用workerman替换掉octane的swoole层。
如此一来，我既享受了octane解决常驻内存下变量污染的便利，又提供了建立一个长连接到任何服务器的能力。
代码如下：

namespace app\console\commands;
use datetime;
use illuminate\console\command;
use illuminate\foundation\application;
use illuminate\http\request as laravelrequest;
use laravel\octane\applicationfactory;
use laravel\octane\octane;
use laravel\octane\octaneresponse;
use laravel\octane\requestcontext;
use symfony\component\console\input\inputargument;
use symfony\component\console\input\inputoption;
use symfony\component\httpfoundation\binaryfileresponse;
use throwable;
use workerman\connection\tcpconnection;
use workerman\protocols\http\request as workermanrequest;
use workerman\protocols\http\response as workermanresponse;
use workerman\worker as workermanworker;
use laravel\octane\worker as octaneworker;
use laravel\octane\contracts\client as octaneclient;
use illuminate\contracts\events\dispatcher as eventdispatcher;
/**
 * 用workerman实现一个简单的laravel server
 * composer require workerman/workerman
 * composer require laravel/octane
 * php artisan octane:install
 */
class laramancommand extends command
{
    /**
     * 服务器启动之前调度的事件
     * 自定义进程可以监听该事件进行启动
     */
    public const event_laraman_starting = 'event_laraman_starting';
    protected workermanworker|null $workermanworker;
    protected octaneworker|null $octaneworker;
    protected octaneclient|null $octaneclient;
    protected function configure(): void
    {
        $this->setname('laraman');
        $this->setdescription('manage server');
        $this->addargument('action', inputargument::required, 'start|stop|status|connections');
        $this->addoption('host', null, inputoption::value_optional, 'the ip address the server should bind to');
        $this->addoption('port', null, inputoption::value_optional, 'the port the server should be available on [default: "8000"]');
        $this->addoption('workers', null, inputoption::value_optional, 'the number of workers that should be available to handle requests');
        $this->addoption('d', null, inputoption::value_none, 'run in the daemon mode');
        $this->addoption('g', null, inputoption::value_none, 'gracefully stop');
    }
    public function __construct()
    {
        parent::__construct();
        workermanworker::$pidfile = storage_path('laraman.pid');
        workermanworker::$logfile = storage_path('logs/laraman.log');
    }
    /**
     * execute the console command.
     */
    public function handle(): void
    {
        $action = $this->argument('action');
        if ($action === 'start') {
            $this->start();
        } elseif ($action === 'stop') {
            $this->stop();
        } elseif ($action === 'status') {
            $this->status();
        } elseif ($action === 'connections') {
            $this->connections();
        } else {
            $this->error('invalid action');
        }
    }
    protected function start(): void
    {
        $host = $this->option('host') ?? '127.0.0.1';
        $port = $this->option('port') ?? '8000';
        $workers = $this->option('workers') ?? 'auto';
        $socket = "http://$host:$port";
        workermanworker::$daemonize = (bool)$this->option('d');
        $this->workermanworker = new workermanworker($socket);
        $this->workermanworker->name = $this->getname();
        $this->workermanworker->count = $workers === 'auto' ? $this->getcpunum() * 2 : (int)$workers;
        $_server['var_dumper_format'] = workermanworker::$daemonize ? 'server' : 'cli';
        $this->workermanworker->onworkerstart = function () {
            $this->octaneclient = $this->getoctaneclient();
            $this->octaneworker = new octaneworker(
                new applicationfactory(base_path()),
                $this->octaneclient
            );
            $this->octaneworker->boot();
        };
        $this->workermanworker->onmessage = function (tcpconnection $connection, workermanrequest $request) {
            $this->octaneworker->handle(...$this->octaneclient->marshalrequest(new requestcontext([
                'request' => $request,
                'tcpconnection' => $connection,
            ])));
        };
        $this->info("starting server on $socket");
        app(eventdispatcher::class)?->dispatch(self::event_laraman_starting, self::event_laraman_starting);
        workermanworker::runall();
    }
    protected function stop(): void
    {
        workermanworker::runall();
    }
    protected function status(): void
    {
        workermanworker::runall();
    }
    protected function connections(): void
    {
        workermanworker::runall();
    }
    /**
     * 获取cpu核心数
     * @return int
     */
    protected function getcpunum(): int
    {
        if (directory_separator === '\\') {
            return 1;
        }
        $count = 4;
        if (is_callable('shell_exec')) {
            if (strtolower(php_os) === 'darwin') {
                $count = (int)shell_exec('sysctl -n machdep.cpu.core_count');
            } else {
                $count = (int)shell_exec('nproc');
            }
        }
        return $count > 0 ? $count : 4;
    }
    /**
     * 获取octaneclient
     * @return octaneclient
     */
    protected function getoctaneclient(): octaneclient
    {
        return new class implements octaneclient {
            protected const status_code_reasons = [
                419 => 'page expired',
                425 => 'too early',
                431 => 'request header fields too large', // rfc6585
                451 => 'unavailable for legal reasons', // rfc7725
            ];
            public function marshalrequest(requestcontext $context): array
            {
                /**
                 * @var tcpconnection $tcpconnection
                 */
                $tcpconnection = $context['tcpconnection'];
                /**
                 * @var workermanrequest $workermanrequest
                 */
                $workermanrequest = $context['request'];
                $server = [];
                foreach ($workermanrequest->header() as $key => $value) {
                    if ($key === 'cookie') {
                        continue;
                    }
                    $server['http_' . strtoupper(str_replace('-', '_', $key))] = $value;
                }
                $server['request_method'] = $workermanrequest->method();
                $server['path_info'] = $workermanrequest->path();
                $server['request_uri'] = $workermanrequest->uri();
                $server['query_string'] = $workermanrequest->querystring();
                $server['master_time'] = $server['request_time'] = time();
                $server['request_time_float'] = microtime(true);
                $server['server_protocol'] = 'http/' . $workermanrequest->protocolversion();
                $server['server_port'] = $tcpconnection->getlocalport();
                $server['remote_port'] = $tcpconnection->getremoteport();
                $server['remote_addr'] = $tcpconnection->getremoteip();
                $laravelrequest = new laravelrequest(
                    $workermanrequest->get() ?? [],
                    $workermanrequest->post() ?? [],
                    [],
                    $workermanrequest->cookie() ?? [],
                    $workermanrequest->file() ?? [],
                    $server,
                    $workermanrequest->rawbody()
                );
                return [
                    $laravelrequest,
                    $context,
                ];
            }
            public function respond(requestcontext $context, octaneresponse $response): void
            {
                /**
                 * @var tcpconnection $tcpconnection
                 */
                $tcpconnection = $context['tcpconnection'];
                /**
                 * @var workermanrequest $workermanrequest
                 */
                $workermanrequest = $context['request'];
                $symfonyresponse = $response->response;
                $workermanresponse = new workermanresponse();
                $workermanresponse->withstatus($symfonyresponse->getstatuscode(), self::status_code_reasons[$symfonyresponse->getstatuscode()] ?? null);
                $workermanresponse->withprotocolversion($symfonyresponse->getprotocolversion());
                if (!$symfonyresponse->headers->has('date')) {
                    $symfonyresponse->setdate(datetime::createfromformat('u', time()));
                }
                if ($symfonyresponse instanceof binaryfileresponse) {
                    $headers = $symfonyresponse->headers->allpreservecase();
                    unset($headers['content-length'], $headers['accept-ranges'], $headers['content-range']);
                    $workermanresponse->withheaders($headers);
                    $workermanresponse->withfile($symfonyresponse->getfile()->getpathname());
                } else {
                    $workermanresponse->withheaders($symfonyresponse->headers->allpreservecase());
                    $workermanresponse->withbody($symfonyresponse->getcontent());
                }
                $keepalive = $workermanrequest->header('connection');
                if (
                    ($keepalive === null && $workermanrequest->protocolversion() === '1.1')
                    || $keepalive === 'keep-alive'
                    || $keepalive === 'keep-alive'
                ) {
                    $tcpconnection->send($workermanresponse);
                    return;
                }
                $tcpconnection->close($workermanresponse);
            }
            public function error(throwable $e, application $app, laravelrequest $request, requestcontext $context): void
            {
                $workermanresponse = new workermanresponse();
                $workermanresponse->header('status', '500 internal server error');
                $workermanresponse->header('content-type', 'text/plain');
                $workermanresponse->withbody(octane::formatexceptionforclient($e, $app->make('config')->get('app.debug')));
                /**
                 * @var tcpconnection $tcpconnection
                 */
                $tcpconnection = $context['tcpconnection'];
                $tcpconnection->close($workermanresponse);
            }
        };
    }
}

全双工的websocket开发

架构如下：

要实现上述架构，你可以选择workerman提供的长连接框架。
也可以选择我开发的https://github.com/buexplain/netsvr-business-serial。
以我的包为例子，结合上面的laramancommand类，你只需实现一个监听器即可，监听器代码如下：
ps：要将下面这个监听器跑通，请先仔细阅读我的包的readme文件：

namespace app\listeners;
use exception;
use illuminate\support\facades\log;
use laravel\octane\events\workerstarting;
use laravel\octane\events\workerstopping;
use netsvr\connclose;
use netsvr\connopen;
use netsvr\event;
use netsvr\transfer;
use netsvrbusiness\container;
use netsvrbusiness\contract\eventinterface;
use netsvrbusiness\contract\mainsocketmanagerinterface;
use netsvrbusiness\contract\tasksocketmangerinterface;
use netsvrbusiness\mainsocketmanager;
use netsvrbusiness\netbus;
use netsvrbusiness\socket;
use netsvrbusiness\tasksocketmanger;
use netsvrbusiness\workerman\mainsocket;
use netsvrbusiness\workerman\tasksocket;
use psr\container\containerinterface;
class netbuslistener
{
    /**
     * create the event listener.
     */
    public function __construct()
    {
    }
    /**
     * handle the event.
     * @throws exception
     */
    public function handle(workerstarting|workerstopping|null $event): void
    {
        //初始化容器
        /**
         * @var $container container
         */
        $container = container::getinstance();
        self::inittasksocketmangerinterface($container);
        if ($event instanceof workerstarting) {
            self::initmainsocketmanagerinterface($container);
        } else if ($event instanceof workerstopping) {
            //先关闭mainsocket
            $container->has(mainsocketmanagerinterface::class) && $container->get(mainsocketmanagerinterface::class)->close();
            //再关闭tasksocket
            $container->has(tasksocketmangerinterface::class) && $container->get(tasksocketmangerinterface::class)->close();
        }
    }
    /**
     * 初始化配置信息，配置信息最好放在框架规定的目录，我写在这里只是方便演示
     * @return array
     */
    protected static function getconfig(): array
    {
        return [
            //如果一台网关服务机器承载不了业务的websocket连接数，可以再部署一台网关服务机器，这里支持配置多个网关服务，处理多个网关服务的websocket消息
            'netsvr' => [
                [
                    //netsvr网关的worker服务器监听的tcp地址
                    'workeraddr' => '127.0.0.1:6061',
                    //该参数表示接下来，需要网关服务的worker服务器开启多少协程来处理mainsocket连接的请求
                    'processcmdgoroutinenum' => 25,
                    //该参数表示接下来，需要网关服务的worker服务器转发如下事件给到business进程的mainsocket连接
                    'events' => event::onopen | event::onclose | event::onmessage,
                ],
            ],
            //tasksocket的最大闲置时间，单位秒，建议比netsvr网关的worker服务器的readdeadline配置小3秒
            'maxidletime' => 117,
            //socket读写网关数据的超时时间，单位秒
            'sendreceivetimeout' => 5,
            //连接到网关的超时时间，单位秒
            'connecttimeout' => 5,
            //business进程向网关的worker服务器发送的心跳消息，这个字符串与网关的worker服务器的配置要一致，如果错误，网关的worker服务器是会强制关闭连接的
            'workerheartbeatmessage' => '~6yot5rw35pio~',
            //维持心跳的间隔时间，单位毫秒
            'heartbeatintervalmillisecond' => 25 * 1000,
        ];
    }
    /**
     * 初始化tasksocketmanger
     * @param container $container
     * @return void
     */
    protected static function inittasksocketmangerinterface(containerinterface $container): void
    {
        //这里只是绑定一个闭包，实际上并不会与netsvr网关进行连接，后续使用到了，才会进行连接
        $container->bind(tasksocketmangerinterface::class, function () {
            $tasksocketmanger = new tasksocketmanger();
            $logprefix = sprintf('tasksocket#%d', getmypid());
            foreach (self::getconfig()['netsvr'] as $item) {
                //将网关的特定参数与公共参数进行合并，网关的特定参数覆盖公共参数
                $item = array_merge(self::getconfig(), $item);
                //创建连接对象，并添加到管理器，如果不用这个对象，则不会与netsvr网关进行连接
                $tasksocket = new tasksocket(
                    $logprefix,
                    log::channel(),
                    $item['workeraddr'],
                    $item['sendreceivetimeout'],
                    $item['connecttimeout'],
                    $item['maxidletime'],
                    $item['workerheartbeatmessage'],
                    $item['heartbeatintervalmillisecond'],
                );
                $tasksocketmanger->addsocket($tasksocket);
            }
            return $tasksocketmanger;
        });
    }
    /**
     * 初始化mainsocket，初始化成功后，会接收到来自netsvr网关转发过来的websocket事件
     * @param container $container
     * @return void
     * @throws exception
     * @throws exception
     */
    public static function initmainsocketmanagerinterface(containerinterface $container): void
    {
        $mainsocketmanager = new mainsocketmanager();
        $logprefix = sprintf('mainsocket#%d', getmypid());
        $event = self::getevent();
        foreach (self::getconfig()['netsvr'] as $item) {
            //将网关的特定参数与公共参数进行合并，网关的特定参数覆盖公共参数
            $item = array_merge(self::getconfig(), $item);
            //创建socket
            $socket = new socket(
                $logprefix,
                log::channel(),
                $item['workeraddr'],
                $item['sendreceivetimeout'],
                $item['connecttimeout']);
            //创建mainsocket连接
            $mainsocket = new mainsocket(
                $logprefix,
                log::channel(),
                $event,
                $socket,
                $item['workerheartbeatmessage'],
                $item['events'],
                $item['processcmdgoroutinenum'],
                $item['heartbeatintervalmillisecond']);
            //添加到管理器
            $mainsocketmanager->addsocket($mainsocket);
        }
        //启动成功后，将mainsocketmanager绑定到容器中，提供给netbus类使用
        if ($mainsocketmanager->start()) {
            $container->bind(mainsocketmanagerinterface::class, $mainsocketmanager);
        }
    }
    /**
     * 获取事件对象，这个类应该创建一个文件，实现eventinterface接口，我写在这里是为了演示方便
     * @return eventinterface
     */
    protected static function getevent(): eventinterface
    {
        return new class implements eventinterface {
            /**
             * 处理连接打开事件
             * @param connopen $connopen
             * @return void
             */
            public function onopen(connopen $connopen): void
            {
                log::channel()->info('onopen ' . $connopen->serializetojsonstring());
            }
            /**
             * 处理消息事件
             * @param transfer $transfer
             * @return void
             */
            public function onmessage(transfer $transfer): void
            {
                //将消息转发给netbus，netbus会根据uniqid将消息转发给对应的客户端
                netbus::singlecast($transfer->getuniqid(), $transfer->getdata());
            }
            /**
             * 处理连接关闭事件
             * @param connclose $connclose
             * @return void
             */
            public function onclose(connclose $connclose): void
            {
                log::channel()->info('onclose ' . $connclose->serializetojsonstring());
            }
        };
    }
}

本作品采用《cc 协议》，转载必须注明作者和本文链接