kadet1090 / nucleus

XmppClient.php

<?php
/**
 * Nucleus - XMPP Library for PHP
 *
 * Copyright (C) 2016, Some rights reserved.
 *
 * @author Kacper "Kadet" Donat <kacper@kadet.net>
 *
 * Contact with author:
 * Xmpp: me@kadet.net
 * E-mail: contact@kadet.net
 *
 * From Kadet with love.
 */

namespace Kadet\Xmpp;

use DI\Container;
use DI\ContainerBuilder;
use Interop\Container\ContainerInterface;
use Kadet\Xmpp\Exception\InvalidArgumentException;
use Kadet\Xmpp\Exception\WriteOnlyException;
use Kadet\Xmpp\Module\Authenticator;
use Kadet\Xmpp\Module\Binding;
use Kadet\Xmpp\Module\ClientModule;
use Kadet\Xmpp\Module\ClientModuleInterface;
use Kadet\Xmpp\Module\SaslAuthenticator;
use Kadet\Xmpp\Module\TlsEnabler;
use Kadet\Xmpp\Network\Connector;
use Kadet\Xmpp\Stream\Features;
use Kadet\Xmpp\Utils\Accessors;
use Kadet\Xmpp\Utils\filter as with;
use Kadet\Xmpp\Utils\ObservableCollection;
use Kadet\Xmpp\Utils\ServiceManager;
use Kadet\Xmpp\Xml\XmlElementFactory;
use Kadet\Xmpp\Xml\XmlParser;
use Kadet\Xmpp\Xml\XmlStream;
use React\EventLoop\LoopInterface;

/**
 * Class XmppClient
 * @package Kadet\Xmpp
 *
 * @property Features           $features  Features provided by that stream
 * @property XmlParser          $parser    XmlParser instance used to process data from stream, can be exchanged only
 *                                         when client is not connected to server.
 * @property string             $resource  Client's jid resource
 * @property Jid                $jid       Client's jid (Jabber Identifier) address.
 * @property ContainerInterface $container Dependency container used for module management.
 * @property string             $language  Stream language (reflects xml:language attribute)
 * @property string             $state     Current client state
 *                                         `disconnected`   - not connected to any server,
 *                                         `connected`      - connected to server, but nothing happened yet,
 *                                         `secured`        - [optional] TLS negotiation succeeded, after stream restart
 *                                         `authenticated`  - authentication succeeded,
 *                                         `bound`          - resource binding succeeded,
 *                                         `ready`          - client is ready to operate
 *
 *                                         However modules can add custom states.
 *
 * @property Connector    $connector Connector used for obtaining stream
 * @property-write string       $password  Password used for client authentication
 */
class XmppClient extends XmlStream implements ContainerInterface
{
    use ServiceManager, Accessors;

    /**
     * Connector used to instantiate stream connection to server.
     *
     * @var Connector
     */
    private $_connector;

    /**
     * Client's jid (Jabber Identifier) address.
     *
     * @var Jid
     */
    private $_jid;

    /**
     * Dependency container used as service manager.
     *
     * @var Container
     */
    private $_container;

    /**
     * Features provided by that stream
     *
     * @var Features
     */
    private $_features;

    /**
     * Current client state.
     *
     * @var string
     */
    private $_state = 'disconnected';
    private $_attributes = [];
    private $_lang;

    /**
     * XmppClient constructor.
     * @param Jid              $jid
     * @param array            $options {
     *     @var XmlParser          $parser          Parser used for interpreting streams.
     *     @var ClientModule[]     $modules         Additional modules registered when creating client.
     *     @var string             $language        Stream language (reflects xml:language attribute)
     *     @var ContainerInterface $container       Dependency container used for module management.
     *     @var bool               $default-modules Load default modules or not
     * }
     */
    public function __construct(Jid $jid, array $options = [])
    {
        $options = array_replace([
            'parser'    => new XmlParser(new XmlElementFactory()),
            'language'  => 'en',
            'container' => ContainerBuilder::buildDevContainer(),
            'connector' => $options['connector'] ?? new Connector\TcpXmppConnector($jid->domain, $options['loop']),
            'jid'       => $jid,

            'modules'         => [],
            'default-modules' => true,
        ], $options);

        parent::__construct($options['parser'], null);
        unset($options['parser']);

        $this->applyOptions($options);

        $this->on('element', function (Features $element) {
            $this->_features = $element;
            $this->emit('features', [$element]);
        }, Features::class);

        $this->on('close', function (Features $element) {
            $this->state = 'disconnected';
        }, Features::class);
    }

    public function applyOptions(array $options)
    {
        $options = \Kadet\Xmpp\Utils\helper\rearrange($options, [
            'container' => 6,
            'jid'       => 5,
            'connector' => 4,
            'modules'   => 3,
            'password'  => -1
        ]);

        if ($options['default-modules']) {
            $options['modules'] = array_merge([
                TlsEnabler::class    => new TlsEnabler(),
                Binding::class       => new Binding(),
                Authenticator::class => new SaslAuthenticator()
            ], $options['modules']);
        }

        foreach ($options as $name => $value) {
            $this->$name = $value;
        }
    }

