Wie bindet man den ZeroMQ-Socket mit der Ratchet-Web-Socket-Bibliothek, um eine Echtzeit-Anwendung für die PHP-Anwendung zu erstellen?

Question

Ich bin nur ein Anfänger in diesem ganzen Bereich mit Websocket, Ratchet und ZeroMQ.

Zu meinem Grundverständnis:

websocket ist etwas, die offene Verbindung zwischen Server und Client erstellen kann.

Ratchet ist eine PHP-basierte Bibliothek, die die PHP Socket-Funktionen verwendet, um ein PHP-Socket-Framework zu erstellen, das es uns ermöglicht, PHP-Socket-Programmierung zu vereinfachen.

ZeroMQ ist eine Socket-Bibliothek, die nicht-Ratchet-Anwendung (andere PHP-Skript) hilft, die Daten über Ratchet-Socket und Web-Socket zu senden.

Ich folge dem Tutorial in Ratchet über 'Hallo Welt' und 'Pusher', aber beide scheint unvollständig zu sein und lehrt nur, wie man nur mit der Konsole arbeitet. Ich habe auch ein Ratschen-Beispiel in Github gefunden, aber es ist nicht richtig dokumentiert. Ich war auf der Suche nach einem vollständigen Beispiel (mit einer dedizierten HTML-Seite und Javascript)

Unten ist der Code, ich arbeite an: Dies ist eine der Methode des Controllers, die ich eine Ajax-Anfrage für. Diese Methode erstellt einen neuen Post (sagen wir mal). Ich möchte die Liste der Post dynamisch im Browser des Multi-Clients aktualisieren, indem ich mit Hilfe von ZeroMq sende oder drehe.

Verfahren in einem Controller:

public function create_new_post(){ 
    // ------ 
    // code to create a new post. 
    // ------- 

    // After creating a post 
    $response = [ 
     'new_post_title' => $title, 
     'post_id'   => $id 
    ]; 

    $context = new ZMQContext(); 
    $socket = $context->getSocket(ZMQ::SOCKET_PUSH, 'my pusher'); 
    $socket->connect("tcp://localhost:8000"); 
    $socket->send(json_encode($response)); 

} 

Pusher Datei:

use Ratchet\ConnectionInterface; 
use Ratchet\Wamp\WampServerInterface; 

class Pusher implements WampServerInterface{ 

    public function onPostEntry($data){ 
     // Data that were sent by ZeroMQ through create_new_post() method 
     $entry_data = json_decode($data);  

     // AND AFTER THIS, I DONT HAVE CLUE OF WHAT TO DO NEXT !!    

    } 
} 

Shell-Skript ausführen Server:

require dirname(__DIR__) . '/vendor/autoload.php'; 

$loop = React\EventLoop\Factory::create(); 
$pusher = new MyApp\Pusher; 

// Listen for the web server to make a ZeroMQ push after an ajax request 
$context = new React\ZMQ\Context($loop); 
$pull = $context->getSocket(ZMQ::SOCKET_PULL); 
$pull->bind('tcp://127.0.0.1:8000'); 
$pull->on('message', array($pusher, 'onBidEntry')); 

// Set up our WebSocket server for clients wanting real-time updates 
$webSock = new React\Socket\Server($loop); 
$webSock->listen(8080, '0.0.0.0'); 
$webServer = new Ratchet\Server\IoServer(
    new Ratchet\Http\HttpServer(
     new Ratchet\WebSocket\WsServer(
      new Ratchet\Wamp\WampServer(
       $pusher 
      ) 
     ) 
    ), 
    $webSock 
); 

$loop->run(); 

Shell-Skript sagt nur, dass es im Hafen dienen 8080, aber wie würde ich meine Routen nennen? Sagen wir, ich möchte die offene Verbindung nur in der Seite 'mysite/allposts'. Außerdem, was wäre das Skript, das ich auf der Client-Seite (eine Javascript-Datei) schreiben muss und wie man diese neuen Daten durch Client-Seite erhält, die ein bestimmtes DOM-Objekt aktualisiert.

Answer 1

Ich folgte den Beispielen, über die Sie sprechen. Sie schienen mir nicht unvollständig zu sein, aber ich verstehe, was du meinst. Ratchet ist ein serverseitiges Skript und ermöglicht Ihnen nur das Schreiben eines Dienstes, der Websockets implementiert und ZMQ-Nachrichten abhören kann. Sie werden Ihr Ratchet-Skript in der Befehlszeile starten und es wird als Dienst parallel zu Apache ausgeführt.

