Server.php

Go to the documentation of this file.

<?php

namespace Rsi\Fred\Socket;

class Server extends \Rsi\Thing implements \Ratchet\MessageComponentInterface{

  public $clients = []; //!< Array with all connected clients (key = resource ID, value = Client object).
  public $id = null; //!< Resource ID for current client.

  protected $_loop = null;
  protected $_client = null; //!< Client/public WebSocket.
  protected $_local = null; //!< Local socket (raw).
  protected $_server = null;

  protected $_socket = null;
  protected $_tokens = []; //!< Array with allowed client tokens (key = token, value = array with keys 'time' and 'params').

  public function __construct($socket){
    $this->_socket = $socket;
  }
  /**
   * Client connection resource ID's.
   * @param string $controller_name  Get ID's for clients with this controller (empty = all).
   * @return array
   */
  public function ids($controller_name = null){
    $ids = [];
    foreach($this->clients as $id => $client)
      if(!$controller_name || ($client->controller->name == $controller_name)) $ids[] = $id;
    return $ids;
  }
  /**
   * Send data to a client.
   * @param int $id  Client connection resource ID.
   * @param mixed $data
   */
  public function send($id,$data){
    $this->clients[$id]->connection->send(json_encode($data));
  }
  /**
   * Broadcast data to all clients.
   * @param mixed $data
   * @param string $controller_name  Only to clients with this controller (empty = all).
   * @param array $except_ids  Exclude cients with these resource ID's.
   * @return array  Resource ID's that received the data.
   */
  public function broadcast($data,$controller_name = null,$except_ids = null){
    $ids = array_diff($this->ids($controller_name),$except_ids ?: []);
    foreach($ids as $id) $this->send($id,$data);
    return $ids;
  }
  /**
   * Create a WebSocket access token through a local connection.
   * @param array $data  Array with a key for the 'token'.
   * @return array  Key for 'time' until which the token is valid.
   */
  protected function localToken($data){
    if($token = \Rsi\Record::get($data,'token')){
      $this->_tokens[$token] = ['time' => $time = time() + $this->_socket->tokenTtl,'params' => $data];
      return ['time' => $time];
    }
  }
  /**
   * Add or update client data (session data).
   * @param array $data  Array with key 'sessionId'. All other data is merged with the client data.
   * @return array  Key for 'count' (number of data sets modified).
   */
  protected function localParams($data){
    $count = 0;
    if($session_id = \Rsi\Record::get($data,'sessionId')){
      foreach($this->_tokens as &$token_data) if($token_data['sessionId'] == $session_id){
        $token_data = array_merge($token_data,$data);
        $count++;
      }
      unset($token_data);
      foreach($this->clients as $client) if($client->params['sessionId'] == $session_id){
        $client->params = array_merge($client->params,$data);
        $count++;
      }
      return ['count' => 0];
    }
  }
  /**
   * Active session ID's through a local connection.
   * @param array $data  Array with an optional key 'controller' (if set only the session ID' for clients with this controller
   *   are returned).
   * @return array  Key for 'sessionIds' (array with active session ID's).
   */
  protected function localSessionIds($data){
    $controller_name = \Rsi\Record::get($data,'controller');
    $session_ids = [];
    foreach($this->clients as $id => $client)
      if(!$controller_name || ($client->controller->name == $controller_name))
        $session_ids[$id] = $client->params['sessionId'];
    return ['sessionIds' => $session_ids];
  }
  /**
   * Close one or more connections through a local connection.
   * @param array $data  Array with optional keys 'controller' (if set only the connections for clients with this controller
   *   are closed) and 'sessions' (if set only the connections for clients with these sesion ID's are closed).
   * @return array  Key for 'count' (number of sessions closed).
   */
  protected function localClose($data){
    $controller_name = \Rsi\Record::get($data,'controller');
    $session_ids = \Rsi\Record::get($data,'sessions');
    $count = 0;
    foreach($this->clients as $client) if(
      (!$session_ids || in_array($client->params['sessionId'],$session_ids)) &&
      (!$controller_name || ($client->controller->name == $controller_name))
    ){
      $client->connection->close();
      $count++;
    }
    return ['count' => $count];
  }
  /**
   * Request a shutdown of the WebSocket server through a local connection.
   * @param array $data  Expects nothing.
   */
  protected function localShutdown($data){
    $this->log->notice('Shutdown requested',__FILE__,__LINE__);
    $this->loop->stop();
  }
  /**
   * Broadcast data to all clients through a local connection.
   * @param array $data  Array with a key 'data' (data to send to the clients), and optional keys 'controller' (if set only the
   *   clients with this controller will receive the data) and 'except' (if set clients with these sesion ID's will not receive
   *   the data).
   * @return array  Key for 'count' (number of clients that received the data).
   */
  protected function localBroadcast($data){
    return ['count' => count($this->broadcast(
      \Rsi\Record::get($data,'data'),
      \Rsi\Record::get($data,'controller'),
      \Rsi\Record::get($data,'except')
    ))];
  }
  /**
   * Local data handler.
   * @param mixed $data  Data received from HTTP server.
   * @return mixed  Response to HTTP server.
   * @see send()
   */
  protected function onLocalData($data){
    if($controller_name = \Rsi\Record::get($data,'controller')){
      $_POST = $data;
      $this->_socket->component('front')->controller($controller_name)->execute();
      return $this->_socket->component('request')->data;
    }
    elseif(method_exists($this,$method = 'local' . ucfirst(\Rsi\Record::get($data,'action'))))
      return call_user_func([$this,$method],$data);
    return false;
  }
  /**
   * Called on a new local connection.
   * @param \React\Socket\ConnectionInterface $connection
   */
  public function onLocalConnection($connection){
    $log = $this->log;
    if(in_array($connection->getRemoteAddress(),$this->_socket->localClients)){
      $log->debug('New local connection',__FILE__,__LINE__);
      $connection->on('data',function($data) use ($connection,$log){
        $log->debug('Received local data (' . strlen($data) . ' bytes)',['data' => $data]);
        $connection->write(serialize($this->onLocalData(unserialize($data))));
      });
    }
    else{
      $log->notice('Local connection not allowed',__FILE__,__LINE__,['connection' => $connection]);
      $connection->close();
    }
  }
  /**
   * Called on a new client connection.
   * @param \Ratchet\ConnectionInterface $connection
   */
  public function onOpen(\Ratchet\ConnectionInterface $connection){
    $log = $this->log;
    $request = $connection->WebSocket->request;
    if($origins = $this->_socket->clientOrigins){
      $origin = parse_url($origin = (string)$request->getHeader('Origin'),PHP_URL_HOST) ?: $origin;
      if(!in_array($origin,$origins)){
        $log->notice('Origin not allowed',__FILE__,__LINE__,['connection' => $connection,'origin' => $origin]);
        return $connection->close();
      }
    }
    parse_str($request->getQuery(),$query);
    $time = time();
    foreach($this->_tokens as $token => $params) if($params['time'] < $time) unset($this->_tokens[$token]);
    if(!array_key_exists($token = $query['token'] ?? null,$this->_tokens)){
      $log->notice('Token too old ',__FILE__,__LINE__,['connection' => $connection]);
      return $connection->close();
    }
    $_SESSION = $params = $this->_tokens[$token]['params'];
    $_SERVER['REMOTE_ADDR'] = $connection->remoteAddress;
    $router = $this->_socket->component('router');
    $router->execute($request->getPath());
    $controller = $this->_socket->component('front')->controller($router->controllerName);
    $_SESSION = [];
    unset($_SERVER['REMOTE_ADDR']);
    $log->debug("New connection ({$connection->resourceId}) for {$controller->name}",__FILE__,__LINE__);
    $this->clients[$connection->resourceId] = new Client($connection,$params,$controller);
    unset($this->_tokens[$token]);
  }

