Introduce new classes for client-server communication.

Still based on what we had already, though more separated.
Change-Id: I4cce298003a4ffc2ebcec01fea1a07adfbfdf990
Reviewed-by: Tim Jenssen <tim.jenssen@digia.com>
Reviewed-by: Niels Weber <niels.weber@digia.com>

1 files changed, 519 insertions, 0 deletions

diff --git a/src/libs/installer/remotefileengine.cpp b/src/libs/installer/remotefileengine.cpp
new file mode 100644
index 000000000..776f8301e
--- /dev/null
+++ b/src/libs/installer/remotefileengine.cpp
@@ -0,0 +1,519 @@
+/**************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Installer Framework.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, 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 included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia 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 included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+**************************************************************************/
+
+#include "remotefileengine.h"
+
+#include "protocol.h"
+#include "remoteclient.h"
+
+#include <QTcpSocket>
+
+namespace QInstaller {
+
+
+// -- RemoteFileEngineHandler
+
+QAbstractFileEngine* RemoteFileEngineHandler::create(const QString &fileName) const
+{
+    if (!RemoteClient::instance().isActive())
+        return 0;
+
+    static QRegExp re(QLatin1String("^[a-z0-9]*://.*$"));
+    if (re.exactMatch(fileName))  // stuff like installer://
+        return 0;
+
+    if (fileName.isEmpty() || fileName.startsWith(QLatin1String(":")))
+        return 0; // empty filename or Qt resource
+
+    QScopedPointer<RemoteFileEngine> client(new RemoteFileEngine());
+    client->setFileName(fileName);
+    if (client->isConnectedToServer())
+        return client.take();
+    return 0;
+}
+
+
+// -- RemoteFileEngineIterator
+
+class RemoteFileEngineIterator : public QAbstractFileEngineIterator
+{
+public:
+    RemoteFileEngineIterator(QDir::Filters filters, const QStringList &nameFilters,
+            const QStringList &files)
+        : QAbstractFileEngineIterator(filters, nameFilters)
+        , entries(files)
+        , index(-1)
+    {
+    }
+
+    /*!
+        \reimp
+    */
+    bool hasNext() const
+    {
+        return index < entries.size() - 1;
+    }
+
+    /*!
+        \reimp
+    */
+    QString next()
+    {
+       if (!hasNext())
+           return QString();
+       ++index;
+       return currentFilePath();
+    }
+
+    /*!
+        \reimp
+    */
+    QString currentFileName() const
+    {
+        return entries.at(index);
+    }
+
+private:
+    const QStringList entries;
+    int index;
+};
+
+
+// -- RemoteFileEngine
+
+RemoteFileEngine::RemoteFileEngine()
+    : RemoteObject(QLatin1String(Protocol::QAbstractFileEngine))
+{
+}
+
+RemoteFileEngine::~RemoteFileEngine()
+{
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::atEnd() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineAtEnd));
+    return m_fileEngine.atEnd();
+}
+
+/*!
+    \reimp
+*/
+QAbstractFileEngine::Iterator* RemoteFileEngine::beginEntryList(QDir::Filters filters,
+    const QStringList &filterNames)
+{
+    QStringList entries = entryList(filters, filterNames);
+    entries.removeAll(QString());
+    return new RemoteFileEngineIterator(filters, filterNames, entries);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::caseSensitive() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineCaseSensitive));
+    return m_fileEngine.caseSensitive();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::close()
+{
+    if (connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineClose));
+    return m_fileEngine.close();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::copy(const QString &newName)
+{
+    if (connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineCopy), newName);
+    return m_fileEngine.copy(newName);
+}
+
+/*!
+    \reimp
+*/
+QStringList RemoteFileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return callRemoteMethod<QStringList>
+            (QString::fromLatin1(Protocol::QAbstractFileEngineEntryList), static_cast<int>(filters),
+            filterNames);
+    }
+    return m_fileEngine.entryList(filters, filterNames);
+}
+
+/*!
+    \reimp
+*/
+QFile::FileError RemoteFileEngine::error() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return static_cast<QFile::FileError>
+            (callRemoteMethod<int>(QString::fromLatin1(Protocol::QAbstractFileEngineError)));
+    }
+    return m_fileEngine.error();
+}
+
+/*!
+    \reimp
+*/
+QString RemoteFileEngine::errorString() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<QString>(QString::fromLatin1(Protocol::QAbstractFileEngineErrorString));
+    return m_fileEngine.errorString();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::extension(Extension extension, const ExtensionOption *eo, ExtensionReturn *er)
+{
+    return false;
+    if (extension == UnMapExtension || extension == MapExtension)
+        return false;
+
+    if (connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineExtension),
+            static_cast<qint32> (extension));
+    }
+    return m_fileEngine.extension(extension, eo, er);
+}
+
+/*!
+    \reimp
+*/
+QAbstractFileEngine::FileFlags RemoteFileEngine::fileFlags(FileFlags type) const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return static_cast<QAbstractFileEngine::FileFlags>
+            (callRemoteMethod<int>(QString::fromLatin1(Protocol::QAbstractFileEngineFileFlags),
+            static_cast<int>(type)));
+    }
+    return m_fileEngine.fileFlags(type);
+}
+
+/*!
+    \reimp
+*/
+QString RemoteFileEngine::fileName(FileName file) const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return callRemoteMethod<QString>(QString::fromLatin1(Protocol::QAbstractFileEngineFileName),
+            static_cast<int>(file));
+    }
+    return m_fileEngine.fileName(file);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::flush()
+{
+    if (connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineFlush));
+    return m_fileEngine.flush();
+}
+
+/*!
+    \reimp
+*/
+int RemoteFileEngine::handle() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<int>(QString::fromLatin1(Protocol::QAbstractFileEngineHandle));
+    return m_fileEngine.handle();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::isRelativePath() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineIsRelativePath));
+    return m_fileEngine.isRelativePath();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::isSequential() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineIsSequential));
+    return m_fileEngine.isSequential();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::link(const QString &newName)
+{
+    if (connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineLink),
+            newName);
+    }
+    return m_fileEngine.link(newName);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::mkdir(const QString &dirName, bool createParentDirectories) const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineMkdir),
+            dirName, createParentDirectories);
+    }
+    return m_fileEngine.mkdir(dirName, createParentDirectories);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::open(QIODevice::OpenMode mode)
+{
+    if (connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineOpen),
+            static_cast<int>(mode));
+    }
+    return m_fileEngine.open(mode);
+}
+
+/*!
+    \reimp
+*/
+QString RemoteFileEngine::owner(FileOwner owner) const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return callRemoteMethod<QString>(QString::fromLatin1(Protocol::QAbstractFileEngineOwner),
+            static_cast<int>(owner));
+    }
+    return m_fileEngine.owner(owner);
+}
+
+/*!
+    \reimp
+*/
+uint RemoteFileEngine::ownerId(FileOwner owner) const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return callRemoteMethod<uint>(QString::fromLatin1(Protocol::QAbstractFileEngineOwnerId),
+            static_cast<int>(owner));
+    }
+    return m_fileEngine.ownerId(owner);
+}
+
+/*!
+    \reimp
+*/
+qint64 RemoteFileEngine::pos() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<qint64>(QString::fromLatin1(Protocol::QAbstractFileEnginePos));
+    return m_fileEngine.pos();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::remove()
+{
+    if (connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineRemove));
+    return m_fileEngine.remove();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::rename(const QString &newName)
+{
+    if (connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineRename),
+            newName);
+    }
+    return m_fileEngine.rename(newName);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::rmdir(const QString &dirName, bool recurseParentDirectories) const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineRmdir),
+            dirName, recurseParentDirectories);
+    }
+    return m_fileEngine.rmdir(dirName, recurseParentDirectories);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::seek(qint64 offset)
+{
+    if (connectToServer())
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineSeek), offset);
+    return m_fileEngine.seek(offset);
+}
+
+/*!
+    \reimp
+*/
+void RemoteFileEngine::setFileName(const QString &fileName)
+{
+    if (connectToServer()) {
+        callRemoteMethod(QString::fromLatin1(Protocol::QAbstractFileEngineSetFileName), fileName,
+            dummy);
+    }
+    m_fileEngine.setFileName(fileName);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::setPermissions(uint perms)
+{
+    if (connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineSetPermissions),
+            perms);
+    }
+    return m_fileEngine.setPermissions(perms);
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::setSize(qint64 size)
+{
+    if (connectToServer()) {
+        return callRemoteMethod<bool>(QString::fromLatin1(Protocol::QAbstractFileEngineSetSize),
+            size);
+    }
+    return m_fileEngine.setSize(size);
+}
+
+/*!
+    \reimp
+*/
+qint64 RemoteFileEngine::size() const
+{
+    if ((const_cast<RemoteFileEngine *>(this))->connectToServer())
+        return callRemoteMethod<qint64>(QString::fromLatin1(Protocol::QAbstractFileEngineSize));
+    return m_fileEngine.size();
+}
+
+/*!
+    \reimp
+*/
+bool RemoteFileEngine::supportsExtension(Extension extension) const
+{
+    return false;
+    if (extension == UnMapExtension || extension == MapExtension)
+        return false;
+    return m_fileEngine.supportsExtension(extension);
+}
+
+/*!
+    \reimp
+*/
+qint64 RemoteFileEngine::read(char *data, qint64 maxlen)
+{
+    if (!connectToServer())
+        return m_fileEngine.read(data, maxlen);
+
+    QPair<qint64, QByteArray> result = callRemoteMethod<QPair<qint64, QByteArray> >
+        (QString::fromLatin1(Protocol::QAbstractFileEngineRead), maxlen);
+
+    if (result.first <= 0)
+        return result.first;
+
+    QDataStream dataStream(result.second);
+    dataStream.readRawData(data, result.first);
+    return result.first;
+}
+
+/*!
+    \reimp
+*/
+qint64 RemoteFileEngine::readLine(char *data, qint64 maxlen)
+{
+    if (!connectToServer())
+        return m_fileEngine.readLine(data, maxlen);
+
+    QPair<qint64, QByteArray> result = callRemoteMethod<QPair<qint64, QByteArray> >
+        (QString::fromLatin1(Protocol::QAbstractFileEngineReadLine), maxlen);
+
+    if (result.first <= 0)
+        return result.first;
+
+    QDataStream dataStream(result.second);
+    dataStream.readRawData(data, result.first);
+    return result.first;
+}
+
+/*!
+    \reimp
+*/
+qint64 RemoteFileEngine::write(const char *data, qint64 len)
+{
+    if (!connectToServer())
+        return m_fileEngine.write(data, len);
+
+    QByteArray ba(data, len);
+    return callRemoteMethod<qint64>(QString::fromLatin1(Protocol::QAbstractFileEngineWrite), ba);
+}
+
+} // namespace QInstaller