How to access Laravel Auth in Ratchet

In real-world applications, integrating WebSocket servers (such as those built with the Ratchet framework) with the Laravel framework to ensure WebSocket connections can access Laravel's authentication state is a common requirement. Below is a concise step-by-step guide on how to access Laravel's Auth authentication information within a WebSocket server using Ratchet.

Step 1: Install Ratchet via Composer

First, ensure that you have already installed the Ratchet library in your Laravel project via Composer.

bash
composer require cboden/ratchet

Step 2: Set Up the WebSocket Server

Create a new PHP class to set up the WebSocket server, which will use the Ratchet library.

php
use Ratchet\MessageComponentInterface;
use Ratchet\ConnectionInterface;

class WebSocketController implements MessageComponentInterface {
    public function onOpen(ConnectionInterface $conn) {
        // Connection opened logic
    }

    public function onMessage(ConnectionInterface $conn, $msg) {
        // Handle received messages
    }

    public function onClose(ConnectionInterface $conn) {
        // Connection closed logic
    }

    public function onError(ConnectionInterface $conn, \Exception $e) {
        // Error handling logic
    }
}

Step 3: Integrate Laravel Auth

To enable the Ratchet WebSocket service to access Laravel Auth, we need to read and validate HTTP cookies or tokens during WebSocket connection, which are typically passed via HTTP headers. We'll use the http-middleware to achieve this.

First, use the HTTP middleware in your WebSocket service:

php
use Ratchet\Http\HttpServer;
use Ratchet\WebSocket\WsServer;
use Ratchet\Server\IoServer;

$server = IoServer::factory(
    new HttpServer(
        new WsServer(
            new WebSocketController()
        )
    ),
    8080
);

Then, create a middleware to handle Auth:

php
use Symfony\Component\HttpFoundation\Request;
use Illuminate\Http\Response;
use Ratchet\Http\HttpServerInterface;

class HttpMiddleware implements HttpServerInterface {
    protected $http;

    public function __construct(HttpServerInterface $http) {
        $this->http = $http;
    }

    public function onOpen(ConnectionInterface $conn, Request $request = null) {
        // Check user's Auth state
        $laravelApp = require __DIR__.'/../bootstrap/app.php';
        $laravelApp->make('Illuminate\Contracts\Http\Kernel')->handle(
            Illuminate\Http\Request::create(
                $request->getPath(),
                $request->getMethod(),
                $request->query->all(),
                $request->cookies->all(),
                $request->files->all(),
                $request->server->all()
            )
        );
        $user = Auth::user();  // Get authenticated user
        $conn->User = $user;   // Store user information in the connection object

        // Pass to the next middleware or WebSocket controller
        $this->http->onOpen($conn, $request);
    }
}

In this middleware, we instantiate a Laravel application, load the user state using an HTTP request, and then store the user information in the WebSocket connection object for subsequent use.

Step 4: Start the WebSocket Server

Finally, you need to run the WebSocket server. Ensure you are listening on the correct port and address, and that network configuration allows client connections.

bash
php artisan serve --host=your server IP --port=8080

Now, your WebSocket server should be able to handle user information from Laravel Auth, enabling you to implement user-based real-time features in your application.