[Request/Feature] Real-time bidirectional communication / inter-app communication

[nilskretschmer]

Hi,

sorry for cross-posting (see: Laracasts but I think this feature would be indeed very useful for multiple Laravel applications so I wanted to start a discussion about it over here.

I was very excited about the first release of Laravel Reverb. I really appreciate the effort to have a first party Laravel package for websocket communcation.

Right from https://reverb.laravel.com/ it says:

Reverb is a first-party WebSocket server for Laravel applications, bringing real-time communication between client and server directly to your fingertips.

I am not sure if I get the wording/idea right, but I think Laravel Reverb is "just" a first party websocket server written in PHP. All known functionality from Laravel Broadcasting should work with Reverb. But from that statement above I really was hoping that Reverb adds client TO server communcation to Laravel's features as well. But I think that's not true (for now)?

Example

Currently I am working on a project where real-time communcation between a "Laravel Client" and a "Laravel Server" would be beneficial over just using HTTPS. You can imagine the project as a device management application. So there is a central server application that handles many devices in the field (like edge devices). As soon as a device turns on and has a working internet connection it connects to the central server. Because the devices may be in networks behind firewalls or even using cellular connections the communcation needs to be established from the client-side.

After the connection is established the devices should constantly push their diagnostics (like network connectivity, cpu/gpu usage etc..). For this a real-time communcation FROM the device TO the server would be very nice. But if I get it right Larvel Reverb also "just" enables server to client communication over websockets. So it is like a replacement for Laravel Websockets or Soketi. The mechanisms (pusher, websockets, redis..) are still the same. As well as the direction FROM server TO client.

Or am I missing something here?

Please don't get me wrong: I really like the idea of having a PHP first party package for this and I appreciate all the efforts to create such a package. Also Reverb seems to have "scalability in mind" which is also great. But I still miss bidirectional real-time communcation capabilities in Laravel. This would also be a nice feature to enable real-time communcation between two separate Laravel Apps (microservices!).

The idea

1. Having a built-in way in Laravel to communicate FROM client to server
2. And/or having a built-in way to communicate between multiple app backends (these could also be many different Laravel backends written in PHP)

For my understanding this would require a "client"-side library that is able to connect to the websocket server and push messages to the server. This would also require a backend library to listen to these messagesand handle them properly.

There already is a websocket client and a websocket server over there @amphp.org but I think it would be nice to integrate this functionality directly into the new Laravel Reverb.

I would love to help implementing this feature but I am not sure where to start. In the sense of my use case I imagine the workflow being like:

How it could be done

1. Laravel Backend A is able to emit Broadcasting Events to Laravel Reverb. Laravel Backend A is also able to listen to those events asynchronously.
2. Laravel Backend B is also able to emit Broadcasting Events to Laravel Reverb. Laravel Backend B is also able to listen to those events asynchronously.
3. Authorization could be achieved using Passport Client Credential Tokens, because we are talking about M2M in this scenario.

What do you think about this idea? Is it possible and how could it be done?

[roy-codeur]

Hi, do you think if I can use "amphp/websocket-client" with reberb ?

[nilskretschmer]

Hey @roy-codeur

I think basically, yes. That would be my idea, too. The only problem is that you would need to implement the Laravel Broadcasting Authentication within the websocket client to use private/presence channels.

You could look into Laravel Echo for how that's done. But the problem is that Echo uses the JavaScript Pusher SDK under the hood. And there is no Pusher SDK for client side PHP. So you would need to implement a pusher-compatible authorization and subscription flow yourself. That's exactly the problem I see in this approach: We need a "client-side" PHP Pusher compatible SDK / Websocket client.

[usmanarain350]

Hello, after reviewing the code in the Laravel Reverb repository, I discovered a solution for Real-time bidirectional communication that worked for me. I created a listener named BroadcastMessage, as shown in the example code below:

namespace App\Listeners;

use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Laravel\Reverb\Events\MessageReceived;

class BroadcastMessage
{
    /**
     * Create the event listener.
     */
    public function __construct()
    {
        //
    }

    /**
     * Handle the event.
     */
    public function handle(MessageReceived $event): void
    {
        $message = json_decode($event->message);
        $data = $message->data;

        if(!$message->event || !$message->event !== 'SendMessage'){
            return ;
        }

        $data = json_decode($data);
    }
}

Ensure that you use the MessageReceived Laravel Reverb event and listen to it in EventServiceProvider.php:

MessageReceived::class => [
    BroadcastMessage::class
], 

Here's an example of sending an event using Laravel Echo with Pusher from the client side:

Echo.connector.pusher.send_event(
      'SendMessage',   // Event Name
       JSON.stringify({message : "Hello from client"}),  // data
       `analytics-project-channel`,  // channel
    );

[prdip]

perfecly working bidirectional communication code , Thanks heaps

[nadirabbas]

It would be awesome to have a third-party package that abstracts all this and also makes us able to write controllers to handle the ws events. Like Nestjs does.

[shaedrich]

It would be nice if channels.php was utilized for that more in terms of routing, just like web.php and api.php 🤔

[Fypex]

This works, but in my case with Laravel 11.
The code in the provider was duplicating requests.
As far as I understood, add "public function handle(MessageReceived $event)" to the listener class was enough for Laravel to register everything itself and the problem with duplicates disappeared.

on EventServiceProvider (Bad)

MessageReceived::class => [
    TestEventListener::class
], 

or in AppServiceProvider (Bad)

Event::listen(
    MessageReceived::class,
    TestEventListener::class
);

Good

<?php

namespace App\Listeners;

use App\Events\TestEvent;
use Laravel\Reverb\Events\MessageReceived;

class TestEventListener
{

    public function handle(MessageReceived $event): void
    {

        $message = json_decode($event->message, true);
        if (@$message['event'] == 'notification' && @$message['channel'] === 'notifications') {
            broadcast(new TestEvent(0, $message['message']))->toOthers();
        }

    }
}

[Sindoweb]

I'm alo using Laravel 11 and I have been losing countless hours with this - but MessageReceived is not firing in my case.

public function boot(): void
    {
        Event::listen(
            MessageReceived::class,
            BroadcastMessageListener::class
        );
    }

<?php

namespace App\Listeners;

use App\Events\PusherResponse;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Support\Facades\Log;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Support\Facades\Broadcast;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Support\Str;
use Laravel\Reverb\Events\MessageReceived;

class BroadcastMessageListener
{
    /**
     * Create the event listener.
     */
    public function __construct()
    {
        //
    }

    /**
     * Handle the event.
     */
    public function handle(MessageReceived $event): void
    {
        $message = json_decode($event->message);

        Log::info('Message received - ' . $message->event);

        broadcast(new PusherResponse())->toOthers();
    }
}

No matter what I try - I don't see the log entry from BroadcastMessageListener in my log files.
The event is fired from my javascript code.

[nyljzabala]

Hello. I really love reverb because it made our job much more efficient in terms of data requests.

We are currently developing a chatbot and we use reverb as the process for sending the question to the backend server. The process is to send the message with echo send_event and process receive the message with reverb's MessageReceived event then process the message and broadcast back to the specified channel.

Question, What is the purpose of MessageSent event in reverb? Can we use it to directly send a message to the connection rather than broadcasting it thru the channel?

[trongio]

can you please show me a snippet how you handle MessageReceived ?
I tried a many different things but nothing works.

this is my last attempt in laravel 11

class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     */
    public function register(): void
    {
        //
    }

    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        Event::listen(
            MessageReceived::class,
            BroadcastMessage::class
        );
    }
}

