VFS_websocket_client.cpp

Go to the documentation of this file.

 
#include "VFS_websocket_client.h"
#include "VFS_websocket_server.h"
 
#include "VFS.h"
 
#include <QTimerEvent>
 
VFS_websocket_client::VFS_websocket_client(QWebSocket *socket, VFS_websocket_server *server)
: VFS_node()
, _socket(socket)
, _server(server)
, _authenticated(false)
, _authorized(false)
, _pingID(-1)
, _isClient(false)
, _connectID(-1)
, _interval(3000)
{
        init();
}
 
VFS_websocket_client::VFS_websocket_client(QString wsurl, quint16 interval)
: VFS_node()
, _socket(0)
, _server(0)
, _authenticated(false)
, _authorized(false)
, _pingID(-1)
, _isClient(true)
, _connectID(-1)
, _wsurl(wsurl)
, _interval(interval)
{
        _socket = new QWebSocket();
        _socket->setParent(this);
 
        init();
 
        VFS::LOG( QString("%1 attempting connection to %2...").arg(className()).arg(_wsurl) );
        _socket->open(_wsurl);
}
 
void VFS_websocket_client::init()
{
        _address = _socket->peerAddress();
        //_hwaddress =
        //_port = _socket->peerPort();
 
        if (_isClient)
        {
                //this is for auto-reconnect
                connect(        _socket,        SIGNAL( connected()             ),
                                this,           SLOT(   socket_connected()      )               );
 
                connect(        _socket,        SIGNAL( textMessageReceived(QString) ),
                                this,           SLOT(   socket_receive_text(QString) )          );
 
                connect(        _socket,        SIGNAL( binaryMessageReceived(QByteArray) ),
                                this,           SLOT(   socket_receive_binary(QByteArray) )     );
        }
        else
        {
                if (!_socket->isValid())
                        printf("WARNING! socket is invalid?\n");
        }
 
        connect(        _socket,        SIGNAL( disconnected()          ),
                        this,           SLOT(   socket_disconnected()           )       );
 
        connect(        _socket,        SIGNAL( textMessageReceived(QString) ),
                                        SIGNAL( readyTextMessage(QString))      );
 
        connect(        _socket,        SIGNAL( binaryMessageReceived(QByteArray) ),
                                        SIGNAL( readyBinaryMessage(QByteArray)) );
 
        connect(        _socket,        SIGNAL( error(QAbstractSocket::SocketError) ),
                        this,           SIGNAL( error(QAbstractSocket::SocketError) )   );
 
        connect(this,SIGNAL(mounted()),this,SLOT(startPing()));
        connect(this,SIGNAL(unmounted(VFS_node*)),this,SLOT(close()));
}
 
VFS_websocket_client::~VFS_websocket_client()
{
        //QMutexLocker l(&_lock);
 
        close();
 
        if (_socket)
                _socket->deleteLater();
        //delete _socket;
}
 
void VFS_websocket_client::authorized()
{
        QHostAddress a = _socket->peerAddress();
        QString name = _server->uniqueChildName(a.toString());
        _server->append(name,this,false);       //disregard container-ness of the _server, and just add clients.  This is useful for presenting menus.
}
 
void VFS_websocket_client::startPing()
{
        if (_pingID != -1)
                killTimer(_pingID);
 
        _pingID = startTimer(1000*20);          //every 20 seconds... just in case we're behind a proxy of some kind
}
 
void VFS_websocket_client::timerEvent(QTimerEvent *e)
{
        //QMutexLocker l(&_lock);
 
        int id = e->timerId();
 
        if (id == _pingID)
        {
                if (_socket->isValid())
                        _socket->ping();                //keep the connection open
        }
 
        if (id == _connectID)
        {
                if (_isClient)
                {       VFS::LOG( QString("%1 attempting connection to %2...").arg(className()).arg(_wsurl) );
                        _socket->open(_wsurl);          //attempt a connection
                }
        }
}
 
void VFS_websocket_client::socket_connected()
{
        VFS::LOG( QString("%1 connected to %2").arg(className()).arg(_wsurl), 2 );
 
        startPing();
        _address = _socket->peerAddress();
 
        //printf("CONNECTED! KILL TIMER!\n");
        if (_connectID != -1)
        {       killTimer(_connectID);
                _connectID = -1;
        }
 
        emit connected();
}
 
void VFS_websocket_client::socket_disconnected()
{
        emit disconnected();
 
        //printf("DISCONNECTED! START TIMER!\n");
        if (_isClient && _connectID == -1)
        {       VFS::WARN( QString("Socket disconnected... will attempt to reconnect."), 8, className() );
                _connectID = startTimer(_interval);
        }
}
 
bool VFS_websocket_client::isConnecting()
{
        return _connectID != -1;
}
 
bool VFS_websocket_client::isConnected()
{
        return _socket->isValid();
}
 
void VFS_websocket_client::socket_receive_text(QString message)
{
        receive( message.toUtf8() );
}
 
void VFS_websocket_client::socket_receive_binary(QByteArray message)
{
        receive( message );
}
 
void VFS_websocket_client::close()
{
        if (_socket && _socket->isValid())
                _socket->close();
}
 
void VFS_websocket_client::write(VFS_request *r)
{
        VFS::ERROR( QString("Cannot write to '%1:%2' node.  Create a subclass?" ).arg(className()).arg(r->_path) );
}
 
void VFS_websocket_client::submit(VFS_request *r)
{
        VFS::ERROR( QString("Cannot submit to '%1:%2' node.  Create a subclass?" ).arg(className()).arg(r->_path) );
}
 
bool VFS_websocket_client::writeText(QString data)
{
        qint64 w = _socket->sendTextMessage(data);
 
        if (false)                              //FIXME: websockets often misreport bytes written... a documented bug in Qt5.6-5.7
        if (w!=data.length())
        {       VFS::ERROR( QString("Could not write all data to websocket! (%1/%2)").arg(w).arg(data.length()) );
                //printf("Tried to write %lld bytes, but only %d made it.\n",w,data.length());
                printf("%s",qUtf8Printable(data));
                return false;
        }
        return true;
}
 
bool VFS_websocket_client::writeBinary(QByteArray data)
{
        qint64 w = _socket->sendBinaryMessage(data);
 
        if (w!=data.length())
        {       VFS::ERROR( QString("Could not write all binary data to websocket! (%1/%2)").arg(w).arg(data.length()) );
                return false;
        }
        return true;
}
 
bool VFS_websocket_client::isContainer()
{
        return false;
}
 
QJsonDocument VFS_websocket_client::receive(QByteArray message)
{
        QJsonParseError e;
        QJsonDocument d = QJsonDocument::fromJson(message, &e);
        if (e.error != QJsonParseError::NoError)
        {
                VFS::ERROR( QString("Unparseable command received from %1: %2\n%3").arg(_address.toString()).arg(e.errorString()).arg(QString(message)), 0 );
                close();
                return QJsonDocument();
        }
 
        return d;
}