Merge pull request #9139 from nextcloud/bugfix/enforceEnterpriseUpdateChannel

Bugfix/enforce enterprise update channel

Author: Aiiaiiio

src/gui/accountmanager.cpp

@@ -78,6 +78,7 @@ constexpr auto maxAccountsVersion = 13;
 constexpr auto maxAccountVersion = 13;
 
 constexpr auto serverHasValidSubscriptionC = "serverHasValidSubscription";
+constexpr auto serverDesktopEnterpriseUpdateChannelC = "desktopEnterpriseChannel";
 
 constexpr auto generalC = "General";
 }
@@ -424,6 +425,7 @@ void AccountManager::saveAccountHelper(const AccountPtr &account, QSettings &set
     settings.setValue(QLatin1String(serverColorC), account->_serverColor);
     settings.setValue(QLatin1String(serverTextColorC), account->_serverTextColor);
     settings.setValue(QLatin1String(serverHasValidSubscriptionC), account->serverHasValidSubscription());
+    settings.setValue(QLatin1String(serverDesktopEnterpriseUpdateChannelC), account->enterpriseUpdateChannel().toString());
     settings.setValue(QLatin1String(encryptionCertificateSha256FingerprintC), account->encryptionCertificateFingerprint());
     if (!account->_skipE2eeMetadataChecksumValidation) {
         settings.remove(QLatin1String(skipE2eeMetadataChecksumValidationC));
@@ -757,10 +759,9 @@ void AccountManager::deleteAccount(OCC::AccountState *account)
 
     account->account()->deleteAppToken();
 
-    // clean up config from subscriptions if the account removed was the only with valid subscription
-    if (account->account()->serverHasValidSubscription()) {
-        updateServerHasValidSubscriptionConfig();
-    }
+    // clean up config from subscriptions and enterprise channel
+    updateServerHasValidSubscriptionConfig();
+    updateServerDesktopEnterpriseUpdateChannel();
 
     emit accountSyncConnectionRemoved(account);
     emit accountRemoved(account);
@@ -770,15 +771,28 @@ void AccountManager::updateServerHasValidSubscriptionConfig()
 {
     auto serverHasValidSubscription = false;
     for (const auto &account : std::as_const(_accounts)) {
-        if (!account->account()->serverHasValidSubscription()) {
-            continue;
+        if (account->account()->serverHasValidSubscription()) {
+            serverHasValidSubscription = true;
+            break;
         }
+    }
+
+    if (ConfigFile().serverHasValidSubscription() != serverHasValidSubscription) {
+        ConfigFile().setServerHasValidSubscription(serverHasValidSubscription);
+    }
+}
 
-        serverHasValidSubscription = true;
-        break;
+void AccountManager::updateServerDesktopEnterpriseUpdateChannel()
+{
+    UpdateChannel most_stable_channel = UpdateChannel::Invalid;
+    for (const auto &account : std::as_const(_accounts)) {
+        if (const auto accounts_channel = account->account()->enterpriseUpdateChannel();
+            account->account()->serverHasValidSubscription() && accounts_channel > most_stable_channel) {
+            most_stable_channel = accounts_channel;
+        }
     }
 
-    ConfigFile().setServerHasValidSubscription(serverHasValidSubscription);
+    ConfigFile().setDesktopEnterpriseChannel(most_stable_channel.toString());
 }
 
 AccountPtr AccountManager::createAccount()
@@ -842,10 +856,8 @@ void AccountManager::addAccountState(AccountState *const accountState)
     _accounts << ptr;
     ptr->trySignIn();
 
-    // update config subscriptions if the account added is the only with valid subscription
-    if (accountState->account()->serverHasValidSubscription() && !ConfigFile().serverHasValidSubscription()) {
-        updateServerHasValidSubscriptionConfig();
-    }
+    updateServerHasValidSubscriptionConfig();
+    updateServerDesktopEnterpriseUpdateChannel();
 
     emit accountAdded(accountState);
 }

src/gui/accountmanager.h

@@ -126,6 +126,7 @@ public slots:
 
     // update config serverHasValidSubscription when accounts list changes
     void updateServerHasValidSubscriptionConfig();
+    void updateServerDesktopEnterpriseUpdateChannel();
 
     AccountManager() = default;
     QList<AccountStatePtr> _accounts;

src/gui/application.cpp

@@ -9,24 +9,25 @@
 #include <iostream>
 #include <random>
 
-#include "config.h"
 #include "account.h"
+#include "accountmanager.h"
 #include "accountsetupcommandlinemanager.h"
 #include "accountstate.h"
-#include "editlocallymanager.h"
+#include "clientproxy.h"
+#include "config.h"
+#include "configfile.h"
 #include "connectionvalidator.h"
+#include "creds/abstractcredentials.h"
+#include "editlocallymanager.h"
 #include "folder.h"
 #include "folderman.h"
 #include "logger.h"
-#include "configfile.h"
+#include "pushnotifications.h"
+#include "shellextensionsserver.h"
 #include "socketapi/socketapi.h"
 #include "sslerrordialog.h"
 #include "theme.h"
-#include "clientproxy.h"
-#include "accountmanager.h"
-#include "creds/abstractcredentials.h"
-#include "pushnotifications.h"
-#include "shellextensionsserver.h"
+#include "updatechannel.h"
 
 #if defined(BUILD_UPDATER)
 #include "updater/ocupdater.h"
@@ -294,6 +295,10 @@ Application::Application(int &argc, char **argv)
         setupConfigFile();
     }
 
+    // In the config, set the enterprise update channel to invalid, so it can be bumped up
+    // when recieving server capabilities.
+    ConfigFile().setDesktopEnterpriseChannel(UpdateChannel::Invalid.toString());
+
     if (_theme->doNotUseProxy()) {
         ConfigFile().setProxyType(QNetworkProxy::NoProxy);
         const auto &allAccounts = AccountManager::instance()->accounts();

src/libsync/CMakeLists.txt

@@ -58,6 +58,8 @@ set(libsync_SRCS
     helpers.cpp
     httplogger.h
     httplogger.cpp
+    updatechannel.h
+    updatechannel.cpp
     logger.h
     logger.cpp
     accessmanager.h

src/libsync/account.cpp

@@ -16,6 +16,7 @@
 #include "networkjobs.h"
 #include "pushnotifications.h"
 #include "theme.h"
+#include "updatechannel.h"
 #include "version.h"
 
 #include "deletejob.h"
@@ -1272,6 +1273,16 @@ void Account::setServerHasValidSubscription(bool valid)
     _serverHasValidSubscription = valid;
 }
 
+UpdateChannel Account::enterpriseUpdateChannel() const
+{
+    return _enterpriseUpdateChannel;
+}
+
+void Account::setEnterpriseUpdateChannel(const UpdateChannel &channel)
+{
+    _enterpriseUpdateChannel = channel;
+}
+
 void Account::updateServerSubcription()
 {
     ConfigFile currentConfig;
@@ -1286,10 +1297,13 @@ void Account::updateServerSubcription()
 
 void Account::updateDesktopEnterpriseChannel()
 {
+    const auto capabilityEnterpriseChannel = UpdateChannel::fromString(_capabilities.desktopEnterpriseChannel());
+    _enterpriseUpdateChannel = capabilityEnterpriseChannel;
+
     ConfigFile currentConfig;
-    if (const auto desktopEnterpriseChannel = _capabilities.desktopEnterpriseChannel();
-        desktopEnterpriseChannel != currentConfig.desktopEnterpriseChannel()) {
-        currentConfig.setDesktopEnterpriseChannel(desktopEnterpriseChannel);
+    const auto configEnterpriseChannel = UpdateChannel::fromString(currentConfig.desktopEnterpriseChannel());
+    if (capabilityEnterpriseChannel > configEnterpriseChannel) {
+        currentConfig.setDesktopEnterpriseChannel(capabilityEnterpriseChannel.toString());
     }
 }
 

src/libsync/account.h

@@ -12,8 +12,9 @@
 #include "clientsideencryption.h"
 #include "clientstatusreporting.h"
 #include "common/utility.h"
-#include "syncfileitem.h"
 #include "common/vfs.h"
+#include "syncfileitem.h"
+#include "updatechannel.h"
 
 #include <QByteArray>
 #include <QUrl>
@@ -411,6 +412,9 @@ class OWNCLOUDSYNC_EXPORT Account : public QObject
     [[nodiscard]] bool serverHasValidSubscription() const;
     void setServerHasValidSubscription(bool valid);
 
+    [[nodiscard]] UpdateChannel enterpriseUpdateChannel() const;
+    void setEnterpriseUpdateChannel(const UpdateChannel &channel);
+
     [[nodiscard]] bool enforceUseHardwareTokenEncryption() const;
 
     [[nodiscard]] QString encryptionHardwareTokenDriverPath() const;
@@ -577,6 +581,7 @@ private slots:
     unsigned int _uploadLimit = 0;
     unsigned int _downloadLimit = 0;
     bool _serverHasValidSubscription = false;
+    UpdateChannel _enterpriseUpdateChannel = UpdateChannel::Invalid;
     QByteArray _encryptionCertificateFingerprint;
 
     /* IMPORTANT - remove later - FIXME MS@2019-12-07 -->

src/libsync/configfile.cpp

@@ -4,19 +4,16 @@
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
-#include "config.h"
-
 #include "configfile.h"
-#include "theme.h"
-#include "version.h"
-#include "common/utility.h"
-#include "common/asserts.h"
-#include "version.h"
 
-#include "creds/abstractcredentials.h"
+#include "common/asserts.h"
+#include "common/utility.h"
+#include "config.h"
 #include "creds/keychainchunk.h"
-
 #include "csync_exclude.h"
+#include "theme.h"
+#include "updatechannel.h"
+#include "version.h"
 
 #ifndef TOKEN_AUTH_ONLY
 #include <QWidget>
@@ -77,11 +74,6 @@ static constexpr char certPasswd[] = "http_certificatePasswd";
 static constexpr char serverHasValidSubscriptionC[] = "serverHasValidSubscription";
 static constexpr char desktopEnterpriseChannelName[] = "desktopEnterpriseChannel";
 
-static const QStringList defaultUpdateChannelsList { QStringLiteral("stable"), QStringLiteral("beta"), QStringLiteral("daily") };
-static const QString defaultUpdateChannelName = "stable";
-static const QStringList enterpriseUpdateChannelsList { QStringLiteral("stable"), QStringLiteral("enterprise") };
-static const QString defaultEnterpriseChannel = "enterprise";
-
 static constexpr char languageC[] = "language";
 
 static constexpr char lastSelectedAccountC[] = "lastSelectedAccount";
@@ -686,14 +678,20 @@ QStringList ConfigFile::validUpdateChannels() const
     const auto isBranded = Theme::instance()->isBranded();
 
     if (isBranded) {
-        return { defaultUpdateChannelName };
+        return {UpdateChannel::defaultUpdateChannel().toString()};
     }
 
+    const QList<UpdateChannel> *channel_list = &UpdateChannel::defaultUpdateChannelList();
     if (serverHasValidSubscription()) {
-        return enterpriseUpdateChannelsList;
+        channel_list = &UpdateChannel::enterpriseUpdateChannelsList();
+    }
+
+    QStringList list;
+    for (const auto &channel : *channel_list) {
+        list.append(channel.toString());
     }
 
-    return defaultUpdateChannelsList;
+    return list;
 }
 
 QString ConfigFile::defaultUpdateChannel() const
@@ -713,14 +711,24 @@ QString ConfigFile::defaultUpdateChannel() const
         return currentVersionSuffix;
     }
 
-    qCWarning(lcConfigFile()) << "Default update channel is" << defaultUpdateChannelName;
-    return defaultUpdateChannelName;
+    qCWarning(lcConfigFile()) << "Default update channel is" << UpdateChannel::defaultUpdateChannel().toString();
+    return UpdateChannel::defaultUpdateChannel().toString();
 }
 
 QString ConfigFile::currentUpdateChannel() const
 {
+    if (const auto isBranded = Theme::instance()->isBranded(); isBranded) {
+        return UpdateChannel::defaultUpdateChannel().toString();
+    }
+
     QSettings settings(configFile(), QSettings::IniFormat);
-    return settings.value(QLatin1String(updateChannelC), defaultUpdateChannel()).toString();
+    const auto currentChannel = UpdateChannel::fromString(settings.value(QLatin1String(updateChannelC), defaultUpdateChannel()).toString());
+    if (serverHasValidSubscription()) {
+        const auto enterpriseChannel = UpdateChannel::fromString(desktopEnterpriseChannel());
+        return UpdateChannel::mostStable(currentChannel, enterpriseChannel).toString();
+    }
+
+    return currentChannel.toString();
 }
 
 void ConfigFile::setUpdateChannel(const QString &channel)
@@ -1209,13 +1217,13 @@ void ConfigFile::setServerHasValidSubscription(const bool valid)
 QString ConfigFile::desktopEnterpriseChannel() const
 {
     QSettings settings(configFile(), QSettings::IniFormat);
-    return settings.value(QLatin1String(desktopEnterpriseChannelName), defaultUpdateChannelName).toString();
+    return settings.value(QLatin1String(desktopEnterpriseChannelName), UpdateChannel::defaultUpdateChannel().toString()).toString();
 }
 
 void ConfigFile::setDesktopEnterpriseChannel(const QString &channel)
 {
     QSettings settings(configFile(), QSettings::IniFormat);
-    settings.setValue(QLatin1String(desktopEnterpriseChannelName), channel);
+    settings.setValue(QLatin1String(desktopEnterpriseChannelName), UpdateChannel::fromString(channel).toString());
 }
 
 QString ConfigFile::language() const

src/libsync/updatechannel.cpp

@@ -0,0 +1,83 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "updatechannel.h"
+
+#include <QMap>
+
+UpdateChannel::ChannelName UpdateChannel::channelName() const
+{
+    return _channelName;
+}
+
+bool UpdateChannel::isValid() const
+{
+    return _channelName != ChannelName::invalid;
+}
+
+QString UpdateChannel::toString() const
+{
+    using enum ChannelName;
+    static const QMap<ChannelName, QString> enumToNameLut = {{invalid, "invalid"},
+                                                             {daily, "daily"},
+                                                             {beta, "beta"},
+                                                             {stable, "stable"},
+                                                             {enterprise, "enterprise"}};
+    return enumToNameLut.value(_channelName);
+}
+
+std::strong_ordering UpdateChannel::operator<=>(const UpdateChannel &rhs) const = default;
+
+UpdateChannel UpdateChannel::mostStable(const UpdateChannel &channelA, const UpdateChannel &channelB)
+{
+    return std::max(channelA, channelB);
+}
+
+const QList<UpdateChannel> &UpdateChannel::defaultUpdateChannelList()
+{
+    static const QList<UpdateChannel> list{UpdateChannel::Stable, UpdateChannel::Beta, UpdateChannel::Daily};
+    return list;
+}
+
+const UpdateChannel &UpdateChannel::defaultUpdateChannel()
+{
+    static const auto channel = UpdateChannel::Stable;
+    return channel;
+}
+
+const QList<UpdateChannel> &UpdateChannel::enterpriseUpdateChannelsList()
+{
+    static const QList<UpdateChannel> list{UpdateChannel::Stable, UpdateChannel::Enterprise};
+    return list;
+}
+
+const UpdateChannel &UpdateChannel::defaultEnterpriseChannel()
+{
+    static const auto channel = UpdateChannel::Enterprise;
+    return channel;
+}
+
+const UpdateChannel UpdateChannel::Invalid = UpdateChannel::fromString("invalid");
+const UpdateChannel UpdateChannel::Daily = UpdateChannel::fromString("daily");
+const UpdateChannel UpdateChannel::Beta = UpdateChannel::fromString("beta");
+const UpdateChannel UpdateChannel::Stable = UpdateChannel::fromString("stable");
+const UpdateChannel UpdateChannel::Enterprise = UpdateChannel::fromString("enterprise");
+
+UpdateChannel UpdateChannel::fromString(const QString &channelName) // static
+{
+    using enum ChannelName;
+    static const QMap<QString, ChannelName> nameToEnumLut = {{"invalid", invalid},
+                                                             {"daily", daily},
+                                                             {"beta", beta},
+                                                             {"stable", stable},
+                                                             {"enterprise", enterprise}};
+    auto channelEnum = nameToEnumLut.contains(channelName) ? nameToEnumLut.value(channelName) : invalid;
+    return UpdateChannel(channelEnum);
+}
+
+UpdateChannel::UpdateChannel(const ChannelName &channelName)
+    : _channelName(channelName)
+{
+}