namespace App\Listeners;

use App\Events\SendMessage;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Support\Facades\Log;
use Laravel\Reverb\Events\MessageReceived;

class BroadcastMessage
{
    /**
     * Create the event listener.
     */
    public function __construct()
    {
        //
    }

    /**
     * Handle the event.
     */
    public function handle(MessageReceived $event): void
    {

        Log::info('BroadcastMessage');
        $message = json_decode($event->message);
        $data = $message->data;

        if(!$message->event || !$message->event !== 'SendMessage'){
            return ;
        }

        $data = json_decode($data);

        SendMessage::dispatch($data);
    }
}

this is my function in js:

function sendPackage() {
    Echo.connector.pusher.send_event('SendMessage',
        JSON.stringify( messageData.value ), 'channel.name');
}

I get this in reverb debug console:

  Message Received ................................................... 434572681.804986462

   1▕ {

   2▕     "event": "SendMessage",

   3▕     "data": "hello",

   4▕     "channel": "channel.name"

   5▕ }


  Message Handled .................................................... 434572681.804986462

but nothing happens.

[njzabala]

That is the correct setup except I didn't add the Event in the AppServiceProvider. MessageReceived event listener is automatically registered so it should work.

Edit:
I don't think SendMessage::dispatch($data); will work. You should put that as ShouldQueue

[NXC-Controls]

i was facing the same issue resolved by correcting sequence in appserviceprovider

namespace App\Providers;
use app\Listeners\BroadcastMessage;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\ServiceProvider;
use Laravel\Reverb\Events\MessageReceived;

[najeeb-anwari]

In your code there is also a mistake

if(!$message->event || !$message->event !== 'SendMessage'){
    return ;
}

there is ! (not) before $message->event !== 'SendMessage which will make the statement true if the event is SendMessage and it will return.
The code should look like this

if(!$message->event || $message->event !== 'SendMessage'){
    return ;
}

I think you should also clear your event cache by
php artisan event:clear
doesn't hurt if also use
php artisan optimize:clear
also restart the reverb server

[nilskretschmer]

Also just a guess:
Which queue-Driver are you using? I assume you should switch from sync to redis even for local development if you want to catch the reverb event as reverb itself is using redis most of the time.

[shaedrich]

I guess, that wasn't a priority, because you could send client to server requests without websockets via an API. However, I do see that it may be convenient to do it both in the same way.

This could even enable a package to implement something like waiting for a response to the event without coding its relation to the request sent, just by convention 🤔

[mandatoryGithubUser]

because you could send client to server requests without websockets via an API

Except, websockets solve a different problem compared to an API. Bidirectional communication is usually assumed with websockets. Reverb is closer to server sent events.

[shaedrich]

But that's the point: Send requests to the server via an API, get something back immediately or via SSE. Not that WebSockets don't have their use case, it's just that it can be worked around and Laravel tries to not bloat their core.