VirtualBox

Changeset 44028 in vbox


Ignore:
Timestamp:
Dec 4, 2012 8:03:41 AM (12 years ago)
Author:
vboxsync
Message:

Frontends/VBoxManage: improve snapshot information, unify wrappers for opening a medium object, cleanup

Location:
trunk/src/VBox/Frontends/VBoxManage
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.h

    r42460 r44028  
    199199                      ComPtr<ISnapshot> &currentSnapshot,
    200200                      VMINFO_DETAILS details,
    201                       const com::Bstr &prefix = "",
     201                      const com::Utf8Str &prefix = "",
    202202                      int level = 0);
    203203int handleShowVMInfo(HandlerArg *a);
    … …  
    231231
    232232/* VBoxManageDisk.cpp */
    233 HRESULT findMedium(HandlerArg *a, const char *pszFilenameOrUuid,
    234                    DeviceType_T enmDevType, bool fSilent,
    235                    ComPtr<IMedium> &pMedium);
    236 HRESULT findOrOpenMedium(HandlerArg *a, const char *pszFilenameOrUuid,
    237                          DeviceType_T enmDevType, AccessMode_T enmAccessMode,
    238                          ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
    239                          bool *pfWasUnknown);
     233HRESULT openMedium(HandlerArg *a, const char *pszFilenameOrUuid,
     234                   DeviceType_T enmDevType, AccessMode_T enmAccessMode,
     235                   ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
     236                   bool fSilent);
    240237int handleCreateHardDisk(HandlerArg *a);
    241238int handleModifyHardDisk(HandlerArg *a);

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

    r43862 r44028  
    149149}
    150150
    151 HRESULT findMedium(HandlerArg *a, const char *pszFilenameOrUuid,
    152                    DeviceType_T enmDevType, bool fSilent,
    153                    ComPtr<IMedium> &pMedium)
     151HRESULT openMedium(HandlerArg *a, const char *pszFilenameOrUuid,
     152                   DeviceType_T enmDevType, AccessMode_T enmAccessMode,
     153                   ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
     154                   bool fSilent)
    154155{
    155156    HRESULT rc;
    … …  
    171172
    172173    if (!fSilent)
    173         CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
    174                                    enmDevType,
    175                                    AccessMode_ReadWrite,
    176                                    /*fForceNewUidOnOpen */ false,
    177                                    pMedium.asOutParam()));
    178     else
    179         rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
    180                                        enmDevType,
    181                                        AccessMode_ReadWrite,
    182                                        /*fForceNewUidOnOpen */ false,
    183                                        pMedium.asOutParam());
    184     return rc;
    185 }
    186 
    187 HRESULT findOrOpenMedium(HandlerArg *a, const char *pszFilenameOrUuid,
    188                          DeviceType_T enmDevType, AccessMode_T enmAccessMode,
    189                          ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
    190                          bool *pfWasUnknown)
    191 {
    192     HRESULT rc;
    193     bool fWasUnknown = false;
    194     Guid id(pszFilenameOrUuid);
    195     char szFilenameAbs[RTPATH_MAX] = "";
    196 
    197     /* If it is no UUID, convert the filename to an absolute one. */
    198     if (id.isEmpty())
    199     {
    200         int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
    201         if (RT_FAILURE(irc))
    202         {
    203             RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
    204             return E_FAIL;
    205         }
    206         pszFilenameOrUuid = szFilenameAbs;
    207     }
    208 
    209     rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
    210                                    enmDevType,
    211                                    enmAccessMode,
    212                                    /*fForceNewUidOnOpen */ false,
    213                                    pMedium.asOutParam());
    214     /* If the medium is unknown try to open it. */
    215     if (!pMedium)
    216     {
    217174        CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
    218                                               enmDevType, enmAccessMode,
     175                                              enmDevType,
     176                                              enmAccessMode,
    219177                                              fForceNewUuidOnOpen,
    220178                                              pMedium.asOutParam()));
    221         if (SUCCEEDED(rc))
    222             fWasUnknown = true;
    223     }
    224     if (RT_VALID_PTR(pfWasUnknown))
    225         *pfWasUnknown = fWasUnknown;
     179    else
     180        rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
     181                                       enmDevType,
     182                                       enmAccessMode,
     183                                       fForceNewUuidOnOpen,
     184                                       pMedium.asOutParam());
     185
    226186    return rc;
    227187}
    … …  
    344304
    345305    /* check the outcome */
    346     bool fUnknownParent = false;
    347306    ComPtr<IMedium> parentHardDisk;
    348307    if (fBase)
    … …  
    373332                format = pszExt;
    374333        }
    375         rc = findOrOpenMedium(a, diffparent, DeviceType_HardDisk, AccessMode_ReadWrite,
    376                               parentHardDisk, false /* fForceNewUuidOnOpen */,
    377                               &fUnknownParent);
     334        rc = openMedium(a, diffparent, DeviceType_HardDisk,
     335                        AccessMode_ReadWrite, parentHardDisk,
     336                        false /* fForceNewUuidOnOpen */, false /* fSilent */);
    378337        if (FAILED(rc))
    379338            return 1;
    … …  
    431390
    432391        CHECK_ERROR(hardDisk, Close());
    433         if (!fBase && fUnknownParent)
    434             CHECK_ERROR(parentHardDisk, Close());
    435392    }
    436393    return SUCCEEDED(rc) ? 0 : 1;
    … …  
    463420    uint64_t cbResize = 0;
    464421    const char *FilenameOrUuid = NULL;
    465     bool unknown = false;
    466422
    467423    int c;
    … …  
    533489        return errorSyntax(USAGE_MODIFYHD, "No operation specified");
    534490
    535     /* Depending on the operation the medium must be in the registry or
    536      * may be opened on demand. */
    537     if (fModifyDiskType || fModifyAutoReset)
    538         rc = findMedium(a, FilenameOrUuid, DeviceType_HardDisk, false /* fSilent */, hardDisk);
    539     else
    540         rc = findOrOpenMedium(a, FilenameOrUuid, DeviceType_HardDisk, AccessMode_ReadWrite,
    541                               hardDisk, false /* fForceNewUuidOnOpen */, &unknown);
     491    /* Always open the medium if necessary, there is no other way. */
     492    rc = openMedium(a, FilenameOrUuid, DeviceType_HardDisk,
     493                    AccessMode_ReadWrite, hardDisk,
     494                    false /* fForceNewUuidOnOpen */, false /* fSilent */);
    542495    if (FAILED(rc))
    543496        return 1;
    … …  
    597550        }
    598551    }
    599 
    600     if (unknown)
    601         hardDisk->Close();
    602552
    603553    return SUCCEEDED(rc) ? 0 : 1;
    … …  
    692642    ComPtr<IMedium> srcDisk;
    693643    ComPtr<IMedium> dstDisk;
    694     bool fSrcUnknown = false;
    695     bool fDstUnknown = false;
    696 
    697     rc = findOrOpenMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly,
    698                           srcDisk, false /* fForceNewUuidOnOpen */, &fSrcUnknown);
     644
     645    rc = openMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly,
     646                    srcDisk, false /* fForceNewUuidOnOpen */,
     647                    false /* fSilent */);
    699648    if (FAILED(rc))
    700649        return 1;
    … …  
    705654        if (fExisting)
    706655        {
    707             rc = findOrOpenMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite,
    708                                   dstDisk, false /* fForceNewUuidOnOpen */, &fDstUnknown);
     656            rc = openMedium(a, pszDst, DeviceType_HardDisk,
     657                            AccessMode_ReadWrite, dstDisk,
     658                            false /* fForceNewUuidOnOpen */,
     659                            false /* fSilent */);
    709660            if (FAILED(rc))
    710661                break;
    … …  
    723674            if (FAILED(rc))
    724675                break;
    725             fDstUnknown = true;
    726676        }
    727677
    … …  
    739689    }
    740690    while (0);
    741 
    742     if (fDstUnknown && !dstDisk.isNull())
    743     {
    744         /* forget the created clone */
    745         dstDisk->Close();
    746     }
    747     if (fSrcUnknown)
    748     {
    749         /* close the unknown hard disk to forget it again */
    750         srcDisk->Close();
    751     }
    752691
    753692    return SUCCEEDED(rc) ? 0 : 1;
    … …  
    986925
    987926    ComPtr<IMedium> hardDisk;
    988     bool unknown = false;
    989 
    990     rc = findOrOpenMedium(a, FilenameOrUuid, DeviceType_HardDisk, AccessMode_ReadOnly,
    991                           hardDisk, false /* fForceNewUuidOnOpen */, &unknown);
     927
     928    rc = openMedium(a, FilenameOrUuid, DeviceType_HardDisk,
     929                    AccessMode_ReadOnly, hardDisk,
     930                    false /* fForceNewUuidOnOpen */, false /* fSilent */);
    992931    if (FAILED(rc))
    993932        return 1;
    … …  
    10891028        /// @todo also dump config parameters (iSCSI)
    10901029
    1091         if (!unknown)
    1092         {
    1093             com::SafeArray<BSTR> machineIds;
    1094             hardDisk->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
    1095             for (size_t j = 0; j < machineIds.size(); ++ j)
    1096             {
    1097                 ComPtr<IMachine> machine;
    1098                 CHECK_ERROR(a->virtualBox, FindMachine(machineIds[j], machine.asOutParam()));
    1099                 ASSERT(machine);
    1100                 Bstr name;
    1101                 machine->COMGETTER(Name)(name.asOutParam());
    1102                 machine->COMGETTER(Id)(uuid.asOutParam());
    1103                 RTPrintf("%s%ls (UUID: %ls)\n",
    1104                          j == 0 ? "In use by VMs:        " : "                      ",
    1105                          name.raw(), machineIds[j]);
    1106             }
    1107             /// @todo NEWMEDIA check usage in snapshots too
    1108             /// @todo NEWMEDIA also list children
    1109         }
     1030        com::SafeArray<BSTR> machineIds;
     1031        hardDisk->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
     1032        for (size_t j = 0; j < machineIds.size(); ++ j)
     1033        {
     1034            ComPtr<IMachine> machine;
     1035            CHECK_ERROR(a->virtualBox, FindMachine(machineIds[j], machine.asOutParam()));
     1036            ASSERT(machine);
     1037            Bstr name;
     1038            machine->COMGETTER(Name)(name.asOutParam());
     1039            machine->COMGETTER(Id)(uuid.asOutParam());
     1040            RTPrintf("%s%ls (UUID: %ls)\n",
     1041                     j == 0 ? "In use by VMs:        " : "                      ",
     1042                     name.raw(), machineIds[j]);
     1043        }
     1044        /// @todo NEWMEDIA check usage in snapshots too
     1045        /// @todo NEWMEDIA also list children
    11101046
    11111047        Bstr loc;
    … …  
    11221058    }
    11231059    while (0);
    1124 
    1125     if (unknown)
    1126     {
    1127         /* close the unknown hard disk to forget it again */
    1128         hardDisk->Close();
    1129     }
    11301060
    11311061    return SUCCEEDED(rc) ? 0 : 1;
    … …  
    12171147
    12181148    if (cmd == CMD_DISK)
    1219         rc = findMedium(a, FilenameOrUuid, DeviceType_HardDisk, false /* fSilent */, medium);
     1149        rc = openMedium(a, FilenameOrUuid, DeviceType_HardDisk,
     1150                        AccessMode_ReadWrite, medium,
     1151                        false /* fForceNewUuidOnOpen */, false /* fSilent */);
    12201152    else if (cmd == CMD_DVD)
    1221         rc = findMedium(a, FilenameOrUuid, DeviceType_DVD, false /* fSilent */, medium);
     1153        rc = openMedium(a, FilenameOrUuid, DeviceType_DVD,
     1154                        AccessMode_ReadOnly, medium,
     1155                        false /* fForceNewUuidOnOpen */, false /* fSilent */);
    12221156    else if (cmd == CMD_FLOPPY)
    1223         rc = findMedium(a, FilenameOrUuid, DeviceType_Floppy, false /* fSilent */, medium);
     1157        rc = openMedium(a, FilenameOrUuid, DeviceType_Floppy,
     1158                        AccessMode_ReadWrite, medium,
     1159                        false /* fForceNewUuidOnOpen */, false /* fSilent */);
    12241160
    12251161    if (SUCCEEDED(rc) && medium)

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

    r43635 r44028  
    5151                      ComPtr<ISnapshot> &currentSnapshot,
    5252                      VMINFO_DETAILS details,
    53                       const Bstr &prefix /* = ""*/,
     53                      const Utf8Str &prefix /* = ""*/,
    5454                      int level /*= 0*/)
    5555{
    … …  
    5757    Bstr name;
    5858    Bstr uuid;
    59     CHECK_ERROR2_RET(rootSnapshot,COMGETTER(Name)(name.asOutParam()), hrcCheck);
    60     CHECK_ERROR2_RET(rootSnapshot,COMGETTER(Id)(uuid.asOutParam()), hrcCheck);
     59    Bstr description;
     60    CHECK_ERROR2_RET(rootSnapshot, COMGETTER(Name)(name.asOutParam()), hrcCheck);
     61    CHECK_ERROR2_RET(rootSnapshot, COMGETTER(Id)(uuid.asOutParam()), hrcCheck);
     62    CHECK_ERROR2_RET(rootSnapshot, COMGETTER(Description)(description.asOutParam()), hrcCheck);
     63    bool fCurrent = (rootSnapshot == currentSnapshot);
    6164    if (details == VMINFO_MACHINEREADABLE)
    6265    {
    6366        /* print with hierarchical numbering */
    64         RTPrintf("SnapshotName%ls=\"%ls\"\n", prefix.raw(), name.raw());
    65         RTPrintf("SnapshotUUID%ls=\"%s\"\n", prefix.raw(), Utf8Str(uuid).c_str());
     67        RTPrintf("SnapshotName%s=\"%ls\"\n", prefix.c_str(), name.raw());
     68        RTPrintf("SnapshotUUID%s=\"%s\"\n", prefix.c_str(), Utf8Str(uuid).c_str());
     69        if (!description.isEmpty())
     70            RTPrintf("SnapshotDescription%s=\"%ls\"\n", prefix.c_str(), description.raw());
     71        if (fCurrent)
     72        {
     73            RTPrintf("CurrentSnapshotName=\"%ls\"\n", name.raw());
     74            RTPrintf("CurrentSnapshotUUID=\"%s\"\n", Utf8Str(uuid).c_str());
     75            RTPrintf("CurrentSnapshotNode=\"SnapshotName%s\"\n", prefix.c_str());
     76        }
    6677    }
    6778    else
    6879    {
    6980        /* print with indentation */
    70         bool fCurrent = (rootSnapshot == currentSnapshot);
    71         RTPrintf("   %lsName: %ls (UUID: %s)%s\n",
    72                  prefix.raw(),
     81        RTPrintf("   %sName: %ls (UUID: %s)%s\n",
     82                 prefix.c_str(),
    7383                 name.raw(),
    7484                 Utf8Str(uuid).c_str(),
    7585                 (fCurrent) ? " *" : "");
     86        if (!description.isEmpty())
     87            RTPrintf("   %sDescription:\n%ls\n", prefix.c_str(), description.raw());
    7688    }
    7789
    … …  
    8799            if (snapshot)
    88100            {
    89                 Bstr newPrefix;
     101                Utf8Str newPrefix;
    90102                if (details == VMINFO_MACHINEREADABLE)
    91                     newPrefix = Utf8StrFmt("%ls-%d", prefix.raw(), index + 1);
     103                    newPrefix = Utf8StrFmt("%s-%d", prefix.c_str(), index + 1);
    92104                else
    93105                {
    94                     newPrefix = Utf8StrFmt("%ls   ", prefix.raw());
     106                    newPrefix = Utf8StrFmt("%s   ", prefix.c_str());
    95107                }
    96108
    … …  
    22852297    }
    22862298
    2287 
    22882299    if (details != VMINFO_MACHINEREADABLE)
    22892300        RTPrintf("Guest:\n\n");

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

    r43023 r44028  
    770770                {
    771771                    ComPtr<IMedium> hardDisk;
    772                     rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_HardDisk,
    773                                           AccessMode_ReadWrite, hardDisk,
    774                                           false /* fForceNewUuidOnOpen */, NULL);
     772                    rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
     773                                    AccessMode_ReadWrite, hardDisk,
     774                                    false /* fForceNewUuidOnOpen */,
     775                                    false /* fSilent */);
    775776                    if (FAILED(rc))
    776777                        break;
    … …  
    855856                {
    856857                    ComPtr<IMedium> hardDisk;
    857                     rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_HardDisk,
    858                                           AccessMode_ReadWrite, hardDisk,
    859                                           false /* fForceNewUuidOnOpen */, NULL);
     858                    rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
     859                                    AccessMode_ReadWrite, hardDisk,
     860                                    false /* fForceNewUuidOnOpen */,
     861                                    false /* fSilent */);
    860862                    if (FAILED(rc))
    861863                        break;
    … …  
    983985                else
    984986                {
    985                     rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_DVD,
    986                                           AccessMode_ReadOnly, dvdMedium,
    987                                           false /* fForceNewUuidOnOpen */, NULL);
     987                    rc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
     988                                    AccessMode_ReadOnly, dvdMedium,
     989                                    false /* fForceNewUuidOnOpen */,
     990                                    false /* fSilent */);
    988991                    if (FAILED(rc))
    989992                        break;
    … …  
    10471050                    else
    10481051                    {
    1049                         rc = findOrOpenMedium(a, ValueUnion.psz, DeviceType_Floppy,
    1050                                               AccessMode_ReadWrite, floppyMedium,
    1051                                               false /* fForceNewUuidOnOpen */, NULL);
     1052                        rc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
     1053                                        AccessMode_ReadWrite, floppyMedium,
     1054                                        false /* fForceNewUuidOnOpen */,
     1055                                        false /* fSilent */);
    10521056                        if (FAILED(rc))
    10531057                            break;

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

    r43914 r44028  
    484484                        {
    485485                            ComPtr<IMedium> pExistingMedium;
    486                             rc = findMedium(a, pszMedium, deviceType, true /* fSilent */,
    487                                             pExistingMedium);
     486                            rc = openMedium(a, pszMedium, deviceType,
     487                                            AccessMode_ReadWrite,
     488                                            pExistingMedium,
     489                                            false /* fForceNewUuidOnOpen */,
     490                                            true /* fSilent */);
    488491                            if (SUCCEEDED(rc) && pExistingMedium)
    489492                            {
    … …  
    638641                {
    639642                    Bstr bstrMedium(pszMedium);
    640                     rc = findOrOpenMedium(a, pszMedium, devTypeRequested,
    641                                           AccessMode_ReadWrite, pMedium2Mount,
    642                                           fSetNewUuid, NULL);
     643                    rc = openMedium(a, pszMedium, devTypeRequested,
     644                                    AccessMode_ReadWrite, pMedium2Mount,
     645                                    fSetNewUuid, false /* fSilent */);
    643646                    if (FAILED(rc) || !pMedium2Mount)
    644647                        throw Utf8StrFmt("Invalid UUID or filename \"%s\"", pszMedium);
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