VBoxManageAppliance.cpp@ 35828

Last change on this file since 35828 was 33540, checked in by vboxsync, 14 years ago
*: spelling fixes, thanks Timeless!
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 48.3 KB

Line
1	/* $Id: VBoxManageAppliance.cpp 33540 2010-10-28 09:27:05Z vboxsync $ */
2	/** @file
3	* VBoxManage - The appliance-related commands.
4	*/
5
6	/*
7	* Copyright (C) 2009-2010 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	* Header Files *
22	*******************************************************************************/
23	#ifndef VBOX_ONLY_DOCS
24	#include <VBox/com/com.h>
25	#include <VBox/com/string.h>
26	#include <VBox/com/Guid.h>
27	#include <VBox/com/array.h>
28	#include <VBox/com/ErrorInfo.h>
29	#include <VBox/com/errorprint.h>
30	#include <VBox/com/EventQueue.h>
31
32	#include <VBox/com/VirtualBox.h>
33
34	#include <list>
35	#include <map>
36	#endif /* !VBOX_ONLY_DOCS */
37
38	#include <iprt/stream.h>
39	#include <iprt/getopt.h>
40	#include <iprt/ctype.h>
41	#include <iprt/path.h>
42	#include <iprt/file.h>
43
44	#include <VBox/log.h>
45	#include <VBox/param.h>
46
47	#include "VBoxManage.h"
48	using namespace com;
49
50
51	// funcs
52	///////////////////////////////////////////////////////////////////////////////
53
54	typedef std::map<Utf8Str, Utf8Str> ArgsMap; // pairs of strings like "vmname" => "newvmname"
55	typedef std::map<uint32_t, ArgsMap> ArgsMapsMap; // map of maps, one for each virtual system, sorted by index
56
57	typedef std::map<uint32_t, bool> IgnoresMap; // pairs of numeric description entry indices
58	typedef std::map<uint32_t, IgnoresMap> IgnoresMapsMap; // map of maps, one for each virtual system, sorted by index
59
60	static bool findArgValue(Utf8Str &strOut,
61	ArgsMap *pmapArgs,
62	const Utf8Str &strKey)
63	{
64	if (pmapArgs)
65	{
66	ArgsMap::iterator it;
67	it = pmapArgs->find(strKey);
68	if (it != pmapArgs->end())
69	{
70	strOut = it->second;
71	pmapArgs->erase(it);
72	return true;
73	}
74	}
75
76	return false;
77	}
78
79	static const RTGETOPTDEF g_aImportApplianceOptions[] =
80	{
81	{ "--dry-run", 'n', RTGETOPT_REQ_NOTHING },
82	{ "-dry-run", 'n', RTGETOPT_REQ_NOTHING }, // deprecated
83	{ "--dryrun", 'n', RTGETOPT_REQ_NOTHING },
84	{ "-dryrun", 'n', RTGETOPT_REQ_NOTHING }, // deprecated
85	{ "--detailed-progress", 'P', RTGETOPT_REQ_NOTHING },
86	{ "-detailed-progress", 'P', RTGETOPT_REQ_NOTHING }, // deprecated
87	{ "--vsys", 's', RTGETOPT_REQ_UINT32 },
88	{ "-vsys", 's', RTGETOPT_REQ_UINT32 }, // deprecated
89	{ "--ostype", 'o', RTGETOPT_REQ_STRING },
90	{ "-ostype", 'o', RTGETOPT_REQ_STRING }, // deprecated
91	{ "--vmname", 'V', RTGETOPT_REQ_STRING },
92	{ "-vmname", 'V', RTGETOPT_REQ_STRING }, // deprecated
93	{ "--memory", 'm', RTGETOPT_REQ_STRING },
94	{ "-memory", 'm', RTGETOPT_REQ_STRING }, // deprecated
95	{ "--cpus", 'c', RTGETOPT_REQ_STRING },
96	{ "--description", 'd', RTGETOPT_REQ_STRING },
97	{ "--eula", 'L', RTGETOPT_REQ_STRING },
98	{ "-eula", 'L', RTGETOPT_REQ_STRING }, // deprecated
99	{ "--unit", 'u', RTGETOPT_REQ_UINT32 },
100	{ "-unit", 'u', RTGETOPT_REQ_UINT32 }, // deprecated
101	{ "--ignore", 'x', RTGETOPT_REQ_NOTHING },
102	{ "-ignore", 'x', RTGETOPT_REQ_NOTHING }, // deprecated
103	{ "--scsitype", 'T', RTGETOPT_REQ_UINT32 },
104	{ "-scsitype", 'T', RTGETOPT_REQ_UINT32 }, // deprecated
105	{ "--type", 'T', RTGETOPT_REQ_UINT32 }, // deprecated
106	{ "-type", 'T', RTGETOPT_REQ_UINT32 }, // deprecated
107	#if 0 /* Changing the controller is fully valid, but the current design on how
108	the params are evaluated here doesn't allow two parameter for one
109	unit. The target disk path is more important. I leave it for future
110	improvments. */
111	{ "--controller", 'C', RTGETOPT_REQ_STRING },
112	#endif
113	{ "--disk", 'D', RTGETOPT_REQ_STRING },
114	};
115
116	int handleImportAppliance(HandlerArg *arg)
117	{
118	HRESULT rc = S_OK;
119
120	Utf8Str strOvfFilename;
121	bool fExecute = true; // if true, then we actually do the import
122	uint32_t ulCurVsys = (uint32_t)-1;
123	uint32_t ulCurUnit = (uint32_t)-1;
124	// for each --vsys X command, maintain a map of command line items
125	// (we'll parse them later after interpreting the OVF, when we can
126	// actually check whether they make sense semantically)
127	ArgsMapsMap mapArgsMapsPerVsys;
128	IgnoresMapsMap mapIgnoresMapsPerVsys;
129
130	int c;
131	RTGETOPTUNION ValueUnion;
132	RTGETOPTSTATE GetState;
133	// start at 0 because main() has hacked both the argc and argv given to us
134	RTGetOptInit(&GetState, arg->argc, arg->argv, g_aImportApplianceOptions, RT_ELEMENTS(g_aImportApplianceOptions),
135	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
136	while ((c = RTGetOpt(&GetState, &ValueUnion)))
137	{
138	switch (c)
139	{
140	case 'n': // --dry-run
141	fExecute = false;
142	break;
143
144	case 'P': // --detailed-progress
145	g_fDetailedProgress = true;
146	break;
147
148	case 's': // --vsys
149	ulCurVsys = ValueUnion.u32;
150	ulCurUnit = (uint32_t)-1;
151	break;
152
153	case 'o': // --ostype
154	if (ulCurVsys == (uint32_t)-1)
155	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
156	mapArgsMapsPerVsys[ulCurVsys]["ostype"] = ValueUnion.psz;
157	break;
158
159	case 'V': // --vmname
160	if (ulCurVsys == (uint32_t)-1)
161	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
162	mapArgsMapsPerVsys[ulCurVsys]["vmname"] = ValueUnion.psz;
163	break;
164
165	case 'd': // --description
166	if (ulCurVsys == (uint32_t)-1)
167	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
168	mapArgsMapsPerVsys[ulCurVsys]["description"] = ValueUnion.psz;
169	break;
170
171	case 'L': // --eula
172	if (ulCurVsys == (uint32_t)-1)
173	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
174	mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz;
175	break;
176
177	case 'm': // --memory
178	if (ulCurVsys == (uint32_t)-1)
179	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
180	mapArgsMapsPerVsys[ulCurVsys]["memory"] = ValueUnion.psz;
181	break;
182
183	case 'c': // --cpus
184	if (ulCurVsys == (uint32_t)-1)
185	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
186	mapArgsMapsPerVsys[ulCurVsys]["cpus"] = ValueUnion.psz;
187	break;
188
189	case 'u': // --unit
190	ulCurUnit = ValueUnion.u32;
191	break;
192
193	case 'x': // --ignore
194	if (ulCurVsys == (uint32_t)-1)
195	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
196	if (ulCurUnit == (uint32_t)-1)
197	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
198	mapIgnoresMapsPerVsys[ulCurVsys][ulCurUnit] = true;
199	break;
200
201	case 'T': // --scsitype
202	if (ulCurVsys == (uint32_t)-1)
203	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
204	if (ulCurUnit == (uint32_t)-1)
205	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
206	mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("scsitype%u", ulCurUnit)] = ValueUnion.psz;
207	break;
208
209	case 'C': // --controller
210	if (ulCurVsys == (uint32_t)-1)
211	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
212	if (ulCurUnit == (uint32_t)-1)
213	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
214	mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("controller%u", ulCurUnit)] = ValueUnion.psz;
215	break;
216
217	case 'D': // --disk
218	if (ulCurVsys == (uint32_t)-1)
219	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
220	if (ulCurUnit == (uint32_t)-1)
221	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong);
222	mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("disk%u", ulCurUnit)] = ValueUnion.psz;
223	break;
224
225	case VINF_GETOPT_NOT_OPTION:
226	if (strOvfFilename.isEmpty())
227	strOvfFilename = ValueUnion.psz;
228	else
229	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid parameter '%s'", ValueUnion.psz);
230	break;
231
232	default:
233	if (c > 0)
234	{
235	if (RT_C_IS_PRINT(c))
236	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option -%c", c);
237	else
238	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option case %i", c);
239	}
240	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
241	return errorSyntax(USAGE_IMPORTAPPLIANCE, "unknown option: %s\n", ValueUnion.psz);
242	else if (ValueUnion.pDef)
243	return errorSyntax(USAGE_IMPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
244	else
245	return errorSyntax(USAGE_IMPORTAPPLIANCE, "error: %Rrs", c);
246	}
247	}
248
249	if (strOvfFilename.isEmpty())
250	return errorSyntax(USAGE_IMPORTAPPLIANCE, "Not enough arguments for \"import\" command.");
251
252	do
253	{
254	ComPtr<IAppliance> pAppliance;
255	CHECK_ERROR_BREAK(arg->virtualBox, CreateAppliance(pAppliance.asOutParam()));
256
257	char *pszAbsFilePath;
258	if (strOvfFilename.startsWith("S3://", iprt::MiniString::CaseInsensitive) \|\|
259	strOvfFilename.startsWith("SunCloud://", iprt::MiniString::CaseInsensitive) \|\|
260	strOvfFilename.startsWith("webdav://", iprt::MiniString::CaseInsensitive))
261	pszAbsFilePath = RTStrDup(strOvfFilename.c_str());
262	else
263	pszAbsFilePath = RTPathAbsDup(strOvfFilename.c_str());
264	ComPtr<IProgress> progressRead;
265	CHECK_ERROR_BREAK(pAppliance, Read(Bstr(pszAbsFilePath).raw(),
266	progressRead.asOutParam()));
267	RTStrFree(pszAbsFilePath);
268
269	rc = showProgress(progressRead);
270
271	if (FAILED(rc))
272	{
273	com::ProgressErrorInfo info(progressRead);
274	com::GluePrintErrorInfo(info);
275	com::GluePrintErrorContext("ImportAppliance", __FILE__, __LINE__);
276	return 1;
277	}
278
279	Bstr path; /* fetch the path, there is stuff like username/password removed if any */
280	CHECK_ERROR_BREAK(pAppliance, COMGETTER(Path)(path.asOutParam()));
281	// call interpret(); this can yield both warnings and errors, so we need
282	// to tinker with the error info a bit
283	RTStrmPrintf(g_pStdErr, "Interpreting %ls...\n", path.raw());
284	rc = pAppliance->Interpret();
285	com::ErrorInfo info0(pAppliance, COM_IIDOF(IAppliance));
286
287	com::SafeArray<BSTR> aWarnings;
288	if (SUCCEEDED(pAppliance->GetWarnings(ComSafeArrayAsOutParam(aWarnings))))
289	{
290	size_t cWarnings = aWarnings.size();
291	for (unsigned i = 0; i < cWarnings; ++i)
292	{
293	Bstr bstrWarning(aWarnings[i]);
294	RTMsgWarning("%ls.", bstrWarning.raw());
295	}
296	}
297
298	if (FAILED(rc)) // during interpret, after printing warnings
299	{
300	com::GluePrintErrorInfo(info0);
301	com::GluePrintErrorContext("Interpret", __FILE__, __LINE__);
302	break;
303	}
304
305	RTStrmPrintf(g_pStdErr, "OK.\n");
306
307	// fetch all disks
308	com::SafeArray<BSTR> retDisks;
309	CHECK_ERROR_BREAK(pAppliance,
310	COMGETTER(Disks)(ComSafeArrayAsOutParam(retDisks)));
311	if (retDisks.size() > 0)
312	{
313	RTPrintf("Disks:");
314	for (unsigned i = 0; i < retDisks.size(); i++)
315	RTPrintf(" %ls", retDisks[i]);
316	RTPrintf("\n");
317	}
318
319	// fetch virtual system descriptions
320	com::SafeIfaceArray<IVirtualSystemDescription> aVirtualSystemDescriptions;
321	CHECK_ERROR_BREAK(pAppliance,
322	COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(aVirtualSystemDescriptions)));
323
324	size_t cVirtualSystemDescriptions = aVirtualSystemDescriptions.size();
325
326	// match command line arguments with virtual system descriptions;
327	// this is only to sort out invalid indices at this time
328	ArgsMapsMap::const_iterator it;
329	for (it = mapArgsMapsPerVsys.begin();
330	it != mapArgsMapsPerVsys.end();
331	++it)
332	{
333	uint32_t ulVsys = it->first;
334	if (ulVsys >= cVirtualSystemDescriptions)
335	return errorSyntax(USAGE_IMPORTAPPLIANCE,
336	"Invalid index %RI32 with -vsys option; the OVF contains only %zu virtual system(s).",
337	ulVsys, cVirtualSystemDescriptions);
338	}
339
340	uint32_t cLicensesInTheWay = 0;
341
342	// dump virtual system descriptions and match command-line arguments
343	if (cVirtualSystemDescriptions > 0)
344	{
345	for (unsigned i = 0; i < cVirtualSystemDescriptions; ++i)
346	{
347	com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
348	com::SafeArray<BSTR> aRefs;
349	com::SafeArray<BSTR> aOvfValues;
350	com::SafeArray<BSTR> aVboxValues;
351	com::SafeArray<BSTR> aExtraConfigValues;
352	CHECK_ERROR_BREAK(aVirtualSystemDescriptions[i],
353	GetDescription(ComSafeArrayAsOutParam(retTypes),
354	ComSafeArrayAsOutParam(aRefs),
355	ComSafeArrayAsOutParam(aOvfValues),
356	ComSafeArrayAsOutParam(aVboxValues),
357	ComSafeArrayAsOutParam(aExtraConfigValues)));
358
359	RTPrintf("Virtual system %u:\n", i);
360
361	// look up the corresponding command line options, if any
362	ArgsMap *pmapArgs = NULL;
363	ArgsMapsMap::iterator itm = mapArgsMapsPerVsys.find(i);
364	if (itm != mapArgsMapsPerVsys.end())
365	pmapArgs = &itm->second;
366
367	// this collects the final values for setFinalValues()
368	com::SafeArray<BOOL> aEnabled(retTypes.size());
369	com::SafeArray<BSTR> aFinalValues(retTypes.size());
370
371	for (unsigned a = 0; a < retTypes.size(); ++a)
372	{
373	VirtualSystemDescriptionType_T t = retTypes[a];
374
375	Utf8Str strOverride;
376
377	Bstr bstrFinalValue = aVboxValues[a];
378
379	bool fIgnoreThis = mapIgnoresMapsPerVsys[i][a];
380
381	aEnabled[a] = true;
382
383	switch (t)
384	{
385	case VirtualSystemDescriptionType_OS:
386	if (findArgValue(strOverride, pmapArgs, "ostype"))
387	{
388	bstrFinalValue = strOverride;
389	RTPrintf("%2u: OS type specified with --ostype: \"%ls\"\n",
390	a, bstrFinalValue.raw());
391	}
392	else
393	RTPrintf("%2u: Suggested OS type: \"%ls\""
394	"\n (change with \"--vsys %u --ostype <type>\"; use \"list ostypes\" to list all possible values)\n",
395	a, bstrFinalValue.raw(), i);
396	break;
397
398	case VirtualSystemDescriptionType_Name:
399	if (findArgValue(strOverride, pmapArgs, "vmname"))
400	{
401	bstrFinalValue = strOverride;
402	RTPrintf("%2u: VM name specified with --vmname: \"%ls\"\n",
403	a, bstrFinalValue.raw());
404	}
405	else
406	RTPrintf("%2u: Suggested VM name \"%ls\""
407	"\n (change with \"--vsys %u --vmname <name>\")\n",
408	a, bstrFinalValue.raw(), i);
409	break;
410
411	case VirtualSystemDescriptionType_Product:
412	RTPrintf("%2u: Product (ignored): %ls\n",
413	a, aVboxValues[a]);
414	break;
415
416	case VirtualSystemDescriptionType_ProductUrl:
417	RTPrintf("%2u: ProductUrl (ignored): %ls\n",
418	a, aVboxValues[a]);
419	break;
420
421	case VirtualSystemDescriptionType_Vendor:
422	RTPrintf("%2u: Vendor (ignored): %ls\n",
423	a, aVboxValues[a]);
424	break;
425
426	case VirtualSystemDescriptionType_VendorUrl:
427	RTPrintf("%2u: VendorUrl (ignored): %ls\n",
428	a, aVboxValues[a]);
429	break;
430
431	case VirtualSystemDescriptionType_Version:
432	RTPrintf("%2u: Version (ignored): %ls\n",
433	a, aVboxValues[a]);
434	break;
435
436	case VirtualSystemDescriptionType_Description:
437	if (findArgValue(strOverride, pmapArgs, "description"))
438	{
439	bstrFinalValue = strOverride;
440	RTPrintf("%2u: Description specified with --description: \"%ls\"\n",
441	a, bstrFinalValue.raw());
442	}
443	else
444	RTPrintf("%2u: Description \"%ls\""
445	"\n (change with \"--vsys %u --description <desc>\")\n",
446	a, bstrFinalValue.raw(), i);
447	break;
448
449	case VirtualSystemDescriptionType_License:
450	++cLicensesInTheWay;
451	if (findArgValue(strOverride, pmapArgs, "eula"))
452	{
453	if (strOverride == "show")
454	{
455	RTPrintf("%2u: End-user license agreement"
456	"\n (accept with \"--vsys %u --eula accept\"):"
457	"\n\n%ls\n\n",
458	a, i, bstrFinalValue.raw());
459	}
460	else if (strOverride == "accept")
461	{
462	RTPrintf("%2u: End-user license agreement (accepted)\n",
463	a);
464	--cLicensesInTheWay;
465	}
466	else
467	return errorSyntax(USAGE_IMPORTAPPLIANCE,
468	"Argument to --eula must be either \"show\" or \"accept\".");
469	}
470	else
471	RTPrintf("%2u: End-user license agreement"
472	"\n (display with \"--vsys %u --eula show\";"
473	"\n accept with \"--vsys %u --eula accept\")\n",
474	a, i, i);
475	break;
476
477	case VirtualSystemDescriptionType_CPU:
478	if (findArgValue(strOverride, pmapArgs, "cpus"))
479	{
480	uint32_t cCPUs;
481	if ( strOverride.toInt(cCPUs) == VINF_SUCCESS
482	&& cCPUs >= VMM_MIN_CPU_COUNT
483	&& cCPUs <= VMM_MAX_CPU_COUNT
484	)
485	{
486	bstrFinalValue = strOverride;
487	RTPrintf("%2u: No. of CPUs specified with --cpus: %ls\n",
488	a, bstrFinalValue.raw());
489	}
490	else
491	return errorSyntax(USAGE_IMPORTAPPLIANCE,
492	"Argument to --cpus option must be a number greater than %d and less than %d.",
493	VMM_MIN_CPU_COUNT - 1, VMM_MAX_CPU_COUNT + 1);
494	}
495	else
496	RTPrintf("%2u: Number of CPUs: %ls\n (change with \"--vsys %u --cpus <n>\")\n",
497	a, bstrFinalValue.raw(), i);
498	break;
499
500	case VirtualSystemDescriptionType_Memory:
501	{
502	if (findArgValue(strOverride, pmapArgs, "memory"))
503	{
504	uint32_t ulMemMB;
505	if (VINF_SUCCESS == strOverride.toInt(ulMemMB))
506	{
507	bstrFinalValue = strOverride;
508	RTPrintf("%2u: Guest memory specified with --memory: %ls MB\n",
509	a, bstrFinalValue.raw());
510	}
511	else
512	return errorSyntax(USAGE_IMPORTAPPLIANCE,
513	"Argument to --memory option must be a non-negative number.");
514	}
515	else
516	RTPrintf("%2u: Guest memory: %ls MB\n (change with \"--vsys %u --memory <MB>\")\n",
517	a, bstrFinalValue.raw(), i);
518	}
519	break;
520
521	case VirtualSystemDescriptionType_HardDiskControllerIDE:
522	if (fIgnoreThis)
523	{
524	RTPrintf("%2u: IDE controller, type %ls -- disabled\n",
525	a,
526	aVboxValues[a]);
527	aEnabled[a] = false;
528	}
529	else
530	RTPrintf("%2u: IDE controller, type %ls"
531	"\n (disable with \"--vsys %u --unit %u --ignore\")\n",
532	a,
533	aVboxValues[a],
534	i, a);
535	break;
536
537	case VirtualSystemDescriptionType_HardDiskControllerSATA:
538	if (fIgnoreThis)
539	{
540	RTPrintf("%2u: SATA controller, type %ls -- disabled\n",
541	a,
542	aVboxValues[a]);
543	aEnabled[a] = false;
544	}
545	else
546	RTPrintf("%2u: SATA controller, type %ls"
547	"\n (disable with \"--vsys %u --unit %u --ignore\")\n",
548	a,
549	aVboxValues[a],
550	i, a);
551	break;
552
553	case VirtualSystemDescriptionType_HardDiskControllerSAS:
554	if (fIgnoreThis)
555	{
556	RTPrintf("%2u: SAS controller, type %ls -- disabled\n",
557	a,
558	aVboxValues[a]);
559	aEnabled[a] = false;
560	}
561	else
562	RTPrintf("%2u: SAS controller, type %ls"
563	"\n (disable with \"--vsys %u --unit %u --ignore\")\n",
564	a,
565	aVboxValues[a],
566	i, a);
567	break;
568
569	case VirtualSystemDescriptionType_HardDiskControllerSCSI:
570	if (fIgnoreThis)
571	{
572	RTPrintf("%2u: SCSI controller, type %ls -- disabled\n",
573	a,
574	aVboxValues[a]);
575	aEnabled[a] = false;
576	}
577	else
578	{
579	Utf8StrFmt strTypeArg("scsitype%u", a);
580	if (findArgValue(strOverride, pmapArgs, strTypeArg))
581	{
582	bstrFinalValue = strOverride;
583	RTPrintf("%2u: SCSI controller, type set with --unit %u --scsitype: \"%ls\"\n",
584	a,
585	a,
586	bstrFinalValue.raw());
587	}
588	else
589	RTPrintf("%2u: SCSI controller, type %ls"
590	"\n (change with \"--vsys %u --unit %u --scsitype {BusLogic\|LsiLogic}\";"
591	"\n disable with \"--vsys %u --unit %u --ignore\")\n",
592	a,
593	aVboxValues[a],
594	i, a, i, a);
595	}
596	break;
597
598	case VirtualSystemDescriptionType_HardDiskImage:
599	if (fIgnoreThis)
600	{
601	RTPrintf("%2u: Hard disk image: source image=%ls -- disabled\n",
602	a,
603	aOvfValues[a]);
604	aEnabled[a] = false;
605	}
606	else
607	{
608	Utf8StrFmt strTypeArg("disk%u", a);
609	if (findArgValue(strOverride, pmapArgs, strTypeArg))
610	{
611	RTUUID uuid;
612	/* Check if this is a uuid. If so, don't touch. */
613	int vrc = RTUuidFromStr(&uuid, strOverride.c_str());
614	if (vrc != VINF_SUCCESS)
615	{
616	/* Make the path absolute. */
617	if (!RTPathStartsWithRoot(strOverride.c_str()))
618	{
619	char pszPwd[RTPATH_MAX];
620	vrc = RTPathGetCurrent(pszPwd, RTPATH_MAX);
621	if (RT_SUCCESS(vrc))
622	strOverride = Utf8Str(pszPwd).append(RTPATH_SLASH).append(strOverride);
623	}
624	}
625	bstrFinalValue = strOverride;
626	RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n",
627	a,
628	aOvfValues[a],
629	bstrFinalValue.raw(),
630	aExtraConfigValues[a]);
631	}
632	#if 0 /* Changing the controller is fully valid, but the current design on how
633	the params are evaluated here doesn't allow two parameter for one
634	unit. The target disk path is more important I leave it for future
635	improvments. */
636	Utf8StrFmt strTypeArg("controller%u", a);
637	if (findArgValue(strOverride, pmapArgs, strTypeArg))
638	{
639	// strOverride now has the controller index as a number, but we
640	// need a "controller=X" format string
641	strOverride = Utf8StrFmt("controller=%s", strOverride.c_str());
642	Bstr bstrExtraConfigValue = strOverride;
643	bstrExtraConfigValue.detachTo(&aExtraConfigValues[a]);
644	RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n",
645	a,
646	aOvfValues[a],
647	aVboxValues[a],
648	aExtraConfigValues[a]);
649	}
650	#endif
651	else
652	RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls"
653	"\n (change target path with \"--vsys %u --unit %u --disk path\";"
654	"\n disable with \"--vsys %u --unit %u --ignore\")\n",
655	a,
656	aOvfValues[a],
657	aVboxValues[a],
658	aExtraConfigValues[a],
659	i, a, i, a);
660	}
661	break;
662
663	case VirtualSystemDescriptionType_CDROM:
664	if (fIgnoreThis)
665	{
666	RTPrintf("%2u: CD-ROM -- disabled\n",
667	a);
668	aEnabled[a] = false;
669	}
670	else
671	RTPrintf("%2u: CD-ROM"
672	"\n (disable with \"--vsys %u --unit %u --ignore\")\n",
673	a, i, a);
674	break;
675
676	case VirtualSystemDescriptionType_Floppy:
677	if (fIgnoreThis)
678	{
679	RTPrintf("%2u: Floppy -- disabled\n",
680	a);
681	aEnabled[a] = false;
682	}
683	else
684	RTPrintf("%2u: Floppy"
685	"\n (disable with \"--vsys %u --unit %u --ignore\")\n",
686	a, i, a);
687	break;
688
689	case VirtualSystemDescriptionType_NetworkAdapter:
690	RTPrintf("%2u: Network adapter: orig %ls, config %ls, extra %ls\n", // @todo implement once we have a plan for the back-end
691	a,
692	aOvfValues[a],
693	aVboxValues[a],
694	aExtraConfigValues[a]);
695	break;
696
697	case VirtualSystemDescriptionType_USBController:
698	if (fIgnoreThis)
699	{
700	RTPrintf("%2u: USB controller -- disabled\n",
701	a);
702	aEnabled[a] = false;
703	}
704	else
705	RTPrintf("%2u: USB controller"
706	"\n (disable with \"--vsys %u --unit %u --ignore\")\n",
707	a, i, a);
708	break;
709
710	case VirtualSystemDescriptionType_SoundCard:
711	if (fIgnoreThis)
712	{
713	RTPrintf("%2u: Sound card \"%ls\" -- disabled\n",
714	a,
715	aOvfValues[a]);
716	aEnabled[a] = false;
717	}
718	else
719	RTPrintf("%2u: Sound card (appliance expects \"%ls\", can change on import)"
720	"\n (disable with \"--vsys %u --unit %u --ignore\")\n",
721	a,
722	aOvfValues[a],
723	i,
724	a);
725	break;
726	}
727
728	bstrFinalValue.detachTo(&aFinalValues[a]);
729	}
730
731	if (fExecute)
732	CHECK_ERROR_BREAK(aVirtualSystemDescriptions[i],
733	SetFinalValues(ComSafeArrayAsInParam(aEnabled),
734	ComSafeArrayAsInParam(aFinalValues),
735	ComSafeArrayAsInParam(aExtraConfigValues)));
736
737	} // for (unsigned i = 0; i < cVirtualSystemDescriptions; ++i)
738
739	if (cLicensesInTheWay == 1)
740	RTMsgError("Cannot import until the license agreement listed above is accepted.");
741	else if (cLicensesInTheWay > 1)
742	RTMsgError("Cannot import until the %c license agreements listed above are accepted.", cLicensesInTheWay);
743
744	if (!cLicensesInTheWay && fExecute)
745	{
746	// go!
747	ComPtr<IProgress> progress;
748	CHECK_ERROR_BREAK(pAppliance,
749	ImportMachines(progress.asOutParam()));
750
751	rc = showProgress(progress);
752
753	if (FAILED(rc))
754	{
755	com::ProgressErrorInfo info(progress);
756	com::GluePrintErrorInfo(info);
757	com::GluePrintErrorContext("ImportAppliance", __FILE__, __LINE__);
758	return 1;
759	}
760	else
761	RTPrintf("Successfully imported the appliance.\n");
762	}
763	} // end if (aVirtualSystemDescriptions.size() > 0)
764	} while (0);
765
766	return SUCCEEDED(rc) ? 0 : 1;
767	}
768
769	static const RTGETOPTDEF g_aExportOptions[]
770	= {
771	{ "--output", 'o', RTGETOPT_REQ_STRING },
772	{ "--legacy09", 'l', RTGETOPT_REQ_NOTHING },
773	{ "--manifest", 'm', RTGETOPT_REQ_NOTHING },
774	{ "--vsys", 's', RTGETOPT_REQ_UINT32 },
775	{ "--product", 'p', RTGETOPT_REQ_STRING },
776	{ "--producturl", 'P', RTGETOPT_REQ_STRING },
777	{ "--vendor", 'd', RTGETOPT_REQ_STRING },
778	{ "--vendorurl", 'D', RTGETOPT_REQ_STRING },
779	{ "--version", 'v', RTGETOPT_REQ_STRING },
780	{ "--eula", 'e', RTGETOPT_REQ_STRING },
781	{ "--eulafile", 'E', RTGETOPT_REQ_STRING },
782	};
783
784	int handleExportAppliance(HandlerArg *a)
785	{
786	HRESULT rc = S_OK;
787
788	Utf8Str strOutputFile;
789	Utf8Str strOvfFormat("ovf-1.0"); // the default export version
790	bool fManifest = false; // the default
791	std::list< ComPtr<IMachine> > llMachines;
792
793	uint32_t ulCurVsys = (uint32_t)-1;
794	// for each --vsys X command, maintain a map of command line items
795	ArgsMapsMap mapArgsMapsPerVsys;
796	do
797	{
798	int c;
799
800	RTGETOPTUNION ValueUnion;
801	RTGETOPTSTATE GetState;
802	// start at 0 because main() has hacked both the argc and argv given to us
803	RTGetOptInit(&GetState, a->argc, a->argv, g_aExportOptions,
804	RT_ELEMENTS(g_aExportOptions), 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
805
806	Utf8Str strProductUrl;
807	while ((c = RTGetOpt(&GetState, &ValueUnion)))
808	{
809	switch (c)
810	{
811	case 'o': // --output
812	if (strOutputFile.length())
813	return errorSyntax(USAGE_EXPORTAPPLIANCE, "You can only specify --output once.");
814	else
815	strOutputFile = ValueUnion.psz;
816	break;
817
818	case 'l': // --legacy09
819	strOvfFormat = "ovf-0.9";
820	break;
821
822	case 'm': // --manifest
823	fManifest = true;
824	break;
825
826	case 's': // --vsys
827	ulCurVsys = ValueUnion.u32;
828	break;
829
830	case 'p': // --product
831	if (ulCurVsys == (uint32_t)-1)
832	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
833	mapArgsMapsPerVsys[ulCurVsys]["product"] = ValueUnion.psz;
834	break;
835
836	case 'P': // --producturl
837	if (ulCurVsys == (uint32_t)-1)
838	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
839	mapArgsMapsPerVsys[ulCurVsys]["producturl"] = ValueUnion.psz;
840	break;
841
842	case 'd': // --vendor
843	if (ulCurVsys == (uint32_t)-1)
844	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
845	mapArgsMapsPerVsys[ulCurVsys]["vendor"] = ValueUnion.psz;
846	break;
847
848	case 'D': // --vendorurl
849	if (ulCurVsys == (uint32_t)-1)
850	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
851	mapArgsMapsPerVsys[ulCurVsys]["vendorurl"] = ValueUnion.psz;
852	break;
853
854	case 'v': // --version
855	if (ulCurVsys == (uint32_t)-1)
856	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
857	mapArgsMapsPerVsys[ulCurVsys]["version"] = ValueUnion.psz;
858	break;
859
860	case 'e': // --eula
861	if (ulCurVsys == (uint32_t)-1)
862	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
863	mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz;
864	break;
865
866	case 'E': // --eulafile
867	if (ulCurVsys == (uint32_t)-1)
868	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong);
869	mapArgsMapsPerVsys[ulCurVsys]["eulafile"] = ValueUnion.psz;
870	break;
871
872	case VINF_GETOPT_NOT_OPTION:
873	{
874	Utf8Str strMachine(ValueUnion.psz);
875	// must be machine: try UUID or name
876	ComPtr<IMachine> machine;
877	CHECK_ERROR_BREAK(a->virtualBox, FindMachine(Bstr(strMachine).raw(),
878	machine.asOutParam()));
879	if (machine)
880	llMachines.push_back(machine);
881	}
882	break;
883
884	default:
885	if (c > 0)
886	{
887	if (RT_C_IS_GRAPH(c))
888	return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: -%c", c);
889	else
890	return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: %i", c);
891	}
892	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
893	return errorSyntax(USAGE_EXPORTAPPLIANCE, "unknown option: %s", ValueUnion.psz);
894	else if (ValueUnion.pDef)
895	return errorSyntax(USAGE_EXPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
896	else
897	return errorSyntax(USAGE_EXPORTAPPLIANCE, "%Rrs", c);
898	}
899
900	if (FAILED(rc))
901	break;
902	}
903
904	if (FAILED(rc))
905	break;
906
907	if (llMachines.size() == 0)
908	return errorSyntax(USAGE_EXPORTAPPLIANCE, "At least one machine must be specified with the export command.");
909	if (!strOutputFile.length())
910	return errorSyntax(USAGE_EXPORTAPPLIANCE, "Missing --output argument with export command.");
911
912	// match command line arguments with the machines count
913	// this is only to sort out invalid indices at this time
914	ArgsMapsMap::const_iterator it;
915	for (it = mapArgsMapsPerVsys.begin();
916	it != mapArgsMapsPerVsys.end();
917	++it)
918	{
919	uint32_t ulVsys = it->first;
920	if (ulVsys >= llMachines.size())
921	return errorSyntax(USAGE_EXPORTAPPLIANCE,
922	"Invalid index %RI32 with -vsys option; you specified only %zu virtual system(s).",
923	ulVsys, llMachines.size());
924	}
925
926	ComPtr<IAppliance> pAppliance;
927	CHECK_ERROR_BREAK(a->virtualBox, CreateAppliance(pAppliance.asOutParam()));
928
929	char *pszAbsFilePath = 0;
930	if (strOutputFile.startsWith("S3://", iprt::MiniString::CaseInsensitive) \|\|
931	strOutputFile.startsWith("SunCloud://", iprt::MiniString::CaseInsensitive) \|\|
932	strOutputFile.startsWith("webdav://", iprt::MiniString::CaseInsensitive))
933	pszAbsFilePath = RTStrDup(strOutputFile.c_str());
934	else
935	pszAbsFilePath = RTPathAbsDup(strOutputFile.c_str());
936
937	std::list< ComPtr<IMachine> >::iterator itM;
938	uint32_t i=0;
939	for (itM = llMachines.begin();
940	itM != llMachines.end();
941	++itM, ++i)
942	{
943	ComPtr<IMachine> pMachine = *itM;
944	ComPtr<IVirtualSystemDescription> pVSD;
945	CHECK_ERROR_BREAK(pMachine, Export(pAppliance, Bstr(pszAbsFilePath).raw(), pVSD.asOutParam()));
946	// Add additional info to the virtual system description if the user wants so
947	ArgsMap *pmapArgs = NULL;
948	ArgsMapsMap::iterator itm = mapArgsMapsPerVsys.find(i);
949	if (itm != mapArgsMapsPerVsys.end())
950	pmapArgs = &itm->second;
951	if (pmapArgs)
952	{
953	ArgsMap::iterator itD;
954	for (itD = pmapArgs->begin();
955	itD != pmapArgs->end();
956	++itD)
957	{
958	if (itD->first == "product")
959	pVSD->AddDescription(VirtualSystemDescriptionType_Product,
960	Bstr(itD->second).raw(),
961	Bstr(itD->second).raw());
962	else if (itD->first == "producturl")
963	pVSD->AddDescription(VirtualSystemDescriptionType_ProductUrl,
964	Bstr(itD->second).raw(),
965	Bstr(itD->second).raw());
966	else if (itD->first == "vendor")
967	pVSD->AddDescription(VirtualSystemDescriptionType_Vendor,
968	Bstr(itD->second).raw(),
969	Bstr(itD->second).raw());
970	else if (itD->first == "vendorurl")
971	pVSD->AddDescription(VirtualSystemDescriptionType_VendorUrl,
972	Bstr(itD->second).raw(),
973	Bstr(itD->second).raw());
974	else if (itD->first == "version")
975	pVSD->AddDescription(VirtualSystemDescriptionType_Version,
976	Bstr(itD->second).raw(),
977	Bstr(itD->second).raw());
978	else if (itD->first == "eula")
979	pVSD->AddDescription(VirtualSystemDescriptionType_License,
980	Bstr(itD->second).raw(),
981	Bstr(itD->second).raw());
982	else if (itD->first == "eulafile")
983	{
984	Utf8Str strContent;
985	void *pvFile;
986	size_t cbFile;
987	int irc = RTFileReadAll(itD->second.c_str(), &pvFile, &cbFile);
988	if (RT_SUCCESS(irc))
989	{
990	Bstr bstrContent((char*)pvFile);
991	pVSD->AddDescription(VirtualSystemDescriptionType_License,
992	bstrContent.raw(),
993	bstrContent.raw());
994	RTFileReadAllFree(pvFile, cbFile);
995	}
996	else
997	{
998	RTMsgError("Cannot read license file \"%s\" which should be included in the virtual system %u.",
999	itD->second.c_str(), i);
1000	return 1;
1001	}
1002	}
1003	}
1004	}
1005	}
1006
1007	if (FAILED(rc))
1008	break;
1009
1010	ComPtr<IProgress> progress;
1011	CHECK_ERROR_BREAK(pAppliance, Write(Bstr(strOvfFormat).raw(),
1012	fManifest,
1013	Bstr(pszAbsFilePath).raw(),
1014	progress.asOutParam()));
1015	RTStrFree(pszAbsFilePath);
1016
1017	rc = showProgress(progress);
1018
1019	if (FAILED(rc))
1020	{
1021	com::ProgressErrorInfo info(progress);
1022	com::GluePrintErrorInfo(info);
1023	com::GluePrintErrorContext("Write", __FILE__, __LINE__);
1024	return 1;
1025	}
1026	else
1027	RTPrintf("Successfully exported %d machine(s).\n", llMachines.size());
1028
1029	} while (0);
1030
1031	return SUCCEEDED(rc) ? 0 : 1;
1032	}
1033
1034	#endif /* !VBOX_ONLY_DOCS */

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: