1 | /* $Id: MachineImplMoveVM.cpp 74804 2018-10-12 15:09:44Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * Implementation of MachineMoveVM
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2011-2017 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | */
|
---|
17 | #include <iprt/fs.h>
|
---|
18 | #include <iprt/dir.h>
|
---|
19 | #include <iprt/file.h>
|
---|
20 | #include <iprt/path.h>
|
---|
21 | #include <iprt/cpp/utils.h>
|
---|
22 | #include <iprt/stream.h>
|
---|
23 | #include <VBox/com/ErrorInfo.h>
|
---|
24 |
|
---|
25 | #include "MachineImplMoveVM.h"
|
---|
26 | #include "MediumFormatImpl.h"
|
---|
27 | #include "VirtualBoxImpl.h"
|
---|
28 | #include "Logging.h"
|
---|
29 |
|
---|
30 | /** @todo r=klaus this file is abusing the release log by putting pretty much
|
---|
31 | * everything there. Should be adjusted to use debug logging where appropriate
|
---|
32 | * and if really necessary some LogRel2 and the like. */
|
---|
33 |
|
---|
34 |
|
---|
35 | /* This variable is global and used in the different places so it must be cleared each time before usage to avoid failure */
|
---|
36 | std::vector< ComObjPtr<Machine> > machineList;
|
---|
37 |
|
---|
38 | typedef std::multimap<Utf8Str, Utf8Str> list_t;
|
---|
39 | typedef std::multimap<Utf8Str, Utf8Str>::const_iterator cit_t;
|
---|
40 | typedef std::multimap<Utf8Str, Utf8Str>::iterator it_t;
|
---|
41 | typedef std::pair <std::multimap<Utf8Str, Utf8Str>::iterator, std::multimap<Utf8Str, Utf8Str>::iterator> rangeRes_t;
|
---|
42 |
|
---|
43 | struct fileList_t
|
---|
44 | {
|
---|
45 | HRESULT add(const Utf8Str& folder, const Utf8Str& file)
|
---|
46 | {
|
---|
47 | HRESULT rc = S_OK;
|
---|
48 | m_list.insert(std::make_pair(folder, file));
|
---|
49 | return rc;
|
---|
50 | }
|
---|
51 |
|
---|
52 | HRESULT add(const Utf8Str& fullPath)
|
---|
53 | {
|
---|
54 | HRESULT rc = S_OK;
|
---|
55 | Utf8Str folder = fullPath;
|
---|
56 | folder.stripFilename();
|
---|
57 | Utf8Str filename = fullPath;
|
---|
58 | filename.stripPath();
|
---|
59 | m_list.insert(std::make_pair(folder, filename));
|
---|
60 | return rc;
|
---|
61 | }
|
---|
62 |
|
---|
63 | HRESULT removeFileFromList(const Utf8Str& fullPath)
|
---|
64 | {
|
---|
65 | HRESULT rc = S_OK;
|
---|
66 | Utf8Str folder = fullPath;
|
---|
67 | folder.stripFilename();
|
---|
68 | Utf8Str filename = fullPath;
|
---|
69 | filename.stripPath();
|
---|
70 | rangeRes_t res = m_list.equal_range(folder);
|
---|
71 | for (it_t it=res.first; it!=res.second;)
|
---|
72 | {
|
---|
73 | if (it->second.equals(filename))
|
---|
74 | {
|
---|
75 | it_t it2 = it;
|
---|
76 | ++it;
|
---|
77 | m_list.erase(it2);
|
---|
78 | }
|
---|
79 | else
|
---|
80 | ++it;
|
---|
81 | }
|
---|
82 |
|
---|
83 | return rc;
|
---|
84 | }
|
---|
85 |
|
---|
86 | HRESULT removeFileFromList(const Utf8Str& path, const Utf8Str& fileName)
|
---|
87 | {
|
---|
88 | HRESULT rc = S_OK;
|
---|
89 | rangeRes_t res = m_list.equal_range(path);
|
---|
90 | for (it_t it=res.first; it!=res.second;)
|
---|
91 | {
|
---|
92 | if (it->second.equals(fileName))
|
---|
93 | {
|
---|
94 | it_t it2 = it;
|
---|
95 | ++it;
|
---|
96 | m_list.erase(it2);
|
---|
97 | }
|
---|
98 | else
|
---|
99 | ++it;
|
---|
100 | }
|
---|
101 | return rc;
|
---|
102 | }
|
---|
103 |
|
---|
104 | HRESULT removeFolderFromList(const Utf8Str& path)
|
---|
105 | {
|
---|
106 | HRESULT rc = S_OK;
|
---|
107 | m_list.erase(path);
|
---|
108 | return rc;
|
---|
109 | }
|
---|
110 |
|
---|
111 | rangeRes_t getFilesInRange(const Utf8Str& path)
|
---|
112 | {
|
---|
113 | rangeRes_t res;
|
---|
114 | res = m_list.equal_range(path);
|
---|
115 | return res;
|
---|
116 | }
|
---|
117 |
|
---|
118 | std::list<Utf8Str> getFilesInList(const Utf8Str& path)
|
---|
119 | {
|
---|
120 | std::list<Utf8Str> list_;
|
---|
121 | rangeRes_t res = m_list.equal_range(path);
|
---|
122 | for (it_t it=res.first; it!=res.second; ++it)
|
---|
123 | list_.push_back(it->second);
|
---|
124 | return list_;
|
---|
125 | }
|
---|
126 |
|
---|
127 |
|
---|
128 | list_t m_list;
|
---|
129 |
|
---|
130 | };
|
---|
131 |
|
---|
132 |
|
---|
133 | void MachineMoveVM::ErrorInfoItem::printItem(bool fLog) const
|
---|
134 | {
|
---|
135 | if (fLog)
|
---|
136 | {
|
---|
137 | LogRelFunc(("(The error code is %Rrc): %s\n",m_code, m_description.c_str()));
|
---|
138 | }
|
---|
139 | else
|
---|
140 | RTPrintf("(The error code is %Rrc): %s\n",m_code, m_description.c_str());
|
---|
141 | }
|
---|
142 |
|
---|
143 | HRESULT MachineMoveVM::init()
|
---|
144 | {
|
---|
145 | HRESULT rc = S_OK;
|
---|
146 |
|
---|
147 | errorsList.clear();
|
---|
148 |
|
---|
149 | Utf8Str strTargetFolder;
|
---|
150 | /* adding a trailing slash if it's needed */
|
---|
151 | {
|
---|
152 | size_t len = m_targetPath.length() + 2;
|
---|
153 | if (len >=RTPATH_MAX)
|
---|
154 | {
|
---|
155 | Utf8Str errorDesc(" The destination path isn't correct. The length of path exceeded the maximum value.");
|
---|
156 | errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
157 | throw m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
|
---|
158 | }
|
---|
159 |
|
---|
160 | char* path = new char [len];
|
---|
161 | RTStrCopy(path, len, m_targetPath.c_str());
|
---|
162 | RTPathEnsureTrailingSeparator(path, len);
|
---|
163 | strTargetFolder = m_targetPath = path;
|
---|
164 | delete[] path;
|
---|
165 | }
|
---|
166 |
|
---|
167 | /*
|
---|
168 | * We have a mode which user is able to request
|
---|
169 | * basic mode:
|
---|
170 | * - The images which are solely attached to the VM
|
---|
171 | * and located in the original VM folder will be moved.
|
---|
172 | *
|
---|
173 | * Comment: in the future some other modes can be added.
|
---|
174 | */
|
---|
175 |
|
---|
176 | try
|
---|
177 | {
|
---|
178 | Utf8Str info;
|
---|
179 | int vrc = 0;
|
---|
180 |
|
---|
181 | RTFOFF cbTotal = 0;
|
---|
182 | RTFOFF cbFree = 0;
|
---|
183 | uint32_t cbBlock = 0;
|
---|
184 | uint32_t cbSector = 0;
|
---|
185 |
|
---|
186 | vrc = RTFsQuerySizes(strTargetFolder.c_str(), &cbTotal, &cbFree, &cbBlock, &cbSector);
|
---|
187 | if (FAILED(vrc))
|
---|
188 | {
|
---|
189 | RTPrintf("strTargetFolder is %s\n", strTargetFolder.c_str());
|
---|
190 | Utf8StrFmt errorDesc("Unable to move machine. Can't get the destination storage size (%s)",
|
---|
191 | strTargetFolder.c_str());
|
---|
192 | errorsList.push_back(ErrorInfoItem(E_FAIL, errorDesc.c_str()));
|
---|
193 | rc = m_pMachine->setErrorBoth(E_FAIL, vrc, m_pMachine->tr(errorDesc.c_str()));
|
---|
194 | throw rc;
|
---|
195 | }
|
---|
196 |
|
---|
197 | RTDIR hDir;
|
---|
198 | Utf8Str strTempFile = strTargetFolder + "test.txt";
|
---|
199 | vrc = RTDirOpen(&hDir, strTargetFolder.c_str());
|
---|
200 | if (FAILED(vrc))
|
---|
201 | throw rc = vrc;
|
---|
202 | else
|
---|
203 | {
|
---|
204 | RTFILE hFile;
|
---|
205 | vrc = RTFileOpen(&hFile, strTempFile.c_str(), RTFILE_O_OPEN_CREATE | RTFILE_O_READWRITE | RTFILE_O_DENY_NONE);
|
---|
206 | if (FAILED(vrc))
|
---|
207 | {
|
---|
208 | LogRelFunc(("Can't create a test file %s (The error is %Rrc)\n", strTempFile.c_str(), vrc));
|
---|
209 | Utf8StrFmt errorDesc("Can't create a test file test.txt in the %s. Check the access rights of "
|
---|
210 | "the destination folder.", strTargetFolder.c_str());
|
---|
211 | errorsList.push_back(ErrorInfoItem(HRESULT(vrc), errorDesc.c_str()));
|
---|
212 | rc = m_pMachine->setErrorBoth(VBOX_E_FILE_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
|
---|
213 | }
|
---|
214 |
|
---|
215 | RTFileClose(hFile);
|
---|
216 | RTFileDelete(strTempFile.c_str());
|
---|
217 | RTDirClose(hDir);
|
---|
218 | }
|
---|
219 |
|
---|
220 | long long totalFreeSpace = cbFree;
|
---|
221 | long long totalSpace = cbTotal;
|
---|
222 | info = Utf8StrFmt("blocks: total %lld, free %u ", cbTotal, cbFree);
|
---|
223 | LogRelFunc(("%s \n", info.c_str()));
|
---|
224 | LogRelFunc(("total space (Kb) %lld (Mb) %lld (Gb) %lld\n",
|
---|
225 | totalSpace/1024, totalSpace/(1024*1024), totalSpace/(1024*1024*1024)));
|
---|
226 | LogRelFunc(("total free space (Kb) %lld (Mb) %lld (Gb) %lld\n",
|
---|
227 | totalFreeSpace/1024, totalFreeSpace/(1024*1024), totalFreeSpace/(1024*1024*1024)));
|
---|
228 |
|
---|
229 | RTFSPROPERTIES properties;
|
---|
230 | vrc = RTFsQueryProperties(strTargetFolder.c_str(), &properties);
|
---|
231 | if (FAILED(vrc)) throw vrc;
|
---|
232 | info = Utf8StrFmt("disk properties:\n"
|
---|
233 | "remote: %s \n"
|
---|
234 | "read only: %s \n"
|
---|
235 | "compressed: %s \n",
|
---|
236 | properties.fRemote == true ? "true":"false",
|
---|
237 | properties.fReadOnly == true ? "true":"false",
|
---|
238 | properties.fCompressed == true ? "true":"false");
|
---|
239 |
|
---|
240 | LogRelFunc(("%s \n", info.c_str()));
|
---|
241 |
|
---|
242 | /* Get the original VM path */
|
---|
243 | Utf8Str strSettingsFilePath;
|
---|
244 | Bstr bstr_settingsFilePath;
|
---|
245 | m_pMachine->COMGETTER(SettingsFilePath)(bstr_settingsFilePath.asOutParam());
|
---|
246 | strSettingsFilePath = bstr_settingsFilePath;
|
---|
247 | strSettingsFilePath.stripFilename();
|
---|
248 |
|
---|
249 | vmFolders.insert(std::make_pair(VBox_SettingFolder, strSettingsFilePath));
|
---|
250 |
|
---|
251 | /* Collect all files from the VM's folder */
|
---|
252 | fileList_t fullFileList;
|
---|
253 | rc = getFilesList(strSettingsFilePath, fullFileList);
|
---|
254 | if (FAILED(rc)) throw rc;
|
---|
255 |
|
---|
256 | /*
|
---|
257 | * Collect all known folders used by the VM:
|
---|
258 | * - log folder;
|
---|
259 | * - state folder;
|
---|
260 | * - snapshot folder.
|
---|
261 | */
|
---|
262 | Utf8Str strLogFolder;
|
---|
263 | Bstr bstr_logFolder;
|
---|
264 | m_pMachine->COMGETTER(LogFolder)(bstr_logFolder.asOutParam());
|
---|
265 | strLogFolder = bstr_logFolder;
|
---|
266 | if ( m_type.equals("basic")
|
---|
267 | && strLogFolder.contains(strSettingsFilePath))
|
---|
268 | {
|
---|
269 | vmFolders.insert(std::make_pair(VBox_LogFolder, strLogFolder));
|
---|
270 | }
|
---|
271 |
|
---|
272 | Utf8Str strStateFilePath;
|
---|
273 | Bstr bstr_stateFilePath;
|
---|
274 | MachineState_T machineState;
|
---|
275 | rc = m_pMachine->COMGETTER(State)(&machineState);
|
---|
276 | if (FAILED(rc)) throw rc;
|
---|
277 | else if (machineState == MachineState_Saved)
|
---|
278 | {
|
---|
279 | m_pMachine->COMGETTER(StateFilePath)(bstr_stateFilePath.asOutParam());
|
---|
280 | strStateFilePath = bstr_stateFilePath;
|
---|
281 | strStateFilePath.stripFilename();
|
---|
282 | if ( m_type.equals("basic")
|
---|
283 | && strStateFilePath.contains(strSettingsFilePath))
|
---|
284 | vmFolders.insert(std::make_pair(VBox_StateFolder, strStateFilePath));//Utf8Str(bstr_stateFilePath)));
|
---|
285 | }
|
---|
286 |
|
---|
287 | Utf8Str strSnapshotFolder;
|
---|
288 | Bstr bstr_snapshotFolder;
|
---|
289 | m_pMachine->COMGETTER(SnapshotFolder)(bstr_snapshotFolder.asOutParam());
|
---|
290 | strSnapshotFolder = bstr_snapshotFolder;
|
---|
291 | if ( m_type.equals("basic")
|
---|
292 | && strSnapshotFolder.contains(strSettingsFilePath))
|
---|
293 | vmFolders.insert(std::make_pair(VBox_SnapshotFolder, strSnapshotFolder));
|
---|
294 |
|
---|
295 | if (m_pMachine->i_isSnapshotMachine())
|
---|
296 | {
|
---|
297 | Bstr bstrSrcMachineId;
|
---|
298 | rc = m_pMachine->COMGETTER(Id)(bstrSrcMachineId.asOutParam());
|
---|
299 | if (FAILED(rc)) throw rc;
|
---|
300 | ComPtr<IMachine> newSrcMachine;
|
---|
301 | rc = m_pMachine->i_getVirtualBox()->FindMachine(bstrSrcMachineId.raw(), newSrcMachine.asOutParam());
|
---|
302 | if (FAILED(rc)) throw rc;
|
---|
303 | }
|
---|
304 |
|
---|
305 | /* Add the current machine and all snapshot machines below this machine
|
---|
306 | * in a list for further processing.
|
---|
307 | */
|
---|
308 |
|
---|
309 | long long neededFreeSpace = 0;
|
---|
310 |
|
---|
311 | /* Actual file list */
|
---|
312 | fileList_t actualFileList;
|
---|
313 | Utf8Str strTargetImageName;
|
---|
314 |
|
---|
315 | /* Global variable (defined at the beginning of file), so clear it before usage */
|
---|
316 | machineList.clear();
|
---|
317 | machineList.push_back(m_pMachine);
|
---|
318 |
|
---|
319 | {
|
---|
320 | ULONG cSnapshots = 0;
|
---|
321 | rc = m_pMachine->COMGETTER(SnapshotCount)(&cSnapshots);
|
---|
322 | if (FAILED(rc)) throw rc;
|
---|
323 | if (cSnapshots > 0)
|
---|
324 | {
|
---|
325 | Utf8Str id;
|
---|
326 | if (m_pMachine->i_isSnapshotMachine())
|
---|
327 | id = m_pMachine->i_getSnapshotId().toString();
|
---|
328 | ComPtr<ISnapshot> pSnapshot;
|
---|
329 | rc = m_pMachine->FindSnapshot(Bstr(id).raw(), pSnapshot.asOutParam());
|
---|
330 | if (FAILED(rc)) throw rc;
|
---|
331 | rc = createMachineList(pSnapshot, machineList);
|
---|
332 | if (FAILED(rc)) throw rc;
|
---|
333 | }
|
---|
334 | }
|
---|
335 |
|
---|
336 | ULONG uCount = 1;//looks like it should be initialized by 1. See assertion in the Progress::setNextOperation()
|
---|
337 | ULONG uTotalWeight = 1;
|
---|
338 |
|
---|
339 | /* The lists llMedias and llSaveStateFiles are filled in the queryMediasForAllStates() */
|
---|
340 | queryMediasForAllStates(machineList);
|
---|
341 |
|
---|
342 | {
|
---|
343 | uint64_t totalMediumsSize = 0;
|
---|
344 |
|
---|
345 | for (size_t i = 0; i < llMedias.size(); ++i)
|
---|
346 | {
|
---|
347 | LONG64 cbSize = 0;
|
---|
348 | MEDIUMTASKCHAINMOVE &mtc = llMedias.at(i);
|
---|
349 | for (size_t a = mtc.chain.size(); a > 0; --a)
|
---|
350 | {
|
---|
351 | Bstr bstrLocation;
|
---|
352 | Utf8Str strLocation;
|
---|
353 | Utf8Str name = mtc.chain[a - 1].strBaseName;
|
---|
354 | ComPtr<IMedium> plMedium = mtc.chain[a - 1].pMedium;
|
---|
355 | rc = plMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
356 | if (FAILED(rc)) throw rc;
|
---|
357 | strLocation = bstrLocation;
|
---|
358 |
|
---|
359 | /*if an image is located in the actual VM folder it will be added to the actual list */
|
---|
360 | if (strLocation.contains(strSettingsFilePath))
|
---|
361 | {
|
---|
362 | rc = plMedium->COMGETTER(Size)(&cbSize);
|
---|
363 | if (FAILED(rc)) throw rc;
|
---|
364 |
|
---|
365 | std::pair<std::map<Utf8Str, MEDIUMTASKMOVE>::iterator,bool> ret;
|
---|
366 | ret = finalMediumsMap.insert(std::make_pair(name, mtc.chain[a - 1]));
|
---|
367 | if (ret.second == true)
|
---|
368 | {
|
---|
369 | /* Calculate progress data */
|
---|
370 | ++uCount;
|
---|
371 | uTotalWeight += mtc.chain[a - 1].uWeight;
|
---|
372 | totalMediumsSize += cbSize;
|
---|
373 | LogRelFunc(("Image %s was added into the moved list\n", name.c_str()));
|
---|
374 | }
|
---|
375 | }
|
---|
376 | }
|
---|
377 | }
|
---|
378 |
|
---|
379 | LogRelFunc(("Total Size of images is %lld bytes\n", totalMediumsSize));
|
---|
380 | neededFreeSpace += totalMediumsSize;
|
---|
381 | }
|
---|
382 |
|
---|
383 | /* Prepare data for moving ".sav" files */
|
---|
384 | {
|
---|
385 | uint64_t totalStateSize = 0;
|
---|
386 |
|
---|
387 | for (size_t i = 0; i < llSaveStateFiles.size(); ++i)
|
---|
388 | {
|
---|
389 | uint64_t cbFile = 0;
|
---|
390 | SAVESTATETASKMOVE &sst = llSaveStateFiles.at(i);
|
---|
391 |
|
---|
392 | Utf8Str name = sst.strSaveStateFile;
|
---|
393 | /*if a state file is located in the actual VM folder it will be added to the actual list */
|
---|
394 | if (name.contains(strSettingsFilePath))
|
---|
395 | {
|
---|
396 | vrc = RTFileQuerySize(name.c_str(), &cbFile);
|
---|
397 | if (RT_SUCCESS(vrc))
|
---|
398 | {
|
---|
399 | std::pair<std::map<Utf8Str, SAVESTATETASKMOVE>::iterator,bool> ret;
|
---|
400 | ret = finalSaveStateFilesMap.insert(std::make_pair(name, sst));
|
---|
401 | if (ret.second == true)
|
---|
402 | {
|
---|
403 | totalStateSize += cbFile;
|
---|
404 | ++uCount;
|
---|
405 | uTotalWeight += sst.uWeight;
|
---|
406 | LogRelFunc(("The state file %s was added into the moved list\n", name.c_str()));
|
---|
407 | }
|
---|
408 | }
|
---|
409 | else
|
---|
410 | LogRelFunc(("The state file %s wasn't added into the moved list. Couldn't get the file size.\n",
|
---|
411 | name.c_str()));
|
---|
412 | }
|
---|
413 | }
|
---|
414 |
|
---|
415 | neededFreeSpace += totalStateSize;
|
---|
416 | }
|
---|
417 |
|
---|
418 | /* Prepare data for moving the log files */
|
---|
419 | {
|
---|
420 | Utf8Str strFolder = vmFolders[VBox_LogFolder];
|
---|
421 |
|
---|
422 | if (RTPathExists(strFolder.c_str()))
|
---|
423 | {
|
---|
424 | uint64_t totalLogSize = 0;
|
---|
425 | rc = getFolderSize(strFolder, totalLogSize);
|
---|
426 | if (SUCCEEDED(rc))
|
---|
427 | {
|
---|
428 | neededFreeSpace += totalLogSize;
|
---|
429 | if (totalFreeSpace - neededFreeSpace <= 1024*1024)
|
---|
430 | {
|
---|
431 | throw VERR_OUT_OF_RESOURCES;//less than 1Mb free space on the target location
|
---|
432 | }
|
---|
433 |
|
---|
434 | fileList_t filesList;
|
---|
435 | getFilesList(strFolder, filesList);
|
---|
436 | cit_t it = filesList.m_list.begin();
|
---|
437 | while(it != filesList.m_list.end())
|
---|
438 | {
|
---|
439 | Utf8Str strFile = it->first.c_str();
|
---|
440 | strFile.append(RTPATH_DELIMITER).append(it->second.c_str());
|
---|
441 |
|
---|
442 | uint64_t cbFile = 0;
|
---|
443 | vrc = RTFileQuerySize(strFile.c_str(), &cbFile);
|
---|
444 | if (RT_SUCCESS(vrc))
|
---|
445 | {
|
---|
446 | uCount += 1;
|
---|
447 | uTotalWeight += (ULONG)((cbFile + _1M - 1) / _1M);
|
---|
448 | actualFileList.add(strFile);
|
---|
449 | LogRelFunc(("The log file %s added into the moved list\n", strFile.c_str()));
|
---|
450 | }
|
---|
451 | else
|
---|
452 | LogRelFunc(("The log file %s wasn't added into the moved list. Couldn't get the file size."
|
---|
453 | "\n", strFile.c_str()));
|
---|
454 | ++it;
|
---|
455 | }
|
---|
456 | }
|
---|
457 | }
|
---|
458 | else
|
---|
459 | {
|
---|
460 | LogRelFunc(("Information: The original log folder %s doesn't exist\n", strFolder.c_str()));
|
---|
461 | rc = S_OK;//it's not error in this case if there isn't an original log folder
|
---|
462 | }
|
---|
463 | }
|
---|
464 |
|
---|
465 | LogRelFunc(("Total space needed is %lld bytes\n", neededFreeSpace));
|
---|
466 | /* Check a target location on enough room */
|
---|
467 | if (totalFreeSpace - neededFreeSpace <= 1024*1024)
|
---|
468 | {
|
---|
469 | LogRelFunc(("but free space on destination is %lld\n", totalFreeSpace));
|
---|
470 | throw VERR_OUT_OF_RESOURCES;//less than 1Mb free space on the target location
|
---|
471 | }
|
---|
472 |
|
---|
473 | /* Add step for .vbox machine setting file */
|
---|
474 | {
|
---|
475 | ++uCount;
|
---|
476 | uTotalWeight += 1;
|
---|
477 | }
|
---|
478 |
|
---|
479 | /* Reserve additional steps in case of failure and rollback all changes */
|
---|
480 | {
|
---|
481 | uTotalWeight += uCount;//just add 1 for each possible rollback operation
|
---|
482 | uCount += uCount;//and increase the steps twice
|
---|
483 | }
|
---|
484 |
|
---|
485 | /* Init Progress instance */
|
---|
486 | {
|
---|
487 | rc = m_pProgress->init(m_pMachine->i_getVirtualBox(),
|
---|
488 | static_cast<IMachine*>(m_pMachine) /* aInitiator */,
|
---|
489 | Bstr(m_pMachine->tr("Moving Machine")).raw(),
|
---|
490 | true /* fCancellable */,
|
---|
491 | uCount,
|
---|
492 | uTotalWeight,
|
---|
493 | Bstr(m_pMachine->tr("Initialize Moving")).raw(),
|
---|
494 | 1);
|
---|
495 | if (FAILED(rc))
|
---|
496 | {
|
---|
497 | Utf8StrFmt errorDesc("Couldn't correctly setup the progress object for moving VM operation (%Rrc)", rc);
|
---|
498 | errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
499 |
|
---|
500 | throw m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
|
---|
501 | }
|
---|
502 | }
|
---|
503 |
|
---|
504 | /* save all VM data */
|
---|
505 | m_pMachine->i_setModified(Machine::IsModified_MachineData);
|
---|
506 | rc = m_pMachine->SaveSettings();
|
---|
507 | }
|
---|
508 | catch(HRESULT hrc)
|
---|
509 | {
|
---|
510 | rc = hrc;
|
---|
511 | }
|
---|
512 |
|
---|
513 | LogFlowFuncLeave();
|
---|
514 |
|
---|
515 | return rc;
|
---|
516 | }
|
---|
517 |
|
---|
518 | void MachineMoveVM::printStateFile(settings::SnapshotsList &snl)
|
---|
519 | {
|
---|
520 | settings::SnapshotsList::iterator it;
|
---|
521 | for (it = snl.begin(); it != snl.end(); ++it)
|
---|
522 | {
|
---|
523 | if (!it->strStateFile.isEmpty())
|
---|
524 | {
|
---|
525 | settings::Snapshot snap = (settings::Snapshot)(*it);
|
---|
526 | LogRelFunc(("snap.uuid = %s\n", snap.uuid.toStringCurly().c_str()));
|
---|
527 | LogRelFunc(("snap.strStateFile = %s\n", snap.strStateFile.c_str()));
|
---|
528 | }
|
---|
529 |
|
---|
530 | if (!it->llChildSnapshots.empty())
|
---|
531 | printStateFile(it->llChildSnapshots);
|
---|
532 | }
|
---|
533 | }
|
---|
534 |
|
---|
535 | /* static */
|
---|
536 | DECLCALLBACK(int) MachineMoveVM::updateProgress(unsigned uPercent, void *pvUser)
|
---|
537 | {
|
---|
538 | MachineMoveVM* pTask = *(MachineMoveVM**)pvUser;
|
---|
539 |
|
---|
540 | if ( pTask
|
---|
541 | && !pTask->m_pProgress.isNull())
|
---|
542 | {
|
---|
543 | BOOL fCanceled;
|
---|
544 | pTask->m_pProgress->COMGETTER(Canceled)(&fCanceled);
|
---|
545 | if (fCanceled)
|
---|
546 | return -1;
|
---|
547 | pTask->m_pProgress->SetCurrentOperationProgress(uPercent);
|
---|
548 | }
|
---|
549 | return VINF_SUCCESS;
|
---|
550 | }
|
---|
551 |
|
---|
552 | /* static */
|
---|
553 | DECLCALLBACK(int) MachineMoveVM::copyFileProgress(unsigned uPercentage, void *pvUser)
|
---|
554 | {
|
---|
555 | ComObjPtr<Progress> pProgress = *static_cast< ComObjPtr<Progress>* >(pvUser);
|
---|
556 |
|
---|
557 | BOOL fCanceled = false;
|
---|
558 | HRESULT rc = pProgress->COMGETTER(Canceled)(&fCanceled);
|
---|
559 | if (FAILED(rc)) return VERR_GENERAL_FAILURE;
|
---|
560 | /* If canceled by the user tell it to the copy operation. */
|
---|
561 | if (fCanceled) return VERR_CANCELLED;
|
---|
562 | /* Set the new process. */
|
---|
563 | rc = pProgress->SetCurrentOperationProgress(uPercentage);
|
---|
564 | if (FAILED(rc)) return VERR_GENERAL_FAILURE;
|
---|
565 |
|
---|
566 | return VINF_SUCCESS;
|
---|
567 | }
|
---|
568 |
|
---|
569 |
|
---|
570 | /* static */
|
---|
571 | void MachineMoveVM::i_MoveVMThreadTask(MachineMoveVM* task)
|
---|
572 | {
|
---|
573 | LogFlowFuncEnter();
|
---|
574 | HRESULT rc = S_OK;
|
---|
575 |
|
---|
576 | MachineMoveVM* taskMoveVM = task;
|
---|
577 | ComObjPtr<Machine> &machine = taskMoveVM->m_pMachine;
|
---|
578 |
|
---|
579 | AutoCaller autoCaller(machine);
|
---|
580 | // if (FAILED(autoCaller.rc())) return;//Should we return something here?
|
---|
581 |
|
---|
582 | Utf8Str strTargetFolder = taskMoveVM->m_targetPath;
|
---|
583 | {
|
---|
584 | Bstr bstrMachineName;
|
---|
585 | machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
586 | strTargetFolder.append(Utf8Str(bstrMachineName));
|
---|
587 | }
|
---|
588 |
|
---|
589 | RTCList<Utf8Str> newFiles; /* All extra created files (save states, ...) */
|
---|
590 | RTCList<Utf8Str> originalFiles; /* All original files except images */
|
---|
591 | typedef std::map<Utf8Str, ComObjPtr<Medium> > MediumMap;
|
---|
592 | MediumMap mapOriginalMedium;
|
---|
593 |
|
---|
594 | /*
|
---|
595 | * We have the couple modes which user is able to request
|
---|
596 | * basic mode:
|
---|
597 | * - The images which are solely attached to the VM
|
---|
598 | * and located in the original VM folder will be moved.
|
---|
599 | * All subfolders related to the original VM are also moved from the original location
|
---|
600 | * (Standard - snapshots and logs folders).
|
---|
601 | *
|
---|
602 | * canonical mode:
|
---|
603 | * - All disks tied with the VM will be moved into a new location if it's possible.
|
---|
604 | * All folders related to the original VM are also moved.
|
---|
605 | * This mode is intended to collect all files/images/snapshots related to the VM in the one place.
|
---|
606 | *
|
---|
607 | */
|
---|
608 |
|
---|
609 | /*
|
---|
610 | * A way to handle shareable disk:
|
---|
611 | * Collect the shareable disks attched to the VM.
|
---|
612 | * Get the machines whom the shareable disks attach to.
|
---|
613 | * Return an error if the state of any VM doesn't allow to move a shareable disk and
|
---|
614 | * this disk is located in the VM's folder (it means the disk is intended for "moving").
|
---|
615 | */
|
---|
616 |
|
---|
617 |
|
---|
618 | /*
|
---|
619 | * Check new destination whether enough room for the VM or not. if "not" return an error.
|
---|
620 | * Make a copy of VM settings and a list with all files which are moved. Save the list on the disk.
|
---|
621 | * Start "move" operation.
|
---|
622 | * Check the result of operation.
|
---|
623 | * if the operation was successful:
|
---|
624 | * - delete all files in the original VM folder;
|
---|
625 | * - update VM disks info with new location;
|
---|
626 | * - update all other VM if it's needed;
|
---|
627 | * - update global settings
|
---|
628 | */
|
---|
629 |
|
---|
630 | try
|
---|
631 | {
|
---|
632 | /* Move all disks */
|
---|
633 | rc = taskMoveVM->moveAllDisks(taskMoveVM->finalMediumsMap, &strTargetFolder);
|
---|
634 | if (FAILED(rc))
|
---|
635 | throw rc;
|
---|
636 |
|
---|
637 | /* Get Machine::Data here because moveAllDisks() change it */
|
---|
638 | Machine::Data *machineData = machine->mData.data();
|
---|
639 | settings::MachineConfigFile *machineConfFile = machineData->pMachineConfigFile;
|
---|
640 |
|
---|
641 | /* Copy all save state files. */
|
---|
642 | Utf8Str strTrgSnapshotFolder;
|
---|
643 | {
|
---|
644 | /* When the current snapshot folder is absolute we reset it to the
|
---|
645 | * default relative folder. */
|
---|
646 | if (RTPathStartsWithRoot((*machineConfFile).machineUserData.strSnapshotFolder.c_str()))
|
---|
647 | (*machineConfFile).machineUserData.strSnapshotFolder = "Snapshots";
|
---|
648 | (*machineConfFile).strStateFile = "";
|
---|
649 |
|
---|
650 | /* The absolute name of the snapshot folder. */
|
---|
651 | strTrgSnapshotFolder = Utf8StrFmt("%s%c%s", strTargetFolder.c_str(), RTPATH_DELIMITER,
|
---|
652 | (*machineConfFile).machineUserData.strSnapshotFolder.c_str());
|
---|
653 |
|
---|
654 | /* Check if a snapshot folder is necessary and if so doesn't already
|
---|
655 | * exists. */
|
---|
656 | if ( taskMoveVM->finalSaveStateFilesMap.size() != 0
|
---|
657 | && !RTDirExists(strTrgSnapshotFolder.c_str()))
|
---|
658 | {
|
---|
659 | int vrc = RTDirCreateFullPath(strTrgSnapshotFolder.c_str(), 0700);
|
---|
660 | if (RT_FAILURE(vrc))
|
---|
661 | {
|
---|
662 | Utf8StrFmt errorDesc("Could not create snapshots folder '%s' (%Rrc)", strTrgSnapshotFolder.c_str(), vrc);
|
---|
663 | taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
664 |
|
---|
665 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
|
---|
666 | }
|
---|
667 | }
|
---|
668 |
|
---|
669 | std::map<Utf8Str, SAVESTATETASKMOVE>::iterator itState = taskMoveVM->finalSaveStateFilesMap.begin();
|
---|
670 | while (itState != taskMoveVM->finalSaveStateFilesMap.end())
|
---|
671 | {
|
---|
672 | const SAVESTATETASKMOVE &sst = itState->second;
|
---|
673 | const Utf8Str &strTrgSaveState = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
|
---|
674 | RTPathFilename(sst.strSaveStateFile.c_str()));
|
---|
675 |
|
---|
676 | /* Move to next sub-operation. */
|
---|
677 | rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy the save state file '%s' ..."),
|
---|
678 | RTPathFilename(sst.strSaveStateFile.c_str())).raw(), sst.uWeight);
|
---|
679 | if (FAILED(rc)) throw rc;
|
---|
680 |
|
---|
681 | int vrc = RTFileCopyEx(sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), 0,
|
---|
682 | MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
|
---|
683 | if (RT_FAILURE(vrc))
|
---|
684 | {
|
---|
685 | Utf8StrFmt errorDesc("Could not copy state file '%s' to '%s' (%Rrc)",
|
---|
686 | sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), vrc);
|
---|
687 | taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
688 |
|
---|
689 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
|
---|
690 | }
|
---|
691 |
|
---|
692 | /* save new file in case of restoring */
|
---|
693 | newFiles.append(strTrgSaveState);
|
---|
694 | /* save original file for deletion in the end */
|
---|
695 | originalFiles.append(sst.strSaveStateFile);
|
---|
696 | ++itState;
|
---|
697 | }
|
---|
698 | }
|
---|
699 |
|
---|
700 | /*
|
---|
701 | * Update state file path
|
---|
702 | * very important step!
|
---|
703 | * Not obvious how to do it correctly.
|
---|
704 | */
|
---|
705 | {
|
---|
706 | LogRelFunc(("Update state file path\n"));
|
---|
707 | rc = taskMoveVM->updatePathsToStateFiles(taskMoveVM->finalSaveStateFilesMap,
|
---|
708 | taskMoveVM->vmFolders[VBox_SettingFolder],
|
---|
709 | strTargetFolder);
|
---|
710 | if (FAILED(rc))
|
---|
711 | throw rc;
|
---|
712 | }
|
---|
713 |
|
---|
714 | /*
|
---|
715 | * Moving Machine settings file
|
---|
716 | * The settings file are moved after all disks and snapshots because this file should be updated
|
---|
717 | * with actual information and only then should be moved.
|
---|
718 | */
|
---|
719 | {
|
---|
720 | LogRelFunc(("Copy Machine settings file \n"));
|
---|
721 |
|
---|
722 | rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy Machine settings file '%s' ..."),
|
---|
723 | (*machineConfFile).machineUserData.strName.c_str()).raw(), 1);
|
---|
724 | if (FAILED(rc)) throw rc;
|
---|
725 |
|
---|
726 | Utf8Str strTargetSettingsFilePath = strTargetFolder;
|
---|
727 |
|
---|
728 | /* Check a folder existing and create one if it's not */
|
---|
729 | if (!RTDirExists(strTargetSettingsFilePath.c_str()))
|
---|
730 | {
|
---|
731 | int vrc = RTDirCreateFullPath(strTargetSettingsFilePath.c_str(), 0700);
|
---|
732 | if (RT_FAILURE(vrc))
|
---|
733 | {
|
---|
734 | Utf8StrFmt errorDesc("Could not create a home machine folder '%s' (%Rrc)",
|
---|
735 | strTargetSettingsFilePath.c_str(), vrc);
|
---|
736 | taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
737 |
|
---|
738 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
|
---|
739 | }
|
---|
740 | LogRelFunc(("Created a home machine folder %s\n", strTargetSettingsFilePath.c_str()));
|
---|
741 | }
|
---|
742 |
|
---|
743 | /* Create a full path */
|
---|
744 | Bstr bstrMachineName;
|
---|
745 | machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
746 | strTargetSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName));
|
---|
747 | strTargetSettingsFilePath.append(".vbox");
|
---|
748 |
|
---|
749 | Utf8Str strSettingsFilePath;
|
---|
750 | Bstr bstr_settingsFilePath;
|
---|
751 | machine->COMGETTER(SettingsFilePath)(bstr_settingsFilePath.asOutParam());
|
---|
752 | strSettingsFilePath = bstr_settingsFilePath;
|
---|
753 |
|
---|
754 | int vrc = RTFileCopyEx(strSettingsFilePath.c_str(), strTargetSettingsFilePath.c_str(), 0,
|
---|
755 | MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
|
---|
756 | if (RT_FAILURE(vrc))
|
---|
757 | {
|
---|
758 | Utf8StrFmt errorDesc("Could not copy the setting file '%s' to '%s' (%Rrc)",
|
---|
759 | strSettingsFilePath.c_str(), strTargetSettingsFilePath.stripFilename().c_str(), vrc);
|
---|
760 | taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
761 |
|
---|
762 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
|
---|
763 | }
|
---|
764 |
|
---|
765 | LogRelFunc(("The setting file %s has been copied into the folder %s\n", strSettingsFilePath.c_str(),
|
---|
766 | strTargetSettingsFilePath.stripFilename().c_str()));
|
---|
767 |
|
---|
768 | /* save new file in case of restoring */
|
---|
769 | newFiles.append(strTargetSettingsFilePath);
|
---|
770 | /* save original file for deletion in the end */
|
---|
771 | originalFiles.append(strSettingsFilePath);
|
---|
772 | }
|
---|
773 |
|
---|
774 | /* Moving Machine log files */
|
---|
775 | {
|
---|
776 | LogRelFunc(("Copy machine log files \n"));
|
---|
777 |
|
---|
778 | if (taskMoveVM->vmFolders[VBox_LogFolder].isNotEmpty())
|
---|
779 | {
|
---|
780 | /* Check an original log folder existence */
|
---|
781 | if (RTDirExists(taskMoveVM->vmFolders[VBox_LogFolder].c_str()))
|
---|
782 | {
|
---|
783 | Utf8Str strTargetLogFolderPath = strTargetFolder;
|
---|
784 | strTargetLogFolderPath.append(RTPATH_DELIMITER).append("Logs");
|
---|
785 |
|
---|
786 | /* Check a destination log folder existence and create one if it's not */
|
---|
787 | if (!RTDirExists(strTargetLogFolderPath.c_str()))
|
---|
788 | {
|
---|
789 | int vrc = RTDirCreateFullPath(strTargetLogFolderPath.c_str(), 0700);
|
---|
790 | if (RT_FAILURE(vrc))
|
---|
791 | {
|
---|
792 | Utf8StrFmt errorDesc("Could not create log folder '%s' (%Rrc)",
|
---|
793 | strTargetLogFolderPath.c_str(), vrc);
|
---|
794 | taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
795 |
|
---|
796 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
|
---|
797 | }
|
---|
798 | LogRelFunc(("Created a log machine folder %s\n", strTargetLogFolderPath.c_str()));
|
---|
799 | }
|
---|
800 |
|
---|
801 | fileList_t filesList;
|
---|
802 | taskMoveVM->getFilesList(taskMoveVM->vmFolders[VBox_LogFolder], filesList);
|
---|
803 | cit_t it = filesList.m_list.begin();
|
---|
804 | while(it != filesList.m_list.end())
|
---|
805 | {
|
---|
806 | Utf8Str strFullSourceFilePath = it->first.c_str();
|
---|
807 | strFullSourceFilePath.append(RTPATH_DELIMITER).append(it->second.c_str());
|
---|
808 |
|
---|
809 | Utf8Str strFullTargetFilePath = strTargetLogFolderPath;
|
---|
810 | strFullTargetFilePath.append(RTPATH_DELIMITER).append(it->second.c_str());
|
---|
811 |
|
---|
812 | /* Move to next sub-operation. */
|
---|
813 | rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copying the log file '%s' ..."),
|
---|
814 | RTPathFilename(strFullSourceFilePath.c_str())).raw(),
|
---|
815 | 1);
|
---|
816 | if (FAILED(rc)) throw rc;
|
---|
817 |
|
---|
818 | int vrc = RTFileCopyEx(strFullSourceFilePath.c_str(), strFullTargetFilePath.c_str(), 0,
|
---|
819 | MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
|
---|
820 | if (RT_FAILURE(vrc))
|
---|
821 | {
|
---|
822 | Utf8StrFmt errorDesc("Could not copy the log file '%s' to '%s' (%Rrc)",
|
---|
823 | strFullSourceFilePath.c_str(),
|
---|
824 | strFullTargetFilePath.stripFilename().c_str(),
|
---|
825 | vrc);
|
---|
826 | taskMoveVM->errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
827 |
|
---|
828 | throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, machine->tr(errorDesc.c_str()));
|
---|
829 | }
|
---|
830 |
|
---|
831 | LogRelFunc(("The log file %s has been copied into the folder %s\n", strFullSourceFilePath.c_str(),
|
---|
832 | strFullTargetFilePath.stripFilename().c_str()));
|
---|
833 |
|
---|
834 | /* save new file in case of restoring */
|
---|
835 | newFiles.append(strFullTargetFilePath);
|
---|
836 | /* save original file for deletion in the end */
|
---|
837 | originalFiles.append(strFullSourceFilePath);
|
---|
838 |
|
---|
839 | ++it;
|
---|
840 | }
|
---|
841 | }
|
---|
842 | }
|
---|
843 | }
|
---|
844 |
|
---|
845 | /* save all VM data */
|
---|
846 | {
|
---|
847 | rc = machine->SaveSettings();
|
---|
848 | }
|
---|
849 |
|
---|
850 | {
|
---|
851 | LogRelFunc(("Update path to XML setting file\n"));
|
---|
852 | Utf8Str strTargetSettingsFilePath = strTargetFolder;
|
---|
853 | Bstr bstrMachineName;
|
---|
854 | machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
855 | strTargetSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName)).append(".vbox");
|
---|
856 | machineData->m_strConfigFileFull = strTargetSettingsFilePath;
|
---|
857 | machine->mParent->i_copyPathRelativeToConfig(strTargetSettingsFilePath, machineData->m_strConfigFile);
|
---|
858 | }
|
---|
859 |
|
---|
860 | /* Save global settings in the VirtualBox.xml */
|
---|
861 | {
|
---|
862 | /* Marks the global registry for uuid as modified */
|
---|
863 | Guid uuid = machine->mData->mUuid;
|
---|
864 | machine->mParent->i_markRegistryModified(uuid);
|
---|
865 |
|
---|
866 | /* for saving the global settings we should hold only the VirtualBox lock */
|
---|
867 | AutoWriteLock vboxLock(machine->mParent COMMA_LOCKVAL_SRC_POS);
|
---|
868 |
|
---|
869 | rc = machine->mParent->i_saveSettings();
|
---|
870 | }
|
---|
871 | }
|
---|
872 | catch(HRESULT hrc)
|
---|
873 | {
|
---|
874 | LogRelFunc(("Moving machine to a new destination was failed. Check original and destination places.\n"));
|
---|
875 | rc = hrc;
|
---|
876 | taskMoveVM->result = rc;
|
---|
877 | }
|
---|
878 | catch (...)
|
---|
879 | {
|
---|
880 | LogRelFunc(("Moving machine to a new destination was failed. Check original and destination places.\n"));
|
---|
881 | rc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
|
---|
882 | taskMoveVM->result = rc;
|
---|
883 | }
|
---|
884 |
|
---|
885 | /* Cleanup on failure */
|
---|
886 | if (FAILED(rc))
|
---|
887 | {
|
---|
888 | Machine::Data *machineData = machine->mData.data();
|
---|
889 |
|
---|
890 | /* ! Apparently we should update the Progress object !*/
|
---|
891 | ULONG operationCount = 0;
|
---|
892 | rc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
|
---|
893 | ULONG operation = 0;
|
---|
894 | rc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
|
---|
895 | Bstr bstrOperationDescription;
|
---|
896 | rc = taskMoveVM->m_pProgress->COMGETTER(OperationDescription)(bstrOperationDescription.asOutParam());
|
---|
897 | Utf8Str strOperationDescription = bstrOperationDescription;
|
---|
898 | ULONG operationPercent = 0;
|
---|
899 | rc = taskMoveVM->m_pProgress->COMGETTER(OperationPercent)(&operationPercent);
|
---|
900 |
|
---|
901 | Bstr bstrMachineName;
|
---|
902 | machine->COMGETTER(Name)(bstrMachineName.asOutParam());
|
---|
903 | LogRelFunc(("Moving machine %s was failed on operation %s\n",
|
---|
904 | Utf8Str(bstrMachineName.raw()).c_str(), Utf8Str(bstrOperationDescription.raw()).c_str()));
|
---|
905 |
|
---|
906 | /* Restoring the original mediums */
|
---|
907 | try
|
---|
908 | {
|
---|
909 | /*
|
---|
910 | * Fix the progress counter
|
---|
911 | * In instance, the whole "move vm" operation is failed on 5th step. But total count is 20.
|
---|
912 | * Where 20 = 2 * 10 operations, where 10 is the real number of operations. And this value was doubled
|
---|
913 | * earlier in the init() exactly for one reason - rollback operation. Because in this case we must do
|
---|
914 | * the same operations but in backward direction.
|
---|
915 | * Thus now we want to correct the progress counter from 5 to 15. Why?
|
---|
916 | * Because we should have evaluated the counter as "20/2 + (20/2 - 5)" = 15 or just "20 - 5" = 15
|
---|
917 | * And because the 5th step failed it shouldn't be counted.
|
---|
918 | * As result, we need to rollback 4 operations.
|
---|
919 | * Thus we start from "operation + 1" and finish when "i < operationCount - operation".
|
---|
920 | */
|
---|
921 | for (ULONG i = operation + 1; i < operationCount - operation; ++i)
|
---|
922 | {
|
---|
923 | rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt("Skip the empty operation %d...", i + 1).raw(), 1);
|
---|
924 | if (FAILED(rc)) throw rc;
|
---|
925 | }
|
---|
926 |
|
---|
927 | rc = taskMoveVM->moveAllDisks(taskMoveVM->finalMediumsMap);
|
---|
928 | if (FAILED(rc))
|
---|
929 | throw rc;
|
---|
930 | }
|
---|
931 | catch(HRESULT hrc)
|
---|
932 | {
|
---|
933 | LogRelFunc(("Rollback scenario: restoration the original mediums were failed. Machine can be corrupted.\n"));
|
---|
934 | taskMoveVM->result = hrc;
|
---|
935 | }
|
---|
936 | catch (...)
|
---|
937 | {
|
---|
938 | LogRelFunc(("Rollback scenario: restoration the original mediums were failed. Machine can be corrupted.\n"));
|
---|
939 | rc = VirtualBoxBase::handleUnexpectedExceptions(machine, RT_SRC_POS);
|
---|
940 | taskMoveVM->result = rc;
|
---|
941 | }
|
---|
942 |
|
---|
943 | /* Revert original paths to the state files */
|
---|
944 | rc = taskMoveVM->updatePathsToStateFiles(taskMoveVM->finalSaveStateFilesMap,
|
---|
945 | strTargetFolder,
|
---|
946 | taskMoveVM->vmFolders[VBox_SettingFolder]);
|
---|
947 | if (FAILED(rc))
|
---|
948 | {
|
---|
949 | LogRelFunc(("Rollback scenario: can't restore the original paths to the state files. "
|
---|
950 | "Machine settings %s can be corrupted.\n", machineData->m_strConfigFileFull.c_str()));
|
---|
951 | }
|
---|
952 |
|
---|
953 | /* Delete all created files. Here we update progress object */
|
---|
954 | rc = taskMoveVM->deleteFiles(newFiles);
|
---|
955 | if (FAILED(rc))
|
---|
956 | LogRelFunc(("Rollback scenario: can't delete new created files. Check the destination folder."));
|
---|
957 |
|
---|
958 | /* Delete destination folder */
|
---|
959 | RTDirRemove(strTargetFolder.c_str());
|
---|
960 |
|
---|
961 | /* save all VM data */
|
---|
962 | {
|
---|
963 | AutoWriteLock srcLock(machine COMMA_LOCKVAL_SRC_POS);
|
---|
964 | srcLock.release();
|
---|
965 | rc = machine->SaveSettings();
|
---|
966 | srcLock.acquire();
|
---|
967 | }
|
---|
968 |
|
---|
969 | /* Restore an original path to XML setting file */
|
---|
970 | {
|
---|
971 | LogRelFunc(("Rollback scenario: restoration of the original path to XML setting file\n"));
|
---|
972 | Utf8Str strOriginalSettingsFilePath = taskMoveVM->vmFolders[VBox_SettingFolder];
|
---|
973 | strOriginalSettingsFilePath.append(RTPATH_DELIMITER).append(Utf8Str(bstrMachineName)).append(".vbox");
|
---|
974 | machineData->m_strConfigFileFull = strOriginalSettingsFilePath;
|
---|
975 | machine->mParent->i_copyPathRelativeToConfig(strOriginalSettingsFilePath, machineData->m_strConfigFile);
|
---|
976 | }
|
---|
977 |
|
---|
978 | /* Marks the global registry for uuid as modified */
|
---|
979 | {
|
---|
980 | AutoWriteLock srcLock(machine COMMA_LOCKVAL_SRC_POS);
|
---|
981 | srcLock.release();
|
---|
982 | Guid uuid = machine->mData->mUuid;
|
---|
983 | machine->mParent->i_markRegistryModified(uuid);
|
---|
984 | srcLock.acquire();
|
---|
985 | }
|
---|
986 |
|
---|
987 | /* save the global settings; for that we should hold only the VirtualBox lock */
|
---|
988 | {
|
---|
989 | AutoWriteLock vboxLock(machine->mParent COMMA_LOCKVAL_SRC_POS);
|
---|
990 | rc = machine->mParent->i_saveSettings();
|
---|
991 | }
|
---|
992 |
|
---|
993 | /* In case of failure the progress object on the other side (user side) get notification about operation
|
---|
994 | completion but the operation percentage may not be set to 100% */
|
---|
995 | }
|
---|
996 | else /*Operation was successful and now we can delete the original files like the state files, XML setting, log files */
|
---|
997 | {
|
---|
998 | /*
|
---|
999 | * In case of success it's not urgent to update the progress object because we call i_notifyComplete() with
|
---|
1000 | * the success result. As result, the last number of progress operation can be not equal the number of operations
|
---|
1001 | * because we doubled the number of operations for rollback case.
|
---|
1002 | * But if we want to update the progress object corectly it's needed to add all medium moved by standard
|
---|
1003 | * "move medium" logic (for us it's taskMoveVM->finalMediumsMap) to the current number of operation.
|
---|
1004 | */
|
---|
1005 |
|
---|
1006 | ULONG operationCount = 0;
|
---|
1007 | rc = taskMoveVM->m_pProgress->COMGETTER(OperationCount)(&operationCount);
|
---|
1008 | ULONG operation = 0;
|
---|
1009 | rc = taskMoveVM->m_pProgress->COMGETTER(Operation)(&operation);
|
---|
1010 |
|
---|
1011 | for (ULONG i = operation; i < operation + taskMoveVM->finalMediumsMap.size() - 1; ++i)
|
---|
1012 | {
|
---|
1013 | rc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt("Skip the empty operation %d...", i).raw(), 1);
|
---|
1014 | if (FAILED(rc)) throw rc;
|
---|
1015 | }
|
---|
1016 |
|
---|
1017 | rc = taskMoveVM->deleteFiles(originalFiles);
|
---|
1018 | if (FAILED(rc))
|
---|
1019 | LogRelFunc(("Forward scenario: can't delete all original files.\n"));
|
---|
1020 | }
|
---|
1021 |
|
---|
1022 | if (!taskMoveVM->m_pProgress.isNull())
|
---|
1023 | {
|
---|
1024 | /* Set the first error happened */
|
---|
1025 | if (!taskMoveVM->errorsList.empty())
|
---|
1026 | {
|
---|
1027 | ErrorInfoItem ei = taskMoveVM->errorsList.front();
|
---|
1028 | machine->setError(ei.m_code, machine->tr(ei.m_description.c_str()));
|
---|
1029 | }
|
---|
1030 |
|
---|
1031 | taskMoveVM->m_pProgress->i_notifyComplete(taskMoveVM->result);
|
---|
1032 | }
|
---|
1033 |
|
---|
1034 | LogFlowFuncLeave();
|
---|
1035 | }
|
---|
1036 |
|
---|
1037 | HRESULT MachineMoveVM::moveAllDisks(const std::map<Utf8Str, MEDIUMTASKMOVE>& listOfDisks,
|
---|
1038 | const Utf8Str* strTargetFolder)
|
---|
1039 | {
|
---|
1040 | HRESULT rc = S_OK;
|
---|
1041 | ComObjPtr<Machine> &machine = m_pMachine;
|
---|
1042 | Utf8Str strLocation;
|
---|
1043 |
|
---|
1044 | AutoWriteLock machineLock(machine COMMA_LOCKVAL_SRC_POS);
|
---|
1045 |
|
---|
1046 | try{
|
---|
1047 | std::map<Utf8Str, MEDIUMTASKMOVE>::const_iterator itMedium = listOfDisks.begin();
|
---|
1048 | while(itMedium != listOfDisks.end())
|
---|
1049 | {
|
---|
1050 | const MEDIUMTASKMOVE &mt = itMedium->second;
|
---|
1051 | ComPtr<IMedium> pMedium = mt.pMedium;
|
---|
1052 | Utf8Str strTargetImageName;
|
---|
1053 | Bstr bstrLocation;
|
---|
1054 | Bstr bstrSrcName;
|
---|
1055 |
|
---|
1056 | rc = pMedium->COMGETTER(Name)(bstrSrcName.asOutParam());
|
---|
1057 | if (FAILED(rc)) throw rc;
|
---|
1058 |
|
---|
1059 | if (strTargetFolder != NULL && !strTargetFolder->isEmpty())
|
---|
1060 | {
|
---|
1061 | strTargetImageName = *strTargetFolder;
|
---|
1062 | rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1063 | if (FAILED(rc)) throw rc;
|
---|
1064 | strLocation = bstrLocation;
|
---|
1065 |
|
---|
1066 | if (mt.fSnapshot == true)
|
---|
1067 | {
|
---|
1068 | strLocation.stripFilename().stripPath().append(RTPATH_DELIMITER).append(Utf8Str(bstrSrcName));
|
---|
1069 | }
|
---|
1070 | else
|
---|
1071 | {
|
---|
1072 | strLocation.stripPath();
|
---|
1073 | }
|
---|
1074 |
|
---|
1075 | strTargetImageName.append(RTPATH_DELIMITER).append(strLocation);
|
---|
1076 | rc = m_pProgress->SetNextOperation(BstrFmt(machine->tr("Moving medium '%ls' ..."),
|
---|
1077 | bstrSrcName.raw()).raw(),
|
---|
1078 | mt.uWeight);
|
---|
1079 | if (FAILED(rc)) throw rc;
|
---|
1080 | }
|
---|
1081 | else
|
---|
1082 | {
|
---|
1083 | strTargetImageName = mt.strBaseName;//Should contain full path to the image
|
---|
1084 | rc = m_pProgress->SetNextOperation(BstrFmt(machine->tr("Moving medium '%ls' back..."),
|
---|
1085 | bstrSrcName.raw()).raw(),
|
---|
1086 | mt.uWeight);
|
---|
1087 | if (FAILED(rc)) throw rc;
|
---|
1088 | }
|
---|
1089 |
|
---|
1090 |
|
---|
1091 |
|
---|
1092 | /* consistency: use \ if appropriate on the platform */
|
---|
1093 | RTPathChangeToDosSlashes(strTargetImageName.mutableRaw(), false);
|
---|
1094 |
|
---|
1095 | bstrLocation = strTargetImageName.c_str();
|
---|
1096 |
|
---|
1097 | MediumType_T mediumType;//immutable, shared, passthrough
|
---|
1098 | rc = pMedium->COMGETTER(Type)(&mediumType);
|
---|
1099 | if (FAILED(rc)) throw rc;
|
---|
1100 |
|
---|
1101 | DeviceType_T deviceType;//floppy, hard, DVD
|
---|
1102 | rc = pMedium->COMGETTER(DeviceType)(&deviceType);
|
---|
1103 | if (FAILED(rc)) throw rc;
|
---|
1104 |
|
---|
1105 | /* Drop lock early because IMedium::MoveTo needs to get the VirtualBox one. */
|
---|
1106 | machineLock.release();
|
---|
1107 |
|
---|
1108 | ComPtr<IProgress> moveDiskProgress;
|
---|
1109 | rc = pMedium->MoveTo(bstrLocation.raw(), moveDiskProgress.asOutParam());
|
---|
1110 | if (SUCCEEDED(rc))
|
---|
1111 | {
|
---|
1112 | /* In case of failure moveDiskProgress would be in the invalid state or not initialized at all
|
---|
1113 | * Call i_waitForOtherProgressCompletion only in success
|
---|
1114 | */
|
---|
1115 | /* Wait until the other process has finished. */
|
---|
1116 | rc = m_pProgress->WaitForOtherProgressCompletion(moveDiskProgress, 0 /* indefinite wait */);
|
---|
1117 | }
|
---|
1118 |
|
---|
1119 | /*acquire the lock back*/
|
---|
1120 | machineLock.acquire();
|
---|
1121 |
|
---|
1122 | /** @todo r=klaus get rid of custom error handling logic everywhere in this file */
|
---|
1123 | if (FAILED(rc))
|
---|
1124 | {
|
---|
1125 | com::ErrorInfoKeeper eik;
|
---|
1126 | Utf8Str errorDesc(eik.getText().raw());
|
---|
1127 | errorsList.push_back(ErrorInfoItem(eik.getResultCode(), errorDesc.c_str()));
|
---|
1128 | }
|
---|
1129 |
|
---|
1130 | if (FAILED(rc)) throw rc;
|
---|
1131 |
|
---|
1132 | LogRelFunc(("Moving %s has been finished\n", strTargetImageName.c_str()));
|
---|
1133 |
|
---|
1134 | ++itMedium;
|
---|
1135 | }
|
---|
1136 |
|
---|
1137 | machineLock.release();
|
---|
1138 | }
|
---|
1139 | catch(HRESULT hrc)
|
---|
1140 | {
|
---|
1141 | LogRelFunc(("\nException during moving the disk %s\n", strLocation.c_str()));
|
---|
1142 | rc = hrc;
|
---|
1143 | machineLock.release();
|
---|
1144 | }
|
---|
1145 | catch (...)
|
---|
1146 | {
|
---|
1147 | LogRelFunc(("\nException during moving the disk %s\n", strLocation.c_str()));
|
---|
1148 | rc = VirtualBoxBase::handleUnexpectedExceptions(m_pMachine, RT_SRC_POS);
|
---|
1149 | machineLock.release();
|
---|
1150 | }
|
---|
1151 |
|
---|
1152 | if (FAILED(rc))
|
---|
1153 | {
|
---|
1154 | Utf8StrFmt errorDesc("Exception during moving the disk %s\n", strLocation.c_str());
|
---|
1155 | errorsList.push_back(ErrorInfoItem(rc, errorDesc.c_str()));
|
---|
1156 | }
|
---|
1157 |
|
---|
1158 | return rc;
|
---|
1159 | }
|
---|
1160 |
|
---|
1161 | HRESULT MachineMoveVM::updatePathsToStateFiles(const std::map<Utf8Str, SAVESTATETASKMOVE>& listOfFiles,
|
---|
1162 | const Utf8Str& sourcePath, const Utf8Str& targetPath)
|
---|
1163 | {
|
---|
1164 | HRESULT rc = S_OK;
|
---|
1165 |
|
---|
1166 | std::map<Utf8Str, SAVESTATETASKMOVE>::const_iterator itState = listOfFiles.begin();
|
---|
1167 | while (itState != listOfFiles.end())
|
---|
1168 | {
|
---|
1169 | const SAVESTATETASKMOVE &sst = itState->second;
|
---|
1170 |
|
---|
1171 | if (sst.snapshotUuid != Guid::Empty)
|
---|
1172 | {
|
---|
1173 | Utf8Str strGuidMachine = sst.snapshotUuid.toString();
|
---|
1174 | ComObjPtr<Snapshot> snapshotMachineObj;
|
---|
1175 |
|
---|
1176 | rc = m_pMachine->i_findSnapshotById(sst.snapshotUuid, snapshotMachineObj, true);
|
---|
1177 | if (SUCCEEDED(rc) && !snapshotMachineObj.isNull())
|
---|
1178 | {
|
---|
1179 | snapshotMachineObj->i_updateSavedStatePaths(sourcePath.c_str(),
|
---|
1180 | targetPath.c_str());
|
---|
1181 | }
|
---|
1182 | }
|
---|
1183 | else
|
---|
1184 | {
|
---|
1185 | const Utf8Str &path = m_pMachine->mSSData->strStateFilePath;
|
---|
1186 | /*
|
---|
1187 | * This check for the case when a new value is equal to the old one.
|
---|
1188 | * Maybe the more clever check is needed in the some corner cases.
|
---|
1189 | */
|
---|
1190 | if (!path.contains(targetPath))
|
---|
1191 | {
|
---|
1192 | m_pMachine->mSSData->strStateFilePath = Utf8StrFmt("%s%s",
|
---|
1193 | targetPath.c_str(),
|
---|
1194 | path.c_str() + sourcePath.length());
|
---|
1195 | }
|
---|
1196 | }
|
---|
1197 |
|
---|
1198 | ++itState;
|
---|
1199 | }
|
---|
1200 |
|
---|
1201 | return rc;
|
---|
1202 | }
|
---|
1203 |
|
---|
1204 | HRESULT MachineMoveVM::getFilesList(const Utf8Str& strRootFolder, fileList_t &filesList)
|
---|
1205 | {
|
---|
1206 | RTDIR hDir;
|
---|
1207 | HRESULT rc = S_OK;
|
---|
1208 | int vrc = RTDirOpen(&hDir, strRootFolder.c_str());
|
---|
1209 | if (RT_SUCCESS(vrc))
|
---|
1210 | {
|
---|
1211 | RTDIRENTRY DirEntry;
|
---|
1212 | while (RT_SUCCESS(RTDirRead(hDir, &DirEntry, NULL)))
|
---|
1213 | {
|
---|
1214 | if (RTDirEntryIsStdDotLink(&DirEntry))
|
---|
1215 | continue;
|
---|
1216 |
|
---|
1217 | if (DirEntry.enmType == RTDIRENTRYTYPE_FILE)
|
---|
1218 | {
|
---|
1219 | Utf8Str fullPath(strRootFolder);
|
---|
1220 | filesList.add(strRootFolder, DirEntry.szName);
|
---|
1221 | }
|
---|
1222 | else if (DirEntry.enmType == RTDIRENTRYTYPE_DIRECTORY)
|
---|
1223 | {
|
---|
1224 | Utf8Str strNextFolder(strRootFolder);
|
---|
1225 | strNextFolder.append(RTPATH_DELIMITER).append(DirEntry.szName);
|
---|
1226 | rc = getFilesList(strNextFolder, filesList);
|
---|
1227 | if (FAILED(rc))
|
---|
1228 | break;
|
---|
1229 | }
|
---|
1230 | }
|
---|
1231 |
|
---|
1232 | vrc = RTDirClose(hDir);
|
---|
1233 | AssertRC(vrc);
|
---|
1234 | }
|
---|
1235 | else if (vrc == VERR_FILE_NOT_FOUND)
|
---|
1236 | {
|
---|
1237 | Utf8StrFmt errorDesc("Folder '%s' doesn't exist (%Rrc)", strRootFolder.c_str(), vrc);
|
---|
1238 | errorsList.push_back(ErrorInfoItem(VERR_FILE_NOT_FOUND, errorDesc.c_str()));
|
---|
1239 |
|
---|
1240 | rc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
|
---|
1241 | }
|
---|
1242 | else
|
---|
1243 | {
|
---|
1244 | Utf8StrFmt errorDesc("Could not open folder '%s' (%Rrc)", strRootFolder.c_str(), vrc);
|
---|
1245 | errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
1246 |
|
---|
1247 | /** @todo r=bird: document this throwing business, please! Error handling is
|
---|
1248 | * a bit fishy here. See also */
|
---|
1249 | throw m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
|
---|
1250 | }
|
---|
1251 |
|
---|
1252 | return rc;
|
---|
1253 | }
|
---|
1254 |
|
---|
1255 | HRESULT MachineMoveVM::deleteFiles(const RTCList<Utf8Str>& listOfFiles)
|
---|
1256 | {
|
---|
1257 | HRESULT rc = S_OK;
|
---|
1258 | /* Delete all created files. */
|
---|
1259 | try
|
---|
1260 | {
|
---|
1261 | for (size_t i = 0; i < listOfFiles.size(); ++i)
|
---|
1262 | {
|
---|
1263 | LogRelFunc(("Deleting file %s ...\n", listOfFiles.at(i).c_str()));
|
---|
1264 | rc = m_pProgress->SetNextOperation(BstrFmt("Deleting file %s...", listOfFiles.at(i).c_str()).raw(), 1);
|
---|
1265 | if (FAILED(rc)) throw rc;
|
---|
1266 |
|
---|
1267 | int vrc = RTFileDelete(listOfFiles.at(i).c_str());
|
---|
1268 | if (RT_FAILURE(vrc))
|
---|
1269 | {
|
---|
1270 | Utf8StrFmt errorDesc("Could not delete file '%s' (%Rrc)", listOfFiles.at(i).c_str(), rc);
|
---|
1271 | errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
1272 |
|
---|
1273 | rc = m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
|
---|
1274 | }
|
---|
1275 | else
|
---|
1276 | LogRelFunc(("File %s has been deleted\n", listOfFiles.at(i).c_str()));
|
---|
1277 | }
|
---|
1278 | }
|
---|
1279 | catch(HRESULT hrc)
|
---|
1280 | {
|
---|
1281 | rc = hrc;
|
---|
1282 | }
|
---|
1283 | catch (...)
|
---|
1284 | {
|
---|
1285 | rc = VirtualBoxBase::handleUnexpectedExceptions(m_pMachine, RT_SRC_POS);
|
---|
1286 | }
|
---|
1287 |
|
---|
1288 | return rc;
|
---|
1289 | }
|
---|
1290 |
|
---|
1291 | HRESULT MachineMoveVM::getFolderSize(const Utf8Str& strRootFolder, uint64_t& size)
|
---|
1292 | {
|
---|
1293 | HRESULT rc = S_OK;
|
---|
1294 | int vrc = 0;
|
---|
1295 | uint64_t totalFolderSize = 0;
|
---|
1296 | fileList_t filesList;
|
---|
1297 |
|
---|
1298 | bool ex = RTPathExists(strRootFolder.c_str());
|
---|
1299 | if (ex == true)
|
---|
1300 | {
|
---|
1301 | rc = getFilesList(strRootFolder, filesList);
|
---|
1302 | if (SUCCEEDED(rc))
|
---|
1303 | {
|
---|
1304 | cit_t it = filesList.m_list.begin();
|
---|
1305 | while(it != filesList.m_list.end())
|
---|
1306 | {
|
---|
1307 | uint64_t cbFile = 0;
|
---|
1308 | Utf8Str fullPath = it->first;
|
---|
1309 | fullPath.append(RTPATH_DELIMITER).append(it->second);
|
---|
1310 | vrc = RTFileQuerySize(fullPath.c_str(), &cbFile);
|
---|
1311 | if (RT_SUCCESS(vrc))
|
---|
1312 | {
|
---|
1313 | totalFolderSize += cbFile;
|
---|
1314 | }
|
---|
1315 | else
|
---|
1316 | {
|
---|
1317 | Utf8StrFmt errorDesc("Could not get the size of file '%s' (%Rrc)", fullPath.c_str(), vrc);
|
---|
1318 | errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
1319 |
|
---|
1320 | throw m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
|
---|
1321 | }
|
---|
1322 | ++it;
|
---|
1323 | }
|
---|
1324 |
|
---|
1325 | size = totalFolderSize;
|
---|
1326 | }
|
---|
1327 | else
|
---|
1328 | {
|
---|
1329 | /** @todo r=bird: This only happens if RTDirOpen fails. So, I'm not sure
|
---|
1330 | * what you're going for here... See not about throwing in getFilesList(). */
|
---|
1331 | Utf8StrFmt errorDesc("Could not calculate the size of folder '%s'", strRootFolder.c_str());
|
---|
1332 | errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
1333 |
|
---|
1334 | m_pMachine->setError(VBOX_E_IPRT_ERROR, m_pMachine->tr(errorDesc.c_str()));
|
---|
1335 | }
|
---|
1336 | }
|
---|
1337 | else
|
---|
1338 | size = 0;
|
---|
1339 |
|
---|
1340 | return rc;
|
---|
1341 | }
|
---|
1342 |
|
---|
1343 | HRESULT MachineMoveVM::queryBaseName(const ComPtr<IMedium> &pMedium, Utf8Str &strBaseName) const
|
---|
1344 | {
|
---|
1345 | ComPtr<IMedium> pBaseMedium;
|
---|
1346 | HRESULT rc = pMedium->COMGETTER(Base)(pBaseMedium.asOutParam());
|
---|
1347 | if (FAILED(rc)) return rc;
|
---|
1348 | Bstr bstrBaseName;
|
---|
1349 | rc = pBaseMedium->COMGETTER(Name)(bstrBaseName.asOutParam());
|
---|
1350 | if (FAILED(rc)) return rc;
|
---|
1351 | strBaseName = bstrBaseName;
|
---|
1352 | return rc;
|
---|
1353 | }
|
---|
1354 |
|
---|
1355 | HRESULT MachineMoveVM::createMachineList(const ComPtr<ISnapshot> &pSnapshot,
|
---|
1356 | std::vector< ComObjPtr<Machine> > &aMachineList) const
|
---|
1357 | {
|
---|
1358 | HRESULT rc = S_OK;
|
---|
1359 | Bstr name;
|
---|
1360 | rc = pSnapshot->COMGETTER(Name)(name.asOutParam());
|
---|
1361 | if (FAILED(rc)) return rc;
|
---|
1362 |
|
---|
1363 | ComPtr<IMachine> l_pMachine;
|
---|
1364 | rc = pSnapshot->COMGETTER(Machine)(l_pMachine.asOutParam());
|
---|
1365 | if (FAILED(rc)) return rc;
|
---|
1366 | aMachineList.push_back((Machine*)(IMachine*)l_pMachine);
|
---|
1367 |
|
---|
1368 | SafeIfaceArray<ISnapshot> sfaChilds;
|
---|
1369 | rc = pSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(sfaChilds));
|
---|
1370 | if (FAILED(rc)) return rc;
|
---|
1371 | for (size_t i = 0; i < sfaChilds.size(); ++i)
|
---|
1372 | {
|
---|
1373 | rc = createMachineList(sfaChilds[i], aMachineList);
|
---|
1374 | if (FAILED(rc)) return rc;
|
---|
1375 | }
|
---|
1376 |
|
---|
1377 | return rc;
|
---|
1378 | }
|
---|
1379 |
|
---|
1380 | HRESULT MachineMoveVM::queryMediasForAllStates(const std::vector<ComObjPtr<Machine> > &aMachineList)
|
---|
1381 | {
|
---|
1382 | /* In this case we create a exact copy of the original VM. This means just
|
---|
1383 | * adding all directly and indirectly attached disk images to the worker
|
---|
1384 | * list. */
|
---|
1385 | HRESULT rc = S_OK;
|
---|
1386 | for (size_t i = 0; i < aMachineList.size(); ++i)
|
---|
1387 | {
|
---|
1388 | const ComObjPtr<Machine> &machine = aMachineList.at(i);
|
---|
1389 |
|
---|
1390 | /* Add all attachments (and their parents) of the different
|
---|
1391 | * machines to a worker list. */
|
---|
1392 | SafeIfaceArray<IMediumAttachment> sfaAttachments;
|
---|
1393 | rc = machine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(sfaAttachments));
|
---|
1394 | if (FAILED(rc)) return rc;
|
---|
1395 | for (size_t a = 0; a < sfaAttachments.size(); ++a)
|
---|
1396 | {
|
---|
1397 | const ComPtr<IMediumAttachment> &pAtt = sfaAttachments[a];
|
---|
1398 | DeviceType_T deviceType;//floppy, hard, DVD
|
---|
1399 | rc = pAtt->COMGETTER(Type)(&deviceType);
|
---|
1400 | if (FAILED(rc)) return rc;
|
---|
1401 |
|
---|
1402 | /* Valid medium attached? */
|
---|
1403 | ComPtr<IMedium> pMedium;
|
---|
1404 | rc = pAtt->COMGETTER(Medium)(pMedium.asOutParam());
|
---|
1405 | if (FAILED(rc)) return rc;
|
---|
1406 |
|
---|
1407 | if (pMedium.isNull())
|
---|
1408 | continue;
|
---|
1409 |
|
---|
1410 | Bstr bstrLocation;
|
---|
1411 | rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1412 | if (FAILED(rc)) throw rc;
|
---|
1413 |
|
---|
1414 | /* Cast to ComObjPtr<Medium> */
|
---|
1415 | ComObjPtr<Medium> pObjMedium = (Medium *)(IMedium *)pMedium;
|
---|
1416 |
|
---|
1417 | /*Check for "read-only" medium in terms that VBox can't create this one */
|
---|
1418 | bool fPass = isMediumTypeSupportedForMoving(pMedium);
|
---|
1419 | if(!fPass)
|
---|
1420 | {
|
---|
1421 | LogRelFunc(("Skipping file %s because of this medium type hasn't been supported for moving.\n",
|
---|
1422 | Utf8Str(bstrLocation.raw()).c_str()));
|
---|
1423 | continue;
|
---|
1424 | }
|
---|
1425 |
|
---|
1426 | MEDIUMTASKCHAINMOVE mtc;
|
---|
1427 | mtc.devType = deviceType;
|
---|
1428 | mtc.fAttachLinked = false;
|
---|
1429 | mtc.fCreateDiffs = false;
|
---|
1430 |
|
---|
1431 | while (!pMedium.isNull())
|
---|
1432 | {
|
---|
1433 | /* Refresh the state so that the file size get read. */
|
---|
1434 | MediumState_T e;
|
---|
1435 | rc = pMedium->RefreshState(&e);
|
---|
1436 | if (FAILED(rc)) return rc;
|
---|
1437 |
|
---|
1438 | LONG64 lSize;
|
---|
1439 | rc = pMedium->COMGETTER(Size)(&lSize);
|
---|
1440 | if (FAILED(rc)) return rc;
|
---|
1441 |
|
---|
1442 | MediumType_T mediumType;//immutable, shared, passthrough
|
---|
1443 | rc = pMedium->COMGETTER(Type)(&mediumType);
|
---|
1444 | if (FAILED(rc)) throw rc;
|
---|
1445 |
|
---|
1446 | rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1447 | if (FAILED(rc)) throw rc;
|
---|
1448 |
|
---|
1449 | MEDIUMTASKMOVE mt;// = {false, "basename", NULL, 0, 0};
|
---|
1450 | mt.strBaseName = bstrLocation;
|
---|
1451 | Utf8Str strFolder = vmFolders[VBox_SnapshotFolder];
|
---|
1452 | if (strFolder.isNotEmpty() && mt.strBaseName.contains(strFolder))
|
---|
1453 | {
|
---|
1454 | mt.fSnapshot = true;
|
---|
1455 | }
|
---|
1456 | else
|
---|
1457 | mt.fSnapshot = false;
|
---|
1458 |
|
---|
1459 | mt.uIdx = UINT32_MAX;
|
---|
1460 | mt.pMedium = pMedium;
|
---|
1461 | mt.uWeight = (ULONG)((lSize + _1M - 1) / _1M);
|
---|
1462 | mtc.chain.append(mt);
|
---|
1463 |
|
---|
1464 | /* Query next parent. */
|
---|
1465 | rc = pMedium->COMGETTER(Parent)(pMedium.asOutParam());
|
---|
1466 | if (FAILED(rc)) return rc;
|
---|
1467 | }
|
---|
1468 |
|
---|
1469 | llMedias.append(mtc);
|
---|
1470 | }
|
---|
1471 | /* Add the save state files of this machine if there is one. */
|
---|
1472 | rc = addSaveState(machine);
|
---|
1473 | if (FAILED(rc)) return rc;
|
---|
1474 |
|
---|
1475 | }
|
---|
1476 | /* Build up the index list of the image chain. Unfortunately we can't do
|
---|
1477 | * that in the previous loop, cause there we go from child -> parent and
|
---|
1478 | * didn't know how many are between. */
|
---|
1479 | for (size_t i = 0; i < llMedias.size(); ++i)
|
---|
1480 | {
|
---|
1481 | uint32_t uIdx = 0;
|
---|
1482 | MEDIUMTASKCHAINMOVE &mtc = llMedias.at(i);
|
---|
1483 | for (size_t a = mtc.chain.size(); a > 0; --a)
|
---|
1484 | mtc.chain[a - 1].uIdx = uIdx++;
|
---|
1485 | }
|
---|
1486 |
|
---|
1487 | return rc;
|
---|
1488 | }
|
---|
1489 |
|
---|
1490 | HRESULT MachineMoveVM::addSaveState(const ComObjPtr<Machine> &machine)
|
---|
1491 | {
|
---|
1492 | Bstr bstrSrcSaveStatePath;
|
---|
1493 | HRESULT rc = machine->COMGETTER(StateFilePath)(bstrSrcSaveStatePath.asOutParam());
|
---|
1494 | if (FAILED(rc)) return rc;
|
---|
1495 | if (!bstrSrcSaveStatePath.isEmpty())
|
---|
1496 | {
|
---|
1497 | SAVESTATETASKMOVE sst;
|
---|
1498 |
|
---|
1499 | sst.snapshotUuid = machine->i_getSnapshotId();
|
---|
1500 | sst.strSaveStateFile = bstrSrcSaveStatePath;
|
---|
1501 | uint64_t cbSize;
|
---|
1502 |
|
---|
1503 | int vrc = RTFileQuerySize(sst.strSaveStateFile.c_str(), &cbSize);
|
---|
1504 | if (RT_FAILURE(vrc))
|
---|
1505 | {
|
---|
1506 | Utf8StrFmt errorDesc("Could not get file size of '%s' (%Rrc)", sst.strSaveStateFile.c_str(), vrc);
|
---|
1507 | errorsList.push_back(ErrorInfoItem(VBOX_E_IPRT_ERROR, errorDesc.c_str()));
|
---|
1508 |
|
---|
1509 | return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, m_pMachine->tr(errorDesc.c_str()));
|
---|
1510 | }
|
---|
1511 | /* same rule as above: count both the data which needs to
|
---|
1512 | * be read and written */
|
---|
1513 | sst.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
|
---|
1514 | llSaveStateFiles.append(sst);
|
---|
1515 | }
|
---|
1516 | return S_OK;
|
---|
1517 | }
|
---|
1518 |
|
---|
1519 | void MachineMoveVM::updateProgressStats(MEDIUMTASKCHAINMOVE &mtc, ULONG &uCount, ULONG &uTotalWeight) const
|
---|
1520 | {
|
---|
1521 |
|
---|
1522 | /* Currently the copying of diff images involves reading at least
|
---|
1523 | * the biggest parent in the previous chain. So even if the new
|
---|
1524 | * diff image is small in size, it could need some time to create
|
---|
1525 | * it. Adding the biggest size in the chain should balance this a
|
---|
1526 | * little bit more, i.e. the weight is the sum of the data which
|
---|
1527 | * needs to be read and written. */
|
---|
1528 | ULONG uMaxWeight = 0;
|
---|
1529 | for (size_t e = mtc.chain.size(); e > 0; --e)
|
---|
1530 | {
|
---|
1531 | MEDIUMTASKMOVE &mt = mtc.chain.at(e - 1);
|
---|
1532 | mt.uWeight += uMaxWeight;
|
---|
1533 |
|
---|
1534 | /* Calculate progress data */
|
---|
1535 | ++uCount;
|
---|
1536 | uTotalWeight += mt.uWeight;
|
---|
1537 |
|
---|
1538 | /* Save the max size for better weighting of diff image
|
---|
1539 | * creation. */
|
---|
1540 | uMaxWeight = RT_MAX(uMaxWeight, mt.uWeight);
|
---|
1541 | }
|
---|
1542 | }
|
---|
1543 |
|
---|
1544 | bool MachineMoveVM::isMediumTypeSupportedForMoving(const ComPtr<IMedium> &pMedium)
|
---|
1545 | {
|
---|
1546 | HRESULT rc = S_OK;
|
---|
1547 | bool fSupported = true;
|
---|
1548 | Bstr bstrLocation;
|
---|
1549 | rc = pMedium->COMGETTER(Location)(bstrLocation.asOutParam());
|
---|
1550 | if (FAILED(rc))
|
---|
1551 | {
|
---|
1552 | fSupported = false;
|
---|
1553 | throw rc;
|
---|
1554 | }
|
---|
1555 |
|
---|
1556 | DeviceType_T deviceType;
|
---|
1557 | rc = pMedium->COMGETTER(DeviceType)(&deviceType);
|
---|
1558 | if (FAILED(rc))
|
---|
1559 | {
|
---|
1560 | fSupported = false;
|
---|
1561 | throw rc;
|
---|
1562 | }
|
---|
1563 |
|
---|
1564 | ComPtr<IMediumFormat> mediumFormat;
|
---|
1565 | rc = pMedium->COMGETTER(MediumFormat)(mediumFormat.asOutParam());
|
---|
1566 | if (FAILED(rc))
|
---|
1567 | {
|
---|
1568 | fSupported = false;
|
---|
1569 | throw rc;
|
---|
1570 | }
|
---|
1571 |
|
---|
1572 | /*Check whether VBox is able to create this medium format or not, i.e. medium can be "read-only" */
|
---|
1573 | Bstr bstrFormatName;
|
---|
1574 | rc = mediumFormat->COMGETTER(Name)(bstrFormatName.asOutParam());
|
---|
1575 | if (FAILED(rc))
|
---|
1576 | {
|
---|
1577 | fSupported = false;
|
---|
1578 | throw rc;
|
---|
1579 | }
|
---|
1580 |
|
---|
1581 | Utf8Str formatName = Utf8Str(bstrFormatName);
|
---|
1582 | if (formatName.compare("VHDX", Utf8Str::CaseInsensitive) == 0)
|
---|
1583 | {
|
---|
1584 | LogRelFunc(("Skipping medium %s. VHDX format is supported in \"read-only\" mode only. \n",
|
---|
1585 | Utf8Str(bstrLocation.raw()).c_str()));
|
---|
1586 | fSupported = false;
|
---|
1587 | }
|
---|
1588 |
|
---|
1589 | /* Check whether medium is represented by file on the disk or not */
|
---|
1590 | if (fSupported)
|
---|
1591 | {
|
---|
1592 | ComObjPtr<Medium> pObjMedium = (Medium *)(IMedium *)pMedium;
|
---|
1593 | fSupported = pObjMedium->i_isMediumFormatFile();
|
---|
1594 | if (!fSupported)
|
---|
1595 | {
|
---|
1596 | LogRelFunc(("Skipping medium %s because it's not a real file on the disk.\n",
|
---|
1597 | Utf8Str(bstrLocation.raw()).c_str()));
|
---|
1598 | }
|
---|
1599 | }
|
---|
1600 |
|
---|
1601 | /* some special checks for DVD */
|
---|
1602 | if (fSupported && deviceType == DeviceType_DVD)
|
---|
1603 | {
|
---|
1604 | Utf8Str ext = bstrLocation;
|
---|
1605 | ext.assignEx(RTPathSuffix(ext.c_str()));//returns extension with dot (".iso")
|
---|
1606 |
|
---|
1607 | //only ISO image is moved. Otherwise adding some information into log file
|
---|
1608 | int equality = ext.compare(".iso", Utf8Str::CaseInsensitive);
|
---|
1609 | if (equality != false)
|
---|
1610 | {
|
---|
1611 | LogRelFunc(("Skipping file %s. Only ISO images are supported for now.\n",
|
---|
1612 | Utf8Str(bstrLocation.raw()).c_str()));
|
---|
1613 | fSupported = false;
|
---|
1614 | }
|
---|
1615 | }
|
---|
1616 |
|
---|
1617 | return fSupported;
|
---|
1618 | }
|
---|