VirtualBox

Ignore:
Timestamp:
Sep 30, 2019 6:33:56 PM (5 years ago)
Author:
vboxsync
Message:

bugref:9555. Fixed error: enumeration value 'VirtualSystemDescriptionType_CloudBootVolumeId' not handled in switch.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r81085 r81086  
    4444#include <VBox/param.h>
    4545
    46 
    47 #ifndef VBOX_WITH_PROTOBUF
    48 #define VBOX_WITH_PROTOBUF
    49 #endif
    50 
    51 #ifdef VBOX_WITH_PROTOBUF
    52 #include <google/protobuf/util/json_util.h>
    53 #include <google/protobuf/text_format.h>
    54 #include <VBox/vsd.pb.h>
    55 #include <fstream>
    56 using namespace std;
    57 using namespace google::protobuf;
    58 #endif
    59 
    6046#include "VBoxManage.h"
    6147using namespace com;
     48
    6249
    6350// funcs
    … …  
    313300                break;
    314301
    315                 /*--cloud and --vsys are mutually exclusive, only one must be presented*/
     302                /*--cloud and --vsys are orthogonal, only one must be presented*/
    316303            case 'j':   // --cloud
    317304                if (fCloud == false && actionType == NOT_SET)
    … …  
    15081495         */
    15091496
    1510 #ifdef VBOX_WITH_PROTOBUF
    1511         std::map< ComPtr<IVirtualSystemDescription>, vsd::InstanceDescription > VSDToInstanceDescriptionMap;
    1512 #else
    15131497        /* VSDList is needed for the second stage where we launch the cloud instances if it was requested by user */
    15141498        std::list< ComPtr<IVirtualSystemDescription> > VSDList;
    1515 #endif
    1516 
    15171499        std::list< ComPtr<IMachine> >::iterator itM;
    15181500        uint32_t i=0;
    … …  
    15251507            CHECK_ERROR_BREAK(pMachine, ExportTo(pAppliance, Bstr(pszAbsFilePath).raw(), pVSD.asOutParam()));
    15261508
    1527 #ifdef VBOX_WITH_PROTOBUF
    1528             vsd::InstanceDescription protobufInstDesc;
    1529             RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
    1530             Bstr bstrDesc;
    1531             CHECK_ERROR_BREAK(pVSD, GetVSDDescription(bstrDesc.asOutParam()));
    1532             Utf8Str strHumanReadableFormVSD(bstrDesc);
    1533             {
    1534                 bool st = google::protobuf::TextFormat::ParseFromString(strHumanReadableFormVSD.c_str(), &protobufInstDesc);
    1535                 if (st)
    1536                 {
    1537                     RTPrintf("message protobufInstDesc was parsed.\n");
    1538                     string strJson;
    1539                     google::protobuf::util::Status  status = google::protobuf::util::MessageToJsonString(protobufInstDesc, &strJson);
    1540                     RTPrintf("\nvsd::InstanceDescription:\n%s\n##################\n", strJson.c_str());
    1541                 }
    1542             }
    1543 
    1544             vsd::InstanceDescription protobufUserInstDesc;
    1545 #endif
    1546 
    15471509            // Add additional info to the virtual system description if the user wants so
    15481510            ArgsMap *pmapArgs = NULL;
    … …  
    15521514            if (pmapArgs)
    15531515            {
    1554 
    1555 #ifdef VBOX_WITH_PROTOBUF
    1556                 vsd::InstanceDescription_CloudSettings* pInstCloudSettings = NULL;
    1557                 if (actionType == CLOUD)
    1558                 {
    1559                     pInstCloudSettings = protobufUserInstDesc.mutable_cloud();
    1560                     pInstCloudSettings->set_providershortname(strOutputFile.substr(0, strOutputFile.find("://")).c_str());
    1561                 }
    1562 #endif
    1563 
    15641516                ArgsMap::iterator itD;
    15651517                for (itD = pmapArgs->begin();
    … …  
    15711523                        //remove default value if user has specified new name (default value is set in the ExportTo())
    15721524//                      pVSD->RemoveDescriptionByType(VirtualSystemDescriptionType_Name);
    1573 #ifndef VBOX_WITH_PROTOBUF
    15741525                        pVSD->AddDescription(VirtualSystemDescriptionType_Name,
    15751526                                             Bstr(itD->second).raw(),
    15761527                                             Bstr(itD->second).raw());
    1577 #else
    1578                         protobufUserInstDesc.set_name(itD->second.c_str());
    1579 #endif
    15801528                    }
    15811529                    else if (itD->first == "product")
    1582                     {
    1583 #ifndef VBOX_WITH_PROTOBUF
    15841530                        pVSD->AddDescription(VirtualSystemDescriptionType_Product,
    15851531                                             Bstr(itD->second).raw(),
    15861532                                             Bstr(itD->second).raw());
    1587 #else
    1588                         protobufUserInstDesc.set_product(itD->second.c_str());
    1589 #endif
    1590                     }
    15911533                    else if (itD->first == "producturl")
    1592                     {
    1593 #ifndef VBOX_WITH_PROTOBUF
    15941534                        pVSD->AddDescription(VirtualSystemDescriptionType_ProductUrl,
    15951535                                             Bstr(itD->second).raw(),
    15961536                                             Bstr(itD->second).raw());
    1597 #else
    1598                         protobufUserInstDesc.set_producturl(itD->second.c_str());
    1599 #endif
    1600                     }
    16011537                    else if (itD->first == "vendor")
    1602                     {
    1603 #ifndef VBOX_WITH_PROTOBUF
    16041538                        pVSD->AddDescription(VirtualSystemDescriptionType_Vendor,
    16051539                                             Bstr(itD->second).raw(),
    16061540                                             Bstr(itD->second).raw());
    1607 #else
    1608                         protobufUserInstDesc.set_vendor(itD->second.c_str());
    1609 #endif
    1610                     }
    16111541                    else if (itD->first == "vendorurl")
    1612                     {
    1613 #ifndef VBOX_WITH_PROTOBUF
    16141542                        pVSD->AddDescription(VirtualSystemDescriptionType_VendorUrl,
    16151543                                             Bstr(itD->second).raw(),
    16161544                                             Bstr(itD->second).raw());
    1617 #else
    1618                         protobufUserInstDesc.set_vendorurl(itD->second.c_str());
    1619 #endif
    1620                     }
    16211545                    else if (itD->first == "version")
    1622                     {
    1623 #ifndef VBOX_WITH_PROTOBUF
    16241546                        pVSD->AddDescription(VirtualSystemDescriptionType_Version,
    16251547                                             Bstr(itD->second).raw(),
    16261548                                             Bstr(itD->second).raw());
    1627 #else
    1628                         protobufUserInstDesc.set_version(itD->second.c_str());
    1629 #endif
    1630                     }
    16311549                    else if (itD->first == "description")
    1632                     {
    1633 #ifndef VBOX_WITH_PROTOBUF
    16341550                        pVSD->AddDescription(VirtualSystemDescriptionType_Description,
    16351551                                             Bstr(itD->second).raw(),
    16361552                                             Bstr(itD->second).raw());
    1637 #else
    1638                         protobufUserInstDesc.set_description(itD->second.c_str());
    1639 #endif
    1640                     }
    16411553                    else if (itD->first == "eula")
    1642                     {
    16431554                        pVSD->AddDescription(VirtualSystemDescriptionType_License,
    16441555                                             Bstr(itD->second).raw(),
    16451556                                             Bstr(itD->second).raw());
    1646                     }
    16471557                    else if (itD->first == "eulafile")
    16481558                    {
    … …  
    16681578                    /* add cloud export settings */
    16691579                    else if (itD->first == "cloudshape")
    1670                     {
    1671 #ifndef VBOX_WITH_PROTOBUF
    16721580                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudInstanceShape,
    16731581                                             Bstr(itD->second).raw(),
    16741582                                             Bstr(itD->second).raw());
    1675 #else
    1676                         pInstCloudSettings->set_instanceshape(itD->second.c_str());
    1677 #endif
    1678                     }
    16791583                    else if (itD->first == "clouddomain")
    1680                     {
    1681 #ifndef VBOX_WITH_PROTOBUF
    16821584                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudDomain,
    16831585                                             Bstr(itD->second).raw(),
    16841586                                             Bstr(itD->second).raw());
    1685 #else
    1686                         pInstCloudSettings->set_domain(itD->second.c_str());
    1687 #endif
    1688                     }
    16891587                    else if (itD->first == "clouddisksize")
    1690                     {
    1691 #ifndef VBOX_WITH_PROTOBUF
    16921588                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudBootDiskSize,
    16931589                                             Bstr(itD->second).raw(),
    16941590                                             Bstr(itD->second).raw());
    1695 #else
    1696                         pInstCloudSettings->set_bootdisksize(itD->second.toUInt64());
    1697 #endif
    1698                     }
    16991591                    else if (itD->first == "cloudbucket")
    1700                     {
    1701 #ifndef VBOX_WITH_PROTOBUF
    17021592                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudBucket,
    17031593                                             Bstr(itD->second).raw(),
    17041594                                             Bstr(itD->second).raw());
    1705 #else
    1706                         pInstCloudSettings->set_bucket(itD->second.c_str());
    1707 #endif
    1708                     }
    17091595                    else if (itD->first == "cloudocivcn")
    1710                     {
    1711 #ifndef VBOX_WITH_PROTOBUF
    17121596                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudOCIVCN,
    17131597                                             Bstr(itD->second).raw(),
    17141598                                             Bstr(itD->second).raw());
    1715 #else
    1716                         pInstCloudSettings->set_vcn(itD->second.c_str());
    1717 #endif
    1718                     }
    17191599                    else if (itD->first == "cloudpublicip")
    1720                     {
    1721 #ifndef VBOX_WITH_PROTOBUF
    17221600                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudPublicIP,
    17231601                                             Bstr(itD->second).raw(),
    17241602                                             Bstr(itD->second).raw());
    1725 #else
    1726                         pInstCloudSettings->set_fpublicip(itD->second.equals("true") ? true:false);
    1727 #endif
    1728                     }
    17291603                    else if (itD->first == "cloudprivateip")
    1730                     {
    1731 #ifndef VBOX_WITH_PROTOBUF
    17321604                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudPrivateIP,
    17331605                                             Bstr(itD->second).raw(), NULL);
    1734 #else
    1735 //                      pInstCloudSettings.set_fpublicip(itD->second.equals("true") ? true:false);
    1736 #endif
    1737                     }
    17381606                    else if (itD->first == "cloudprofile")
    1739                     {
    1740 #ifndef VBOX_WITH_PROTOBUF
    17411607                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudProfileName,
    17421608                                             Bstr(itD->second).raw(),
    17431609                                             Bstr(itD->second).raw());
    1744 #else
    1745                         pInstCloudSettings->set_profilename(itD->second.c_str());
    1746 #endif
    1747                     }
    17481610                    else if (itD->first == "cloudocisubnet")
    1749                     {
    1750 #ifndef VBOX_WITH_PROTOBUF
    17511611                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudOCISubnet,
    17521612                                             Bstr(itD->second).raw(),
    17531613                                             Bstr(itD->second).raw());
    1754 #else
    1755                         pInstCloudSettings->set_subnet(itD->second.c_str());
    1756 #endif
    1757                     }
    17581614                    else if (itD->first == "cloudkeepobject")
    1759                     {
    1760 #ifndef VBOX_WITH_PROTOBUF
    17611615                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudKeepObject,
    17621616                                             Bstr(itD->second).raw(),
    17631617                                             Bstr(itD->second).raw());
    1764 #else
    1765                         pInstCloudSettings->set_fkeepobject(itD->second.equals("true") ? true:false);
    1766 #endif
    1767                     }
    17681618                    else if (itD->first == "cloudlaunchmode")
    1769                     {
    1770 #ifndef VBOX_WITH_PROTOBUF
    17711619                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudOCILaunchMode,
    17721620                                             Bstr(itD->second).raw(), NULL);
    1773 #else
    1774 //                      pInstCloudSettings.set_launch_mode(itD->second.c_str());
    1775 #endif
    1776                     }
    17771621                    else if (itD->first == "cloudlaunchinstance")
    1778                     {
    1779 #ifndef VBOX_WITH_PROTOBUF
    17801622                        pVSD->AddDescription(VirtualSystemDescriptionType_CloudLaunchInstance,
    17811623                                             Bstr(itD->second).raw(),
    17821624                                             Bstr(itD->second).raw());
    1783 #else
    1784                         pInstCloudSettings->set_flaunchinstance(itD->second.equals("true") ? true:false);
    1785 #endif
    1786                     }
    17871625                }
    17881626            }
    17891627
    1790 #ifndef VBOX_WITH_PROTOBUF
    17911628            VSDList.push_back(pVSD);//store vsd for the possible second stage
    1792 #else
    1793             protobufInstDesc.MergeFrom(protobufUserInstDesc);
    1794             VSDToInstanceDescriptionMap.insert(make_pair(pVSD,protobufInstDesc));
    1795 
    1796             {
    1797                 int messageSize = protobufUserInstDesc.ByteSizeLong();
    1798                 RTPrintf("messageSize of protobufUserInstDesc is %d\n", messageSize);
    1799                 string output;
    1800                 bool st = google::protobuf::TextFormat::PrintToString(protobufUserInstDesc, &output);
    1801                 if (st)
    1802                 {
    1803                     RTPrintf("message protobufUserInstDesc is %s\n", output.c_str());
    1804                     Bstr updatedVersion(output.c_str());
    1805                     CHECK_ERROR_BREAK(pVSD, UpdateVSDDescription(updatedVersion.raw()));
    1806                 }
    1807             }
    1808 
    1809             {
    1810                 int messageSize = protobufInstDesc.ByteSizeLong();
    1811                 string output;
    1812                 RTPrintf("messageSize of protobufInstDesc is %d\n", messageSize);
    1813                 bool st = google::protobuf::TextFormat::PrintToString(protobufInstDesc, &output);
    1814                 if (st)
    1815                     RTPrintf("message protobufInstDesc is %s\n", output.c_str());
    1816             }
    1817 #endif
    1818 
    18191629        }
    18201630
    … …  
    18771687        {
    18781688            /* Launch the exported VM if the appropriate flag had been set on the first stage */
    1879 
    1880 #ifndef VBOX_WITH_PROTOBUF
    18811689            for (std::list< ComPtr<IVirtualSystemDescription> >::iterator itVSD = VSDList.begin();
    18821690                 itVSD != VSDList.end();
    … …  
    18841692            {
    18851693                ComPtr<IVirtualSystemDescription> pVSD = *itVSD;
     1694
    18861695                com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
    18871696                com::SafeArray<BSTR> aRefs;
    … …  
    19011710
    19021711                if (flagCloudLaunchInstance.equals("true"))
    1903 #else
    1904             for (std::map< ComPtr<IVirtualSystemDescription>, vsd::InstanceDescription >::iterator itIDL = VSDToInstanceDescriptionMap.begin();
    1905                  itIDL != VSDToInstanceDescriptionMap.end();
    1906                  ++itIDL)
    1907             {
    1908                 ComPtr<IVirtualSystemDescription> pVSD = itIDL->first;
    1909                 vsd::InstanceDescription protobufInstDesc = itIDL->second;
    1910                 vsd::InstanceDescription_CloudSettings* pInstCloudSettings = protobufInstDesc.mutable_cloud();
    1911                 bool boolflagCloudLaunchInstance = pInstCloudSettings->flaunchinstance();
    1912 
    1913                 if (boolflagCloudLaunchInstance)
    1914 #endif
    19151712                {
    19161713                    /* Getting the short provider name */
    … …  
    19251722                                     GetProviderByShortName(bstrCloudProviderShortName.raw(), pCloudProvider.asOutParam()));
    19261723
    1927 #ifndef VBOX_WITH_PROTOBUF
    19281724                    CHECK_ERROR_BREAK(pVSD, GetDescriptionByType(VirtualSystemDescriptionType_CloudProfileName,
    19291725                                             ComSafeArrayAsOutParam(retTypes),
    … …  
    19321728                                             ComSafeArrayAsOutParam(aVBoxValues),
    19331729                                             ComSafeArrayAsOutParam(aExtraConfigValues)));
     1730
    19341731                    ComPtr<ICloudProfile> pCloudProfile;
    19351732                    CHECK_ERROR_BREAK(pCloudProvider, GetProfileByName(Bstr(aVBoxValues[0]).raw(), pCloudProfile.asOutParam()));
    19361733                    retTypes.setNull(); aRefs.setNull(); aOvfValues.setNull(); aVBoxValues.setNull(); aExtraConfigValues.setNull();
    1937 #else
    1938                     Utf8Str profilename(pInstCloudSettings->profilename().c_str());
    1939                     ComPtr<ICloudProfile> pCloudProfile;
    1940                     CHECK_ERROR_BREAK(pCloudProvider, GetProfileByName(Bstr(profilename).raw(), pCloudProfile.asOutParam()));
    1941 #endif
    19421734
    19431735                    ComObjPtr<ICloudClient> oCloudClient;
    … …  
    19521744                    if (SUCCEEDED(rc))
    19531745                    {
    1954 #ifndef VBOX_WITH_PROTOBUF
    19551746                        CHECK_ERROR_BREAK(pVSD, GetDescriptionByType(VirtualSystemDescriptionType_CloudInstanceId,
    19561747                                                 ComSafeArrayAsOutParam(retTypes),
    … …  
    19641755                                 Utf8Str(bstrCloudProviderShortName.raw()).c_str());
    19651756                        retTypes.setNull(); aRefs.setNull(); aOvfValues.setNull(); aVBoxValues.setNull(); aExtraConfigValues.setNull();
    1966 #else
    1967                         Bstr bstrDesc;
    1968                         CHECK_ERROR_BREAK(pVSD, GetVSDDescription(bstrDesc.asOutParam()));
    1969                         Utf8Str strHumanReadableFormVSD(bstrDesc);
    1970                         vsd::InstanceDescription protobufInstDescWithInstanceId;
    1971                         bool st = google::protobuf::TextFormat::ParseFromString(strHumanReadableFormVSD.c_str(), &protobufInstDescWithInstanceId);
    1972                         if (st)
    1973                         {
    1974                             RTPrintf("message protobufInstDescWithInstanceId was parsed.\n");
    1975                             string strJson;
    1976                             google::protobuf::util::Status  status = google::protobuf::util::MessageToJsonString(protobufInstDescWithInstanceId, &strJson);
    1977                             RTPrintf("\nvsd::InstanceDescription:\n%s\n##################\n", strJson.c_str());
    1978                         }
    1979 
    1980                         vsd::InstanceDescription_CloudSettings* pInstCloudSettingsWithInstanceId = protobufInstDescWithInstanceId.mutable_cloud();
    1981                         Utf8Str instanceId(pInstCloudSettingsWithInstanceId->instanceid().c_str());
    1982                         RTPrintf("A cloud instance with id '%' (provider '%s') was started\n",
    1983                                  instanceId.c_str(),
    1984                                  /* Utf8Str(Bstr(aVBoxValues[0]).raw()).c_str(),*/
    1985                                  Utf8Str(bstrCloudProviderShortName.raw()).c_str());
    1986 #endif
    19871757                    }
    19881758                }
    19891759            }
    19901760        }
    1991 
    1992 #ifdef VBOX_WITH_PROTOBUF
    1993         std::list< ComPtr<IMachine> >::iterator itM1;
    1994         i=0;
    1995         for (itM1 = llMachines.begin();
    1996              itM1 != llMachines.end();
    1997              ++itM1, ++i)
    1998         {
    1999             ComPtr<IMachine> pMachine = *itM1;
    2000             ComPtr<IVirtualSystemDescription> pVSD;
    2001             vsd::InstanceDescription protobufInstDesc;
    2002 
    2003             Bstr bstrMachineName;
    2004             CHECK_ERROR_BREAK(pMachine, COMGETTER(Name)(bstrMachineName.asOutParam()));
    2005             Bstr bstrSettingsFilePath;
    2006             CHECK_ERROR_BREAK(pMachine, COMGETTER(SettingsFilePath)(bstrSettingsFilePath.asOutParam()));
    2007             com::Utf8Str strBinaryVSDFile(bstrSettingsFilePath);
    2008             strBinaryVSDFile.stripFilename();
    2009             strBinaryVSDFile.append("/").append(Utf8Str(bstrMachineName)).append("-proto.export");
    2010 
    2011             fstream input(strBinaryVSDFile.c_str(), ios::in | ios::binary);
    2012             if (!input.good() || !protobufInstDesc.ParseFromIstream(&input))
    2013             {
    2014                 RTMsgError("Cannot read the file \"%s\"\n", strBinaryVSDFile.c_str());
    2015                 return RTEXITCODE_FAILURE;
    2016             }
    2017             input.close();
    2018 
    2019             RTPrintf("Successfully read the test file \"%s\"\n", strBinaryVSDFile.c_str());
    2020             const google::protobuf::Map< ::std::string, ::vsd::ImageDescription >& imList = protobufInstDesc.images();
    2021             google::protobuf::Map< ::std::string, ::vsd::ImageDescription >::const_iterator imListIt = imList.begin();
    2022             RTPrintf("\n########Instance decription########\n");
    2023             RTPrintf("Name: %s\n", protobufInstDesc.name().c_str());
    2024             RTPrintf("Id: %s\n", protobufInstDesc.id().c_str());
    2025             RTPrintf("Path: %s\n", protobufInstDesc.path().c_str());
    2026             RTPrintf("Description: %s\n", protobufInstDesc.description().c_str());
    2027             RTPrintf("Os: %s\n", protobufInstDesc.os().c_str());
    2028             RTPrintf("Product: %s\n", protobufInstDesc.product().c_str());
    2029             RTPrintf("Vendor: %s\n", protobufInstDesc.vendor().c_str());
    2030             RTPrintf("Version: %s\n", protobufInstDesc.version().c_str());
    2031             RTPrintf("Product url: %s\n", protobufInstDesc.producturl().c_str());
    2032             RTPrintf("Vendor url: %s\n", protobufInstDesc.vendorurl().c_str());
    2033             RTPrintf("Cpu: %u\n", protobufInstDesc.cpu());
    2034             RTPrintf("Memory: %u\n", protobufInstDesc.memory());
    2035             while (imListIt != imList.end())
    2036             {
    2037                 com::Utf8Str key(imListIt->first.c_str());
    2038                 vsd::ImageDescription imDesc(imListIt->second);
    2039                 RTPrintf("\n###Image decription###\n");
    2040                 RTPrintf("Name: %s\n", imDesc.name().c_str());
    2041                 RTPrintf("Id: %s\n", imDesc.id().c_str());
    2042                 RTPrintf("Path: %s\n", imDesc.path().c_str());
    2043                 RTPrintf("Description: %s\n", imDesc.description().c_str());
    2044                 RTPrintf("Size (MB): %u\n", imDesc.size());
    2045                 const vsd::ImageDescription_StorageBus& stBus = imDesc.storagebus();
    2046                 RTPrintf("Bus type: %u\n", stBus.bustype());
    2047                 RTPrintf("Controller: %u\n", stBus.controller());
    2048                 RTPrintf("Channel: %u\n", stBus.channel());
    2049                 RTPrintf("###End Image decription###\n");
    2050                 ++imListIt;
    2051             }
    2052             RTPrintf("########End Instance decription########\n");
    2053         }
    2054 #endif
    2055 
    20561761    } while (0);
    20571762
    … …  
    20601765
    20611766#endif /* !VBOX_ONLY_DOCS */
     1767
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