VirtualBox

Changeset 83169 in vbox


Ignore:
Timestamp:
Feb 27, 2020 9:28:41 AM (5 years ago)
Author:
vboxsync
Message:

OCI: (bugref:9469) cloud network integration multiple targets and configuration support (enabled in Config.kmk).

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Config.kmk

    r83118 r83169  
    807807VBOX_WITH_DHCPD = 1
    808808# Experimental suport for cloud network integration
    809 #VBOX_WITH_CLOUD_NET = 1
     809VBOX_WITH_CLOUD_NET = 1
    810810## @}
    811811

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

    r82968 r83169  
    3232        $(if $(VBOX_WITH_HOSTNETIF_API), VBOX_WITH_HOSTNETIF_API) \
    3333        $(if $(VBOX_WITH_NETFLT), VBOX_WITH_NETFLT) \
     34        $(if $(VBOX_WITH_CLOUD_NET), VBOX_WITH_CLOUD_NET) \
    3435        $(if $(VBOX_WITH_AUDIO_OSS), VBOX_WITH_AUDIO_OSS) \
    3536        $(if $(VBOX_WITH_AUDIO_ALSA), VBOX_WITH_AUDIO_ALSA) \

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageCloud.cpp

    r82968 r83169  
    15991599}
    16001600
     1601#ifdef VBOX_WITH_CLOUD_NET
     1602struct CloudNetworkOptions
     1603{
     1604    BOOL fEnable;
     1605    BOOL fDisable;
     1606    Bstr strNetworkId;
     1607    Bstr strNetworkName;
     1608};
     1609typedef struct CloudNetworkOptions CLOUDNETOPT;
     1610typedef CLOUDNETOPT *PCLOUDNETOPT;
     1611
     1612static RTEXITCODE createUpdateCloudNetworkCommon(ComPtr<ICloudNetwork> cloudNetwork, CLOUDNETOPT& options, PCLOUDCOMMONOPT pCommonOpts)
     1613{
     1614    HRESULT hrc = S_OK;
     1615
     1616    Bstr strProvider = pCommonOpts->provider.pszProviderName;
     1617    Bstr strProfile = pCommonOpts->profile.pszProfileName;
     1618
     1619    if (options.fEnable)
     1620        CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE);
     1621    if (options.fDisable)
     1622        CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE);
     1623    if (options.strNetworkId.isNotEmpty())
     1624        CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(NetworkId)(options.strNetworkId.raw()), RTEXITCODE_FAILURE);
     1625    if (strProvider.isNotEmpty())
     1626        CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Provider)(strProvider.raw()), RTEXITCODE_FAILURE);
     1627    if (strProfile.isNotEmpty())
     1628        CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Profile)(strProfile.raw()), RTEXITCODE_FAILURE);
     1629
     1630    return RTEXITCODE_SUCCESS;
     1631}
     1632
     1633
     1634static RTEXITCODE createCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
     1635{
     1636    HRESULT hrc = S_OK;
     1637    hrc = checkAndSetCommonOptions(a, pCommonOpts);
     1638    if (FAILED(hrc))
     1639        return RTEXITCODE_FAILURE;
     1640
     1641    /* Required parameters, the rest is handled in update */
     1642    static const RTGETOPTDEF s_aOptions[] =
     1643    {
     1644        { "--disable",        'd', RTGETOPT_REQ_NOTHING },
     1645        { "--enable",         'e', RTGETOPT_REQ_NOTHING },
     1646        { "--network-id",     'i', RTGETOPT_REQ_STRING },
     1647        { "--name",           'n', RTGETOPT_REQ_STRING },
     1648    };
     1649
     1650    RTGETOPTSTATE GetState;
     1651    RTGETOPTUNION ValueUnion;
     1652    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     1653    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     1654
     1655    CLOUDNETOPT options;
     1656    options.fEnable = FALSE;
     1657    options.fDisable = FALSE;
     1658
     1659    int c;
     1660    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
     1661    {
     1662        switch (c)
     1663        {
     1664            case 'd':
     1665                options.fDisable = TRUE;
     1666                break;
     1667            case 'e':
     1668                options.fEnable = TRUE;
     1669                break;
     1670            case 'i':
     1671                options.strNetworkId=ValueUnion.psz;
     1672                break;
     1673            case 'n':
     1674                options.strNetworkName=ValueUnion.psz;
     1675                break;
     1676            case VINF_GETOPT_NOT_OPTION:
     1677                return errorUnknownSubcommand(ValueUnion.psz);
     1678            default:
     1679                return errorGetOpt(c, &ValueUnion);
     1680        }
     1681    }
     1682
     1683    if (options.strNetworkName.isEmpty())
     1684        return errorArgument("Missing --name parameter");
     1685    if (options.strNetworkId.isEmpty())
     1686        return errorArgument("Missing --network-id parameter");
     1687
     1688    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
     1689
     1690    ComPtr<ICloudNetwork> cloudNetwork;
     1691    CHECK_ERROR2_RET(hrc, pVirtualBox,
     1692                     CreateCloudNetwork(options.strNetworkName.raw(), cloudNetwork.asOutParam()),
     1693                     RTEXITCODE_FAILURE);
     1694
     1695    /* Fill out the created network */
     1696    RTEXITCODE rc = createUpdateCloudNetworkCommon(cloudNetwork, options, pCommonOpts);
     1697    if (RT_SUCCESS(rc))
     1698        RTPrintf("Cloud network was created successfully\n");
     1699
     1700    return rc;
     1701}
     1702
     1703
     1704static RTEXITCODE showCloudNetworkInfo(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
     1705{
     1706    RT_NOREF(pCommonOpts);
     1707    HRESULT hrc = S_OK;
     1708    static const RTGETOPTDEF s_aOptions[] =
     1709    {
     1710        { "--name",           'n', RTGETOPT_REQ_STRING },
     1711    };
     1712    RTGETOPTSTATE GetState;
     1713    RTGETOPTUNION ValueUnion;
     1714    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     1715    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     1716
     1717    Bstr strNetworkName;
     1718
     1719    int c;
     1720    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
     1721    {
     1722        switch (c)
     1723        {
     1724            case 'n':
     1725                strNetworkName=ValueUnion.psz;
     1726                break;
     1727            case VINF_GETOPT_NOT_OPTION:
     1728                return errorUnknownSubcommand(ValueUnion.psz);
     1729            default:
     1730                return errorGetOpt(c, &ValueUnion);
     1731        }
     1732    }
     1733
     1734    if (strNetworkName.isEmpty())
     1735        return errorArgument("Missing --name parameter");
     1736
     1737    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
     1738    ComPtr<ICloudNetwork> cloudNetwork;
     1739    CHECK_ERROR2_RET(hrc, pVirtualBox,
     1740                     FindCloudNetworkByName(strNetworkName.raw(), cloudNetwork.asOutParam()),
     1741                     RTEXITCODE_FAILURE);
     1742
     1743    RTPrintf("Name:            %ls\n", strNetworkName.raw());
     1744    BOOL fEnabled = FALSE;
     1745    cloudNetwork->COMGETTER(Enabled)(&fEnabled);
     1746    RTPrintf("State:           %s\n", fEnabled ? "Enabled" : "Disabled");
     1747    Bstr Provider;
     1748    cloudNetwork->COMGETTER(Provider)(Provider.asOutParam());
     1749    RTPrintf("CloudProvider:   %ls\n", Provider.raw());
     1750    Bstr Profile;
     1751    cloudNetwork->COMGETTER(Profile)(Profile.asOutParam());
     1752    RTPrintf("CloudProfile:    %ls\n", Profile.raw());
     1753    Bstr NetworkId;
     1754    cloudNetwork->COMGETTER(NetworkId)(NetworkId.asOutParam());
     1755    RTPrintf("CloudNetworkId:  %ls\n", NetworkId.raw());
     1756    Bstr netName = BstrFmt("cloud-%ls", strNetworkName.raw());
     1757    RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
     1758
     1759    return RTEXITCODE_SUCCESS;
     1760}
     1761
     1762
     1763static RTEXITCODE updateCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
     1764{
     1765    HRESULT hrc = S_OK;
     1766
     1767    static const RTGETOPTDEF s_aOptions[] =
     1768    {
     1769        { "--disable",        'd', RTGETOPT_REQ_NOTHING },
     1770        { "--enable",         'e', RTGETOPT_REQ_NOTHING },
     1771        { "--network-id",     'i', RTGETOPT_REQ_STRING },
     1772        { "--name",           'n', RTGETOPT_REQ_STRING },
     1773    };
     1774
     1775    RTGETOPTSTATE GetState;
     1776    RTGETOPTUNION ValueUnion;
     1777    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     1778    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     1779
     1780    CLOUDNETOPT options;
     1781    options.fEnable = FALSE;
     1782    options.fDisable = FALSE;
     1783
     1784    int c;
     1785    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
     1786    {
     1787        switch (c)
     1788        {
     1789            case 'd':
     1790                options.fDisable = TRUE;
     1791                break;
     1792            case 'e':
     1793                options.fEnable = TRUE;
     1794                break;
     1795            case 'i':
     1796                options.strNetworkId=ValueUnion.psz;
     1797                break;
     1798            case 'n':
     1799                options.strNetworkName=ValueUnion.psz;
     1800                break;
     1801            case VINF_GETOPT_NOT_OPTION:
     1802                return errorUnknownSubcommand(ValueUnion.psz);
     1803            default:
     1804                return errorGetOpt(c, &ValueUnion);
     1805        }
     1806    }
     1807
     1808    if (options.strNetworkName.isEmpty())
     1809        return errorArgument("Missing --name parameter");
     1810
     1811    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
     1812    ComPtr<ICloudNetwork> cloudNetwork;
     1813    CHECK_ERROR2_RET(hrc, pVirtualBox,
     1814                     FindCloudNetworkByName(options.strNetworkName.raw(), cloudNetwork.asOutParam()),
     1815                     RTEXITCODE_FAILURE);
     1816
     1817    RTEXITCODE rc = createUpdateCloudNetworkCommon(cloudNetwork, options, pCommonOpts);
     1818    if (RT_SUCCESS(rc))
     1819        RTPrintf("Cloud network %ls was updated successfully\n", options.strNetworkName.raw());
     1820
     1821    return rc;
     1822}
     1823
     1824
     1825static RTEXITCODE deleteCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
     1826{
     1827    RT_NOREF(pCommonOpts);
     1828    HRESULT hrc = S_OK;
     1829    static const RTGETOPTDEF s_aOptions[] =
     1830    {
     1831        { "--name",           'n', RTGETOPT_REQ_STRING },
     1832    };
     1833    RTGETOPTSTATE GetState;
     1834    RTGETOPTUNION ValueUnion;
     1835    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     1836    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     1837
     1838    Bstr strNetworkName;
     1839
     1840    int c;
     1841    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
     1842    {
     1843        switch (c)
     1844        {
     1845            case 'n':
     1846                strNetworkName=ValueUnion.psz;
     1847                break;
     1848            case VINF_GETOPT_NOT_OPTION:
     1849                return errorUnknownSubcommand(ValueUnion.psz);
     1850            default:
     1851                return errorGetOpt(c, &ValueUnion);
     1852        }
     1853    }
     1854
     1855    if (strNetworkName.isEmpty())
     1856        return errorArgument("Missing --name parameter");
     1857
     1858    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
     1859    ComPtr<ICloudNetwork> cloudNetwork;
     1860    CHECK_ERROR2_RET(hrc, pVirtualBox,
     1861                     FindCloudNetworkByName(strNetworkName.raw(), cloudNetwork.asOutParam()),
     1862                     RTEXITCODE_FAILURE);
     1863
     1864    CHECK_ERROR2_RET(hrc, pVirtualBox,
     1865                     RemoveCloudNetwork(cloudNetwork),
     1866                     RTEXITCODE_FAILURE);
     1867
     1868    if (SUCCEEDED(hrc))
     1869        RTPrintf("Cloud network %ls was deleted successfully\n", strNetworkName.raw());
     1870
     1871    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
     1872}
     1873
     1874
     1875static RTEXITCODE handleCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
     1876{
     1877    if (a->argc < 1)
     1878        return errorNoSubcommand();
     1879
     1880    static const RTGETOPTDEF s_aOptions[] =
     1881    {
     1882        { "create",         1000, RTGETOPT_REQ_NOTHING },
     1883        { "info",           1001, RTGETOPT_REQ_NOTHING },
     1884        { "update",         1002, RTGETOPT_REQ_NOTHING },
     1885        { "delete",         1003, RTGETOPT_REQ_NOTHING }
     1886    };
     1887
     1888    RTGETOPTSTATE GetState;
     1889    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
     1890    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     1891
     1892    int c;
     1893    RTGETOPTUNION ValueUnion;
     1894    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
     1895    {
     1896        switch (c)
     1897        {
     1898            /* Sub-commands: */
     1899            case 1000:
     1900                return createCloudNetwork(a, GetState.iNext, pCommonOpts);
     1901            case 1001:
     1902                return showCloudNetworkInfo(a, GetState.iNext, pCommonOpts);
     1903            case 1002:
     1904                return updateCloudNetwork(a, GetState.iNext, pCommonOpts);
     1905            case 1003:
     1906                return deleteCloudNetwork(a, GetState.iNext, pCommonOpts);
     1907            case VINF_GETOPT_NOT_OPTION:
     1908                return errorUnknownSubcommand(ValueUnion.psz);
     1909
     1910            default:
     1911                return errorGetOpt(c, &ValueUnion);
     1912        }
     1913    }
     1914
     1915    return errorNoSubcommand();
     1916}
     1917#endif /* VBOX_WITH_CLOUD_NET */
     1918
     1919
    16011920RTEXITCODE handleCloud(HandlerArg *a)
    16021921{
    … …  
    16411960            case 1002:
    16421961                return handleCloudInstance(a, GetState.iNext, &commonOpts);
     1962#ifdef VBOX_WITH_CLOUD_NET
     1963            case 1003:
     1964                return handleCloudNetwork(a, GetState.iNext, &commonOpts);
     1965#endif /* VBOX_WITH_CLOUD_NET */
    16431966            case VINF_GETOPT_NOT_OPTION:
    16441967                return errorUnknownSubcommand(ValueUnion.psz);

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

    r82968 r83169  
    193193    return rc;
    194194}
     195
     196
     197#ifdef VBOX_WITH_CLOUD_NET
     198/**
     199 * List configured cloud network attachments.
     200 *
     201 * @returns See produceList.
     202 * @param   pVirtualBox         Reference to the IVirtualBox smart pointer.
     203 * @param   Reserved            Placeholder!
     204 */
     205static HRESULT listCloudNetworks(const ComPtr<IVirtualBox> pVirtualBox)
     206{
     207    HRESULT rc;
     208    com::SafeIfaceArray<ICloudNetwork> cloudNetworks;
     209    CHECK_ERROR(pVirtualBox, COMGETTER(CloudNetworks)(ComSafeArrayAsOutParam(cloudNetworks)));
     210    for (size_t i = 0; i < cloudNetworks.size(); ++i)
     211    {
     212        ComPtr<ICloudNetwork> cloudNetwork = cloudNetworks[i];
     213        Bstr networkName;
     214        cloudNetwork->COMGETTER(NetworkName)(networkName.asOutParam());
     215        RTPrintf("Name:            %ls\n", networkName.raw());
     216        // Guid interfaceGuid;
     217        // cloudNetwork->COMGETTER(Id)(interfaceGuid.asOutParam());
     218        // RTPrintf("GUID:        %ls\n\n", Bstr(interfaceGuid.toString()).raw());
     219        BOOL fEnabled = FALSE;
     220        cloudNetwork->COMGETTER(Enabled)(&fEnabled);
     221        RTPrintf("State:           %s\n", fEnabled ? "Enabled" : "Disabled");
     222
     223        Bstr Provider;
     224        cloudNetwork->COMGETTER(Provider)(Provider.asOutParam());
     225        RTPrintf("CloudProvider:   %ls\n", Provider.raw());
     226        Bstr Profile;
     227        cloudNetwork->COMGETTER(Profile)(Profile.asOutParam());
     228        RTPrintf("CloudProfile:    %ls\n", Profile.raw());
     229        Bstr NetworkId;
     230        cloudNetwork->COMGETTER(NetworkId)(NetworkId.asOutParam());
     231        RTPrintf("CloudNetworkId:  %ls\n", NetworkId.raw());
     232        Bstr netName = BstrFmt("cloud-%ls", networkName.raw());
     233        RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
     234    }
     235    return rc;
     236}
     237#endif /* VBOX_WITH_CLOUD_NET */
    195238
    196239
    … …  
    12691312    kListHostOnlyInterfaces,
    12701313#endif
     1314#if defined(VBOX_WITH_CLOUD_NET)
     1315    kListCloudNetworks,
     1316#endif
    12711317    kListHostCpuIDs,
    12721318    kListHostInfo,
    … …  
    14761522            break;
    14771523
     1524#if defined(VBOX_WITH_CLOUD_NET)
     1525        case kListCloudNetworks:
     1526            rc = listCloudNetworks(pVirtualBox);
     1527            break;
     1528#endif
    14781529        case kListHostInfo:
    14791530            rc = listHostInfo(pVirtualBox);
    … …  
    16691720        { "hostonlyifs",        kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
    16701721#endif
     1722#if defined(VBOX_WITH_CLOUD_NET)
     1723        { "cloudnets",          kListCloudNetworks,      RTGETOPT_REQ_NOTHING },
     1724#endif
    16711725        { "natnetworks",        kListNatNetworks,        RTGETOPT_REQ_NOTHING },
    16721726        { "natnets",            kListNatNetworks,        RTGETOPT_REQ_NOTHING },
    … …  
    17221776#if defined(VBOX_WITH_NETFLT)
    17231777            case kListHostOnlyInterfaces:
     1778#endif
     1779#if defined(VBOX_WITH_CLOUD_NET)
     1780            case kListCloudNetworks:
    17241781#endif
    17251782            case kListHostInfo:

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

    r82969 r83169  
    2667126671             uuid="89a63ace-0c65-11ea-ad23-0ff257c71a7f"
    2667226672             wsmap="managed"
    26673              reservedAttributes="8">
     26673             reservedAttributes="5">
    2667426674    <attribute name="publicIP" type="wstring" readonly="yes"/>
     26675    <attribute name="secondaryPublicIP" type="wstring" readonly="yes"/>
     26676    <attribute name="macAddress" type="wstring" readonly="yes"/>
     26677    <attribute name="instanceId" type="wstring" readonly="yes"/>
    2667526678  </interface>
    2667626679

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

    r82968 r83169  
    768768HRESULT i_connectToCloudNetwork(ProgressProxy *aProgress);
    769769HRESULT i_disconnectFromCloudNetwork();
     770HRESULT i_setMacAddress(int slot, const Utf8Str& strMac);
    770771#endif /* VBOX_WITH_CLOUD_NET */
    771772

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

    r82968 r83169  
    211211    HRESULT i_findCloudNetworkByName(const com::Utf8Str &aNetworkName,
    212212                                     ComObjPtr<CloudNetwork> *aNetwork = NULL);
     213    HRESULT i_getEventSource(ComPtr<IEventSource>& aSource);
    213214#endif /* VBOX_WITH_CLOUD_NET */
    214215

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

    r82968 r83169  
    73107310
    73117311#ifdef VBOX_WITH_CLOUD_NET
     7312HRESULT Machine::i_setMacAddress(int slot, const Utf8Str& strMac)
     7313{
     7314    Bstr macAddress = strMac;
     7315    ComPtr<ISession> session;
     7316    HRESULT hrc = session.createInprocObject(CLSID_Session);
     7317    if (FAILED(hrc))
     7318        LogRel(("OCI-NET: Failed to create a session. hrc=%x\n", hrc));
     7319
     7320    hrc = lockMachine(session, LockType_Write);
     7321    if (FAILED(hrc))
     7322    {
     7323        LogRel(("OCI-NET: Failed to lock target VM for modifications. hrc=%x\n", hrc));
     7324        return hrc;
     7325    }
     7326
     7327    ComPtr<IMachine> sessionMachine;
     7328    hrc = session->COMGETTER(Machine)(sessionMachine.asOutParam());
     7329    if (FAILED(hrc))
     7330    {
     7331        LogRel(("OCI-NET: Failed to obtain a mutable machine. hrc=%x\n", hrc));
     7332        return hrc;
     7333    }
     7334
     7335    ComPtr<INetworkAdapter> networkAdapter;
     7336    hrc = sessionMachine->GetNetworkAdapter(slot, networkAdapter.asOutParam());
     7337    if (FAILED(hrc))
     7338    {
     7339        LogRel(("OCI-NET: Failed to locate the second network adapter. hrc=%x\n", hrc));
     7340        return hrc;
     7341    }
     7342
     7343    hrc = networkAdapter->COMSETTER(MACAddress)(macAddress.raw());
     7344    if (FAILED(hrc))
     7345    {
     7346        LogRel(("OCI-NET: Failed to set network name for the second network adapter. hrc=%x\n", hrc));
     7347        return hrc;
     7348    }
     7349
     7350    hrc = sessionMachine->SaveSettings();
     7351    if (FAILED(hrc))
     7352        LogRel(("OCI-NET: Failed to save 'lgw' settings. hrc=%x\n", hrc));
     7353
     7354    session->UnlockMachine();
     7355
     7356    return hrc;
     7357}
     7358
     7359
    73127360HRESULT Machine::i_connectToCloudNetwork(ProgressProxy *aProgress)
    73137361{
    … …  
    73177365    HRESULT hrc = E_FAIL;
    73187366    Bstr name;
     7367    ULONG iSlot = ULONG_MAX;
    73197368
    73207369    LogFlowThisFunc(("Checking if cloud network needs to be connected\n"));
    … …  
    73347383            if (name.isNotEmpty())
    73357384            {
    7336                 LogRel(("VM '%s' uses multiple cloud network attachments. '%ls' will be ignored.\n",
     7385                LogRel(("OCI-NET: VM '%s' uses multiple cloud network attachments. '%ls' will be ignored.\n",
    73377386                        mUserData->s.strName.c_str(), name.raw()));
    73387387                continue;
    … …  
    73417390            if (SUCCEEDED(hrc))
    73427391            {
    7343                 LogRel(("VM '%s' uses cloud network '%ls'\n",
     7392                LogRel(("OCI-NET: VM '%s' uses cloud network '%ls'\n",
    73447393                        mUserData->s.strName.c_str(), name.raw()));
     7394                iSlot = slot;
    73457395            }
    73467396        }
    … …  
    73537403        if (FAILED(hrc))
    73547404        {
    7355             LogRel(("Could not find cloud network '%ls'.\n", name.raw()));
     7405            LogRel(("OCI-NET: Could not find cloud network '%ls'.\n", name.raw()));
    73567406            return hrc;
    73577407        }
     7408        Bstr MacAddress;
     7409        Utf8Str strMacAddress;
    73587410        GatewayInfo gateways;
     7411        gateways.mTargetVM = mUserData->s.strName;
     7412        gateways.mAdapterSlot = iSlot;
     7413        hrc = mNetworkAdapters[iSlot]->COMGETTER(MACAddress)(MacAddress.asOutParam());
     7414        if (FAILED(hrc))
     7415        {
     7416            Host::i_generateMACAddress(strMacAddress);
     7417            LogRel(("OCI-NET: Failed to get MAC address of adapter connected to cloud network '%ls'.\n"
     7418                    "OCI-NET: Will use auto-generated '%s'.\n", name.raw(), strMacAddress.c_str()));
     7419        }
     7420        else
     7421            strMacAddress = MacAddress;
     7422        hrc = gateways.setLocalMacAddress(strMacAddress);
     7423        if (FAILED(hrc))
     7424        {
     7425            LogRel(("OCI-NET: Failed to obtain valid MAC address (%s) from cloud gateway '%ls'.\n",
     7426                    strMacAddress, name.raw()));
     7427            return hrc;
     7428        }
    73597429        hrc = startGateways(mParent, network, gateways);
     7430        /* We copy gateways structure unconditionally in order to be able to undo partially failed gateway setup. */
     7431        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
     7432        mData->mGatewayInfo = gateways;
     7433        alock.release();
    73607434        if (SUCCEEDED(hrc))
    73617435        {
    7362             AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    7363             mData->mGatewayInfo = gateways;
     7436            if (iSlot == ULONG_MAX)
     7437                LogRel(("OCI-NET: No slot information available for cloud network attachment!\n"));
     7438            else
     7439            {
     7440                hrc = i_setMacAddress(iSlot, gateways.getCloudMacAddressWithoutColons());
     7441                if (SUCCEEDED(hrc))
     7442                    LogRel(("OCI-NET: Updated MAC address for '%s' to %RTmac\n",
     7443                            mUserData->s.strName.c_str(), &gateways.mCloudMacAddress));
     7444                else
     7445                    LogRel(("OCI-NET: Failed to update MAC address for '%s' to %RTmac\n",
     7446                            mUserData->s.strName.c_str(), &gateways.mCloudMacAddress));
     7447            }
    73647448        }
    73657449    }
    … …  
    73797463
    73807464    HRESULT hrc = stopGateways(mParent, gateways);
     7465    // @todo Restore original MAC address. I'd hate to wait here for Machine to power off though.
     7466    // i_setMacAddress(gateways.mAdapterSlot, gateways.getLocalMacAddressWithoutColons());
    73817467    return hrc;
    73827468}

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

    r82968 r83169  
    15071507                                             ComObjPtr<CloudNetwork> *aNetwork)
    15081508{
    1509     HRESULT rc = E_FAIL;
     1509    HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
    15101510    ComPtr<CloudNetwork> found;
    15111511    Bstr bstrNameToFind(aNetworkName);
    … …  
    15181518    {
    15191519        Bstr bstrCloudNetworkName;
    1520         rc = (*it)->COMGETTER(NetworkName)(bstrCloudNetworkName.asOutParam());
    1521         if (FAILED(rc)) return rc;
     1520        HRESULT hrc = (*it)->COMGETTER(NetworkName)(bstrCloudNetworkName.asOutParam());
     1521        if (FAILED(hrc)) return hrc;
    15221522
    15231523        if (bstrCloudNetworkName == bstrNameToFind)
    … …  
    16171617#endif /* !VBOX_WITH_CLOUD_NET */
    16181618}
     1619
     1620#ifdef VBOX_WITH_CLOUD_NET
     1621HRESULT VirtualBox::i_getEventSource(ComPtr<IEventSource>& aSource)
     1622{
     1623    m->pEventSource.queryInterfaceTo(aSource.asOutParam());
     1624    return S_OK;
     1625}
     1626#endif /* VBOX_WITH_CLOUD_NET */
    16191627
    16201628HRESULT VirtualBox::getCloudProviderManager(ComPtr<ICloudProviderManager> &aCloudProviderManager)
Note: See TracChangeset for help on using the changeset viewer.

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