Laravel Reverb: Bidirectional communcation?

I have the same question. How to setup bidirectional communication in Reverb. something like this https://beyondco.de/docs/laravel-websockets/advanced-usage/custom-websocket-handlers

Also there is tweet about the possibility: https://twitter.com/djgeisi/status/1754791665515049156

I was also interested in this functionality as I currently use a custom nodejs server with socket.io to have bidirectional communication for a web based game and the documentation does not mention this use case.

I therefore looked at the github repo and I have found some routing services with a Reverb Router and Route classes with static methods for GET/POST/PUT/PATCH/DELETE so I suppose you could register routes in the Laravel Application using the Reverb Route class Laravel\Reverb\Servers\Reverb\Http\Route and thus respond to client side event.

When I have the time I will try to test that, if it works it would be absolutely great 😃 and set Reverb apart from simple server side push events as other services or applications can already do that (I think of Mercure which is meant for server side events with native javascript support and no dependency on pusher protocol)

After toying around a little with a fresh laravel 11 install, I have found that you can register a listener that will listen to the Laravel\Reverb\Events\MessageReceived event that has the connection and the json encoded message sent from Echo.

When subscribing to a channel with Echo (via the Echo.channel method) it will return a connection object, you can use connection.pusher.send_event(event, data) method to send something to the laravel application.

There is probably a better solution, and so far I did not look into private channel or authorization, also with this listener you reveive all events, even the ping message that are automatically sent by Echo.

It is promising, but I find it weird to not have documentation about client side event to the server and not between clients as it is one of the key features of websocket since server side events can be implemented without it.

Hey @giantpopples interesting findings. This looks promising for extending Reverb for such a functionality. I was not thinking about Laravel Echo for client to server communcation for the first place, but that feature could be useful, too.

Currently I am investigating about communicate between multiple Laravel Backends where one backend acts as some kind of centralized server ("control server"). This would require something like a "Laravel Echo PHP Client". I already managed this functionality using SSE (where one backend just offers a basic HTTP-based SSE endpoint and the "client" Laravel app is listening on those events). But using full-duplex communication would have benefits over SSE when data needs to be exchanged bidirectional in real-time. Let's imagine a central dashboard and all connected client apps constantly push their diagnostic data to a centralized Laravel app.

I started on integrating the amphp websocket client with reverb but I have troubles figuring out the reverb websocket endpoints. If I just call laravel using websockets on ws://localhost:8080 (laravel reverb default listening port) I get a 404 and "no http update response found" error from the underlying websocket implementation of amphp.

I think I will try to install laravel Echo next and reverse engineer the requests it makes.

First of all, please forgive me for my limited English... I currently have a Laravel project that uses the Laravel Websockets library (beyond code) precisely because it offers the Custom Handler feature. I need this level of control because, in addition to web clients in this project, there are also .Net clients that connect to the Laravel server through websockets (more precisely, Windows services developed in C#). In short, I am very interested in using Laravel Reverb. I would like to count on you experts to suggest a way to reproduce this concept of "custom Handlers" from the BeyondCode library in Laravel Reverb.

We really need this to be implemented on a first class citizen level. Right now, although we can listen for the messages client side, then handle them via an event listener server side. It's missing a lot of the niceness that the inverse, server to clientside has.

Such as proper authentication, csrf protections etc.

Hey all, @lararara If you use private channels and the client is sending a message over that channel and you use Reverb's event listener to handle that incoming message there is no need for CSRF/authentication. On a private channel a user is already authenticated. So if you listen for an incoming message you can get the channel out of the message's json string (channel-property). And CSRF protection should not be an issue, because this is a websocket connection not http(s).

@marciliojunior The mssage contains all information you need. If the user sent a message on a private channel you get the channel-name from the event-payload (channel-property). If you want to "talk back" to the user - just use Laravel`s default Broadcasting and dispatch an event with Broadcasting enabled on the same channel.

I also had some progress on implementing a PHP "Echo Client" that is able to make a websocket connection to a remote Laravel application that serves Reverb.

I got this working:

1. Websocket connection (initialization)
2. Private channel subscription using Laravel Sanctum API tokens for authentication
3. Receiving messages on the "client" application
4. Sending messages from the "client" application to the remote server (running reverb)
5. Sending/receiving messages on the remote server using the Reverb Event Listener and Broadcast Events

With this setup it is possible to have a persistent duplex connection between two (or more) Laravel applications. A bit like a pub/sub broker like redis but with authentication and authorization already included.

This is how I do it on the "client" application:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use function Amp\Websocket\Client\connect;
use function Amp\async;
use function Amp\delay;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Cache;

class Connect extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'connect';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Connect to control server';

    private $deviceId;

    private $connection;

    private $channelName;

    private $socketId;

    private $auth;

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $this->deviceId = "1";
        $this->channelName = 'private-devices.' . $this->deviceId;
        $this->connection = connect('ws://localhost:8080/app/my-app-key?protocol=7&client=php&version=8.3');

        $this->init();

        // handle outgoing messages
        $handleMessagesSend = async(function () {
            while(true) {
                $message = Cache::pull('send-message');
                if ($message) {
                    $this->connection->sendText(json_encode([
                        'event' => 'client-event',
                        'channel' => $this->channelName,
                        'data' => [
                            'message' => $message,
                        ],
                    ]));
                }
                delay(2);
            }
        });

        // handle incoming ping messages
        foreach ($this->connection as $message) {
            $this->info('Receiving messages');
            $payload = $message->buffer();

            if ($payload === '100') {
                $this->connection->close();
            }

            $data = json_decode($payload);

            if (isset($data->event) && $data->event === 'pusher:ping') {

                $this->connection->sendText(json_encode([
                    'event' => 'pusher:pong',
                    'data' => [
                        'channel' => $this->channelName,
                        'auth' => $this->auth,
                    ],
                ]));
            }
        }
    }

    private function init()
    {
        $payload = $this->connection->receive();
        $bufferedData = $payload->buffer();

        $this->info($bufferedData);

        $data = json_decode($bufferedData);

        if ($payload === '100') {
            $this->connection->close();
        }

        if (isset($data->event) && $data->event === 'pusher:connection_established') {
            $eventData = json_decode($data->data);

            $this->socketId = $eventData->socket_id;

            $authResponse = Http::withToken('my-sanctum-token')->acceptJson()->post('http://localhost/api/broadcasting/auth', [
                'channel_name' => $this->channelName,
                'socket_id' => $this->socketId,
            ]);

            logger()->debug("Auth response", ['response' => $authResponse->body()]);

            $this->auth = $authResponse['auth'];

            $this->connection->sendText(json_encode([
                'event' => 'pusher:subscribe',
                'data' => [
                    'channel' => $this->channelName,
                    'auth' => $this->auth,
                ],
            ]));
        }
    }
}

It is not ideal (I "misuse" the cache to check for new messages to be send every two seconds) but it works.