    public function restart()
    {
        $this->getLogger()->debug('Restarting stream', $this->_attributes);
        $this->start($this->_attributes);
    }

    public function start(array $attributes = [])
    {
        $this->_attributes = $attributes;

        parent::start(array_merge([
            'xmlns'    => 'jabber:client',
            'version'  => '1.0',
            'xml:lang' => $this->_lang
        ], $attributes));
    }

    public function connect()
    {
        $this->getLogger()->debug("Connecting to {$this->_jid->domain}");

        $this->_connector->connect();
    }

    public function bind($jid)
    {
        $this->jid = new Jid($jid);
        $this->emit('bind', [$jid]);

        $this->state = 'bound';

        $queue = new ObservableCollection();
        $queue->on('empty', function () {
            $this->state = 'ready';
        });

        $this->emit('init', [$queue]);
    }

    /**
     * Registers module in client's dependency container.
     *
     * @param ClientModuleInterface $module Module to be registered
     * @param bool|string           $alias  Module alias, class name by default.
     *                                      `true` for aliasing interfaces and parents too,
     *                                      `false` for aliasing as class name only
     *                                      array for multiple aliases,
     *                                      and any string for alias name
     */
    public function register(ClientModuleInterface $module, $alias = true)
    {
        $module->setClient($this);
        if ($alias === true) {
            $this->_container->set(get_class($module), $module);

            $this->register($module, array_merge(class_implements($module), array_slice(class_parents($module), 1)));

array_merge(class_implements($module), array_slice(class_parents($module), 1)) is of type array, but the function expects a boolean|string.

        } elseif(is_array($alias)) {
            foreach ($alias as $name) {
                if (!$this->has($name)) {
                    $this->register($module, $name);
                }
            }
        } else {
            $this->_container->set($alias === false ? get_class($module) : $alias, $module);
        }
    }

    private function handleConnect($stream)
    {
        $this->exchangeStream($stream);

        $this->getLogger()->info("Connected to {$this->_jid->domain}");
        $this->start([
            'from' => (string)$this->_jid,
            'to'   => $this->_jid->domain
        ]);

        $this->state = 'connected';

        return $this->emit('connect');
    }

    //region Features
    public function getFeatures()
    {
        return $this->_features;
    }
    //endregion

    //region Parser
    public function setParser(XmlParser $parser)
    {
        if($this->state !== "disconnected") {
            throw new \BadMethodCallException('Parser can be changed only when client is disconnected.');
        }

        parent::setParser($parser);
        $this->_parser->factory->load(require __DIR__ . '/XmlElementLookup.php');
    }

    public function getParser()
    {
        return $this->_parser;
    }
    //endregion

    //region Connector
    protected function setConnector($connector)
    {
        if ($connector instanceof LoopInterface) {
            $this->_connector = new Connector\TcpXmppConnector($this->_jid->domain, $connector);
        } elseif ($connector instanceof Connector) {
            $this->_connector = $connector;
        } else {
            throw new InvalidArgumentException(sprintf(
                '$connector must be either %s or %s instance, %s given.',
                LoopInterface::class, Connector::class, \Kadet\Xmpp\Utils\helper\typeof($connector)
            ));
        }

        $this->_connector->on('connect', function ($stream) {
            return $this->handleConnect($stream);
        });
    }

    public function getConnector()
    {
        return $this->_connector;
    }
    //endregion

    //region Resource
    public function setResource(string $resource)
    {
        $this->_jid = new Jid($this->_jid->domain, $this->_jid->local, $resource);
    }

    public function getResource()
    {
        return $this->_jid->resource;
    }
    //endregion

    //region Password
    public function setPassword(string $password)
    {
        $this->get(Authenticator::class)->setPassword($password);
    }

    public function getPassword()
    {
        throw new WriteOnlyException("Password can't be obtained.");
    }
    //endregion

    //region Modules
    public function setModules(array $modules)
    {
        foreach ($modules as $name => $module) {
            $this->register($module, is_string($name) ? $name : true);
        }
    }
    //endregion

    //region State
    public function setState($state)
    {
        $this->_state = $state;
        $this->emit('state', [$state]);
    }

    public function getState()
    {
        return $this->_state;
    }
    //endregion

    //region Container
    protected function getContainer() : ContainerInterface
    {
        return $this->_container;
    }

    protected function setContainer(Container $container)
    {
        $this->_container = $container;
    }
    //endregion

    //region Language
    public function getLanguage(): string
    {
        return $this->_lang;
    }

    public function setLanguage(string $language)
    {
        $this->_lang = $language;
    }
    //endregion

    //region JID
    public function getJid()
    {
        return $this->_jid;
    }

    protected function setJid(Jid $jid)
    {
        $this->_jid = $jid;
    }
    //endregion
}