Dies ist alles unabhängig von der Client-Seite des Websocket. Wie sie empfehlen, habe ich Autobahn.js auf der Clientseite verwendet. Diese Bibliothek implementiert das WAMP-Protokoll. Es vereinfacht den clientseitigen Code auf das Maximum. Das Problem mit Ihrem Code ist, dass class Pusher implements WampServerInterface kein public function onPostEntry hat.Diese Klasse muss die WampServerInterface implementieren, bedeutet dies, es muss mindestens diese Funktionen:

• onSubscribe (ConnectionInterface $ conn, $ Thema)
• onUnSubscribe (ConnectionInterface $ conn, $ Thema)
• onOpen (ConnectionInterface $ conn)
• onClose (ConnectionInterface $ conn)
• onPublish (ConnectionInterface $ conn, $ Thema, $ event, array $ ausschließen, array $ qualifizierten
• onError (ConnectionInterface $ Conn, \ Exception $ e)
• onZMQMessage ($ jsondata)

Es können andere für erweiterte Funktionen, wie call ing Remote-Verfahren auf Kunden sein.

Auf der Senderseite (ZMQ Nachricht), setzen Sie diesen Code:

$zmq = new ZMQWrapper; 
$zqm->publish('posts', $response); 

class ZMQWrapper { 
    function __construct(){ 
     $this->context = new ZMQContext(); 
     $this->socket = $this->context->getSocket(ZMQ::SOCKET_PUSH); 
     $this->socket->setSockOpt(ZMQ::SOCKOPT_LINGER, 500); 
     $this->socket->connect("tcp://127.0.0.1:" . ZMQ_PORT); 
    } 
    function publish($topic, $msg){ 
     $data = ['topic' => "mb.$topic", 'msg' => $msg]; 
     $this->socket->send(json_encode($data), ZMQ::MODE_DONTWAIT); 
    } 
} 

In der Pusher-Datei setzen someting wie:

public function onSubscribe(ConnectionInterface $conn, $topic) { 
    $log = $this->getLogger(); 
    $topicId = $topic->getId(); 
    $log->info(sprintf('A client subscribed to %s', $topicId)); 
    // you could broadcast that user x joined the discussion 
} 
public function onUnSubscribe(ConnectionInterface $conn, $topic) { 
    $log = $this->getLogger(); 
    $topicId = $topic->getId(); 
    $log->info(sprintf('A client unsubscribed from %s', $topicId)); 
    // you could broadcast that user x leaved the discussion 
} 
public function onOpen(ConnectionInterface $conn) { 
    $log = $this->getLogger(); 
    $log->info(sprintf('Client %d connected', $conn->resourceId)); 
    $this->clients[$conn->resourceId] = array(); // this will allow you to save state information of the client, you can modify in onSubscribe and onUnsubscribe 
    // clients will contain the list of all clients 
} 
public function onClose(ConnectionInterface $conn) { 
    $log = $this->getLogger(); 
    $log->info(sprintf('Client %d disconnected', $conn->resourceId)); 
    // you could broadcast that user x leaved the discussion 
} 
public function onPublish(ConnectionInterface $conn, $topic, $event, array $exclude, array $eligible) { 
    $log = $this->getLogger(); 
    $topicId = $topic->getId(); 
    $log->info(sprintf('Client %d published to %s : %s', $conn->resourceId, $topicId, json_encode($event))); 
    foreach($topic->getIterator() as $peer){ 
     if(!in_array($peer->WAMP->sessionId, $exclude)){ 
      $peer->event($topicId, $event); 
     } 
    } 
} 

Das letzte Stück auf dem Client ist. Wenn ein Benutzer die Seite mysite/allposts öffnet, schließen Sie in Javascript autobahn.js ein. Der Websocket wird unter der Variablen ab zur Verfügung gestellt. Sie tun dann:

Beim Öffnen der Seite:

var currentSession; 
ab.connect(
    Paths.ws, 
    function(session) { // onconnect 
     currentSession = session 
     onWsConnect(session) 
    }, 
    function(code, reason, detail) {// onhangup 
     onWsDisconnect(code, reason, detail) 
    },{ 
     maxRetries: 60, 
     retryDelay: 2000, 
     skipSubprotocolCheck: true 
    } 
) 
currentSession.subscribe('posts', onPostReceived) 

function onPostReceived(topic, message){ 
    //display the new post 
} 

Wenn die Seite endet:

currentSession.unsubscribe(topic) 

Sie merken, dass ich alles sehr allgemein gehalten. Dies ermöglicht es mir, mehrere Arten von Nachrichten von demselben System zu behandeln. Was sich unterscheidet, sind die ZMQ-Nachrichten und die Argumente von currentSession.subscribe.

ich meine Implementierung, ich auch verfolgen die angemeldeten Benutzer, die die Verbindung geöffnet, aber ich habe diesen Teil des Codes entfernt.

Ich hoffe, das wird Ihnen helfen.