  public function onClose(\Ratchet\ConnectionInterface $connection){
    $this->log->debug("Connection closed ({$connection->resourceId})",__FILE__,__LINE__);
    unset($this->clients[$connection->resourceId]);
  }

  public function onError(\Ratchet\ConnectionInterface $connection,\Exception $exception){
    $this->log->error($exception->getMessage(),__FILE__,__LINE__);
    $connection->close();
  }

  public function onMessage(\Ratchet\ConnectionInterface $connection,$data){
    $data = json_decode($data,true);
    $this->log->debug("Message from connection {$connection->resourceId}",__FILE__,__LINE__,['data' => $data]);
    $client = $this->clients[$this->id = $connection->resourceId];
    $client->controller->reset();
    $_POST = $data;
    $_SESSION = $client->params;
    $_SERVER['REMOTE_ADDR'] = $connection->remoteAddress;
    $client->controller->execute();
    $this->id = null;
    $_POST = $_SESSION = [];
    unset($_SERVER['REMOTE_ADDR']);
  }
  /**
   * Run the WebSocket server.
   */
  public function run(){
    $this->server->run();
  }

  protected function getLocal(){
    $this->getLoop();
    return $this->_local;
  }

  protected function getLog(){
    return $this->_socket->component('log');
  }

  protected function getLoop(){
    if(!$this->_loop){
      if(!$this->_socket->clientPort) throw new \Exception('No client port');
      $this->_loop = \React\EventLoop\Factory::create();
      $this->_client = new \React\Socket\Server($this->_loop);
      $this->_client->listen($port = $this->_socket->clientLocalPort ?: $this->_socket->clientPort,'0.0.0.0');
      $this->log->debug("Listening on port $port for client connections");
      $this->_local = new \React\Socket\Server($this->_loop);
      $this->_local->listen($port = $this->_socket->localPort,'0.0.0.0');
      $this->log->debug("Listening on port $port for local connections");
      $this->_local->on('connection',[$this,'onLocalConnection']);
    }
    return $this->_loop;
  }

  protected function getClient(){
    $this->getLoop();
    return $this->_client;
  }

  protected function getServer(){
    if(!$this->_server) $this->_server = new \Ratchet\Server\IoServer(
      new \Ratchet\Http\HttpServer(new \Ratchet\WebSocket\WsServer($this)),
      $this->client,
      $this->loop
    );
    return $this->_server;
  }

}