VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp@ 74942

Last change on this file since 74942 was 74778, checked in by vboxsync, 6 years ago

OCI: Add VirtualSystemDescriptionType constants CloudOCIKeepObject and
CloudOCILaunchInstance.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 64.9 KB
Line 
1/* $Id: VBoxManageAppliance.cpp 74778 2018-10-11 23:14:43Z vboxsync $ */
2/** @file
3 * VBoxManage - The appliance-related commands.
4 */
5
6/*
7 * Copyright (C) 2009-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
18#ifndef VBOX_ONLY_DOCS
19
20
21/*********************************************************************************************************************************
22* Header Files *
23*********************************************************************************************************************************/
24#ifndef VBOX_ONLY_DOCS
25#include <VBox/com/com.h>
26#include <VBox/com/string.h>
27#include <VBox/com/Guid.h>
28#include <VBox/com/array.h>
29#include <VBox/com/ErrorInfo.h>
30#include <VBox/com/errorprint.h>
31#include <VBox/com/VirtualBox.h>
32
33#include <list>
34#include <map>
35#endif /* !VBOX_ONLY_DOCS */
36
37#include <iprt/stream.h>
38#include <iprt/getopt.h>
39#include <iprt/ctype.h>
40#include <iprt/path.h>
41#include <iprt/file.h>
42
43#include <VBox/log.h>
44#include <VBox/param.h>
45
46#include "VBoxManage.h"
47using namespace com;
48
49
50// funcs
51///////////////////////////////////////////////////////////////////////////////
52
53typedef std::map<Utf8Str, Utf8Str> ArgsMap; // pairs of strings like "vmname" => "newvmname"
54typedef std::map<uint32_t, ArgsMap> ArgsMapsMap; // map of maps, one for each virtual system, sorted by index
55
56typedef std::map<uint32_t, bool> IgnoresMap; // pairs of numeric description entry indices
57typedef std::map<uint32_t, IgnoresMap> IgnoresMapsMap; // map of maps, one for each virtual system, sorted by index
58
59static bool findArgValue(Utf8Str &strOut,
60 ArgsMap *pmapArgs,
61 const Utf8Str &strKey)
62{
63 if (pmapArgs)
64 {
65 ArgsMap::iterator it;
66 it = pmapArgs->find(strKey);
67 if (it != pmapArgs->end())
68 {
69 strOut = it->second;
70 pmapArgs->erase(it);
71 return true;
72 }
73 }
74
75 return false;
76}
77
78static int parseImportOptions(const char *psz, com::SafeArray<ImportOptions_T> *options)
79{
80 int rc = VINF_SUCCESS;
81 while (psz && *psz && RT_SUCCESS(rc))
82 {
83 size_t len;
84 const char *pszComma = strchr(psz, ',');
85 if (pszComma)
86 len = pszComma - psz;
87 else
88 len = strlen(psz);
89 if (len > 0)
90 {
91 if (!RTStrNICmp(psz, "KeepAllMACs", len))
92 options->push_back(ImportOptions_KeepAllMACs);
93 else if (!RTStrNICmp(psz, "KeepNATMACs", len))
94 options->push_back(ImportOptions_KeepNATMACs);
95 else if (!RTStrNICmp(psz, "ImportToVDI", len))
96 options->push_back(ImportOptions_ImportToVDI);
97 else
98 rc = VERR_PARSE_ERROR;
99 }
100 if (pszComma)
101 psz += len + 1;
102 else
103 psz += len;
104 }
105
106 return rc;
107}
108
109static const RTGETOPTDEF g_aImportApplianceOptions[] =
110{
111 { "--dry-run", 'n', RTGETOPT_REQ_NOTHING },
112 { "-dry-run", 'n', RTGETOPT_REQ_NOTHING }, // deprecated
113 { "--dryrun", 'n', RTGETOPT_REQ_NOTHING },
114 { "-dryrun", 'n', RTGETOPT_REQ_NOTHING }, // deprecated
115 { "--detailed-progress", 'P', RTGETOPT_REQ_NOTHING },
116 { "-detailed-progress", 'P', RTGETOPT_REQ_NOTHING }, // deprecated
117 { "--vsys", 's', RTGETOPT_REQ_UINT32 },
118 { "-vsys", 's', RTGETOPT_REQ_UINT32 }, // deprecated
119 { "--ostype", 'o', RTGETOPT_REQ_STRING },
120 { "-ostype", 'o', RTGETOPT_REQ_STRING }, // deprecated
121 { "--vmname", 'V', RTGETOPT_REQ_STRING },
122 { "-vmname", 'V', RTGETOPT_REQ_STRING }, // deprecated
123 { "--settingsfile", 'S', RTGETOPT_REQ_STRING },
124 { "--basefolder", 'p', RTGETOPT_REQ_STRING },
125 { "--group", 'g', RTGETOPT_REQ_STRING },
126 { "--memory", 'm', RTGETOPT_REQ_STRING },
127 { "-memory", 'm', RTGETOPT_REQ_STRING }, // deprecated
128 { "--cpus", 'c', RTGETOPT_REQ_STRING },
129 { "--description", 'd', RTGETOPT_REQ_STRING },
130 { "--eula", 'L', RTGETOPT_REQ_STRING },
131 { "-eula", 'L', RTGETOPT_REQ_STRING }, // deprecated
132 { "--unit", 'u', RTGETOPT_REQ_UINT32 },
133 { "-unit", 'u', RTGETOPT_REQ_UINT32 }, // deprecated
134 { "--ignore", 'x', RTGETOPT_REQ_NOTHING },
135 { "-ignore", 'x', RTGETOPT_REQ_NOTHING }, // deprecated
136 { "--scsitype", 'T', RTGETOPT_REQ_UINT32 },
137 { "-scsitype", 'T', RTGETOPT_REQ_UINT32 }, // deprecated
138 { "--type", 'T', RTGETOPT_REQ_UINT32 }, // deprecated
139 { "-type", 'T', RTGETOPT_REQ_UINT32 }, // deprecated
140#if 0 /* Changing the controller is fully valid, but the current design on how
141 the params are evaluated here doesn't allow two parameter for one
142 unit. The target disk path is more important. I leave it for future
143 improvments. */
144 { "--controller", 'C', RTGETOPT_REQ_STRING },
145#endif
146 { "--disk", 'D', RTGETOPT_REQ_STRING },
147 { "--options", 'O', RTGETOPT_REQ_STRING },
148};
149
150RTEXITCODE handleImportAppliance(HandlerArg *arg)
151{
152 HRESULT rc = S_OK;
153
154 Utf8Str strOvfFilename;
155 bool fExecute = true; // if true, then we actually do the import
156 com::SafeArray<ImportOptions_T> options;
157 uint32_t ulCurVsys = (uint32_t)-1;
158 uint32_t ulCurUnit = (uint32_t)-1;
159 // for each --vsys X command, maintain a map of command line items
160 // (we'll parse them later after interpreting the OVF, when we can
161 // actually check whether they make sense semantically)
162 ArgsMapsMap mapArgsMapsPerVsys;
163 IgnoresMapsMap mapIgnoresMapsPerVsys;
164
165 int c;
166 RTGETOPTUNION ValueUnion;
167 RTGETOPTSTATE GetState;
168 // start at 0 because main() has hacked both the argc and argv given to us
169 RTGetOptInit(&GetState, arg->argc, arg->argv, g_aImportApplianceOptions, RT_ELEMENTS(g_aImportApplianceOptions),
170 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
171 while ((c = RTGetOpt(&GetState, &ValueUnion)))
172 {
173 switch (c)
174 {
175 case 'n': // --dry-run
176 fExecute = false;
177 break;
178
179 case 'P': // --detailed-progress
180 g_fDetailedProgress = true;
181 break;
182
183 case 's': // --vsys
184 ulCurVsys = ValueUnion.u32;
185 ulCurUnit = (uint32_t)-1;
186 break;
187
188 case 'o': // --ostype
189 if (ulCurVsys == (uint32_t)-1)
190 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
191 mapArgsMapsPerVsys[ulCurVsys]["ostype"] = ValueUnion.psz;
192 break;
193
194 case 'V': // --vmname
195 if (ulCurVsys == (uint32_t)-1)
196 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
197 mapArgsMapsPerVsys[ulCurVsys]["vmname"] = ValueUnion.psz;
198 break;
199
200 case 'S': // --settingsfile
201 if (ulCurVsys == (uint32_t)-1)
202 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
203 mapArgsMapsPerVsys[ulCurVsys]["settingsfile"] = ValueUnion.psz;
204 break;
205
206 case 'p': // --basefolder
207 if (ulCurVsys == (uint32_t)-1)
208 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
209 mapArgsMapsPerVsys[ulCurVsys]["basefolder"] = ValueUnion.psz;
210 break;
211
212 case 'g': // --group
213 if (ulCurVsys == (uint32_t)-1)
214 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
215 mapArgsMapsPerVsys[ulCurVsys]["group"] = ValueUnion.psz;
216 break;
217
218 case 'd': // --description
219 if (ulCurVsys == (uint32_t)-1)
220 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
221 mapArgsMapsPerVsys[ulCurVsys]["description"] = ValueUnion.psz;
222 break;
223
224 case 'L': // --eula
225 if (ulCurVsys == (uint32_t)-1)
226 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
227 mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz;
228 break;
229
230 case 'm': // --memory
231 if (ulCurVsys == (uint32_t)-1)
232 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
233 mapArgsMapsPerVsys[ulCurVsys]["memory"] = ValueUnion.psz;
234 break;
235
236 case 'c': // --cpus
237 if (ulCurVsys == (uint32_t)-1)
238 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
239 mapArgsMapsPerVsys[ulCurVsys]["cpus"] = ValueUnion.psz;
240 break;
241
242 case 'u': // --unit
243 ulCurUnit = ValueUnion.u32;
244 break;
245
246 case 'x': // --ignore
247 if (ulCurVsys == (uint32_t)-1)
248 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
249 if (ulCurUnit == (uint32_t)-1)
250 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
251 mapIgnoresMapsPerVsys[ulCurVsys][ulCurUnit] = true;
252 break;
253
254 case 'T': // --scsitype
255 if (ulCurVsys == (uint32_t)-1)
256 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
257 if (ulCurUnit == (uint32_t)-1)
258 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
259 mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("scsitype%u", ulCurUnit)] = ValueUnion.psz;
260 break;
261
262 case 'C': // --controller
263 if (ulCurVsys == (uint32_t)-1)
264 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
265 if (ulCurUnit == (uint32_t)-1)
266 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
267 mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("controller%u", ulCurUnit)] = ValueUnion.psz;
268 break;
269
270 case 'D': // --disk
271 if (ulCurVsys == (uint32_t)-1)
272 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
273 if (ulCurUnit == (uint32_t)-1)
274 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
275 mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("disk%u", ulCurUnit)] = ValueUnion.psz;
276 break;
277
278 case 'O': // --options
279 if (RT_FAILURE(parseImportOptions(ValueUnion.psz, &options)))
280 return errorArgument("Invalid import options '%s'\n", ValueUnion.psz);
281 break;
282
283 case VINF_GETOPT_NOT_OPTION:
284 if (strOvfFilename.isEmpty())
285 strOvfFilename = ValueUnion.psz;
286 else
287 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid parameter '%s'", ValueUnion.psz);
288 break;
289
290 default:
291 if (c > 0)
292 {
293 if (RT_C_IS_PRINT(c))
294 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option -%c", c);
295 else
296 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option case %i", c);
297 }
298 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
299 return errorSyntax(USAGE_IMPORTAPPLIANCE, "unknown option: %s\n", ValueUnion.psz);
300 else if (ValueUnion.pDef)
301 return errorSyntax(USAGE_IMPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
302 else
303 return errorSyntax(USAGE_IMPORTAPPLIANCE, "error: %Rrs", c);
304 }
305 }
306
307 if (strOvfFilename.isEmpty())
308 return errorSyntax(USAGE_IMPORTAPPLIANCE, "Not enough arguments for \"import\" command.");
309
310 do
311 {
312 ComPtr<IAppliance> pAppliance;
313 CHECK_ERROR_BREAK(arg->virtualBox, CreateAppliance(pAppliance.asOutParam()));
314
315 char *pszAbsFilePath;
316 if (strOvfFilename.startsWith("S3://", RTCString::CaseInsensitive) ||
317 strOvfFilename.startsWith("SunCloud://", RTCString::CaseInsensitive) ||
318 strOvfFilename.startsWith("webdav://", RTCString::CaseInsensitive))
319 pszAbsFilePath = RTStrDup(strOvfFilename.c_str());
320 else
321 pszAbsFilePath = RTPathAbsDup(strOvfFilename.c_str());
322 ComPtr<IProgress> progressRead;
323 CHECK_ERROR_BREAK(pAppliance, Read(Bstr(pszAbsFilePath).raw(),
324 progressRead.asOutParam()));
325 RTStrFree(pszAbsFilePath);
326
327 rc = showProgress(progressRead);
328 CHECK_PROGRESS_ERROR_RET(progressRead, ("Appliance read failed"), RTEXITCODE_FAILURE);
329
330 Bstr path; /* fetch the path, there is stuff like username/password removed if any */
331 CHECK_ERROR_BREAK(pAppliance, COMGETTER(Path)(path.asOutParam()));
332 // call interpret(); this can yield both warnings and errors, so we need
333 // to tinker with the error info a bit
334 RTStrmPrintf(g_pStdErr, "Interpreting %ls...\n", path.raw());
335 rc = pAppliance->Interpret();
336 com::ErrorInfo info0(pAppliance, COM_IIDOF(IAppliance));
337
338 com::SafeArray<BSTR> aWarnings;
339 if (SUCCEEDED(pAppliance->GetWarnings(ComSafeArrayAsOutParam(aWarnings))))
340 {
341 size_t cWarnings = aWarnings.size();
342 for (unsigned i = 0; i < cWarnings; ++i)
343 {
344 Bstr bstrWarning(aWarnings[i]);
345 RTMsgWarning("%ls.", bstrWarning.raw());
346 }
347 }
348
349 if (FAILED(rc)) // during interpret, after printing warnings
350 {
351 com::GluePrintErrorInfo(info0);
352 com::GluePrintErrorContext("Interpret", __FILE__, __LINE__);
353 break;
354 }
355
356 RTStrmPrintf(g_pStdErr, "OK.\n");
357
358 // fetch all disks
359 com::SafeArray<BSTR> retDisks;
360 CHECK_ERROR_BREAK(pAppliance,
361 COMGETTER(Disks)(ComSafeArrayAsOutParam(retDisks)));
362 if (retDisks.size() > 0)
363 {
364 RTPrintf("Disks:\n");
365 for (unsigned i = 0; i < retDisks.size(); i++)
366 RTPrintf(" %ls\n", retDisks[i]);
367 RTPrintf("\n");
368 }
369
370 // fetch virtual system descriptions
371 com::SafeIfaceArray<IVirtualSystemDescription> aVirtualSystemDescriptions;
372 CHECK_ERROR_BREAK(pAppliance,
373 COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(aVirtualSystemDescriptions)));
374
375 size_t cVirtualSystemDescriptions = aVirtualSystemDescriptions.size();
376
377 // match command line arguments with virtual system descriptions;
378 // this is only to sort out invalid indices at this time
379 ArgsMapsMap::const_iterator it;
380 for (it = mapArgsMapsPerVsys.begin();
381 it != mapArgsMapsPerVsys.end();
382 ++it)
383 {
384 uint32_t ulVsys = it->first;
385 if (ulVsys >= cVirtualSystemDescriptions)
386 return errorSyntax(USAGE_IMPORTAPPLIANCE,
387 "Invalid index %RI32 with -vsys option; the OVF contains only %zu virtual system(s).",
388 ulVsys, cVirtualSystemDescriptions);
389 }
390
391 uint32_t cLicensesInTheWay = 0;
392
393 // dump virtual system descriptions and match command-line arguments
394 if (cVirtualSystemDescriptions > 0)
395 {
396 for (unsigned i = 0; i < cVirtualSystemDescriptions; ++i)
397 {
398 com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
399 com::SafeArray<BSTR> aRefs;
400 com::SafeArray<BSTR> aOvfValues;
401 com::SafeArray<BSTR> aVBoxValues;
402 com::SafeArray<BSTR> aExtraConfigValues;
403 CHECK_ERROR_BREAK(aVirtualSystemDescriptions[i],
404 GetDescription(ComSafeArrayAsOutParam(retTypes),
405 ComSafeArrayAsOutParam(aRefs),
406 ComSafeArrayAsOutParam(aOvfValues),
407 ComSafeArrayAsOutParam(aVBoxValues),
408 ComSafeArrayAsOutParam(aExtraConfigValues)));
409
410 RTPrintf("Virtual system %u:\n", i);
411
412 // look up the corresponding command line options, if any
413 ArgsMap *pmapArgs = NULL;
414 ArgsMapsMap::iterator itm = mapArgsMapsPerVsys.find(i);
415 if (itm != mapArgsMapsPerVsys.end())
416 pmapArgs = &itm->second;
417
418 // this collects the final values for setFinalValues()
419 com::SafeArray<BOOL> aEnabled(retTypes.size());
420 com::SafeArray<BSTR> aFinalValues(retTypes.size());
421
422 for (unsigned a = 0; a < retTypes.size(); ++a)
423 {
424 VirtualSystemDescriptionType_T t = retTypes[a];
425
426 Utf8Str strOverride;
427
428 Bstr bstrFinalValue = aVBoxValues[a];
429
430 bool fIgnoreThis = mapIgnoresMapsPerVsys[i][a];
431
432 aEnabled[a] = true;
433
434 switch (t)
435 {
436 case VirtualSystemDescriptionType_OS:
437 if (findArgValue(strOverride, pmapArgs, "ostype"))
438 {
439 bstrFinalValue = strOverride;
440 RTPrintf("%2u: OS type specified with --ostype: \"%ls\"\n",
441 a, bstrFinalValue.raw());
442 }
443 else
444 RTPrintf("%2u: Suggested OS type: \"%ls\""
445 "\n (change with \"--vsys %u --ostype <type>\"; use \"list ostypes\" to list all possible values)\n",
446 a, bstrFinalValue.raw(), i);
447 break;
448
449 case VirtualSystemDescriptionType_Name:
450 if (findArgValue(strOverride, pmapArgs, "vmname"))
451 {
452 bstrFinalValue = strOverride;
453 RTPrintf("%2u: VM name specified with --vmname: \"%ls\"\n",
454 a, bstrFinalValue.raw());
455 }
456 else
457 RTPrintf("%2u: Suggested VM name \"%ls\""
458 "\n (change with \"--vsys %u --vmname <name>\")\n",
459 a, bstrFinalValue.raw(), i);
460 break;
461
462 case VirtualSystemDescriptionType_Product:
463 RTPrintf("%2u: Product (ignored): %ls\n",
464 a, aVBoxValues[a]);
465 break;
466
467 case VirtualSystemDescriptionType_ProductUrl:
468 RTPrintf("%2u: ProductUrl (ignored): %ls\n",
469 a, aVBoxValues[a]);
470 break;
471
472 case VirtualSystemDescriptionType_Vendor:
473 RTPrintf("%2u: Vendor (ignored): %ls\n",
474 a, aVBoxValues[a]);
475 break;
476
477 case VirtualSystemDescriptionType_VendorUrl:
478 RTPrintf("%2u: VendorUrl (ignored): %ls\n",
479 a, aVBoxValues[a]);
480 break;
481
482 case VirtualSystemDescriptionType_Version:
483 RTPrintf("%2u: Version (ignored): %ls\n",
484 a, aVBoxValues[a]);
485 break;
486
487 case VirtualSystemDescriptionType_Description:
488 if (findArgValue(strOverride, pmapArgs, "description"))
489 {
490 bstrFinalValue = strOverride;
491 RTPrintf("%2u: Description specified with --description: \"%ls\"\n",
492 a, bstrFinalValue.raw());
493 }
494 else
495 RTPrintf("%2u: Description \"%ls\""
496 "\n (change with \"--vsys %u --description <desc>\")\n",
497 a, bstrFinalValue.raw(), i);
498 break;
499
500 case VirtualSystemDescriptionType_License:
501 ++cLicensesInTheWay;
502 if (findArgValue(strOverride, pmapArgs, "eula"))
503 {
504 if (strOverride == "show")
505 {
506 RTPrintf("%2u: End-user license agreement"
507 "\n (accept with \"--vsys %u --eula accept\"):"
508 "\n\n%ls\n\n",
509 a, i, bstrFinalValue.raw());
510 }
511 else if (strOverride == "accept")
512 {
513 RTPrintf("%2u: End-user license agreement (accepted)\n",
514 a);
515 --cLicensesInTheWay;
516 }
517 else
518 return errorSyntax(USAGE_IMPORTAPPLIANCE,
519 "Argument to --eula must be either \"show\" or \"accept\".");
520 }
521 else
522 RTPrintf("%2u: End-user license agreement"
523 "\n (display with \"--vsys %u --eula show\";"
524 "\n accept with \"--vsys %u --eula accept\")\n",
525 a, i, i);
526 break;
527
528 case VirtualSystemDescriptionType_CPU:
529 if (findArgValue(strOverride, pmapArgs, "cpus"))
530 {
531 uint32_t cCPUs;
532 if ( strOverride.toInt(cCPUs) == VINF_SUCCESS
533 && cCPUs >= VMM_MIN_CPU_COUNT
534 && cCPUs <= VMM_MAX_CPU_COUNT
535 )
536 {
537 bstrFinalValue = strOverride;
538 RTPrintf("%2u: No. of CPUs specified with --cpus: %ls\n",
539 a, bstrFinalValue.raw());
540 }
541 else
542 return errorSyntax(USAGE_IMPORTAPPLIANCE,
543 "Argument to --cpus option must be a number greater than %d and less than %d.",
544 VMM_MIN_CPU_COUNT - 1, VMM_MAX_CPU_COUNT + 1);
545 }
546 else
547 RTPrintf("%2u: Number of CPUs: %ls\n (change with \"--vsys %u --cpus <n>\")\n",
548 a, bstrFinalValue.raw(), i);
549 break;
550
551 case VirtualSystemDescriptionType_Memory:
552 {
553 if (findArgValue(strOverride, pmapArgs, "memory"))
554 {
555 uint32_t ulMemMB;
556 if (VINF_SUCCESS == strOverride.toInt(ulMemMB))
557 {
558 bstrFinalValue = strOverride;
559 RTPrintf("%2u: Guest memory specified with --memory: %ls MB\n",
560 a, bstrFinalValue.raw());
561 }
562 else
563 return errorSyntax(USAGE_IMPORTAPPLIANCE,
564 "Argument to --memory option must be a non-negative number.");
565 }
566 else
567 RTPrintf("%2u: Guest memory: %ls MB\n (change with \"--vsys %u --memory <MB>\")\n",
568 a, bstrFinalValue.raw(), i);
569 break;
570 }
571
572 case VirtualSystemDescriptionType_HardDiskControllerIDE:
573 if (fIgnoreThis)
574 {
575 RTPrintf("%2u: IDE controller, type %ls -- disabled\n",
576 a,
577 aVBoxValues[a]);
578 aEnabled[a] = false;
579 }
580 else
581 RTPrintf("%2u: IDE controller, type %ls"
582 "\n (disable with \"--vsys %u --unit %u --ignore\")\n",
583 a,
584 aVBoxValues[a],
585 i, a);
586 break;
587
588 case VirtualSystemDescriptionType_HardDiskControllerSATA:
589 if (fIgnoreThis)
590 {
591 RTPrintf("%2u: SATA controller, type %ls -- disabled\n",
592 a,
593 aVBoxValues[a]);
594 aEnabled[a] = false;
595 }
596 else
597 RTPrintf("%2u: SATA controller, type %ls"
598 "\n (disable with \"--vsys %u --unit %u --ignore\")\n",
599 a,
600 aVBoxValues[a],
601 i, a);
602 break;
603
604 case VirtualSystemDescriptionType_HardDiskControllerSAS:
605 if (fIgnoreThis)
606 {
607 RTPrintf("%2u: SAS controller, type %ls -- disabled\n",
608 a,
609 aVBoxValues[a]);
610 aEnabled[a] = false;
611 }
612 else
613 RTPrintf("%2u: SAS controller, type %ls"
614 "\n (disable with \"--vsys %u --unit %u --ignore\")\n",
615 a,
616 aVBoxValues[a],
617 i, a);
618 break;
619
620 case VirtualSystemDescriptionType_HardDiskControllerSCSI:
621 if (fIgnoreThis)
622 {
623 RTPrintf("%2u: SCSI controller, type %ls -- disabled\n",
624 a,
625 aVBoxValues[a]);
626 aEnabled[a] = false;
627 }
628 else
629 {
630 Utf8StrFmt strTypeArg("scsitype%u", a);
631 if (findArgValue(strOverride, pmapArgs, strTypeArg))
632 {
633 bstrFinalValue = strOverride;
634 RTPrintf("%2u: SCSI controller, type set with --unit %u --scsitype: \"%ls\"\n",
635 a,
636 a,
637 bstrFinalValue.raw());
638 }
639 else
640 RTPrintf("%2u: SCSI controller, type %ls"
641 "\n (change with \"--vsys %u --unit %u --scsitype {BusLogic|LsiLogic}\";"
642 "\n disable with \"--vsys %u --unit %u --ignore\")\n",
643 a,
644 aVBoxValues[a],
645 i, a, i, a);
646 }
647 break;
648
649 case VirtualSystemDescriptionType_HardDiskImage:
650 if (fIgnoreThis)
651 {
652 RTPrintf("%2u: Hard disk image: source image=%ls -- disabled\n",
653 a,
654 aOvfValues[a]);
655 aEnabled[a] = false;
656 }
657 else
658 {
659 Utf8StrFmt strTypeArg("disk%u", a);
660 RTCList<ImportOptions_T> optionsList = options.toList();
661
662 bstrFinalValue = aVBoxValues[a];
663
664 if (findArgValue(strOverride, pmapArgs, strTypeArg))
665 {
666 if (!optionsList.contains(ImportOptions_ImportToVDI))
667 {
668 RTUUID uuid;
669 /* Check if this is a uuid. If so, don't touch. */
670 int vrc = RTUuidFromStr(&uuid, strOverride.c_str());
671 if (vrc != VINF_SUCCESS)
672 {
673 /* Make the path absolute. */
674 if (!RTPathStartsWithRoot(strOverride.c_str()))
675 {
676 char pszPwd[RTPATH_MAX];
677 vrc = RTPathGetCurrent(pszPwd, RTPATH_MAX);
678 if (RT_SUCCESS(vrc))
679 strOverride = Utf8Str(pszPwd).append(RTPATH_SLASH).append(strOverride);
680 }
681 }
682 bstrFinalValue = strOverride;
683 }
684 else
685 {
686 //print some error about incompatible command-line arguments
687 return errorSyntax(USAGE_IMPORTAPPLIANCE,
688 "Option --ImportToVDI shall not be used together with "
689 "manually set target path.");
690
691 }
692
693 RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n",
694 a,
695 aOvfValues[a],
696 bstrFinalValue.raw(),
697 aExtraConfigValues[a]);
698 }
699#if 0 /* Changing the controller is fully valid, but the current design on how
700 the params are evaluated here doesn't allow two parameter for one
701 unit. The target disk path is more important I leave it for future
702 improvments. */
703 Utf8StrFmt strTypeArg("controller%u", a);
704 if (findArgValue(strOverride, pmapArgs, strTypeArg))
705 {
706 // strOverride now has the controller index as a number, but we
707 // need a "controller=X" format string
708 strOverride = Utf8StrFmt("controller=%s", strOverride.c_str());
709 Bstr bstrExtraConfigValue = strOverride;
710 bstrExtraConfigValue.detachTo(&aExtraConfigValues[a]);
711 RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n",
712 a,
713 aOvfValues[a],
714 aVBoxValues[a],
715 aExtraConfigValues[a]);
716 }
717#endif
718 else
719 {
720 strOverride = aVBoxValues[a];
721
722 /*
723 * Current solution isn't optimal.
724 * Better way is to provide API call for function
725 * Appliance::i_findMediumFormatFromDiskImage()
726 * and creating one new function which returns
727 * struct ovf::DiskImage for currently processed disk.
728 */
729
730 /*
731 * if user wants to convert all imported disks to VDI format
732 * we need to replace files extensions to "vdi"
733 * except CD/DVD disks
734 */
735 if (optionsList.contains(ImportOptions_ImportToVDI))
736 {
737 ComPtr<IVirtualBox> pVirtualBox = arg->virtualBox;
738 ComPtr<ISystemProperties> systemProperties;
739 com::SafeIfaceArray<IMediumFormat> mediumFormats;
740 Bstr bstrFormatName;
741
742 CHECK_ERROR(pVirtualBox,
743 COMGETTER(SystemProperties)(systemProperties.asOutParam()));
744
745 CHECK_ERROR(systemProperties,
746 COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats)));
747
748 /* go through all supported media formats and store files extensions only for RAW */
749 com::SafeArray<BSTR> extensions;
750
751 for (unsigned j = 0; j < mediumFormats.size(); ++j)
752 {
753 com::SafeArray<DeviceType_T> deviceType;
754 ComPtr<IMediumFormat> mediumFormat = mediumFormats[j];
755 CHECK_ERROR(mediumFormat, COMGETTER(Name)(bstrFormatName.asOutParam()));
756 Utf8Str strFormatName = Utf8Str(bstrFormatName);
757
758 if (strFormatName.compare("RAW", Utf8Str::CaseInsensitive) == 0)
759 {
760 /* getting files extensions for "RAW" format */
761 CHECK_ERROR(mediumFormat,
762 DescribeFileExtensions(ComSafeArrayAsOutParam(extensions),
763 ComSafeArrayAsOutParam(deviceType)));
764 break;
765 }
766 }
767
768 /* go through files extensions for RAW format and compare them with
769 * extension of current file
770 */
771 bool fReplace = true;
772
773 const char *pszExtension = RTPathSuffix(strOverride.c_str());
774 if (pszExtension)
775 pszExtension++;
776
777 for (unsigned j = 0; j < extensions.size(); ++j)
778 {
779 Bstr bstrExt(extensions[j]);
780 Utf8Str strExtension(bstrExt);
781 if(strExtension.compare(pszExtension, Utf8Str::CaseInsensitive) == 0)
782 {
783 fReplace = false;
784 break;
785 }
786 }
787
788 if (fReplace)
789 {
790 strOverride = strOverride.stripSuffix();
791 strOverride = strOverride.append(".").append("vdi");
792 }
793 }
794
795 bstrFinalValue = strOverride;
796
797 RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls"
798 "\n (change target path with \"--vsys %u --unit %u --disk path\";"
799 "\n disable with \"--vsys %u --unit %u --ignore\")\n",
800 a,
801 aOvfValues[a],
802 bstrFinalValue.raw(),
803 aExtraConfigValues[a],
804 i, a, i, a);
805 }
806 }
807 break;
808
809 case VirtualSystemDescriptionType_CDROM:
810 if (fIgnoreThis)
811 {
812 RTPrintf("%2u: CD-ROM -- disabled\n",
813 a);
814 aEnabled[a] = false;
815 }
816 else
817 RTPrintf("%2u: CD-ROM"
818 "\n (disable with \"--vsys %u --unit %u --ignore\")\n",
819 a, i, a);
820 break;
821
822 case VirtualSystemDescriptionType_Floppy:
823 if (fIgnoreThis)
824 {
825 RTPrintf("%2u: Floppy -- disabled\n",
826 a);
827 aEnabled[a] = false;
828 }
829 else
830 RTPrintf("%2u: Floppy"
831 "\n (disable with \"--vsys %u --unit %u --ignore\")\n",
832 a, i, a);
833 break;
834
835 case VirtualSystemDescriptionType_NetworkAdapter:
836 RTPrintf("%2u: Network adapter: orig %ls, config %ls, extra %ls\n", /// @todo implement once we have a plan for the back-end
837 a,
838 aOvfValues[a],
839 aVBoxValues[a],
840 aExtraConfigValues[a]);
841 break;
842
843 case VirtualSystemDescriptionType_USBController:
844 if (fIgnoreThis)
845 {
846 RTPrintf("%2u: USB controller -- disabled\n",
847 a);
848 aEnabled[a] = false;
849 }
850 else
851 RTPrintf("%2u: USB controller"
852 "\n (disable with \"--vsys %u --unit %u --ignore\")\n",
853 a, i, a);
854 break;
855
856 case VirtualSystemDescriptionType_SoundCard:
857 if (fIgnoreThis)
858 {
859 RTPrintf("%2u: Sound card \"%ls\" -- disabled\n",
860 a,
861 aOvfValues[a]);
862 aEnabled[a] = false;
863 }
864 else
865 RTPrintf("%2u: Sound card (appliance expects \"%ls\", can change on import)"
866 "\n (disable with \"--vsys %u --unit %u --ignore\")\n",
867 a,
868 aOvfValues[a],
869 i,
870 a);
871 break;
872
873 case VirtualSystemDescriptionType_SettingsFile:
874 if (findArgValue(strOverride, pmapArgs, "settingsfile"))
875 {
876 bstrFinalValue = strOverride;
877 RTPrintf("%2u: VM settings file name specified with --settingsfile: \"%ls\"\n",
878 a, bstrFinalValue.raw());
879 }
880 else
881 RTPrintf("%2u: Suggested VM settings file name \"%ls\""
882 "\n (change with \"--vsys %u --settingsfile <filename>\")\n",
883 a, bstrFinalValue.raw(), i);
884 break;
885
886 case VirtualSystemDescriptionType_BaseFolder:
887 if (findArgValue(strOverride, pmapArgs, "basefolder"))
888 {
889 bstrFinalValue = strOverride;
890 RTPrintf("%2u: VM base folder specified with --basefolder: \"%ls\"\n",
891 a, bstrFinalValue.raw());
892 }
893 else
894 RTPrintf("%2u: Suggested VM base folder \"%ls\""
895 "\n (change with \"--vsys %u --basefolder <path>\")\n",
896 a, bstrFinalValue.raw(), i);
897 break;
898
899 case VirtualSystemDescriptionType_PrimaryGroup:
900 if (findArgValue(strOverride, pmapArgs, "group"))
901 {
902 bstrFinalValue = strOverride;
903 RTPrintf("%2u: VM group specified with --group: \"%ls\"\n",
904 a, bstrFinalValue.raw());
905 }
906 else
907 RTPrintf("%2u: Suggested VM group \"%ls\""
908 "\n (change with \"--vsys %u --group <group>\")\n",
909 a, bstrFinalValue.raw(), i);
910 break;
911
912
913 case VirtualSystemDescriptionType_CloudOCIInstanceShape:
914 case VirtualSystemDescriptionType_CloudOCIDomain:
915 case VirtualSystemDescriptionType_CloudOCIBootDiskSize:
916 case VirtualSystemDescriptionType_CloudOCIBucket:
917 case VirtualSystemDescriptionType_CloudOCIVCN:
918 case VirtualSystemDescriptionType_CloudOCIPublicIP:
919 case VirtualSystemDescriptionType_CloudOCIProfilePath:
920 case VirtualSystemDescriptionType_CloudOCISubnet:
921 case VirtualSystemDescriptionType_CloudOCIKeepObject:
922 case VirtualSystemDescriptionType_CloudOCILaunchInstance:
923 case VirtualSystemDescriptionType_Miscellaneous:
924 /** @todo VirtualSystemDescriptionType_Miscellaneous? */
925 break;
926 case VirtualSystemDescriptionType_Ignore:
927#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
928 case VirtualSystemDescriptionType_32BitHack:
929#endif
930 break;
931 }
932
933 bstrFinalValue.detachTo(&aFinalValues[a]);
934 }
935
936 if (fExecute)
937 CHECK_ERROR_BREAK(aVirtualSystemDescriptions[i],
938 SetFinalValues(ComSafeArrayAsInParam(aEnabled),
939 ComSafeArrayAsInParam(aFinalValues),
940 ComSafeArrayAsInParam(aExtraConfigValues)));
941
942 } // for (unsigned i = 0; i < cVirtualSystemDescriptions; ++i)
943
944 if (cLicensesInTheWay == 1)
945 RTMsgError("Cannot import until the license agreement listed above is accepted.");
946 else if (cLicensesInTheWay > 1)
947 RTMsgError("Cannot import until the %c license agreements listed above are accepted.", cLicensesInTheWay);
948
949 if (!cLicensesInTheWay && fExecute)
950 {
951 // go!
952 ComPtr<IProgress> progress;
953 CHECK_ERROR_BREAK(pAppliance,
954 ImportMachines(ComSafeArrayAsInParam(options), progress.asOutParam()));
955
956 rc = showProgress(progress);
957 CHECK_PROGRESS_ERROR_RET(progress, ("Appliance import failed"), RTEXITCODE_FAILURE);
958
959 if (SUCCEEDED(rc))
960 RTPrintf("Successfully imported the appliance.\n");
961 }
962 } // end if (aVirtualSystemDescriptions.size() > 0)
963 } while (0);
964
965 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
966}
967
968static int parseExportOptions(const char *psz, com::SafeArray<ExportOptions_T> *options)
969{
970 int rc = VINF_SUCCESS;
971 while (psz && *psz && RT_SUCCESS(rc))
972 {
973 size_t len;
974 const char *pszComma = strchr(psz, ',');
975 if (pszComma)
976 len = pszComma - psz;
977 else
978 len = strlen(psz);
979 if (len > 0)
980 {
981 if (!RTStrNICmp(psz, "CreateManifest", len))
982 options->push_back(ExportOptions_CreateManifest);
983 else if (!RTStrNICmp(psz, "manifest", len))
984 options->push_back(ExportOptions_CreateManifest);
985 else if (!RTStrNICmp(psz, "ExportDVDImages", len))
986 options->push_back(ExportOptions_ExportDVDImages);
987 else if (!RTStrNICmp(psz, "iso", len))
988 options->push_back(ExportOptions_ExportDVDImages);
989 else if (!RTStrNICmp(psz, "StripAllMACs", len))
990 options->push_back(ExportOptions_StripAllMACs);
991 else if (!RTStrNICmp(psz, "nomacs", len))
992 options->push_back(ExportOptions_StripAllMACs);
993 else if (!RTStrNICmp(psz, "StripAllNonNATMACs", len))
994 options->push_back(ExportOptions_StripAllNonNATMACs);
995 else if (!RTStrNICmp(psz, "nomacsbutnat", len))
996 options->push_back(ExportOptions_StripAllNonNATMACs);
997 else
998 rc = VERR_PARSE_ERROR;
999 }
1000 if (pszComma)
1001 psz += len + 1;
1002 else
1003 psz += len;
1004 }
1005
1006 return rc;
1007}
1008
1009static const RTGETOPTDEF g_aExportOptions[] =
1010{
1011 { "--output", 'o', RTGETOPT_REQ_STRING },
1012 { "--legacy09", 'l', RTGETOPT_REQ_NOTHING },
1013 { "--ovf09", 'l', RTGETOPT_REQ_NOTHING },
1014 { "--ovf10", '1', RTGETOPT_REQ_NOTHING },
1015 { "--ovf20", '2', RTGETOPT_REQ_NOTHING },
1016 { "--opc10", 'c', RTGETOPT_REQ_NOTHING },
1017 { "--manifest", 'm', RTGETOPT_REQ_NOTHING }, // obsoleted by --options
1018 { "--iso", 'I', RTGETOPT_REQ_NOTHING }, // obsoleted by --options
1019 { "--vsys", 's', RTGETOPT_REQ_UINT32 },
1020 { "--vmname", 'V', RTGETOPT_REQ_STRING },
1021 { "--product", 'p', RTGETOPT_REQ_STRING },
1022 { "--producturl", 'P', RTGETOPT_REQ_STRING },
1023 { "--vendor", 'n', RTGETOPT_REQ_STRING },
1024 { "--vendorurl", 'N', RTGETOPT_REQ_STRING },
1025 { "--version", 'v', RTGETOPT_REQ_STRING },
1026 { "--description", 'd', RTGETOPT_REQ_STRING },
1027 { "--eula", 'e', RTGETOPT_REQ_STRING },
1028 { "--eulafile", 'E', RTGETOPT_REQ_STRING },
1029 { "--options", 'O', RTGETOPT_REQ_STRING },
1030};
1031
1032RTEXITCODE handleExportAppliance(HandlerArg *a)
1033{
1034 HRESULT rc = S_OK;
1035
1036 Utf8Str strOutputFile;
1037 Utf8Str strOvfFormat("ovf-1.0"); // the default export version
1038 bool fManifest = false; // the default
1039 bool fExportISOImages = false; // the default
1040 com::SafeArray<ExportOptions_T> options;
1041 std::list< ComPtr<IMachine> > llMachines;
1042
1043 uint32_t ulCurVsys = (uint32_t)-1;
1044 // for each --vsys X command, maintain a map of command line items
1045 ArgsMapsMap mapArgsMapsPerVsys;
1046 do
1047 {
1048 int c;
1049
1050 RTGETOPTUNION ValueUnion;
1051 RTGETOPTSTATE GetState;
1052 // start at 0 because main() has hacked both the argc and argv given to us
1053 RTGetOptInit(&GetState, a->argc, a->argv, g_aExportOptions,
1054 RT_ELEMENTS(g_aExportOptions), 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1055
1056 Utf8Str strProductUrl;
1057 while ((c = RTGetOpt(&GetState, &ValueUnion)))
1058 {
1059 switch (c)
1060 {
1061 case 'o': // --output
1062 if (strOutputFile.length())
1063 return errorSyntax(USAGE_EXPORTAPPLIANCE, "You can only specify --output once.");
1064 else
1065 strOutputFile = ValueUnion.psz;
1066 break;
1067
1068 case 'l': // --legacy09/--ovf09
1069 strOvfFormat = "ovf-0.9";
1070 break;
1071
1072 case '1': // --ovf10
1073 strOvfFormat = "ovf-1.0";
1074 break;
1075
1076 case '2': // --ovf20
1077 strOvfFormat = "ovf-2.0";
1078 break;
1079
1080 case 'c': // --opc
1081 strOvfFormat = "opc-1.0";
1082 break;
1083
1084 case 'I': // --iso
1085 fExportISOImages = true;
1086 break;
1087
1088 case 'm': // --manifest
1089 fManifest = true;
1090 break;
1091
1092 case 's': // --vsys
1093 ulCurVsys = ValueUnion.u32;
1094 break;
1095
1096 case 'V': // --vmname
1097 if (ulCurVsys == (uint32_t)-1)
1098 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1099 mapArgsMapsPerVsys[ulCurVsys]["vmname"] = ValueUnion.psz;
1100 break;
1101
1102 case 'p': // --product
1103 if (ulCurVsys == (uint32_t)-1)
1104 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1105 mapArgsMapsPerVsys[ulCurVsys]["product"] = ValueUnion.psz;
1106 break;
1107
1108 case 'P': // --producturl
1109 if (ulCurVsys == (uint32_t)-1)
1110 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1111 mapArgsMapsPerVsys[ulCurVsys]["producturl"] = ValueUnion.psz;
1112 break;
1113
1114 case 'n': // --vendor
1115 if (ulCurVsys == (uint32_t)-1)
1116 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1117 mapArgsMapsPerVsys[ulCurVsys]["vendor"] = ValueUnion.psz;
1118 break;
1119
1120 case 'N': // --vendorurl
1121 if (ulCurVsys == (uint32_t)-1)
1122 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1123 mapArgsMapsPerVsys[ulCurVsys]["vendorurl"] = ValueUnion.psz;
1124 break;
1125
1126 case 'v': // --version
1127 if (ulCurVsys == (uint32_t)-1)
1128 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1129 mapArgsMapsPerVsys[ulCurVsys]["version"] = ValueUnion.psz;
1130 break;
1131
1132 case 'd': // --description
1133 if (ulCurVsys == (uint32_t)-1)
1134 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1135 mapArgsMapsPerVsys[ulCurVsys]["description"] = ValueUnion.psz;
1136 break;
1137
1138 case 'e': // --eula
1139 if (ulCurVsys == (uint32_t)-1)
1140 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1141 mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz;
1142 break;
1143
1144 case 'E': // --eulafile
1145 if (ulCurVsys == (uint32_t)-1)
1146 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
1147 mapArgsMapsPerVsys[ulCurVsys]["eulafile"] = ValueUnion.psz;
1148 break;
1149
1150 case 'O': // --options
1151 if (RT_FAILURE(parseExportOptions(ValueUnion.psz, &options)))
1152 return errorArgument("Invalid export options '%s'\n", ValueUnion.psz);
1153 break;
1154
1155 case VINF_GETOPT_NOT_OPTION:
1156 {
1157 Utf8Str strMachine(ValueUnion.psz);
1158 // must be machine: try UUID or name
1159 ComPtr<IMachine> machine;
1160 CHECK_ERROR_BREAK(a->virtualBox, FindMachine(Bstr(strMachine).raw(),
1161 machine.asOutParam()));
1162 if (machine)
1163 llMachines.push_back(machine);
1164 break;
1165 }
1166
1167 default:
1168 if (c > 0)
1169 {
1170 if (RT_C_IS_GRAPH(c))
1171 return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: -%c", c);
1172 else
1173 return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: %i", c);
1174 }
1175 else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1176 return errorSyntax(USAGE_EXPORTAPPLIANCE, "unknown option: %s", ValueUnion.psz);
1177 else if (ValueUnion.pDef)
1178 return errorSyntax(USAGE_EXPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1179 else
1180 return errorSyntax(USAGE_EXPORTAPPLIANCE, "%Rrs", c);
1181 }
1182
1183 if (FAILED(rc))
1184 break;
1185 }
1186
1187 if (FAILED(rc))
1188 break;
1189
1190 if (llMachines.empty())
1191 return errorSyntax(USAGE_EXPORTAPPLIANCE, "At least one machine must be specified with the export command.");
1192 if (!strOutputFile.length())
1193 return errorSyntax(USAGE_EXPORTAPPLIANCE, "Missing --output argument with export command.");
1194
1195 // match command line arguments with the machines count
1196 // this is only to sort out invalid indices at this time
1197 ArgsMapsMap::const_iterator it;
1198 for (it = mapArgsMapsPerVsys.begin();
1199 it != mapArgsMapsPerVsys.end();
1200 ++it)
1201 {
1202 uint32_t ulVsys = it->first;
1203 if (ulVsys >= llMachines.size())
1204 return errorSyntax(USAGE_EXPORTAPPLIANCE,
1205 "Invalid index %RI32 with -vsys option; you specified only %zu virtual system(s).",
1206 ulVsys, llMachines.size());
1207 }
1208
1209 ComPtr<IAppliance> pAppliance;
1210 CHECK_ERROR_BREAK(a->virtualBox, CreateAppliance(pAppliance.asOutParam()));
1211
1212 char *pszAbsFilePath = 0;
1213 if (strOutputFile.startsWith("S3://", RTCString::CaseInsensitive) ||
1214 strOutputFile.startsWith("SunCloud://", RTCString::CaseInsensitive) ||
1215 strOutputFile.startsWith("webdav://", RTCString::CaseInsensitive))
1216 pszAbsFilePath = RTStrDup(strOutputFile.c_str());
1217 else
1218 pszAbsFilePath = RTPathAbsDup(strOutputFile.c_str());
1219
1220 std::list< ComPtr<IMachine> >::iterator itM;
1221 uint32_t i=0;
1222 for (itM = llMachines.begin();
1223 itM != llMachines.end();
1224 ++itM, ++i)
1225 {
1226 ComPtr<IMachine> pMachine = *itM;
1227 ComPtr<IVirtualSystemDescription> pVSD;
1228 CHECK_ERROR_BREAK(pMachine, ExportTo(pAppliance, Bstr(pszAbsFilePath).raw(), pVSD.asOutParam()));
1229 // Add additional info to the virtual system description if the user wants so
1230 ArgsMap *pmapArgs = NULL;
1231 ArgsMapsMap::iterator itm = mapArgsMapsPerVsys.find(i);
1232 if (itm != mapArgsMapsPerVsys.end())
1233 pmapArgs = &itm->second;
1234 if (pmapArgs)
1235 {
1236 ArgsMap::iterator itD;
1237 for (itD = pmapArgs->begin();
1238 itD != pmapArgs->end();
1239 ++itD)
1240 {
1241 if (itD->first == "vmname")
1242 pVSD->AddDescription(VirtualSystemDescriptionType_Name,
1243 Bstr(itD->second).raw(),
1244 Bstr(itD->second).raw());
1245 else if (itD->first == "product")
1246 pVSD->AddDescription(VirtualSystemDescriptionType_Product,
1247 Bstr(itD->second).raw(),
1248 Bstr(itD->second).raw());
1249 else if (itD->first == "producturl")
1250 pVSD->AddDescription(VirtualSystemDescriptionType_ProductUrl,
1251 Bstr(itD->second).raw(),
1252 Bstr(itD->second).raw());
1253 else if (itD->first == "vendor")
1254 pVSD->AddDescription(VirtualSystemDescriptionType_Vendor,
1255 Bstr(itD->second).raw(),
1256 Bstr(itD->second).raw());
1257 else if (itD->first == "vendorurl")
1258 pVSD->AddDescription(VirtualSystemDescriptionType_VendorUrl,
1259 Bstr(itD->second).raw(),
1260 Bstr(itD->second).raw());
1261 else if (itD->first == "version")
1262 pVSD->AddDescription(VirtualSystemDescriptionType_Version,
1263 Bstr(itD->second).raw(),
1264 Bstr(itD->second).raw());
1265 else if (itD->first == "description")
1266 pVSD->AddDescription(VirtualSystemDescriptionType_Description,
1267 Bstr(itD->second).raw(),
1268 Bstr(itD->second).raw());
1269 else if (itD->first == "eula")
1270 pVSD->AddDescription(VirtualSystemDescriptionType_License,
1271 Bstr(itD->second).raw(),
1272 Bstr(itD->second).raw());
1273 else if (itD->first == "eulafile")
1274 {
1275 Utf8Str strContent;
1276 void *pvFile;
1277 size_t cbFile;
1278 int irc = RTFileReadAll(itD->second.c_str(), &pvFile, &cbFile);
1279 if (RT_SUCCESS(irc))
1280 {
1281 Bstr bstrContent((char*)pvFile, cbFile);
1282 pVSD->AddDescription(VirtualSystemDescriptionType_License,
1283 bstrContent.raw(),
1284 bstrContent.raw());
1285 RTFileReadAllFree(pvFile, cbFile);
1286 }
1287 else
1288 {
1289 RTMsgError("Cannot read license file \"%s\" which should be included in the virtual system %u.",
1290 itD->second.c_str(), i);
1291 return RTEXITCODE_FAILURE;
1292 }
1293 }
1294 }
1295 }
1296 }
1297
1298 if (FAILED(rc))
1299 break;
1300
1301 /* Query required passwords and supply them to the appliance. */
1302 com::SafeArray<BSTR> aIdentifiers;
1303
1304 CHECK_ERROR_BREAK(pAppliance, GetPasswordIds(ComSafeArrayAsOutParam(aIdentifiers)));
1305
1306 if (aIdentifiers.size() > 0)
1307 {
1308 com::SafeArray<BSTR> aPasswords(aIdentifiers.size());
1309 RTPrintf("Enter the passwords for the following identifiers to export the apppliance:\n");
1310 for (unsigned idxId = 0; idxId < aIdentifiers.size(); idxId++)
1311 {
1312 com::Utf8Str strPassword;
1313 Bstr bstrPassword;
1314 Bstr bstrId = aIdentifiers[idxId];
1315
1316 RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Password ID %s:", Utf8Str(bstrId).c_str());
1317 if (rcExit == RTEXITCODE_FAILURE)
1318 {
1319 RTStrFree(pszAbsFilePath);
1320 return rcExit;
1321 }
1322
1323 bstrPassword = strPassword;
1324 bstrPassword.detachTo(&aPasswords[idxId]);
1325 }
1326
1327 CHECK_ERROR_BREAK(pAppliance, AddPasswords(ComSafeArrayAsInParam(aIdentifiers),
1328 ComSafeArrayAsInParam(aPasswords)));
1329 }
1330
1331 if (fManifest)
1332 options.push_back(ExportOptions_CreateManifest);
1333
1334 if (fExportISOImages)
1335 options.push_back(ExportOptions_ExportDVDImages);
1336
1337 ComPtr<IProgress> progress;
1338 CHECK_ERROR_BREAK(pAppliance, Write(Bstr(strOvfFormat).raw(),
1339 ComSafeArrayAsInParam(options),
1340 Bstr(pszAbsFilePath).raw(),
1341 progress.asOutParam()));
1342 RTStrFree(pszAbsFilePath);
1343
1344 rc = showProgress(progress);
1345 CHECK_PROGRESS_ERROR_RET(progress, ("Appliance write failed"), RTEXITCODE_FAILURE);
1346
1347 if (SUCCEEDED(rc))
1348 RTPrintf("Successfully exported %d machine(s).\n", llMachines.size());
1349
1350 } while (0);
1351
1352 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1353}
1354
1355#endif /* !VBOX_ONLY_DOCS */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use