ArnClient.hpp

Go to the documentation of this file.

// Copyright (C) 2010-2022 Michael Wiklund.
// All rights reserved.
// Contact: arnlib@wiklunden.se
//
// This file is part of the ArnLib - Active Registry Network.
// Parts of ArnLib depend on Qt and/or other libraries that have their own
// licenses. Usage of these other libraries is subject to their respective
// license agreements.
//
// GNU Lesser General Public License Usage
// This file may be used under the terms of the GNU Lesser General Public
// License version 2.1 as published by the Free Software Foundation and
// appearing in the file LICENSE_LGPL.txt included in the packaging of this
// file. In addition, as a special exception, you may use the rights described
// in the Nokia Qt LGPL Exception version 1.1, included in the file
// LGPL_EXCEPTION.txt in this package.
//
// GNU General Public License Usage
// Alternatively, this file may be used under the terms of the GNU General Public
// License version 3.0 as published by the Free Software Foundation and appearing
// in the file LICENSE_GPL.txt included in the packaging of this file.
//
// Other Usage
// Alternatively, this file may be used in accordance with the terms and conditions
// contained in a signed written agreement between you and Michael Wiklund.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
// PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
//

#ifndef ARNCLIENT_HPP
#define ARNCLIENT_HPP

#include "ArnLib_global.hpp"
#include "ArnM.hpp"
#include "XStringMap.hpp"
#include "MQFlags.hpp"
#include <QObject>
#include <QAbstractSocket>
#include <QStringList>
#include <QList>

class ArnClientPrivate;
class ArnItemNet;
class ArnItemNetEar;


class ArnClientConnectStat {
    Q_GADGET
    Q_ENUMS(E)
public:
    enum E {
        Init = 0,
        Connecting,
        Negotiating,
        Connected,
        Stopped,
        Error,
        Disconnected,
        TriedAll
    };
    MQ_DECLARE_ENUMTXT( ArnClientConnectStat)

    enum NS {NsEnum, NsHuman};
    MQ_DECLARE_ENUM_NSTXT(
        { NsHuman, Init,     "Initialized" },
        { NsHuman, Error,    "Connect error" },
        { NsHuman, MQ_NSTXT_FILL_MISSING_FROM( NsEnum) }
    )
};



class ARNLIBSHARED_EXPORT ArnClient : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ArnClient)

public:
    typedef ArnClientConnectStat  ConnectStat;
    typedef Arn::ClientSyncMode  SyncMode;

    struct HostAddrPort {
        QString  addr;
        quint16  port;

        HostAddrPort() {
            port = Arn::defaultTcpPort;
        }
    };
    typedef QList<HostAddrPort>  HostList;

    explicit ArnClient(QObject *parent = arnNullptr);
    ~ArnClient();


    void  clearArnList( int prioFilter = -1);


    HostList  arnList( int prioFilter = -1)  const;


    void  addToArnList( const QString& arnHost, quint16 port = 0, int prio = 0);


    void  connectToArnList();


    void  connectToArn( const QString& arnHost, quint16 port = 0);


    void  disconnectFromArn();


    void  loginToArn( const QString& userName, const QString& password,
                      Arn::Allow allow = Arn::Allow::All);


    void  loginToArnHashed( const QString& userName, const QString& passwordHashed,
                            Arn::Allow allow = Arn::Allow::All);


    void  close();


    bool  setMountPoint( const QString& path);


    bool  addMountPoint( const QString& localPath, const QString& remotePath = QString());


    bool  removeMountPoint( const QString& localPath);


    ConnectStat  connectStatus()  const;


    void  setAutoConnect( bool isAuto, int retryTime = 2);


    void  registerClient( const QString& id);


    static ArnClient*  getClient( const QString& id);


    QString  id()  const;


    int  receiveTimeout()  const;


    void  setReceiveTimeout( int receiveTimeout);


    bool  isDemandLogin()  const;


    void  setDemandLogin( bool isDemandLogin);


    SyncMode  syncMode()  const;


    void  setSyncMode( SyncMode syncMode);


    static QString  passwordHash( const QString& password);


    QStringList  freePaths()  const;


    void  setWhoIAm( const Arn::XStringMap& whoIAmXsm);


    Arn::XStringMap  remoteWhoIAm()  const;


    bool  isReContact()  const;


    bool  isReConnect()  const;


    void  chatSend( const QString& text, int prioType);


    void  abortKillRequest();


    bool  getTraffic( quint64& in, quint64& out)  const;

    int  curPrio()  const;

    void  commandGet( const QString& path);
    void  commandSet( const QString& path, const QString& data);
    void  commandLs( const QString& path);
    void  commandInfo( int type, const QByteArray& data = QByteArray());
    void  commandVersion();
    bool  getLocalRemotePath( const QString& path,
                              QString& localMountPath, QString& remoteMountPath);
    ArnItemNet*  newNetItem( const QString& path,
                             Arn::ObjectSyncMode syncMode = Arn::ObjectSyncMode::Normal,
                             bool* isNewPtr = arnNullptr);

signals:

    void  tcpError( const QString& errorText, QAbstractSocket::SocketError socketError);


    void  tcpConnected( const QString& arnHost, quint16 port);

    void  tcpDisConnected();


    void  connectionStatusChanged( int status, int curPrio);


    void  loginRequired( int contextCode);


    void  killRequested();


    void  chatReceived( const QString& text, int prioType);

    void  replyRecord( Arn::XStringMap& replyMap);
    void  replyGet( const QString& data, const QString& path);
    void  replyLs( const QStringList& subItems, const QString& path);
    void  replyInfo( int type, const QByteArray& data);
    void  replyVer( const QString& version);

protected:
    ArnClient( ArnClientPrivate& dd, QObject* parent);
    ArnClientPrivate* const  d_ptr;

private slots:
    void  newNetItemProxy( ArnThreadCom* threadCom,
                           const QString& path, int syncMode = 0, void* isNewPtr = arnNullptr);
    void  createNewItem( const QString& path);
    void  doCreateArnTree( const QString& path);
    void  doDestroyArnTree( const QString& path, bool isGlobal);
    void  doReplyRecord( Arn::XStringMap& replyMap);
    void  doLoginRequired( int contextCode);
    void  onConnectWaitDone();
    void  doTcpConnected();
    void  doTcpError( QAbstractSocket::SocketError socketError);
    void  doTcpError( int socketError);
    void  doTcpDisconnected();
    void  doSyncStateChanged( int state);
    void  doRecNotified();
    void  doRecTimeout();
    void  onCommandDelete( const QString& remotePath);
    void  onMessageReceived( int type, const QByteArray& data);

private:
    struct MountPointSlot {
        ArnItemNetEar*  arnMountPoint;
        QString  localPath;
        QString  remotePath;

        MountPointSlot()
        {
            arnMountPoint = arnNullptr;
        }
    };

    void  init();
    void  startConnectArn();
    void  reConnectArn();
    void  doConnectArnLogic();
    static QString  toRemotePathCB( void* context, const QString& path);

    QStringList  makeItemList( Arn::XStringMap& xsMap);

    bool  addMountPointNL( const QString& localPath, const QString& remotePath);
    bool  removeMountPointNL( const QString& localPath);
};

#endif // ARNCLIENT_HPP