diff --git a/autotests/settings/CMakeLists.txt b/autotests/settings/CMakeLists.txt --- a/autotests/settings/CMakeLists.txt +++ b/autotests/settings/CMakeLists.txt @@ -13,6 +13,7 @@ bridgeportsettingtest cdmasettingtest connectionsettingtest + dcbsettingtest gsmsettingtest infinibandsettingtest iptunnelsettingtest diff --git a/autotests/settings/dcbsettingtest.h b/autotests/settings/dcbsettingtest.h new file mode 100644 --- /dev/null +++ b/autotests/settings/dcbsettingtest.h @@ -0,0 +1,36 @@ +/* + Copyright 2018 Pranav Gade + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) version 3, or any + later version accepted by the membership of KDE e.V. (or its + successor approved by the membership of KDE e.V.), which shall + act as a proxy defined in Section 6 of version 3 of the license. + + This library 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. + + You should have received a copy of the GNU Lesser General Public + License along with this library. If not, see . +*/ + +#ifndef NETWORKMANAGERQT_DCBSETTING_TEST_H +#define NETWORKMANAGERQT_DCBSETTING_TEST_H + +#include + +class DcbSettingTest : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + void testSetting_data(); + void testSetting(); +}; + +#endif // NETWORKMANAGERQT_DCBSETTING_TEST_H + diff --git a/autotests/settings/dcbsettingtest.cpp b/autotests/settings/dcbsettingtest.cpp new file mode 100644 --- /dev/null +++ b/autotests/settings/dcbsettingtest.cpp @@ -0,0 +1,144 @@ +/* + Copyright 2018 Pranav Gade + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) version 3, or any + later version accepted by the membership of KDE e.V. (or its + successor approved by the membership of KDE e.V.), which shall + act as a proxy defined in Section 6 of version 3 of the license. + + This library 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. + + You should have received a copy of the GNU Lesser General Public + License along with this library. If not, see . +*/ + +#include "dcbsettingtest.h" + +#include "settings/dcbsetting.h" + +#include + +#include + +void DcbSettingTest::testSetting_data() +{ + QTest::addColumn("appFcoeMode"); + QTest::addColumn("appFcoePriority"); + QTest::addColumn("appFipPriority"); + QTest::addColumn("appIscsiPriority"); + QTest::addColumn("appFcoeFlags"); + QTest::addColumn("appFipFlags"); + QTest::addColumn("appIscsiFlags"); + QTest::addColumn("priorityGroupFlags"); + QTest::addColumn("priorityFlowControlFlags"); + QTest::addColumn("priorityFlowControl"); + QTest::addColumn("priorityBandwidth"); + QTest::addColumn("priorityGroupBandwidth"); + QTest::addColumn("priorityGroupId"); + QTest::addColumn("priorityStrictBandwidth"); + QTest::addColumn("priorityTrafficClass"); + + UIntList priorityFlowControl = {1, 1, 1, 1, 1, 1, 1, 1}; + UIntList priorityBandwidth = {6, 5, 6, 4, 6, 3, 6, 2}; + UIntList priorityGroupBandwidth = {6, 5, 6, 4, 6, 3, 6, 2}; + UIntList priorityGroupId = {6, 5, 6, 4, 6, 3, 6, 2}; + UIntList priorityStrictBandwidth = {1, 1, 1, 1, 1, 1, 1, 1}; + UIntList priorityTrafficClass = {6, 5, 6, 4, 6, 3, 6, 2}; + + QTest::newRow("setting1") + << QString("vn2vn") // appFcoeMode + << (qint32)2 // appFcoePriority + << (qint32)2 // appFipPriority + << (qint32)2 // appIscsiPriority + << (qint32)2 // appFcoeFlags + << (qint32)2 // appFipFlags + << (qint32)2 // appIscsiFlags + << (qint32)2 // priorityGroupFlags + << (qint32)2 // priorityFlowControlFlags + << priorityFlowControl // priorityFlowControl + << priorityBandwidth // priorityBandwidth + << priorityGroupBandwidth // priorityGroupBandwidth + << priorityGroupId // priorityGroupId + << priorityStrictBandwidth // priorityStrictBandwidth + << priorityTrafficClass; // priorityTrafficClass +} + +void DcbSettingTest::testSetting() +{ + QFETCH(QString, appFcoeMode); + QFETCH(qint32, appFcoePriority); + QFETCH(qint32, appFipPriority); + QFETCH(qint32, appIscsiPriority); + QFETCH(qint32, appFcoeFlags); + QFETCH(qint32, appFipFlags); + QFETCH(qint32, appIscsiFlags); + QFETCH(qint32, priorityGroupFlags); + QFETCH(qint32, priorityFlowControlFlags); + + QFETCH(UIntList, priorityFlowControl); + QFETCH(UIntList, priorityBandwidth); + QFETCH(UIntList, priorityGroupBandwidth); + QFETCH(UIntList, priorityGroupId); + QFETCH(UIntList, priorityStrictBandwidth); + QFETCH(UIntList, priorityTrafficClass); + + QVariantMap map; + + map.insert(QLatin1String(NM_SETTING_DCB_APP_FCOE_MODE), appFcoeMode); + map.insert(QLatin1String(NM_SETTING_DCB_APP_FCOE_PRIORITY), appFcoePriority); + map.insert(QLatin1String(NM_SETTING_DCB_APP_FIP_PRIORITY), appFipPriority); + map.insert(QLatin1String(NM_SETTING_DCB_APP_ISCSI_PRIORITY), appIscsiPriority); + map.insert(QLatin1String(NM_SETTING_DCB_APP_FCOE_FLAGS), appFcoeFlags); + map.insert(QLatin1String(NM_SETTING_DCB_APP_FIP_FLAGS), appFipFlags); + map.insert(QLatin1String(NM_SETTING_DCB_APP_ISCSI_FLAGS), appIscsiFlags); + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_FLAGS), priorityGroupFlags); + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS), priorityFlowControlFlags); + + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL), QVariant::fromValue(priorityFlowControl)); + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_BANDWIDTH), QVariant::fromValue(priorityBandwidth)); + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH), QVariant::fromValue(priorityGroupBandwidth)); + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_ID), QVariant::fromValue(priorityGroupId)); + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH), QVariant::fromValue(priorityStrictBandwidth)); + map.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS), QVariant::fromValue(priorityTrafficClass)); + + NetworkManager::DcbSetting setting; + setting.fromMap(map); + + QVariantMap map1 = setting.toMap(); + + // Will fail if set some default values, because they are skipped in toMap() method + QVariantMap::const_iterator it = map.constBegin(); + while (it != map.constEnd()) { + if (it.key() != QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL) && + it.key() != QLatin1String(NM_SETTING_DCB_PRIORITY_BANDWIDTH) && + it.key() != QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH) && + it.key() != QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_ID) && + it.key() != QLatin1String(NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH) && + it.key() != QLatin1String(NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS)) + { + QCOMPARE(it.value(), map1.value(it.key())); + } + ++it; + } + + QCOMPARE(map.value(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL)).value(), + map1.value(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL)).value()); + QCOMPARE(map.value(QLatin1String(NM_SETTING_DCB_PRIORITY_BANDWIDTH)).value(), + map1.value(QLatin1String(NM_SETTING_DCB_PRIORITY_BANDWIDTH)).value()); + QCOMPARE(map.value(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH)).value(), + map1.value(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH)).value()); + QCOMPARE(map.value(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_ID)).value(), + map1.value(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_ID)).value()); + QCOMPARE(map.value(QLatin1String(NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH)).value(), + map1.value(QLatin1String(NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH)).value()); + QCOMPARE(map.value(QLatin1String(NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS)).value(), + map1.value(QLatin1String(NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS)).value()); +} + +QTEST_MAIN(DcbSettingTest) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -58,6 +58,7 @@ settings/bridgeportsetting.cpp settings/cdmasetting.cpp settings/connectionsettings.cpp + settings/dcbsetting.cpp settings/gsmsetting.cpp settings/iptunnelsetting.cpp settings/ipv4setting.cpp diff --git a/src/settings/dcbsetting.h b/src/settings/dcbsetting.h new file mode 100644 --- /dev/null +++ b/src/settings/dcbsetting.h @@ -0,0 +1,130 @@ +/* + Copyright 2018 Pranav Gade + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) version 3, or any + later version accepted by the membership of KDE e.V. (or its + successor approved by the membership of KDE e.V.), which shall + act as a proxy defined in Section 6 of version 3 of the license. + + This library 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. + + You should have received a copy of the GNU Lesser General Public + License along with this library. If not, see . +*/ + +#ifndef NETWORKMANAGERQT_DCBSETTING_H +#define NETWORKMANAGERQT_DCBSETTING_H + +#include +#include "setting.h" + +#include + +namespace NetworkManager +{ + +class DcbSettingPrivate; + +/** + * Represents Dcb setting + */ +class NETWORKMANAGERQT_EXPORT DcbSetting : public Setting +{ +public: + typedef QSharedPointer Ptr; + typedef QList List; + + enum DcbFlagType { + None = 0, + Enable = 0x01, + Advertise = 0x02, + Willing = 0x04 + }; + Q_DECLARE_FLAGS(DcbFlags, DcbFlagType) + + DcbSetting(); + explicit DcbSetting(const Ptr &other); + ~DcbSetting() override; + + QString name() const override; + + void setAppFcoeMode(const QString &mode); + QString appFcoeMode() const; + + void setAppFcoePriority(qint32 priority); + qint32 appFcoePriority() const; + + void setAppFipPriority(qint32 priority); + qint32 appFipPriority() const; + + void setAppIscsiPriority(qint32 priority); + qint32 appIscsiPriority() const; + + void setAppFcoeFlags(DcbFlags flags); + DcbFlags appFcoeFlags() const; + + void setAppFipFlags(DcbFlags flags); + DcbFlags appFipFlags() const; + + void setAppIscsiFlags(DcbFlags flags); + DcbFlags appIscsiFlags() const; + + void setPriorityGroupFlags(DcbFlags flags); + DcbFlags priorityGroupFlags() const; + + void setPriorityFlowControlFlags(DcbFlags flags); + DcbFlags priorityFlowControlFlags() const; + + void setPriorityFlowControl(quint32 userPriority, bool enabled); + bool priorityFlowControl(quint32 userPriority) const; + void setPriorityFlowControl(const UIntList &list); + UIntList priorityFlowControl() const; + + void setPriorityBandwidth(quint32 userPriority, quint32 bandwidthPercent); + quint32 priorityBandwidth(quint32 userPriority) const; + void setPriorityBandwidth(const UIntList &list); + UIntList priorityBandwidth() const; + + void setPriorityGroupBandwidth(quint32 groupId, quint32 bandwidthPercent); + quint32 priorityGroupBandwidth(quint32 groupId) const; + void setPriorityGroupBandwidth(const UIntList &list); + UIntList priorityGroupBandwidth() const; + + void setPriorityGroupId(quint32 userPriority, quint32 groupId); + quint32 priorityGroupId(quint32 userPriority) const; + void setPriorityGroupId(const UIntList &list); + UIntList priorityGroupId() const; + + void setPriorityStrictBandwidth(quint32 userPriority, bool strict); + bool priorityStrictBandwidth(quint32 userPriority) const; + void setPriorityStrictBandwidth(const UIntList &list); + UIntList priorityStrictBandwidth() const; + + void setPriorityTrafficClass(quint32 userPriority, quint32 trafficClass); + quint32 priorityTrafficClass(quint32 userPriority) const; + void setPriorityTrafficClass(const UIntList &list); + UIntList priorityTrafficClass() const; + + void fromMap(const QVariantMap &setting) override; + + QVariantMap toMap() const override; + +protected: + DcbSettingPrivate *d_ptr; + +private: + Q_DECLARE_PRIVATE(DcbSetting) +}; +Q_DECLARE_OPERATORS_FOR_FLAGS(DcbSetting::DcbFlags) + +NETWORKMANAGERQT_EXPORT QDebug operator<<(QDebug dbg, const DcbSetting &setting); + +} + +#endif // NETWORKMANAGERQT_DCBSETTING_H diff --git a/src/settings/dcbsetting.cpp b/src/settings/dcbsetting.cpp new file mode 100644 --- /dev/null +++ b/src/settings/dcbsetting.cpp @@ -0,0 +1,553 @@ +/* + Copyright Pranav Gade + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) version 3, or any + later version accepted by the membership of KDE e.V. (or its + successor approved by the membership of KDE e.V.), which shall + act as a proxy defined in Section 6 of version 3 of the license. + + This library 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. + + You should have received a copy of the GNU Lesser General Public + License along with this library. If not, see . +*/ + +#include "dcbsetting.h" +#include "dcbsetting_p.h" + +#include + +NetworkManager::DcbSettingPrivate::DcbSettingPrivate() + : name(NM_SETTING_DCB_SETTING_NAME) + , appFcoeMode(NM_SETTING_DCB_FCOE_MODE_FABRIC) + , appFcoePriority(-1) + , appFipPriority(-1) + , appIscsiPriority(-1) + , priorityFlowControl({0, 0, 0, 0, 0, 0, 0, 0}) + , priorityBandwidth({0, 0, 0, 0, 0, 0, 0, 0}) + , priorityGroupBandwidth({0, 0, 0, 0, 0, 0, 0, 0}) + , priorityGroupId({0, 0, 0, 0, 0, 0, 0, 0}) + , priorityStrictBandwidth({0, 0, 0, 0, 0, 0, 0, 0}) + , priorityTrafficClass({0, 0, 0, 0, 0, 0, 0, 0}) +{ } + +NetworkManager::DcbSetting::DcbSetting() + : Setting(Setting::Dcb) + , d_ptr(new DcbSettingPrivate()) +{ } + +NetworkManager::DcbSetting::DcbSetting(const Ptr &other) + : Setting(other) + , d_ptr(new DcbSettingPrivate()) +{ + setAppFcoeMode(other->appFcoeMode()); + setAppFcoePriority(other->appFcoePriority()); + setAppFipPriority(other->appFipPriority()); + setAppIscsiPriority(other->appIscsiPriority()); + setAppFcoeFlags(other->appFcoeFlags()); + setAppFipFlags(other->appFipFlags()); + setAppIscsiFlags(other->appIscsiFlags()); + setPriorityGroupFlags(other->priorityGroupFlags()); + setPriorityFlowControlFlags(other->priorityFlowControlFlags()); + setPriorityFlowControl(other->priorityFlowControl()); + setPriorityBandwidth(other->priorityBandwidth()); + setPriorityGroupBandwidth(other->priorityGroupBandwidth()); + setPriorityGroupId(other->priorityGroupId()); + setPriorityStrictBandwidth(other->priorityStrictBandwidth()); + setPriorityTrafficClass(other->priorityTrafficClass()); +} + +NetworkManager::DcbSetting::~DcbSetting() +{ + delete d_ptr; +} + +QString NetworkManager::DcbSetting::name() const +{ + Q_D(const DcbSetting); + + return d->name; +} + +void NetworkManager::DcbSetting::setAppFcoeMode(const QString &mode) +{ + Q_D(DcbSetting); + + d->appFcoeMode = mode; +} + +QString NetworkManager::DcbSetting::appFcoeMode() const +{ + Q_D(const DcbSetting); + + return d->appFcoeMode; +} + +void NetworkManager::DcbSetting::setAppFcoePriority(qint32 priority) +{ + Q_D(DcbSetting); + + d->appFcoePriority = priority; +} + +qint32 NetworkManager::DcbSetting::appFcoePriority() const +{ + Q_D(const DcbSetting); + + return d->appFcoePriority; +} + +void NetworkManager::DcbSetting::setAppFipPriority(qint32 priority) +{ + Q_D(DcbSetting); + + d->appFipPriority = priority; +} + +qint32 NetworkManager::DcbSetting::appFipPriority() const +{ + Q_D(const DcbSetting); + + return d->appFipPriority; +} + +void NetworkManager::DcbSetting::setAppIscsiPriority(qint32 priority) +{ + Q_D(DcbSetting); + + d->appIscsiPriority = priority; +} + +qint32 NetworkManager::DcbSetting::appIscsiPriority() const +{ + Q_D(const DcbSetting); + + return d->appIscsiPriority; +} + +void NetworkManager::DcbSetting::setAppFcoeFlags(NetworkManager::DcbSetting::DcbFlags flags) +{ + Q_D(DcbSetting); + + d->appFcoeFlags = flags; +} + +NetworkManager::DcbSetting::DcbFlags NetworkManager::DcbSetting::appFcoeFlags() const +{ + Q_D(const DcbSetting); + + return d->appFcoeFlags; +} + +void NetworkManager::DcbSetting::setAppFipFlags(NetworkManager::DcbSetting::DcbFlags flags) +{ + Q_D(DcbSetting); + + d->appFipFlags = flags; +} + +NetworkManager::DcbSetting::DcbFlags NetworkManager::DcbSetting::appFipFlags() const +{ + Q_D(const DcbSetting); + + return d->appFipFlags; +} + +void NetworkManager::DcbSetting::setAppIscsiFlags(NetworkManager::DcbSetting::DcbFlags flags) +{ + Q_D(DcbSetting); + + d->appIscsiFlags = flags; +} + +NetworkManager::DcbSetting::DcbFlags NetworkManager::DcbSetting::appIscsiFlags() const +{ + Q_D(const DcbSetting); + + return d->appIscsiFlags; +} + +void NetworkManager::DcbSetting::setPriorityGroupFlags(NetworkManager::DcbSetting::DcbFlags flags) +{ + Q_D(DcbSetting); + + d->priorityGroupFlags = flags; +} + +NetworkManager::DcbSetting::DcbFlags NetworkManager::DcbSetting::priorityGroupFlags() const +{ + Q_D(const DcbSetting); + + return d->priorityGroupFlags; +} + +void NetworkManager::DcbSetting::setPriorityFlowControlFlags(NetworkManager::DcbSetting::DcbFlags flags) +{ + Q_D(DcbSetting); + + d->priorityFlowControlFlags = flags; +} + +NetworkManager::DcbSetting::DcbFlags NetworkManager::DcbSetting::priorityFlowControlFlags() const +{ + Q_D(const DcbSetting); + + return d->priorityFlowControlFlags; +} + +void NetworkManager::DcbSetting::setPriorityFlowControl(quint32 userPriority, bool enabled) +{ + Q_D(DcbSetting); + + if (userPriority < 8) { + d->priorityFlowControl[userPriority] = enabled; + } +} + +bool NetworkManager::DcbSetting::priorityFlowControl(quint32 userPriority) const +{ + Q_D(const DcbSetting); + + if (userPriority < 8) { + return d->priorityFlowControl.value(userPriority); + } + return false; +} + +void NetworkManager::DcbSetting::setPriorityFlowControl(const UIntList &list) +{ + Q_D(DcbSetting); + + d->priorityFlowControl = list; +} + +UIntList NetworkManager::DcbSetting::priorityFlowControl() const +{ + Q_D(const DcbSetting); + + return d->priorityFlowControl; +} + +void NetworkManager::DcbSetting::setPriorityBandwidth(quint32 userPriority, quint32 bandwidthPercent) +{ + Q_D(DcbSetting); + + if (userPriority < 8) { + d->priorityBandwidth[userPriority] = bandwidthPercent; + } +} + +quint32 NetworkManager::DcbSetting::priorityBandwidth(quint32 userPriority) const +{ + Q_D(const DcbSetting); + + if (userPriority < 8) { + return d->priorityBandwidth.value(userPriority); + } + return 0; +} + +void NetworkManager::DcbSetting::setPriorityBandwidth(const UIntList &list) +{ + Q_D(DcbSetting); + + d->priorityBandwidth = list; +} + +UIntList NetworkManager::DcbSetting::priorityBandwidth() const +{ + Q_D(const DcbSetting); + + return d->priorityBandwidth; +} + +void NetworkManager::DcbSetting::setPriorityGroupBandwidth(quint32 groupId, quint32 bandwidthPercent) +{ + Q_D(DcbSetting); + + if (groupId < 8) { + d->priorityGroupBandwidth[groupId] = bandwidthPercent; + } +} + +quint32 NetworkManager::DcbSetting::priorityGroupBandwidth(quint32 groupId) const +{ + Q_D(const DcbSetting); + + if (groupId < 8) { + return d->priorityGroupBandwidth.value(groupId); + } + return 0; +} + +void NetworkManager::DcbSetting::setPriorityGroupBandwidth(const UIntList &list) +{ + Q_D(DcbSetting); + + d->priorityGroupBandwidth = list; +} + +UIntList NetworkManager::DcbSetting::priorityGroupBandwidth() const +{ + Q_D(const DcbSetting); + + return d->priorityGroupBandwidth; +} + +void NetworkManager::DcbSetting::setPriorityGroupId(quint32 userPriority, quint32 groupId) +{ + Q_D(DcbSetting); + + if (userPriority < 8) { + d->priorityGroupId[userPriority] = groupId; + } +} + +quint32 NetworkManager::DcbSetting::priorityGroupId(quint32 userPriority) const +{ + Q_D(const DcbSetting); + + if (userPriority < 8) { + return d->priorityGroupId.value(userPriority); + } + return 0; +} + +void NetworkManager::DcbSetting::setPriorityGroupId(const UIntList &list) +{ + Q_D(DcbSetting); + + d->priorityGroupId = list; +} + +UIntList NetworkManager::DcbSetting::priorityGroupId() const +{ + Q_D(const DcbSetting); + + return d->priorityGroupId; +} + +void NetworkManager::DcbSetting::setPriorityStrictBandwidth(quint32 userPriority, bool strict) +{ + Q_D(DcbSetting); + + if (userPriority < 8) { + d->priorityStrictBandwidth[userPriority] = strict; + } +} + +bool NetworkManager::DcbSetting::priorityStrictBandwidth(quint32 userPriority) const +{ + Q_D(const DcbSetting); + + if (userPriority < 8) { + return d->priorityStrictBandwidth.value(userPriority); + } + return false; +} + +void NetworkManager::DcbSetting::setPriorityStrictBandwidth(const UIntList &list) +{ + Q_D(DcbSetting); + + d->priorityStrictBandwidth = list; +} + +UIntList NetworkManager::DcbSetting::priorityStrictBandwidth() const +{ + Q_D(const DcbSetting); + + return d->priorityStrictBandwidth; +} + +void NetworkManager::DcbSetting::setPriorityTrafficClass(quint32 userPriority, quint32 trafficClass) +{ + Q_D(DcbSetting); + + if (userPriority < 8) { + d->priorityTrafficClass[userPriority] = trafficClass; + } +} + +quint32 NetworkManager::DcbSetting::priorityTrafficClass(quint32 userPriority) const +{ + Q_D(const DcbSetting); + + if (userPriority < 8) { + return d->priorityTrafficClass.value(userPriority); + } + return 0; +} + +void NetworkManager::DcbSetting::setPriorityTrafficClass(const UIntList &list) +{ + Q_D(DcbSetting); + + d->priorityTrafficClass = list; +} + +UIntList NetworkManager::DcbSetting::priorityTrafficClass() const +{ + Q_D(const DcbSetting); + + return d->priorityTrafficClass; +} + +void NetworkManager::DcbSetting::fromMap(const QVariantMap &setting) +{ + if (setting.contains(QLatin1String(NM_SETTING_DCB_APP_FCOE_MODE))) { + setAppFcoeMode(setting.value(QLatin1String(NM_SETTING_DCB_APP_FCOE_MODE)).toString()); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_APP_FCOE_PRIORITY))) { + setAppFcoePriority(setting.value(QLatin1String(NM_SETTING_DCB_APP_FCOE_PRIORITY)).toInt()); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_APP_FIP_PRIORITY))) { + setAppFipPriority(setting.value(QLatin1String(NM_SETTING_DCB_APP_FIP_PRIORITY)).toInt()); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_APP_ISCSI_PRIORITY))) { + setAppIscsiPriority(setting.value(QLatin1String(NM_SETTING_DCB_APP_ISCSI_PRIORITY)).toInt()); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_APP_FCOE_FLAGS))) { + setAppFcoeFlags(static_cast(setting.value(QLatin1String(NM_SETTING_DCB_APP_FCOE_FLAGS)).toUInt())); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_APP_FIP_FLAGS))) { + setAppFipFlags(static_cast(setting.value(QLatin1String(NM_SETTING_DCB_APP_FIP_FLAGS)).toUInt())); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_APP_ISCSI_FLAGS))) { + setAppIscsiFlags(static_cast(setting.value(QLatin1String(NM_SETTING_DCB_APP_ISCSI_FLAGS)).toUInt())); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_FLAGS))) { + setPriorityGroupFlags(static_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_FLAGS)).toUInt())); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS))) { + setPriorityFlowControlFlags(static_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS)).toUInt())); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL))) { + setPriorityFlowControl(qdbus_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL)))); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_BANDWIDTH))) { + setPriorityBandwidth(qdbus_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_BANDWIDTH)))); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH))) { + setPriorityGroupBandwidth(qdbus_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH)))); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_ID))) { + setPriorityGroupId(qdbus_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_ID)))); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH))) { + setPriorityStrictBandwidth(qdbus_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH)))); + } + + if (setting.contains(QLatin1String(NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS))) { + setPriorityTrafficClass(qdbus_cast(setting.value(QLatin1String(NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS)))); + } +} + +QVariantMap NetworkManager::DcbSetting::toMap() const +{ + QVariantMap setting; + + if (!appFcoeMode().isEmpty()) { + setting.insert(QLatin1String(NM_SETTING_DCB_APP_FCOE_MODE), appFcoeMode()); + } + + if (appFcoePriority() >= 0) { + setting.insert(QLatin1String(NM_SETTING_DCB_APP_FCOE_PRIORITY), appFcoePriority()); + } + + if (appFipPriority() >= 0) { + setting.insert(QLatin1String(NM_SETTING_DCB_APP_FIP_PRIORITY), appFipPriority()); + } + + if (appIscsiPriority() >= 0) { + setting.insert(QLatin1String(NM_SETTING_DCB_APP_ISCSI_PRIORITY), appIscsiPriority()); + } + + setting.insert(QLatin1String(NM_SETTING_DCB_APP_FCOE_FLAGS), (int)appFcoeFlags()); + setting.insert(QLatin1String(NM_SETTING_DCB_APP_FIP_FLAGS), (int)appFipFlags()); + setting.insert(QLatin1String(NM_SETTING_DCB_APP_ISCSI_FLAGS), (int)appIscsiFlags()); + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_FLAGS), (int)priorityGroupFlags()); + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS), (int)priorityFlowControlFlags()); + + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_FLOW_CONTROL), QVariant::fromValue(priorityFlowControl())); + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_BANDWIDTH), QVariant::fromValue(priorityBandwidth())); + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH), QVariant::fromValue(priorityGroupBandwidth())); + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_GROUP_ID), QVariant::fromValue(priorityGroupId())); + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH), QVariant::fromValue(priorityStrictBandwidth())); + setting.insert(QLatin1String(NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS), QVariant::fromValue(priorityTrafficClass())); + + return setting; +} + +QDebug NetworkManager::operator <<(QDebug dbg, const NetworkManager::DcbSetting &setting) +{ + dbg.nospace() << "type: " << setting.typeAsString(setting.type()) << '\n'; + dbg.nospace() << "initialized: " << !setting.isNull() << '\n'; + + dbg.nospace() << NM_SETTING_DCB_APP_FCOE_MODE << ": " << setting.appFcoeMode() << '\n'; + dbg.nospace() << NM_SETTING_DCB_APP_FCOE_PRIORITY << ": " << setting.appFcoePriority() << '\n'; + dbg.nospace() << NM_SETTING_DCB_APP_FIP_PRIORITY << ": " << setting.appFipPriority() << '\n'; + dbg.nospace() << NM_SETTING_DCB_APP_ISCSI_PRIORITY << ": " << setting.appIscsiPriority() << '\n'; + dbg.nospace() << NM_SETTING_DCB_APP_FCOE_FLAGS << ": " << setting.appFcoeFlags() << '\n'; + dbg.nospace() << NM_SETTING_DCB_APP_FIP_FLAGS << ": " << setting.appFipFlags() << '\n'; + dbg.nospace() << NM_SETTING_DCB_APP_ISCSI_FLAGS << ": " << setting.appIscsiFlags() << '\n'; + dbg.nospace() << NM_SETTING_DCB_PRIORITY_GROUP_FLAGS << ": " << setting.priorityGroupFlags() << '\n'; + dbg.nospace() << NM_SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS << ": " << setting.priorityFlowControlFlags() << '\n'; + + dbg.nospace() << NM_SETTING_DCB_PRIORITY_FLOW_CONTROL << ": "; + Q_FOREACH (const quint32 enabled, setting.priorityFlowControl()) { + dbg.nospace() << enabled << ' '; + } + dbg.nospace() << '\n'; + + dbg.nospace() << NM_SETTING_DCB_PRIORITY_BANDWIDTH << ": "; + Q_FOREACH (const quint32 bandwidthPercent, setting.priorityBandwidth()) { + dbg.nospace() << bandwidthPercent << ' '; + } + dbg.nospace() << '\n'; + + dbg.nospace() << NM_SETTING_DCB_PRIORITY_GROUP_BANDWIDTH << ": "; + Q_FOREACH (const quint32 bandwidthPercent, setting.priorityGroupBandwidth()) { + dbg.nospace() << bandwidthPercent << ' '; + } + dbg.nospace() << '\n'; + + dbg.nospace() << NM_SETTING_DCB_PRIORITY_GROUP_ID << ": "; + Q_FOREACH (const quint32 groupId, setting.priorityGroupId()) { + dbg.nospace() << groupId << ' '; + } + dbg.nospace() << '\n'; + + dbg.nospace() << NM_SETTING_DCB_PRIORITY_STRICT_BANDWIDTH << ": "; + Q_FOREACH (const quint32 strict, setting.priorityStrictBandwidth()) { + dbg.nospace() << strict << ' '; + } + dbg.nospace() << '\n'; + + dbg.nospace() << NM_SETTING_DCB_PRIORITY_TRAFFIC_CLASS << ": "; + Q_FOREACH (const quint32 trafficClass, setting.priorityTrafficClass()) { + dbg.nospace() << trafficClass << ' '; + } + dbg.nospace() << '\n'; + + return dbg.maybeSpace(); +} diff --git a/src/settings/dcbsetting_p.h b/src/settings/dcbsetting_p.h new file mode 100644 --- /dev/null +++ b/src/settings/dcbsetting_p.h @@ -0,0 +1,55 @@ +/* + Copyright 2018 Pranav Gade + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) version 3, or any + later version accepted by the membership of KDE e.V. (or its + successor approved by the membership of KDE e.V.), which shall + act as a proxy defined in Section 6 of version 3 of the license. + + This library 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. + + You should have received a copy of the GNU Lesser General Public + License along with this library. If not, see . +*/ + +#ifndef NETWORKMANAGERQT_DCBSETTING_P_H +#define NETWORKMANAGERQT_DCBSETTING_P_H + +#include + +namespace NetworkManager +{ + +class DcbSettingPrivate +{ +public: + DcbSettingPrivate(); + + QString name; + + QString appFcoeMode; + qint32 appFcoePriority; + qint32 appFipPriority; + qint32 appIscsiPriority; + NetworkManager::DcbSetting::DcbFlags appFcoeFlags; + NetworkManager::DcbSetting::DcbFlags appFipFlags; + NetworkManager::DcbSetting::DcbFlags appIscsiFlags; + NetworkManager::DcbSetting::DcbFlags priorityGroupFlags; + NetworkManager::DcbSetting::DcbFlags priorityFlowControlFlags; + UIntList priorityFlowControl; + UIntList priorityBandwidth; + UIntList priorityGroupBandwidth; + UIntList priorityGroupId; + UIntList priorityStrictBandwidth; + UIntList priorityTrafficClass; +}; + +} + +#endif // NETWORKMANAGERQT_DCBSETTING_P_H diff --git a/src/settings/setting.h b/src/settings/setting.h --- a/src/settings/setting.h +++ b/src/settings/setting.h @@ -83,7 +83,8 @@ Match, Tc, TeamPort, - Macsec + Macsec, + Dcb }; enum SecretFlagType { diff --git a/src/settings/setting.cpp b/src/settings/setting.cpp --- a/src/settings/setting.cpp +++ b/src/settings/setting.cpp @@ -173,6 +173,9 @@ case Macsec: typeString = QLatin1String(NM_SETTING_MACSEC_SETTING_NAME); break; + case Dcb: + typeString = QLatin1String(NM_SETTING_DCB_SETTING_NAME); + break; case NetworkManager::Setting::Generic: typeString = QLatin1String(NM_SETTING_GENERIC_SETTING_NAME); break; @@ -251,6 +254,8 @@ type = TeamPort; } else if (typeString == QLatin1String(NM_SETTING_MACSEC_SETTING_NAME)) { type = Macsec; + } else if (typeString == QLatin1String(NM_SETTING_DCB_SETTING_NAME)) { + type = Dcb; } return type;