VirtualBox

Changeset 81422 in vbox for trunk


Ignore:
Timestamp:
Oct 21, 2019 6:04:10 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
134139
Message:

OCI: (bugref:9469) cloud network integration concept (disabled in Config.kmk).

Location:
trunk
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Config.kmk

    r81386 r81422  
    796796# Use new VBoxNetDhcpd instead of old VBoxNetDHCP
    797797VBOX_WITH_DHCPD = 1
     798# Experimental suport for cloud network integration
     799#VBOX_WITH_CLOUD_NET = 1
    798800## @}
    799801

  • trunk/include/VBox/log.h

    r81406 r81422  
    363363    /** Main group, ICloudClient. */
    364364    LOG_GROUP_MAIN_CLOUDCLIENT,
     365    /** Main group, ICloudNetwork. */
     366    LOG_GROUP_MAIN_CLOUDNETWORK,
    365367    /** Main group, ICloudProfile. */
    366368    LOG_GROUP_MAIN_CLOUDPROFILE,
    … …  
    908910    "MAIN_CHOICEFORMVALUE", \
    909911    "MAIN_CLOUDCLIENT", \
     912    "MAIN_CLOUDNETWORK", \
    910913    "MAIN_CLOUDPROFILE", \
    911914    "MAIN_CLOUDPROVIDER", \

  • trunk/include/VBox/settings.h

    r81299 r81422  
    430430typedef std::list<NATNetwork> NATNetworksList;
    431431
     432#ifdef VBOX_WITH_CLOUD_NET
     433/**
     434 * Cloud Networking settings.
     435 */
     436struct CloudNetwork
     437{
     438    CloudNetwork();
     439
     440    com::Utf8Str strNetworkName;
     441    com::Utf8Str strProviderShortName;
     442    com::Utf8Str strProfileName;
     443    com::Utf8Str strNetworkId;
     444    bool         fEnabled;
     445};
     446
     447typedef std::list<CloudNetwork> CloudNetworksList;
     448#endif /* VBOX_WITH_CLOUD_NET */
     449
    432450
    433451class MainConfigFile : public ConfigFileBase
    … …  
    438456    void readMachineRegistry(const xml::ElementNode &elmMachineRegistry);
    439457    void readNATNetworks(const xml::ElementNode &elmNATNetworks);
     458#ifdef VBOX_WITH_CLOUD_NET
     459    void readCloudNetworks(const xml::ElementNode &elmCloudNetworks);
     460#endif /* VBOX_WITH_CLOUD_NET */
    440461
    441462    void write(const com::Utf8Str strFilename);
    … …  
    447468    DHCPServersList         llDhcpServers;
    448469    NATNetworksList         llNATNetworks;
     470#ifdef VBOX_WITH_CLOUD_NET
     471    CloudNetworksList       llCloudNetworks;
     472#endif /* VBOX_WITH_CLOUD_NET */
    449473    StringsMap              mapExtraDataItems;
    450474
    … …  
    723747    StringsMap                          genericProperties;
    724748    com::Utf8Str                        strNATNetworkName;
     749#ifdef VBOX_WITH_CLOUD_NET
     750    com::Utf8Str                        strCloudNetworkName;
     751#endif /* VBOX_WITH_CLOUD_NET */
    725752    uint32_t                            ulBootPriority;
    726753    com::Utf8Str                        strBandwidthGroup; // requires settings version 1.13 (VirtualBox 4.2)

  • trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

    r81261 r81422  
    243243        $(if $(VBOX_WITH_AUDIO_ALSA),VBOX_WITH_AUDIO_ALSA) \
    244244        $(if $(VBOX_WITH_AUDIO_PULSE),VBOX_WITH_AUDIO_PULSE) \
     245        $(if $(VBOX_WITH_CLOUD_NET),VBOX_WITH_CLOUD_NET) \
    245246        $(if $(VBOX_WITH_E1000),VBOX_WITH_E1000) \
    246247        $(if $(VBOX_WITH_NETFLT)$(eq $(KBUILD_TARGET),freebsd),VBOX_WITH_NETFLT) \

  • trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendCOM.cpp

    r81163 r81422  
    346346        case KNetworkAttachmentType_Generic:    return QApplication::translate("UICommon", "Generic Driver", "NetworkAttachmentType");
    347347        case KNetworkAttachmentType_NATNetwork: return QApplication::translate("UICommon", "NAT Network", "NetworkAttachmentType");
     348#ifdef VBOX_WITH_CLOUD_NET
     349        case KNetworkAttachmentType_Cloud:      return QApplication::translate("UICommon", "Cloud Network", "NetworkAttachmentType");
     350#endif /* VBOX_WITH_CLOUD_NET */
    348351        default: AssertMsgFailed(("No text for %d", type)); break;
    349352    }

  • trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp

    r79365 r81422  
    11871187        case UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_GenericDriver:   strResult = "GenericDriver"; break;
    11881188        case UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_NATNetwork:      strResult = "NATNetwork"; break;
     1189#ifdef VBOX_WITH_CLOUD_NET
     1190        case UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_CloudNetwork:    strResult = "CloudNetwork"; break;
     1191#endif /* VBOX_WITH_CLOUD_NET */
    11891192        default:
    11901193        {
    … …  
    12091212    keys << "GenericDriver";   values << UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_GenericDriver;
    12101213    keys << "NATNetwork";      values << UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_NATNetwork;
     1214#ifdef VBOX_WITH_CLOUD_NET
     1215    keys << "CloudNetwork";    values << UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_CloudNetwork;
     1216#endif /* VBOX_WITH_CLOUD_NET */
    12111217    /* Invalid type for unknown words: */
    12121218    if (!keys.contains(strDetailsElementOptionTypeNetwork, Qt::CaseInsensitive))

  • trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.h

    r81309 r81422  
    718718        DetailsElementOptionTypeNetwork_GenericDriver   = RT_BIT(5),
    719719        DetailsElementOptionTypeNetwork_NATNetwork      = RT_BIT(6),
     720#ifdef VBOX_WITH_CLOUD_NET
     721        DetailsElementOptionTypeNetwork_CloudNetwork    = RT_BIT(7),
     722#endif /* VBOX_WITH_CLOUD_NET */
    720723        DetailsElementOptionTypeNetwork_Default         = 0xFFFF
    721724    };

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIMachineAttributeSetter.cpp

    r80215 r81422  
    244244                    case KNetworkAttachmentType_Generic: comAdapter.SetGenericDriver(nad.m_strName); break;
    245245                    case KNetworkAttachmentType_NATNetwork: comAdapter.SetNATNetwork(nad.m_strName); break;
     246#ifdef VBOX_WITH_CLOUD_NET
     247                    case KNetworkAttachmentType_Cloud: comAdapter.SetCloudNetwork(nad.m_strName); break;
     248#endif /* VBOX_WITH_CLOUD_NET */
    246249                    default: break;
    247250                }

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsNetwork.cpp

    r81088 r81422  
    6060        , m_strGenericProperties(QString())
    6161        , m_strNATNetworkName(QString())
     62#ifdef VBOX_WITH_CLOUD_NET
     63        , m_strCloudNetworkName(QString())
     64#endif /* VBOX_WITH_CLOUD_NET */
    6265        , m_strMACAddress(QString())
    6366        , m_fCableConnected(false)
    … …  
    7982               && (m_strGenericProperties == other.m_strGenericProperties)
    8083               && (m_strNATNetworkName == other.m_strNATNetworkName)
     84#ifdef VBOX_WITH_CLOUD_NET
     85               && (m_strCloudNetworkName == other.m_strCloudNetworkName)
     86#endif /* VBOX_WITH_CLOUD_NET */
    8187               && (m_strMACAddress == other.m_strMACAddress)
    8288               && (m_fCableConnected == other.m_fCableConnected)
    … …  
    111117    /** Holds the NAT network name. */
    112118    QString                           m_strNATNetworkName;
     119#ifdef VBOX_WITH_CLOUD_NET
     120    /** Holds the cloud network name. */
     121    QString                           m_strCloudNetworkName;
     122#endif /* VBOX_WITH_CLOUD_NET */
    113123    /** Holds the network adapter MAC address. */
    114124    QString                           m_strMACAddress;
    … …  
    274284    m_pAttachmentTypeEditor->setValueName(KNetworkAttachmentType_Generic, wipedOutString(oldAdapterData.m_strGenericDriverName));
    275285    m_pAttachmentTypeEditor->setValueName(KNetworkAttachmentType_NATNetwork, wipedOutString(oldAdapterData.m_strNATNetworkName));
     286#ifdef VBOX_WITH_CLOUD_NET
     287    m_pAttachmentTypeEditor->setValueName(KNetworkAttachmentType_Cloud, wipedOutString(oldAdapterData.m_strCloudNetworkName));
     288#endif /* VBOX_WITH_CLOUD_NET */
    276289    /* Handle attachment type change: */
    277290    sltHandleAttachmentTypeChange();
    … …  
    331344            newAdapterData.m_strNATNetworkName = m_pAttachmentTypeEditor->valueName(KNetworkAttachmentType_NATNetwork);
    332345            break;
     346#ifdef VBOX_WITH_CLOUD_NET
     347        case KNetworkAttachmentType_Cloud:
     348            newAdapterData.m_strCloudNetworkName = m_pAttachmentTypeEditor->valueName(KNetworkAttachmentType_Cloud);
     349            break;
     350#endif /* VBOX_WITH_CLOUD_NET */
    333351        default:
    334352            break;
    … …  
    414432            break;
    415433        }
     434#ifdef VBOX_WITH_CLOUD_NET
     435        case KNetworkAttachmentType_Cloud:
     436        {
     437            if (alternativeName().isNull())
     438            {
     439                message.second << tr("No cloud network name is currently specified.");
     440                fPass = false;
     441            }
     442            break;
     443        }
     444#endif /* VBOX_WITH_CLOUD_NET */
    416445        default:
    417446            break;
    … …  
    518547    m_pAttachmentTypeEditor->setValueNames(KNetworkAttachmentType_Generic, m_pParent->genericDriverList());
    519548    m_pAttachmentTypeEditor->setValueNames(KNetworkAttachmentType_NATNetwork, m_pParent->natNetworkList());
     549#ifdef VBOX_WITH_CLOUD_NET
     550    m_pAttachmentTypeEditor->setValueNames(KNetworkAttachmentType_Cloud, m_pParent->cloudNetworkList());
     551#endif /* VBOX_WITH_CLOUD_NET */
    520552}
    521553
    … …  
    782814    refreshGenericDriverList(true);
    783815    refreshNATNetworkList();
     816#ifdef VBOX_WITH_CLOUD_NET
     817    refreshCloudNetworkList();
     818#endif /* VBOX_WITH_CLOUD_NET */
    784819
    785820    /* Prepare old network data: */
    … …  
    805840            oldAdapterData.m_strGenericDriverName = wipedOutString(comAdapter.GetGenericDriver());
    806841            oldAdapterData.m_strNATNetworkName = wipedOutString(comAdapter.GetNATNetwork());
     842#ifdef VBOX_WITH_CLOUD_NET
     843            oldAdapterData.m_strCloudNetworkName = wipedOutString(comAdapter.GetCloudNetwork());
     844#endif /* VBOX_WITH_CLOUD_NET */
    807845            oldAdapterData.m_adapterType = comAdapter.GetAdapterType();
    808846            oldAdapterData.m_promiscuousMode = comAdapter.GetPromiscModePolicy();
    … …  
    10661104    }
    10671105}
     1106
     1107#ifdef VBOX_WITH_CLOUD_NET
     1108void UIMachineSettingsNetworkPage::refreshCloudNetworkList()
     1109{
     1110    /* Reload cloud network list: */
     1111    m_cloudNetworkList = UINetworkAttachmentEditor::cloudNetworks();
     1112}
     1113#endif /* VBOX_WITH_CLOUD_NET */
    10681114
    10691115void UIMachineSettingsNetworkPage::refreshHostInterfaceList()
    … …  
    12791325                    break;
    12801326                }
     1327#ifdef VBOX_WITH_CLOUD_NET
     1328                case KNetworkAttachmentType_Cloud:
     1329                {
     1330                    if (fSuccess && newAdapterData.m_strCloudNetworkName != oldAdapterData.m_strCloudNetworkName)
     1331                    {
     1332                        comAdapter.SetCloudNetwork(newAdapterData.m_strCloudNetworkName);
     1333                        fSuccess = comAdapter.isOk();
     1334                    }
     1335                    break;
     1336                }
     1337#endif /* VBOX_WITH_CLOUD_NET */
    12811338                default:
    12821339                    break;

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsNetwork.h

    r81088 r81422  
    5757    /** Returns the NAT network list. */
    5858    const QStringList &natNetworkList() const { return m_natNetworkList; }
     59#ifdef VBOX_WITH_CLOUD_NET
     60    /** Returns the cloud network list. */
     61    const QStringList &cloudNetworkList() const { return m_cloudNetworkList; }
     62#endif /* VBOX_WITH_CLOUD_NET */
    5963
    6064 public slots:
    … …  
    113117    /** Repopulates NAT network list. */
    114118    void refreshNATNetworkList();
     119#ifdef VBOX_WITH_CLOUD_NET
     120    /** Repopulates cloud network list. */
     121    void refreshCloudNetworkList();
     122#endif /* VBOX_WITH_CLOUD_NET */
    115123
    116124    /** Loads generic properties from passed @a adapter. */
    … …  
    141149    /** Holds the NAT network list. */
    142150    QStringList  m_natNetworkList;
     151#ifdef VBOX_WITH_CLOUD_NET
     152    /** Holds the cloud network list. */
     153    QStringList  m_cloudNetworkList;
     154#endif /* VBOX_WITH_CLOUD_NET */
    143155
    144156    /** Holds the page data cache instance. */

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UINetworkAttachmentEditor.cpp

    r80275 r81422  
    3131#include "CHostNetworkInterface.h"
    3232#include "CNATNetwork.h"
     33#ifdef VBOX_WITH_CLOUD_NET
     34#include "CCloudNetwork.h"
     35#endif /* VBOX_WITH_CLOUD_NET */
    3336
    3437
    … …  
    159162    return natNetworkList;
    160163}
     164
     165#ifdef VBOX_WITH_CLOUD_NET
     166/* static */
     167QStringList UINetworkAttachmentEditor::cloudNetworks()
     168{
     169    QStringList cloudNetworkList;
     170    foreach (const CCloudNetwork &comNetwork, uiCommon().virtualBox().GetCloudNetworks())
     171        cloudNetworkList << comNetwork.GetNetworkName();
     172    return cloudNetworkList;
     173}
     174#endif /* VBOX_WITH_CLOUD_NET */
    161175
    162176void UINetworkAttachmentEditor::retranslateUi()
    … …  
    338352                                                  << KNetworkAttachmentType_Bridged << KNetworkAttachmentType_Internal
    339353                                                  << KNetworkAttachmentType_HostOnly << KNetworkAttachmentType_Generic;
     354#ifdef VBOX_WITH_CLOUD_NET
     355    attachmentTypes.append(KNetworkAttachmentType_Cloud);
     356#endif /* VBOX_WITH_CLOUD_NET */
    340357    for (int i = 0; i < attachmentTypes.size(); ++i)
    341358    {
    … …  
    382399            case KNetworkAttachmentType_HostOnly:
    383400            case KNetworkAttachmentType_NATNetwork:
     401#ifdef VBOX_WITH_CLOUD_NET
     402            case KNetworkAttachmentType_Cloud:
     403#endif /* VBOX_WITH_CLOUD_NET */
    384404            {
    385405                /* If adapter list is empty => add 'Not selected' item: */
    … …  
    445465                                          "manager window."));
    446466            break;
     467#ifdef VBOX_WITH_CLOUD_NET
     468        case KNetworkAttachmentType_Cloud:
     469            m_pComboName->setWhatsThis(tr("(experimental) Holds the name of the cloud network that this network card "
     470                                          "will be connected to. You can add and remove cloud networks "
     471                                          "using the global network settings in the virtual machine "
     472                                          "manager window."));
     473            break;
     474#endif /* VBOX_WITH_CLOUD_NET */
    447475        default:
    448476            m_pComboName->setWhatsThis(QString());
    … …  
    461489        case KNetworkAttachmentType_Generic:
    462490        case KNetworkAttachmentType_NATNetwork:
     491#ifdef VBOX_WITH_CLOUD_NET
     492        case KNetworkAttachmentType_Cloud:
     493#endif /* VBOX_WITH_CLOUD_NET */
    463494            fSuccess = !valueName(valueType()).isEmpty();
    464495            break;
    … …  
    481512        case KNetworkAttachmentType_Generic:    return UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_GenericDriver;
    482513        case KNetworkAttachmentType_NATNetwork: return UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_NATNetwork;
     514#ifdef VBOX_WITH_CLOUD_NET
     515        case KNetworkAttachmentType_Cloud:      return UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_CloudNetwork;
     516#endif /* VBOX_WITH_CLOUD_NET */
    483517        default:                                return UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Invalid;
    484518    }

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UINetworkAttachmentEditor.h

    r80213 r81422  
    8585    /** Returns NAT network list. */
    8686    static QStringList natNetworks();
     87#ifdef VBOX_WITH_CLOUD_NET
     88    /** Returns cloud network list. */
     89    static QStringList cloudNetworks();
     90#endif /* VBOX_WITH_CLOUD_NET */
    8791
    8892protected:

  • trunk/src/VBox/Main/Makefile.kmk

    r80849 r81422  
    118118ifdef VBOX_WITH_NETFLT
    119119VBOX_MAIN_DEFS += VBOX_WITH_NETFLT
     120endif
     121ifdef VBOX_WITH_CLOUD_NET
     122VBOX_MAIN_DEFS += VBOX_WITH_CLOUD_NET
    120123endif
    121124ifdef VBOX_WITH_PCI_PASSTHROUGH
    … …  
    556559        src-server/NetworkServiceRunner.cpp \
    557560        src-server/NATNetworkImpl.cpp \
     561        $(if $(VBOX_WITH_CLOUD_NET), \
     562        src-server/CloudGateway.cpp \
     563        src-server/CloudNetworkImpl.cpp \
     564        ,) \
    558565        src-server/GuestOSTypeImpl.cpp \
    559566        src-server/HostDnsService.cpp \

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r81398 r81422  
    17341734  </interface>
    17351735
     1736
     1737  <!--
     1738  // ICloudNetwork
     1739  /////////////////////////////////////////////////////////////////////////
     1740  -->
     1741
     1742  <interface name="ICloudNetwork" extends="$unknown"
     1743    uuid="d8e3496e-735f-4fde-8a54-427d49409b5f"
     1744    wsmap="managed"
     1745    reservedMethods="4" reservedAttributes="3"
     1746    >
     1747
     1748    <attribute name="networkName" type="wstring">
     1749      <desc>
     1750        TBD: User-friendly, descriptive name of cloud subnet. For example, domain
     1751        names of subnet and vcn, separated by dot.
     1752      </desc>
     1753    </attribute>
     1754    <attribute name="enabled" type="boolean"/>
     1755    <attribute name="provider" type="wstring">
     1756      <desc>
     1757        Cloud provider short name.
     1758      </desc>
     1759    </attribute>
     1760    <attribute name="profile" type="wstring">
     1761      <desc>
     1762        Cloud profile name.
     1763      </desc>
     1764    </attribute>
     1765    <attribute name="networkId" type="wstring">
     1766      <desc>
     1767        Cloud network id.
     1768      </desc>
     1769    </attribute>
     1770  </interface>
    17361771
    17371772  <!--
    … …  
    26462681    </attribute>
    26472682
     2683    <attribute name="cloudNetworks" type="ICloudNetwork" safearray="yes" readonly="yes">
     2684      <desc>
     2685        Names of all configured cloud networks.
     2686      </desc>
     2687    </attribute>
     2688
    26482689    <attribute name="cloudProviderManager" type="ICloudProviderManager" readonly="yes">
    26492690      <desc>
    … …  
    33833424    <method name="removeNATNetwork">
    33843425      <param name="network" type="INATNetwork" dir="in"/>
     3426    </method>
     3427
     3428    <!-- bunch of methods to manage cloud networks -->
     3429    <method name="createCloudNetwork">
     3430      <!-- Here we create a record in cloud network array with specified name.
     3431      -->
     3432      <param name="networkName" type="wstring" dir="in"/>
     3433      <param name="network" type="ICloudNetwork" dir="return"/>
     3434    </method>
     3435
     3436    <!--
     3437          Returns the cloud network by name.
     3438    -->
     3439    <method name="findCloudNetworkByName">
     3440      <param name="networkName" type="wstring" dir="in"/>
     3441      <param name="network" type="ICloudNetwork" dir="return"/>
     3442    </method>
     3443    <!--
     3444        Deletes given cloud network.
     3445    -->
     3446    <method name="removeCloudNetwork">
     3447      <param name="network" type="ICloudNetwork" dir="in"/>
    33853448    </method>
    33863449
    … …  
    1931819381    <const name="Generic"               value="5"/>
    1931919382    <const name="NATNetwork"            value="6"/>
     19383    <const name="Cloud"                 value="7"/>
    1932019384  </enum>
    1932119385
    … …  
    1946119525      <desc>
    1946219526        Name of the driver to use for the "Generic" network attachment type.
     19527      </desc>
     19528    </attribute>
     19529
     19530    <attribute name="cloudNetwork" type="wstring">
     19531      <desc>
     19532        Name of the cloud network the VM is attached to.
    1946319533      </desc>
    1946419534    </attribute>

  • trunk/src/VBox/Main/include/MachineImpl.h

    r81299 r81422  
    4545# include "ThreadTask.h"
    4646#endif
     47#ifdef VBOX_WITH_CLOUD_NET
     48# include "CloudNetworkImpl.h"
     49# include "CloudGateway.h"
     50#endif /* VBOX_WITH_CLOUD_NET */
    4751
    4852// generated header
    … …  
    199203        // list of files to delete in Delete(); this list is filled by Unregister()
    200204        std::list<Utf8Str>  llFilesToDelete;
    201     };
     205   
     206#ifdef VBOX_WITH_CLOUD_NET
     207        GatewayInfo         mGatewayInfo;
     208#endif /* VBOX_WITH_CLOUD_NET */
     209};
    202210
    203211    /**
    … …  
    759767    pm::CollectorGuest     *mCollectorGuest;
    760768#endif /* VBOX_WITH_RESOURCE_USAGE_API */
     769
     770#ifdef VBOX_WITH_CLOUD_NET
     771HRESULT i_connectToCloudNetwork(ProgressProxy *aProgress);
     772HRESULT i_disconnectFromCloudNetwork();
     773#endif /* VBOX_WITH_CLOUD_NET */
    761774
    762775    Machine * const         mPeer;

  • trunk/src/VBox/Main/include/NetworkAdapterImpl.h

    r76562 r81422  
    8585    HRESULT getGenericDriver(com::Utf8Str &aGenericDriver);
    8686    HRESULT setGenericDriver(const com::Utf8Str &aGenericDriver);
     87    HRESULT getCloudNetwork(com::Utf8Str &aCloudNetwork);
     88    HRESULT setCloudNetwork(const com::Utf8Str &aCloudNetwork);
    8789    HRESULT getCableConnected(BOOL *aCableConnected);
    8890    HRESULT setCableConnected(BOOL aCableConnected);

  • trunk/src/VBox/Main/include/VirtualBoxImpl.h

    r80849 r81422  
    5353class AutostartDb;
    5454class NATNetwork;
     55#ifdef VBOX_WITH_CLOUD_NET
     56class CloudNetwork;
     57#endif /* VBOX_WITH_CLOUD_NET */
    5558
    5659
    … …  
    204207    int i_natNetworkRefInc(const Utf8Str &aNetworkName);
    205208    int i_natNetworkRefDec(const Utf8Str &aNetworkName);
     209
     210#ifdef VBOX_WITH_CLOUD_NET
     211    HRESULT i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
     212                                     ComObjPtr<CloudNetwork> *aNetwork = NULL);
     213#endif /* VBOX_WITH_CLOUD_NET */
    206214
    207215    ComObjPtr<GuestOSType> i_getUnknownOSType();
    … …  
    319327    HRESULT getInternalNetworks(std::vector<com::Utf8Str> &aInternalNetworks);
    320328    HRESULT getGenericNetworkDrivers(std::vector<com::Utf8Str> &aGenericNetworkDrivers);
     329    HRESULT getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks);
    321330    HRESULT getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager);
    322331
    … …  
    378387                                 ComPtr<INATNetwork> &aNetwork);
    379388    HRESULT removeNATNetwork(const ComPtr<INATNetwork> &aNetwork);
     389    HRESULT createCloudNetwork(const com::Utf8Str &aNetworkName,
     390                               ComPtr<ICloudNetwork> &aNetwork);
     391    HRESULT findCloudNetworkByName(const com::Utf8Str &aNetworkName,
     392                                   ComPtr<ICloudNetwork> &aNetwork);
     393    HRESULT removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork);
    380394    HRESULT checkFirmwarePresent(FirmwareType_T aFirmwareType,
    381395                                 const com::Utf8Str &aVersion,

  • trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

    r81345 r81422  
    58025802            }
    58035803
     5804#ifdef VBOX_WITH_CLOUD_NET
     5805            case NetworkAttachmentType_Cloud:
     5806            {
     5807                hrc = aNetworkAdapter->COMGETTER(CloudNetwork)(bstr.asOutParam());       H();
     5808                if (!bstr.isEmpty())
     5809                {
     5810                    InsertConfigString(pLunL0, "Driver", "IntNet");
     5811                    InsertConfigNode(pLunL0, "Config", &pCfg);
     5812                    InsertConfigString(pCfg, "Network", BstrFmt("cloud-%ls", bstr));
     5813                    InsertConfigInteger(pCfg, "TrunkType", kIntNetTrunkType_WhateverNone);
     5814                    InsertConfigString(pCfg, "IfPolicyPromisc", pszPromiscuousGuestPolicy);
     5815                    networkName = bstr;
     5816                    trunkType = Bstr(TRUNKTYPE_WHATEVER);
     5817                }
     5818                break;
     5819            }
     5820#endif /* VBOX_WITH_CLOUD_NET */
     5821
    58045822            default:
    58055823                AssertMsgFailed(("should not get here!\n"));
    … …  
    58215839            case NetworkAttachmentType_Generic:
    58225840            case NetworkAttachmentType_NATNetwork:
     5841#ifdef VBOX_WITH_CLOUD_NET
     5842            case NetworkAttachmentType_Cloud:
     5843#endif /* VBOX_WITH_CLOUD_NET */
    58235844            {
    58245845                if (SUCCEEDED(hrc) && RT_SUCCESS(rc))

  • trunk/src/VBox/Main/src-server/ApplianceImpl.cpp

    r78923 r81422  
    329329        case NetworkAttachmentType_NATNetwork: strType = "NATNetwork"; break;
    330330        case NetworkAttachmentType_Null: strType = "Null"; break;
     331        case NetworkAttachmentType_Cloud: strType = "Cloud"; break;
    331332#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
    332333        case NetworkAttachmentType_32BitHack: AssertFailedBreak(); /* (compiler warnings) */

  • trunk/src/VBox/Main/src-server/MachineImpl.cpp

    r81299 r81422  
    5050#include "ExtPackManagerImpl.h"
    5151#include "MachineLaunchVMCommonWorker.h"
     52#ifdef VBOX_WITH_CLOUD_NET
     53#include "ApplianceImpl.h"
     54#include "CloudGateway.h"
     55#endif /* VBOX_WITH_CLOUD_NET */
    5256
    5357// generated header
    … …  
    34763480        if (SUCCEEDED(rc))
    34773481        {
     3482#ifdef VBOX_WITH_CLOUD_NET
     3483            i_connectToCloudNetwork(progress);
     3484#endif /* VBOX_WITH_CLOUD_NET */
     3485
    34783486            rc = i_launchVMProcess(control, strFrontend, aEnvironmentChanges, progress);
    34793487            if (SUCCEEDED(rc))
    … …  
    74307438    return (mUSBControllers->size() > 0);
    74317439}
     7440
     7441#ifdef VBOX_WITH_CLOUD_NET
     7442HRESULT Machine::i_connectToCloudNetwork(ProgressProxy *aProgress)
     7443{
     7444    LogFlowThisFuncEnter();
     7445    AssertReturn(aProgress, E_FAIL);
     7446
     7447    HRESULT hrc = E_FAIL;
     7448    Bstr name;
     7449
     7450    LogFlowThisFunc(("Checking if cloud network needs to be connected\n"));
     7451    for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
     7452    {
     7453        BOOL enabled;
     7454        hrc = mNetworkAdapters[slot]->COMGETTER(Enabled)(&enabled);
     7455        if (   FAILED(hrc)
     7456            || !enabled)
     7457            continue;
     7458
     7459        NetworkAttachmentType_T type;
     7460        hrc = mNetworkAdapters[slot]->COMGETTER(AttachmentType)(&type);
     7461        if (   SUCCEEDED(hrc)
     7462            && type == NetworkAttachmentType_Cloud)
     7463        {
     7464            if (name.isNotEmpty())
     7465            {
     7466                LogRel(("VM '%s' uses multiple cloud network attachments. '%ls' will be ignored.\n",
     7467                        mUserData->s.strName.c_str(), name.raw()));
     7468                continue;
     7469            }
     7470            hrc = mNetworkAdapters[slot]->COMGETTER(CloudNetwork)(name.asOutParam());
     7471            if (SUCCEEDED(hrc))
     7472            {
     7473                LogRel(("VM '%s' uses cloud network '%ls'\n",
     7474                        mUserData->s.strName.c_str(), name.raw()));
     7475            }
     7476        }
     7477    }
     7478    if (name.isNotEmpty())
     7479    {
     7480        LogFlowThisFunc(("Connecting to cloud network '%ls'...\n", name.raw()));
     7481        ComObjPtr<CloudNetwork> network;
     7482        hrc = mParent->i_findCloudNetworkByName(name, &network);
     7483        if (FAILED(hrc))
     7484        {
     7485            LogRel(("Could not find cloud network '%ls'.\n", name.raw()));
     7486            return hrc;
     7487        }
     7488        GatewayInfo gateways;
     7489        hrc = startGateways(mParent, network, gateways);
     7490        if (SUCCEEDED(hrc))
     7491        {
     7492            AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     7493            mData->mGatewayInfo = gateways;
     7494        }
     7495    }
     7496    else
     7497        LogFlowThisFunc(("VM '%s' has no cloud network attachments.\n", mUserData->s.strName.c_str()));
     7498
     7499    LogFlowThisFuncLeave();
     7500    return hrc;
     7501}
     7502
     7503HRESULT Machine::i_disconnectFromCloudNetwork()
     7504{
     7505    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     7506    GatewayInfo gateways(mData->mGatewayInfo);
     7507    mData->mGatewayInfo.setNull();
     7508    alock.release();
     7509
     7510    HRESULT hrc = stopGateways(mParent, gateways);
     7511    return hrc;
     7512}
     7513#endif /* VBOX_WITH_CLOUD_NET */
     7514
    74327515
    74337516/**
    … …  
    1318713270{
    1318813271    LogFlowThisFuncEnter();
     13272   
     13273#ifdef VBOX_WITH_CLOUD_NET
     13274    mPeer->i_disconnectFromCloudNetwork();
     13275#endif /* VBOX_WITH_CLOUD_NET */
    1318913276
    1319013277    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

  • trunk/src/VBox/Main/src-server/NetworkAdapterImpl.cpp

    r76592 r81422  
    724724
    725725
     726HRESULT NetworkAdapter::getCloudNetwork(com::Utf8Str &aCloudNetwork)
     727{
     728#ifdef VBOX_WITH_CLOUD_NET
     729   AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
     730
     731    aCloudNetwork = mData->strCloudNetworkName;
     732
     733    return S_OK;
     734#else /* !VBOX_WITH_CLOUD_NET */
     735    NOREF(aCloudNetwork);
     736    return E_NOTIMPL;
     737#endif /* !VBOX_WITH_CLOUD_NET */
     738}
     739
     740HRESULT NetworkAdapter::setCloudNetwork(const com::Utf8Str &aCloudNetwork)
     741{
     742#ifdef VBOX_WITH_CLOUD_NET
     743    /* the machine needs to be mutable */
     744    AutoMutableOrSavedOrRunningStateDependency adep(mParent);
     745    if (FAILED(adep.rc())) return adep.rc();
     746
     747    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     748
     749    if (mData->strCloudNetworkName != aCloudNetwork)
     750    {
     751        /* if an empty/null string is to be set, Cloud networking must be
     752         * turned off */
     753        if (   aCloudNetwork.isEmpty()
     754            && mData->fEnabled
     755            && mData->mode == NetworkAttachmentType_Cloud)
     756        {
     757            return setError(E_FAIL,
     758                            tr("Empty or null Cloud network name is not valid"));
     759        }
     760        mData.backup();
     761        mData->strCloudNetworkName = aCloudNetwork;
     762
     763        // leave the lock before informing callbacks
     764        alock.release();
     765
     766#if 0
     767        // @todo Implement dynamic re-attachment of cloud network
     768        AutoWriteLock mlock(mParent COMMA_LOCKVAL_SRC_POS);       // mParent is const, no need to lock
     769        mParent->i_setModified(Machine::IsModified_NetworkAdapters);
     770        mlock.release();
     771
     772        /* When changing the internal network, adapt the CFGM logic to make this
     773         * change immediately effect and to notify the guest that the network
     774         * might have changed, therefore changeAdapter=TRUE. */
     775        mParent->i_onNetworkAdapterChange(this, TRUE);
     776#else
     777        mParent->i_onNetworkAdapterChange(this, FALSE);
     778#endif
     779    }
     780    return S_OK;
     781#else /* !VBOX_WITH_CLOUD_NET */
     782    NOREF(aCloudNetwork);
     783    return E_NOTIMPL;
     784#endif /* !VBOX_WITH_CLOUD_NET */
     785}
     786
     787
    726788HRESULT NetworkAdapter::getCableConnected(BOOL *aConnected)
    727789{

  • trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

    r81369 r81422  
    7171#include "DHCPServerImpl.h"
    7272#include "NATNetworkImpl.h"
     73#ifdef VBOX_WITH_CLOUD_NET
     74#include "CloudNetworkImpl.h"
     75#endif /* VBOX_WITH_CLOUD_NET */
    7376#ifdef VBOX_WITH_RESOURCE_USAGE_API
    7477# include "PerformanceImpl.h"
    … …  
    219222typedef ObjectsList<DHCPServer> DHCPServersOList;
    220223typedef ObjectsList<NATNetwork> NATNetworksOList;
     224#ifdef VBOX_WITH_CLOUD_NET
     225typedef ObjectsList<CloudNetwork> CloudNetworksOList;
     226#endif /* VBOX_WITH_CLOUD_NET */
    221227
    222228typedef std::map<Guid, ComPtr<IProgress> > ProgressMap;
    … …  
    324330        , lockNATNetworks(LOCKCLASS_LISTOFOTHEROBJECTS)
    325331        , allNATNetworks(lockNATNetworks)
     332#ifdef VBOX_WITH_CLOUD_NET
     333        , lockCloudNetworks(LOCKCLASS_LISTOFOTHEROBJECTS)
     334        , allCloudNetworks(lockCloudNetworks)
     335#endif /* VBOX_WITH_CLOUD_NET */
    326336        , mtxProgressOperations(LOCKCLASS_PROGRESSLIST)
    327337        , pClientWatcher(NULL)
    … …  
    409419    RWLockHandle                        lockNATNetworks;
    410420    NATNetworksOList                    allNATNetworks;
     421#ifdef VBOX_WITH_CLOUD_NET
     422    RWLockHandle                        lockCloudNetworks;
     423    CloudNetworksOList                  allCloudNetworks;
     424#endif /* VBOX_WITH_CLOUD_NET */
    411425
    412426    RWLockHandle                        mtxProgressOperations;
    … …  
    686700            AssertComRCThrowRC(rc);
    687701        }
     702
     703#ifdef VBOX_WITH_CLOUD_NET
     704        /* net services - cloud networks */
     705        for (settings::CloudNetworksList::const_iterator it = m->pMainConfigFile->llCloudNetworks.begin();
     706             it != m->pMainConfigFile->llCloudNetworks.end();
     707             ++it)
     708        {
     709            ComObjPtr<CloudNetwork> pCloudNetwork;
     710            rc = pCloudNetwork.createObject();
     711            AssertComRCThrowRC(rc);
     712            rc = pCloudNetwork->init(this, "");
     713            AssertComRCThrowRC(rc);
     714            rc = pCloudNetwork->i_loadSettings(*it);
     715            AssertComRCThrowRC(rc);
     716            m->allCloudNetworks.addChild(pCloudNetwork);
     717            AssertComRCThrowRC(rc);
     718        }
     719#endif /* VBOX_WITH_CLOUD_NET */
    688720
    689721        /* events */
    … …  
    14661498
    14671499    return S_OK;
     1500}
     1501
     1502/**
     1503 * Cloud Network
     1504 */
     1505#ifdef VBOX_WITH_CLOUD_NET
     1506HRESULT VirtualBox::i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
     1507                                             ComObjPtr<CloudNetwork> *aNetwork)
     1508{
     1509    HRESULT rc = E_FAIL;
     1510    ComPtr<CloudNetwork> found;
     1511    Bstr bstrNameToFind(aNetworkName);
     1512
     1513    AutoReadLock alock(m->allCloudNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
     1514
     1515    for (CloudNetworksOList::const_iterator it = m->allCloudNetworks.begin();
     1516         it != m->allCloudNetworks.end();
     1517         ++it)
     1518    {
     1519        Bstr bstrCloudNetworkName;
     1520        rc = (*it)->COMGETTER(NetworkName)(bstrCloudNetworkName.asOutParam());
     1521        if (FAILED(rc)) return rc;
     1522
     1523        if (bstrCloudNetworkName == bstrNameToFind)
     1524        {
     1525            *aNetwork = *it;
     1526            rc = S_OK;
     1527            break;
     1528        }
     1529    }
     1530    return rc;
     1531}                                 
     1532#endif /* VBOX_WITH_CLOUD_NET */
     1533
     1534HRESULT VirtualBox::createCloudNetwork(const com::Utf8Str &aNetworkName,
     1535                                       ComPtr<ICloudNetwork> &aNetwork)
     1536{
     1537#ifdef VBOX_WITH_CLOUD_NET
     1538    ComObjPtr<CloudNetwork> cloudNetwork;
     1539    cloudNetwork.createObject();
     1540    HRESULT rc = cloudNetwork->init(this, aNetworkName);
     1541    if (FAILED(rc)) return rc;
     1542
     1543    m->allCloudNetworks.addChild(cloudNetwork);
     1544
     1545    cloudNetwork.queryInterfaceTo(aNetwork.asOutParam());
     1546
     1547    return rc;
     1548#else /* !VBOX_WITH_CLOUD_NET */
     1549    NOREF(aNetworkName);
     1550    NOREF(aNetwork);
     1551    return E_NOTIMPL;
     1552#endif /* !VBOX_WITH_CLOUD_NET */
     1553}
     1554
     1555HRESULT VirtualBox::findCloudNetworkByName(const com::Utf8Str &aNetworkName,
     1556                                           ComPtr<ICloudNetwork> &aNetwork)
     1557{
     1558#ifdef VBOX_WITH_CLOUD_NET
     1559    ComObjPtr<CloudNetwork> network;
     1560    HRESULT hrc = i_findCloudNetworkByName(aNetworkName, &network);
     1561    if (SUCCEEDED(hrc))
     1562        network.queryInterfaceTo(aNetwork.asOutParam());
     1563    return hrc;
     1564#else /* !VBOX_WITH_CLOUD_NET */
     1565    NOREF(aNetworkName);
     1566    NOREF(aNetwork);
     1567    return E_NOTIMPL;
     1568#endif /* !VBOX_WITH_CLOUD_NET */
     1569}
     1570
     1571HRESULT VirtualBox::removeCloudNetwork(const ComPtr<ICloudNetwork> &aNetwork)
     1572{
     1573#ifdef VBOX_WITH_CLOUD_NET
     1574    Bstr name;
     1575    HRESULT rc = aNetwork->COMGETTER(NetworkName)(name.asOutParam());
     1576    if (FAILED(rc))
     1577        return rc;
     1578    ICloudNetwork *p = aNetwork;
     1579    CloudNetwork *network = static_cast<CloudNetwork *>(p);
     1580
     1581    AutoCaller autoCaller(this);
     1582    AssertComRCReturnRC(autoCaller.rc());
     1583
     1584    AutoCaller cloudNetworkCaller(network);
     1585    AssertComRCReturnRC(cloudNetworkCaller.rc());
     1586
     1587    m->allCloudNetworks.removeChild(network);
     1588
     1589    {
     1590        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
     1591        rc = i_saveSettings();
     1592        vboxLock.release();
     1593
     1594        if (FAILED(rc))
     1595            m->allCloudNetworks.addChild(network);
     1596    }
     1597    return rc;
     1598#else /* !VBOX_WITH_CLOUD_NET */
     1599    NOREF(aNetwork);
     1600    return E_NOTIMPL;
     1601#endif /* !VBOX_WITH_CLOUD_NET */
     1602}
     1603
     1604HRESULT VirtualBox::getCloudNetworks(std::vector<ComPtr<ICloudNetwork> > &aCloudNetworks)
     1605{
     1606#ifdef VBOX_WITH_CLOUD_NET
     1607    AutoReadLock al(m->allCloudNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
     1608    aCloudNetworks.resize(m->allCloudNetworks.size());
     1609    size_t i = 0;
     1610    for (CloudNetworksOList::const_iterator it = m->allCloudNetworks.begin();
     1611         it != m->allCloudNetworks.end(); ++it)
     1612         (*it).queryInterfaceTo(aCloudNetworks[i++].asOutParam());
     1613    return S_OK;
     1614#else /* !VBOX_WITH_CLOUD_NET */
     1615    NOREF(aCloudNetworks);
     1616    return E_NOTIMPL;
     1617#endif /* !VBOX_WITH_CLOUD_NET */
    14681618}
    14691619
    … …  
    49305080#endif
    49315081
     5082#ifdef VBOX_WITH_CLOUD_NET
     5083        m->pMainConfigFile->llCloudNetworks.clear();
     5084        {
     5085            AutoReadLock cloudNetworkLock(m->allCloudNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
     5086            for (CloudNetworksOList::const_iterator it = m->allCloudNetworks.begin();
     5087                 it != m->allCloudNetworks.end();
     5088                 ++it)
     5089            {
     5090                settings::CloudNetwork n;
     5091                rc = (*it)->i_saveSettings(n);
     5092                if (FAILED(rc)) throw rc;
     5093                m->pMainConfigFile->llCloudNetworks.push_back(n);
     5094            }
     5095        }
     5096#endif /* VBOX_WITH_CLOUD_NET */
    49325097        // leave extra data alone, it's still in the config file
    49335098

  • trunk/src/VBox/Main/xml/Settings.cpp

    r81299 r81422  
    16911691}
    16921692
     1693#ifdef VBOX_WITH_CLOUD_NET
     1694/**
     1695 * Constructor. Needs to set sane defaults which stand the test of time.
     1696 */
     1697CloudNetwork::CloudNetwork() :
     1698    fEnabled(true),
     1699    strProviderShortName("OCI"),
     1700    strProfileName("Default")
     1701{
     1702}
     1703#endif /* VBOX_WITH_CLOUD_NET */
     1704
    16931705
    16941706
    … …  
    20032015    }
    20042016}
     2017
     2018#ifdef VBOX_WITH_CLOUD_NET
     2019/**
     2020 * Reads in the \<CloudNetworks\> chunk.
     2021 * @param elmCloudNetworks
     2022 */
     2023void MainConfigFile::readCloudNetworks(const xml::ElementNode &elmCloudNetworks)
     2024{
     2025    xml::NodesLoop nl1(elmCloudNetworks);
     2026    const xml::ElementNode *pelmNet;
     2027    while ((pelmNet = nl1.forAllNodes()))
     2028    {
     2029        if (pelmNet->nameEquals("CloudNetwork"))
     2030        {
     2031            CloudNetwork net;
     2032            if (   pelmNet->getAttributeValue("name", net.strNetworkName)
     2033                && pelmNet->getAttributeValue("provider", net.strProviderShortName)
     2034                && pelmNet->getAttributeValue("profile", net.strProfileName)
     2035                && pelmNet->getAttributeValue("id", net.strNetworkId)
     2036                && pelmNet->getAttributeValue("enabled", net.fEnabled) )
     2037            {
     2038                llCloudNetworks.push_back(net);
     2039            }
     2040            else
     2041                throw ConfigFileError(this, pelmNet, N_("Required CloudNetwork/@name, @provider, @profile, @id or @enabled attribute is missing"));
     2042        }
     2043    }
     2044}
     2045#endif /* VBOX_WITH_CLOUD_NET */
    20052046
    20062047/**
    … …  
    22292270                            if (pelmLevel4Child->nameEquals("NATNetworks"))
    22302271                                readNATNetworks(*pelmLevel4Child);
     2272#ifdef VBOX_WITH_CLOUD_NET
     2273                            if (pelmLevel4Child->nameEquals("CloudNetworks"))
     2274                                readCloudNetworks(*pelmLevel4Child);
     2275#endif /* VBOX_WITH_CLOUD_NET */
    22312276                        }
    22322277                    }
    … …  
    22762321void MainConfigFile::bumpSettingsVersionIfNeeded()
    22772322{
     2323#ifdef VBOX_WITH_CLOUD_NET
     2324    if (m->sv < SettingsVersion_v1_18)
     2325    {
     2326        // VirtualBox 6.1 adds support for cloud networks.
     2327        if (!llCloudNetworks.empty())
     2328            m->sv = SettingsVersion_v1_18;
     2329    }
     2330#endif /* VBOX_WITH_CLOUD_NET */
     2331
    22782332    if (m->sv < SettingsVersion_v1_16)
    22792333    {
    … …  
    23622416        }
    23632417    }
     2418
     2419#ifdef VBOX_WITH_CLOUD_NET
     2420    xml::ElementNode *pelmCloudNetworks;
     2421    /* don't create entry if no cloud networks are registered. */
     2422    if (!llCloudNetworks.empty())
     2423    {
     2424        pelmCloudNetworks = pelmNetServiceRegistry->createChild("CloudNetworks");
     2425        for (CloudNetworksList::const_iterator it = llCloudNetworks.begin();
     2426             it != llCloudNetworks.end();
     2427             ++it)
     2428        {
     2429            const CloudNetwork &n = *it;
     2430            xml::ElementNode *pelmThis = pelmCloudNetworks->createChild("CloudNetwork");
     2431            pelmThis->setAttribute("name", n.strNetworkName);
     2432            pelmThis->setAttribute("provider", n.strProviderShortName);
     2433            pelmThis->setAttribute("profile", n.strProfileName);
     2434            pelmThis->setAttribute("id", n.strNetworkId);
     2435            pelmThis->setAttribute("enabled", (n.fEnabled) ? 1 : 0);        // too bad we chose 1 vs. 0 here
     2436        }
     2437    }
     2438#endif /* VBOX_WITH_CLOUD_NET */
    23642439
    23652440
    … …  
    28592934        && strBridgedName.isEmpty()
    28602935        && strInternalNetworkName.isEmpty()
     2936#ifdef VBOX_WITH_CLOUD_NET
     2937        && strCloudNetworkName.isEmpty()
     2938#endif /* VBOX_WITH_CLOUD_NET */
    28612939        && strHostOnlyName.isEmpty()
    28622940        && areGenericDriverDefaultSettings()
    … …  
    28722950        && (mode != NetworkAttachmentType_Bridged ? strBridgedName.isEmpty() : true)
    28732951        && (mode != NetworkAttachmentType_Internal ? strInternalNetworkName.isEmpty() : true)
     2952#ifdef VBOX_WITH_CLOUD_NET
     2953        && (mode != NetworkAttachmentType_Cloud ? strCloudNetworkName.isEmpty() : true)
     2954#endif /* VBOX_WITH_CLOUD_NET */
    28742955        && (mode != NetworkAttachmentType_HostOnly ? strHostOnlyName.isEmpty() : true)
    28752956        && (mode != NetworkAttachmentType_Generic ? areGenericDriverDefaultSettings() : true)
    … …  
    28992980            && strHostOnlyName       == n.strHostOnlyName
    29002981            && strInternalNetworkName == n.strInternalNetworkName
     2982#ifdef VBOX_WITH_CLOUD_NET
     2983            && strCloudNetworkName   == n.strCloudNetworkName
     2984#endif /* VBOX_WITH_CLOUD_NET */
    29012985            && strGenericDriver      == n.strGenericDriver
    29022986            && genericProperties     == n.genericProperties
    … …  
    39714055        nic.genericProperties["network"] = strVDEName;
    39724056    }
     4057#ifdef VBOX_WITH_CLOUD_NET
     4058    else if (elmMode.nameEquals("CloudNetwork"))
     4059    {
     4060        enmAttachmentType = NetworkAttachmentType_Cloud;
     4061
     4062        // optional network name, cannot be required or we have trouble with
     4063        // settings which are saved before configuring the network name
     4064        elmMode.getAttributeValue("name", nic.strCloudNetworkName);
     4065    }
     4066#endif /* VBOX_WITH_CLOUD_NET */
    39734067
    39744068    if (fEnabled && enmAttachmentType != NetworkAttachmentType_Null)
    … …  
    64496543                        if (nic.mode != NetworkAttachmentType_NATNetwork)
    64506544                            buildNetworkXML(NetworkAttachmentType_NATNetwork, false, *pelmDisabledNode, nic);
     6545#ifdef VBOX_WITH_CLOUD_NET
     6546                        // @todo Bump settings version!
     6547                        if (nic.mode != NetworkAttachmentType_Cloud)
     6548                            buildNetworkXML(NetworkAttachmentType_Cloud, false, *pelmDisabledNode, nic);
     6549#endif /* VBOX_WITH_CLOUD_NET */
    64516550                    }
    64526551                    buildNetworkXML(nic.mode, true, *pelmAdapter, nic);
    … …  
    69347033            }
    69357034            break;
     7035
     7036#ifdef VBOX_WITH_CLOUD_NET
     7037        case NetworkAttachmentType_Cloud:
     7038            // For the currently active network attachment type we have to
     7039            // generate the tag, otherwise the attachment type is lost.
     7040            if (fEnabled || !nic.strCloudNetworkName.isEmpty())
     7041            {
     7042                xml::ElementNode *pelmMode = elmParent.createChild("CloudNetwork");
     7043                if (!nic.strCloudNetworkName.isEmpty())
     7044                    pelmMode->setAttribute("name", nic.strCloudNetworkName);
     7045            }
     7046            break;
     7047#endif /* VBOX_WITH_CLOUD_NET */
    69367048
    69377049        default: /*case NetworkAttachmentType_Null:*/
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette