VBoxManageCloud.cpp@ 91999

Last change on this file since 91999 was 91157, checked in by vboxsync, 3 years ago
VBoxManage: Make "cloud showvminfo" (parallel to "showvminfo" for local vms) a synonym for "cloud machine info". bugref:10065.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 105.5 KB

Line
1	/* $Id: VBoxManageCloud.cpp 91157 2021-09-08 14:24:32Z vboxsync $ */
2	/** @file
3	* VBoxManageCloud - The cloud related commands.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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	#include <VBox/com/com.h>
19	#include <VBox/com/string.h>
20	#include <VBox/com/Guid.h>
21	#include <VBox/com/array.h>
22	#include <VBox/com/ErrorInfo.h>
23	#include <VBox/com/errorprint.h>
24	#include <VBox/com/VirtualBox.h>
25
26	#include <iprt/ctype.h>
27	#include <iprt/getopt.h>
28	#include <iprt/stream.h>
29	#include <iprt/string.h>
30	#include <iprt/thread.h>
31	#include <iprt/uuid.h>
32	#include <iprt/file.h>
33	#include <iprt/http.h>
34	#include <VBox/log.h>
35
36	#include <iprt/cpp/path.h>
37
38	#include "VBoxManage.h"
39
40	#include <list>
41
42	using namespace com;//at least for Bstr
43
44
45	/**
46	* Common Cloud options.
47	*/
48	typedef struct
49	{
50	struct {
51	const char *pszProviderName;
52	ComPtr<ICloudProvider> pCloudProvider;
53	}provider;
54	struct {
55	const char *pszProfileName;
56	ComPtr<ICloudProfile> pCloudProfile;
57	}profile;
58
59	} CLOUDCOMMONOPT;
60	typedef CLOUDCOMMONOPT *PCLOUDCOMMONOPT;
61
62	static HRESULT checkAndSetCommonOptions(HandlerArg *a, PCLOUDCOMMONOPT pCommonOpts)
63	{
64	HRESULT hrc = S_OK;
65
66	Bstr bstrProvider(pCommonOpts->provider.pszProviderName);
67	Bstr bstrProfile(pCommonOpts->profile.pszProfileName);
68
69	/* check for required options */
70	if (bstrProvider.isEmpty())
71	{
72	errorSyntax(USAGE_S_NEWCMD, "Parameter --provider is required");
73	return E_FAIL;
74	}
75	if (bstrProfile.isEmpty())
76	{
77	errorSyntax(USAGE_S_NEWCMD, "Parameter --profile is required");
78	return E_FAIL;
79	}
80
81	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
82	ComPtr<ICloudProviderManager> pCloudProviderManager;
83	CHECK_ERROR2_RET(hrc, pVirtualBox,
84	COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
85	RTEXITCODE_FAILURE);
86
87	ComPtr<ICloudProvider> pCloudProvider;
88	CHECK_ERROR2_RET(hrc, pCloudProviderManager,
89	GetProviderByShortName(bstrProvider.raw(), pCloudProvider.asOutParam()),
90	RTEXITCODE_FAILURE);
91	pCommonOpts->provider.pCloudProvider = pCloudProvider;
92
93	ComPtr<ICloudProfile> pCloudProfile;
94	CHECK_ERROR2_RET(hrc, pCloudProvider,
95	GetProfileByName(bstrProfile.raw(), pCloudProfile.asOutParam()),
96	RTEXITCODE_FAILURE);
97	pCommonOpts->profile.pCloudProfile = pCloudProfile;
98
99	return hrc;
100	}
101
102
103	/**
104	* List all available cloud instances for the specified cloud provider.
105	* Available cloud instance is one which state whether "running" or "stopped".
106	*
107	* @returns RTEXITCODE
108	* @param a is the list of passed arguments
109	* @param iFirst is the position of the first unparsed argument in the arguments list
110	* @param pCommonOpts is a pointer to the structure CLOUDCOMMONOPT with some common
111	* arguments which have been already parsed before
112	*/
113	static RTEXITCODE listCloudInstances(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
114	{
115	static const RTGETOPTDEF s_aOptions[] =
116	{
117	{ "--compartment-id", 'c', RTGETOPT_REQ_STRING },
118	{ "--state", 's', RTGETOPT_REQ_STRING },
119	{ "help", 1001, RTGETOPT_REQ_NOTHING },
120	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
121	};
122	RTGETOPTSTATE GetState;
123	RTGETOPTUNION ValueUnion;
124	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
125	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
126
127	Utf8Str strCompartmentId;
128	com::SafeArray<CloudMachineState_T> machineStates;
129
130	int c;
131	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
132	{
133	switch (c)
134	{
135	case 'c':
136	strCompartmentId = ValueUnion.psz;
137	break;
138
139	case 's':
140	{
141	const char * const pszState = ValueUnion.psz;
142
143	if (RTStrICmp(pszState, "creatingimage") == 0)
144	machineStates.push_back(CloudMachineState_CreatingImage);
145	else if (RTStrICmp(pszState, "paused") == 0) /* XXX */
146	machineStates.push_back(CloudMachineState_Stopped);
147	else if (RTStrICmp(pszState, "provisioning") == 0)
148	machineStates.push_back(CloudMachineState_Provisioning);
149	else if (RTStrICmp(pszState, "running") == 0)
150	machineStates.push_back(CloudMachineState_Running);
151	else if (RTStrICmp(pszState, "starting") == 0)
152	machineStates.push_back(CloudMachineState_Starting);
153	else if (RTStrICmp(pszState, "stopped") == 0)
154	machineStates.push_back(CloudMachineState_Stopped);
155	else if (RTStrICmp(pszState, "stopping") == 0)
156	machineStates.push_back(CloudMachineState_Stopping);
157	else if (RTStrICmp(pszState, "terminated") == 0)
158	machineStates.push_back(CloudMachineState_Terminated);
159	else if (RTStrICmp(pszState, "terminating") == 0)
160	machineStates.push_back(CloudMachineState_Terminating);
161	else
162	return errorArgument("Unknown cloud instance state \"%s\"", pszState);
163	break;
164	}
165	case 1001:
166	case 1002:
167	printHelp(g_pStdOut);
168	return RTEXITCODE_SUCCESS;
169	case VINF_GETOPT_NOT_OPTION:
170	return errorUnknownSubcommand(ValueUnion.psz);
171
172	default:
173	return errorGetOpt(c, &ValueUnion);
174	}
175	}
176
177	HRESULT hrc = S_OK;
178
179	/* Delayed check. It allows us to print help information.*/
180	hrc = checkAndSetCommonOptions(a, pCommonOpts);
181	if (FAILED(hrc))
182	return RTEXITCODE_FAILURE;
183
184	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
185
186	ComPtr<ICloudProviderManager> pCloudProviderManager;
187	CHECK_ERROR2_RET(hrc, pVirtualBox,
188	COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
189	RTEXITCODE_FAILURE);
190
191	ComPtr<ICloudProvider> pCloudProvider;
192	CHECK_ERROR2_RET(hrc, pCloudProviderManager,
193	GetProviderByShortName(Bstr(pCommonOpts->provider.pszProviderName).raw(), pCloudProvider.asOutParam()),
194	RTEXITCODE_FAILURE);
195
196	ComPtr<ICloudProfile> pCloudProfile;
197	CHECK_ERROR2_RET(hrc, pCloudProvider,
198	GetProfileByName(Bstr(pCommonOpts->profile.pszProfileName).raw(), pCloudProfile.asOutParam()),
199	RTEXITCODE_FAILURE);
200
201	if (strCompartmentId.isNotEmpty())
202	{
203	CHECK_ERROR2_RET(hrc, pCloudProfile,
204	SetProperty(Bstr("compartment").raw(), Bstr(strCompartmentId).raw()),
205	RTEXITCODE_FAILURE);
206	}
207	else
208	{
209	RTPrintf("Parameter \'compartment\' is empty or absent.\n"
210	"Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
211	Bstr bStrCompartmentId;
212	CHECK_ERROR2_RET(hrc, pCloudProfile,
213	GetProperty(Bstr("compartment").raw(), bStrCompartmentId.asOutParam()),
214	RTEXITCODE_FAILURE);
215	strCompartmentId = bStrCompartmentId;
216	if (strCompartmentId.isNotEmpty())
217	RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
218	else
219	return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
220	}
221
222	Bstr bstrProfileName;
223	pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
224
225	ComObjPtr<ICloudClient> oCloudClient;
226	CHECK_ERROR2_RET(hrc, pCloudProfile,
227	CreateCloudClient(oCloudClient.asOutParam()),
228	RTEXITCODE_FAILURE);
229
230	ComPtr<IStringArray> pVMNamesHolder;
231	ComPtr<IStringArray> pVMIdsHolder;
232	com::SafeArray<BSTR> arrayVMNames;
233	com::SafeArray<BSTR> arrayVMIds;
234	ComPtr<IProgress> pProgress;
235
236	RTPrintf("Reply is in the form \'instance name\' = \'instance id\'\n");
237
238	CHECK_ERROR2_RET(hrc, oCloudClient,
239	ListInstances(ComSafeArrayAsInParam(machineStates),
240	pVMNamesHolder.asOutParam(),
241	pVMIdsHolder.asOutParam(),
242	pProgress.asOutParam()),
243	RTEXITCODE_FAILURE);
244	showProgress(pProgress);
245	CHECK_PROGRESS_ERROR_RET(pProgress, ("Failed to list instances"), RTEXITCODE_FAILURE);
246
247	CHECK_ERROR2_RET(hrc,
248	pVMNamesHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMNames)),
249	RTEXITCODE_FAILURE);
250	CHECK_ERROR2_RET(hrc,
251	pVMIdsHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMIds)),
252	RTEXITCODE_FAILURE);
253
254	RTPrintf("The list of the instances for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
255	bstrProfileName.raw(), strCompartmentId.c_str());
256	size_t cIds = arrayVMIds.size();
257	size_t cNames = arrayVMNames.size();
258	for (size_t k = 0; k < cNames; k++)
259	{
260	Bstr value;
261	if (k < cIds)
262	value = arrayVMIds[k];
263	RTPrintf("\t%ls = %ls\n", arrayVMNames[k], value.raw());
264	}
265
266	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
267	}
268
269
270	/**
271	* List all available cloud images for the specified cloud provider.
272	*
273	* @returns RTEXITCODE
274	* @param a is the list of passed arguments
275	* @param iFirst is the position of the first unparsed argument in the arguments list
276	* @param pCommonOpts is a pointer to the structure CLOUDCOMMONOPT with some common
277	* arguments which have been already parsed before
278	*/
279	static RTEXITCODE listCloudImages(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
280	{
281	static const RTGETOPTDEF s_aOptions[] =
282	{
283	{ "--compartment-id", 'c', RTGETOPT_REQ_STRING },
284	{ "--state", 's', RTGETOPT_REQ_STRING },
285	{ "help", 1001, RTGETOPT_REQ_NOTHING },
286	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
287	};
288	RTGETOPTSTATE GetState;
289	RTGETOPTUNION ValueUnion;
290	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
291	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
292
293	Utf8Str strCompartmentId;
294	com::SafeArray<CloudImageState_T> imageStates;
295
296	int c;
297	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
298	{
299	switch (c)
300	{
301	case 'c':
302	strCompartmentId = ValueUnion.psz;
303	break;
304
305	case 's':
306	{
307	const char * const pszState = ValueUnion.psz;
308
309	if (RTStrICmp(pszState, "available") == 0)
310	imageStates.push_back(CloudImageState_Available);
311	else if (RTStrICmp(pszState, "deleted") == 0)
312	imageStates.push_back(CloudImageState_Deleted);
313	else if (RTStrICmp(pszState, "disabled") == 0)
314	imageStates.push_back(CloudImageState_Disabled);
315	else if (RTStrICmp(pszState, "exporting") == 0)
316	imageStates.push_back(CloudImageState_Exporting);
317	else if (RTStrICmp(pszState, "importing") == 0)
318	imageStates.push_back(CloudImageState_Importing);
319	else if (RTStrICmp(pszState, "provisioning") == 0)
320	imageStates.push_back(CloudImageState_Provisioning);
321	else
322	return errorArgument("Unknown cloud image state \"%s\"", pszState);
323	break;
324	}
325	case 1001:
326	case 1002:
327	printHelp(g_pStdOut);
328	return RTEXITCODE_SUCCESS;
329	case VINF_GETOPT_NOT_OPTION:
330	return errorUnknownSubcommand(ValueUnion.psz);
331
332	default:
333	return errorGetOpt(c, &ValueUnion);
334	}
335	}
336
337
338	HRESULT hrc = S_OK;
339
340	/* Delayed check. It allows us to print help information.*/
341	hrc = checkAndSetCommonOptions(a, pCommonOpts);
342	if (FAILED(hrc))
343	return RTEXITCODE_FAILURE;
344
345	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
346
347	ComPtr<ICloudProviderManager> pCloudProviderManager;
348	CHECK_ERROR2_RET(hrc, pVirtualBox,
349	COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
350	RTEXITCODE_FAILURE);
351
352	ComPtr<ICloudProvider> pCloudProvider;
353	CHECK_ERROR2_RET(hrc, pCloudProviderManager,
354	GetProviderByShortName(Bstr(pCommonOpts->provider.pszProviderName).raw(), pCloudProvider.asOutParam()),
355	RTEXITCODE_FAILURE);
356
357	ComPtr<ICloudProfile> pCloudProfile;
358	CHECK_ERROR2_RET(hrc, pCloudProvider,
359	GetProfileByName(Bstr(pCommonOpts->profile.pszProfileName).raw(), pCloudProfile.asOutParam()),
360	RTEXITCODE_FAILURE);
361
362	if (strCompartmentId.isNotEmpty())
363	{
364	CHECK_ERROR2_RET(hrc, pCloudProfile,
365	SetProperty(Bstr("compartment").raw(), Bstr(strCompartmentId).raw()),\
366	RTEXITCODE_FAILURE);
367	}
368	else
369	{
370	RTPrintf("Parameter \'compartment\' is empty or absent.\n"
371	"Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
372	Bstr bStrCompartmentId;
373	CHECK_ERROR2_RET(hrc, pCloudProfile,
374	GetProperty(Bstr("compartment").raw(), bStrCompartmentId.asOutParam()),
375	RTEXITCODE_FAILURE);
376	strCompartmentId = bStrCompartmentId;
377	if (strCompartmentId.isNotEmpty())
378	RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
379	else
380	return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
381	}
382
383	Bstr bstrProfileName;
384	pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
385
386	ComObjPtr<ICloudClient> oCloudClient;
387	CHECK_ERROR2_RET(hrc, pCloudProfile,
388	CreateCloudClient(oCloudClient.asOutParam()),
389	RTEXITCODE_FAILURE);
390
391	ComPtr<IStringArray> pVMNamesHolder;
392	ComPtr<IStringArray> pVMIdsHolder;
393	com::SafeArray<BSTR> arrayVMNames;
394	com::SafeArray<BSTR> arrayVMIds;
395	ComPtr<IProgress> pProgress;
396
397	RTPrintf("Reply is in the form \'image name\' = \'image id\'\n");
398	CHECK_ERROR2_RET(hrc, oCloudClient,
399	ListImages(ComSafeArrayAsInParam(imageStates),
400	pVMNamesHolder.asOutParam(),
401	pVMIdsHolder.asOutParam(),
402	pProgress.asOutParam()),
403	RTEXITCODE_FAILURE);
404	showProgress(pProgress);
405	CHECK_PROGRESS_ERROR_RET(pProgress, ("Failed to list images"), RTEXITCODE_FAILURE);
406
407	CHECK_ERROR2_RET(hrc,
408	pVMNamesHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMNames)),
409	RTEXITCODE_FAILURE);
410	CHECK_ERROR2_RET(hrc,
411	pVMIdsHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMIds)),
412	RTEXITCODE_FAILURE);
413
414	RTPrintf("The list of the images for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
415	bstrProfileName.raw(), strCompartmentId.c_str());
416	size_t cNames = arrayVMNames.size();
417	size_t cIds = arrayVMIds.size();
418	for (size_t k = 0; k < cNames; k++)
419	{
420	Bstr value;
421	if (k < cIds)
422	value = arrayVMIds[k];
423	RTPrintf("\t%ls = %ls\n", arrayVMNames[k], value.raw());
424	}
425
426	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
427	}
428
429	/**
430	* General function which handles the "list" commands
431	*
432	* @returns RTEXITCODE
433	* @param a is the list of passed arguments
434	* @param iFirst is the position of the first unparsed argument in the arguments list
435	* @param pCommonOpts is a pointer to the structure CLOUDCOMMONOPT with some common
436	* arguments which have been already parsed before
437	*/
438	static RTEXITCODE handleCloudLists(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
439	{
440	enum
441	{
442	kCloudListIota = 1000,
443	kCloudList_Images,
444	kCloudList_Instances,
445	kCloudList_Machines,
446	kCloudList_Networks,
447	kCloudList_Objects,
448	kCloudList_Subnets,
449	kCloudList_Vcns,
450	};
451
452	static const RTGETOPTDEF s_aOptions[] =
453	{
454	{ "images", kCloudList_Images, RTGETOPT_REQ_NOTHING },
455	{ "instances", kCloudList_Instances, RTGETOPT_REQ_NOTHING },
456	{ "machines", kCloudList_Machines, RTGETOPT_REQ_NOTHING },
457	{ "networks", kCloudList_Networks, RTGETOPT_REQ_NOTHING },
458	{ "objects", kCloudList_Objects, RTGETOPT_REQ_NOTHING },
459	{ "subnets", kCloudList_Subnets, RTGETOPT_REQ_NOTHING },
460	{ "vcns", kCloudList_Vcns, RTGETOPT_REQ_NOTHING },
461	{ "vms", kCloudList_Machines, RTGETOPT_REQ_NOTHING },
462
463	{ "help", 'h', RTGETOPT_REQ_NOTHING },
464	{ "-?", 'h', RTGETOPT_REQ_NOTHING },
465	{ "-help", 'h', RTGETOPT_REQ_NOTHING },
466	{ "--help", 'h', RTGETOPT_REQ_NOTHING },
467	};
468
469	if (a->argc == iFirst)
470	{
471	RTPrintf("Empty command parameter list, show help.\n");
472	printHelp(g_pStdOut);
473	return RTEXITCODE_SUCCESS;
474	}
475
476	RTGETOPTSTATE GetState;
477	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
478	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
479
480	int c;
481	RTGETOPTUNION ValueUnion;
482	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
483	{
484	switch (c)
485	{
486	case kCloudList_Images:
487	setCurrentSubcommand(HELP_SCOPE_CLOUDLIST_IMAGES);
488	return listCloudImages(a, GetState.iNext, pCommonOpts);
489
490	case kCloudList_Instances:
491	setCurrentSubcommand(HELP_SCOPE_CLOUDLIST_INSTANCES);
492	return listCloudInstances(a, GetState.iNext, pCommonOpts);
493
494	case kCloudList_Machines:
495	return listCloudMachines(a, GetState.iNext,
496	pCommonOpts->provider.pszProviderName,
497	pCommonOpts->profile.pszProfileName);
498
499	case 'h':
500	printHelp(g_pStdOut);
501	return RTEXITCODE_SUCCESS;
502
503	case VINF_GETOPT_NOT_OPTION:
504	return errorUnknownSubcommand(ValueUnion.psz);
505
506	default:
507	return errorGetOpt(c, &ValueUnion);
508	}
509	}
510
511	return errorNoSubcommand();
512	}
513
514	static RTEXITCODE createCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
515	{
516	HRESULT hrc = S_OK;
517
518	static const RTGETOPTDEF s_aOptions[] =
519	{
520	{ "--image-id", 'i', RTGETOPT_REQ_STRING },
521	{ "--boot-volume-id", 'v', RTGETOPT_REQ_STRING },
522	{ "--display-name", 'n', RTGETOPT_REQ_STRING },
523	{ "--launch-mode", 'm', RTGETOPT_REQ_STRING },
524	{ "--shape", 's', RTGETOPT_REQ_STRING },
525	{ "--domain-name", 'd', RTGETOPT_REQ_STRING },
526	{ "--boot-disk-size", 'b', RTGETOPT_REQ_STRING },
527	{ "--publicip", 'p', RTGETOPT_REQ_STRING },
528	{ "--subnet", 't', RTGETOPT_REQ_STRING },
529	{ "--privateip", 'P', RTGETOPT_REQ_STRING },
530	{ "--launch", 'l', RTGETOPT_REQ_STRING },
531	{ "--public-ssh-key", 'k', RTGETOPT_REQ_STRING },
532	{ "--cloud-init-script-path", 'c', RTGETOPT_REQ_STRING },
533	{ "help", 1001, RTGETOPT_REQ_NOTHING },
534	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
535	};
536	RTGETOPTSTATE GetState;
537	RTGETOPTUNION ValueUnion;
538	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
539	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
540	if (a->argc == iFirst)
541	{
542	RTPrintf("Empty command parameter list, show help.\n");
543	printHelp(g_pStdOut);
544	return RTEXITCODE_SUCCESS;
545	}
546
547	ComPtr<IAppliance> pAppliance;
548	CHECK_ERROR2_RET(hrc, a->virtualBox, CreateAppliance(pAppliance.asOutParam()), RTEXITCODE_FAILURE);
549	ULONG vsdNum = 1;
550	CHECK_ERROR2_RET(hrc, pAppliance, CreateVirtualSystemDescriptions(1, &vsdNum), RTEXITCODE_FAILURE);
551	com::SafeIfaceArray<IVirtualSystemDescription> virtualSystemDescriptions;
552	CHECK_ERROR2_RET(hrc, pAppliance,
553	COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(virtualSystemDescriptions)),
554	RTEXITCODE_FAILURE);
555	ComPtr<IVirtualSystemDescription> pVSD = virtualSystemDescriptions[0];
556
557	Utf8Str strDisplayName, strImageId, strBootVolumeId, strPublicSSHKey;
558	int c;
559	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
560	{
561	switch (c)
562	{
563	case 'i':
564	strImageId = ValueUnion.psz;
565	pVSD->AddDescription(VirtualSystemDescriptionType_CloudImageId,
566	Bstr(ValueUnion.psz).raw(), NULL);
567	break;
568
569	case 'v':
570	strBootVolumeId = ValueUnion.psz;
571	pVSD->AddDescription(VirtualSystemDescriptionType_CloudBootVolumeId,
572	Bstr(ValueUnion.psz).raw(), NULL);
573	break;
574	case 'n':
575	strDisplayName = ValueUnion.psz;
576	pVSD->AddDescription(VirtualSystemDescriptionType_Name,
577	Bstr(ValueUnion.psz).raw(), NULL);
578	break;
579	case 'm':
580	pVSD->AddDescription(VirtualSystemDescriptionType_CloudOCILaunchMode,
581	Bstr(ValueUnion.psz).raw(), NULL);
582	break;
583	case 's':
584	pVSD->AddDescription(VirtualSystemDescriptionType_CloudInstanceShape,
585	Bstr(ValueUnion.psz).raw(), NULL);
586	break;
587	case 'd':
588	pVSD->AddDescription(VirtualSystemDescriptionType_CloudDomain,
589	Bstr(ValueUnion.psz).raw(), NULL);
590	break;
591	case 'b':
592	pVSD->AddDescription(VirtualSystemDescriptionType_CloudBootDiskSize,
593	Bstr(ValueUnion.psz).raw(), NULL);
594	break;
595	case 'p':
596	pVSD->AddDescription(VirtualSystemDescriptionType_CloudPublicIP,
597	Bstr(ValueUnion.psz).raw(), NULL);
598	break;
599	case 'P':
600	pVSD->AddDescription(VirtualSystemDescriptionType_CloudPrivateIP,
601	Bstr(ValueUnion.psz).raw(), NULL);
602	break;
603	case 't':
604	pVSD->AddDescription(VirtualSystemDescriptionType_CloudOCISubnet,
605	Bstr(ValueUnion.psz).raw(), NULL);
606	break;
607	case 'l':
608	{
609	Utf8Str strLaunch(ValueUnion.psz);
610	if (strLaunch.isNotEmpty() && (strLaunch.equalsIgnoreCase("true") \|\| strLaunch.equalsIgnoreCase("false")))
611	pVSD->AddDescription(VirtualSystemDescriptionType_CloudLaunchInstance,
612	Bstr(ValueUnion.psz).raw(), NULL);
613	break;
614	}
615	case 'k':
616	strPublicSSHKey = ValueUnion.psz;
617	pVSD->AddDescription(VirtualSystemDescriptionType_CloudPublicSSHKey,
618	Bstr(ValueUnion.psz).raw(), NULL);
619	break;
620	case 'c':
621	pVSD->AddDescription(VirtualSystemDescriptionType_CloudInitScriptPath,
622	Bstr(ValueUnion.psz).raw(), NULL);
623	break;
624	case 1001:
625	case 1002:
626	printHelp(g_pStdOut);
627	return RTEXITCODE_SUCCESS;
628	case VINF_GETOPT_NOT_OPTION:
629	return errorUnknownSubcommand(ValueUnion.psz);
630	default:
631	return errorGetOpt(c, &ValueUnion);
632	}
633	}
634
635	/* Delayed check. It allows us to print help information.*/
636	hrc = checkAndSetCommonOptions(a, pCommonOpts);
637	if (FAILED(hrc))
638	return RTEXITCODE_FAILURE;
639
640	if (strPublicSSHKey.isEmpty())
641	RTPrintf("Warning!!! Public SSH key doesn't present in the passed arguments...\n");
642
643	if (strImageId.isNotEmpty() && strBootVolumeId.isNotEmpty())
644	return errorArgument("Parameters --image-id and --boot-volume-id are mutually exclusive. "
645	"Only one of them must be presented.");
646
647	if (strImageId.isEmpty() && strBootVolumeId.isEmpty())
648	return errorArgument("Missing parameter --image-id or --boot-volume-id. One of them must be presented.");
649
650	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
651
652	pVSD->AddDescription(VirtualSystemDescriptionType_CloudProfileName,
653	Bstr(pCommonOpts->profile.pszProfileName).raw(),
654	NULL);
655
656	ComObjPtr<ICloudClient> oCloudClient;
657	CHECK_ERROR2_RET(hrc, pCloudProfile,
658	CreateCloudClient(oCloudClient.asOutParam()),
659	RTEXITCODE_FAILURE);
660
661	ComPtr<IStringArray> infoArray;
662	com::SafeArray<BSTR> pStrInfoArray;
663	ComPtr<IProgress> pProgress;
664
665	#if 0
666	/*
667	* OCI API returns an error during an instance creation if the image isn't available
668	* or in the inappropriate state. So the check can be omitted.
669	*/
670	RTPrintf("Checking the cloud image with id \'%s\'...\n", strImageId.c_str());
671	CHECK_ERROR2_RET(hrc, oCloudClient,
672	GetImageInfo(Bstr(strImageId).raw(),
673	infoArray.asOutParam(),
674	pProgress.asOutParam()),
675	RTEXITCODE_FAILURE);
676
677	hrc = showProgress(pProgress);
678	CHECK_PROGRESS_ERROR_RET(pProgress, ("Checking the cloud image failed"), RTEXITCODE_FAILURE);
679
680	pProgress.setNull();
681	#endif
682
683	if (strImageId.isNotEmpty())
684	RTPrintf("Creating cloud instance with name \'%s\' from the image \'%s\'...\n",
685	strDisplayName.c_str(), strImageId.c_str());
686	else
687	RTPrintf("Creating cloud instance with name \'%s\' from the boot volume \'%s\'...\n",
688	strDisplayName.c_str(), strBootVolumeId.c_str());
689
690	CHECK_ERROR2_RET(hrc, oCloudClient, LaunchVM(pVSD, pProgress.asOutParam()), RTEXITCODE_FAILURE);
691
692	hrc = showProgress(pProgress);
693	CHECK_PROGRESS_ERROR_RET(pProgress, ("Creating cloud instance failed"), RTEXITCODE_FAILURE);
694
695	if (SUCCEEDED(hrc))
696	RTPrintf("Cloud instance was created successfully\n");
697
698	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
699	}
700
701	static RTEXITCODE updateCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
702	{
703	RT_NOREF(a);
704	RT_NOREF(iFirst);
705	RT_NOREF(pCommonOpts);
706	return RTEXITCODE_SUCCESS;
707	}
708
709	static RTEXITCODE showCloudInstanceInfo(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
710	{
711	HRESULT hrc = S_OK;
712
713	static const RTGETOPTDEF s_aOptions[] =
714	{
715	{ "--id", 'i', RTGETOPT_REQ_STRING },
716	{ "help", 1001, RTGETOPT_REQ_NOTHING },
717	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
718	};
719	RTGETOPTSTATE GetState;
720	RTGETOPTUNION ValueUnion;
721	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
722	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
723	if (a->argc == iFirst)
724	{
725	RTPrintf("Empty command parameter list, show help.\n");
726	printHelp(g_pStdOut);
727	return RTEXITCODE_SUCCESS;
728	}
729
730	Utf8Str strInstanceId;
731
732	int c;
733	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
734	{
735	switch (c)
736	{
737	case 'i':
738	{
739	if (strInstanceId.isNotEmpty())
740	return errorArgument("Duplicate parameter: --id");
741
742	strInstanceId = ValueUnion.psz;
743	if (strInstanceId.isEmpty())
744	return errorArgument("Empty parameter: --id");
745
746	break;
747	}
748	case 1001:
749	case 1002:
750	printHelp(g_pStdOut);
751	return RTEXITCODE_SUCCESS;
752	case VINF_GETOPT_NOT_OPTION:
753	return errorUnknownSubcommand(ValueUnion.psz);
754
755	default:
756	return errorGetOpt(c, &ValueUnion);
757	}
758	}
759
760	/* Delayed check. It allows us to print help information.*/
761	hrc = checkAndSetCommonOptions(a, pCommonOpts);
762	if (FAILED(hrc))
763	return RTEXITCODE_FAILURE;
764
765	if (strInstanceId.isEmpty())
766	return errorArgument("Missing parameter: --id");
767
768	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
769
770	ComObjPtr<ICloudClient> oCloudClient;
771	CHECK_ERROR2_RET(hrc, pCloudProfile,
772	CreateCloudClient(oCloudClient.asOutParam()),
773	RTEXITCODE_FAILURE);
774	RTPrintf("Getting information about cloud instance with id %s...\n", strInstanceId.c_str());
775	RTPrintf("Reply is in the form \'setting name\' = \'value\'\n");
776
777	ComPtr<IAppliance> pAppliance;
778	CHECK_ERROR2_RET(hrc, a->virtualBox, CreateAppliance(pAppliance.asOutParam()), RTEXITCODE_FAILURE);
779
780	com::SafeIfaceArray<IVirtualSystemDescription> vsdArray;
781	ULONG requestedVSDnums = 1;
782	ULONG newVSDnums = 0;
783	CHECK_ERROR2_RET(hrc, pAppliance, CreateVirtualSystemDescriptions(requestedVSDnums, &newVSDnums), RTEXITCODE_FAILURE);
784	if (requestedVSDnums != newVSDnums)
785	return RTEXITCODE_FAILURE;
786
787	CHECK_ERROR2_RET(hrc, pAppliance, COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(vsdArray)), RTEXITCODE_FAILURE);
788	ComPtr<IVirtualSystemDescription> instanceDescription = vsdArray[0];
789
790	ComPtr<IProgress> progress;
791	CHECK_ERROR2_RET(hrc, oCloudClient,
792	GetInstanceInfo(Bstr(strInstanceId).raw(), instanceDescription, progress.asOutParam()),
793	RTEXITCODE_FAILURE);
794
795	hrc = showProgress(progress);
796	CHECK_PROGRESS_ERROR_RET(progress, ("Getting information about cloud instance failed"), RTEXITCODE_FAILURE);
797
798	RTPrintf("Cloud instance info (provider '%s'):\n",
799	pCommonOpts->provider.pszProviderName);
800
801	struct vsdHReadable {
802	VirtualSystemDescriptionType_T vsdType;
803	Utf8Str strFound;
804	Utf8Str strNotFound;
805	};
806
807	const size_t vsdHReadableArraySize = 13;//the number of items in the vsdHReadableArray
808	vsdHReadable vsdHReadableArray[vsdHReadableArraySize] = {
809	{VirtualSystemDescriptionType_CloudDomain, "Availability domain = %ls\n", "Availability domain wasn't found\n"},
810	{VirtualSystemDescriptionType_Name, "Instance displayed name = %ls\n", "Instance displayed name wasn't found\n"},
811	{VirtualSystemDescriptionType_CloudInstanceState, "Instance state = %ls\n", "Instance state wasn't found\n"},
812	{VirtualSystemDescriptionType_CloudInstanceId, "Instance Id = %ls\n", "Instance Id wasn't found\n"},
813	{VirtualSystemDescriptionType_CloudInstanceDisplayName, "Instance name = %ls\n", "Instance name wasn't found\n"},
814	{VirtualSystemDescriptionType_CloudImageId, "Bootable image Id = %ls\n",
815	"Image Id whom the instance is booted up wasn't found\n"},
816	{VirtualSystemDescriptionType_CloudInstanceShape, "Shape of the instance = %ls\n",
817	"The shape of the instance wasn't found\n"},
818	{VirtualSystemDescriptionType_OS, "Type of guest OS = %ls\n", "Type of guest OS wasn't found\n"},
819	{VirtualSystemDescriptionType_Memory, "RAM = %ls MB\n", "Value for RAM wasn't found\n"},
820	{VirtualSystemDescriptionType_CPU, "CPUs = %ls\n", "Numbers of CPUs weren't found\n"},
821	{VirtualSystemDescriptionType_CloudPublicIP, "Instance public IP = %ls\n", "Public IP wasn't found\n"},
822	{VirtualSystemDescriptionType_Miscellaneous, "%ls\n", "Free-form tags or metadata weren't found\n"},
823	{VirtualSystemDescriptionType_CloudInitScriptPath, "%ls\n", "Cloud-init script wasn't found\n"}
824	};
825
826	com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
827	com::SafeArray<BSTR> aRefs;
828	com::SafeArray<BSTR> aOvfValues;
829	com::SafeArray<BSTR> aVBoxValues;
830	com::SafeArray<BSTR> aExtraConfigValues;
831
832	for (size_t i=0; i<vsdHReadableArraySize ; ++i)
833	{
834	hrc = instanceDescription->GetDescriptionByType(vsdHReadableArray[i].vsdType,
835	ComSafeArrayAsOutParam(retTypes),
836	ComSafeArrayAsOutParam(aRefs),
837	ComSafeArrayAsOutParam(aOvfValues),
838	ComSafeArrayAsOutParam(aVBoxValues),
839	ComSafeArrayAsOutParam(aExtraConfigValues));
840	if (FAILED(hrc) \|\| aVBoxValues.size() == 0)
841	LogRel((vsdHReadableArray[i].strNotFound.c_str()));
842	else
843	{
844	LogRel(("Size is %d", aVBoxValues.size()));
845	for (size_t j = 0; j<aVBoxValues.size(); ++j)
846	{
847	RTPrintf(vsdHReadableArray[i].strFound.c_str(), aVBoxValues[j]);
848	}
849	}
850
851	retTypes.setNull();
852	aRefs.setNull();
853	aOvfValues.setNull();
854	aVBoxValues.setNull();
855	aExtraConfigValues.setNull();
856	}
857
858	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
859	}
860
861	static RTEXITCODE startCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
862	{
863	HRESULT hrc = S_OK;
864
865	static const RTGETOPTDEF s_aOptions[] =
866	{
867	{ "--id", 'i', RTGETOPT_REQ_STRING },
868	{ "help", 1001, RTGETOPT_REQ_NOTHING },
869	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
870	};
871	RTGETOPTSTATE GetState;
872	RTGETOPTUNION ValueUnion;
873	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
874	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
875	if (a->argc == iFirst)
876	{
877	RTPrintf("Empty command parameter list, show help.\n");
878	printHelp(g_pStdOut);
879	return RTEXITCODE_SUCCESS;
880	}
881
882	Utf8Str strInstanceId;
883
884	int c;
885	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
886	{
887	switch (c)
888	{
889	case 'i':
890	{
891	if (strInstanceId.isNotEmpty())
892	return errorArgument("Duplicate parameter: --id");
893
894	strInstanceId = ValueUnion.psz;
895	if (strInstanceId.isEmpty())
896	return errorArgument("Empty parameter: --id");
897
898	break;
899	}
900	case 1001:
901	case 1002:
902	printHelp(g_pStdOut);
903	return RTEXITCODE_SUCCESS;
904	case VINF_GETOPT_NOT_OPTION:
905	return errorUnknownSubcommand(ValueUnion.psz);
906
907	default:
908	return errorGetOpt(c, &ValueUnion);
909	}
910	}
911
912	/* Delayed check. It allows us to print help information.*/
913	hrc = checkAndSetCommonOptions(a, pCommonOpts);
914	if (FAILED(hrc))
915	return RTEXITCODE_FAILURE;
916
917	if (strInstanceId.isEmpty())
918	return errorArgument("Missing parameter: --id");
919
920	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
921
922	ComObjPtr<ICloudClient> oCloudClient;
923	CHECK_ERROR2_RET(hrc, pCloudProfile,
924	CreateCloudClient(oCloudClient.asOutParam()),
925	RTEXITCODE_FAILURE);
926	RTPrintf("Starting cloud instance with id %s...\n", strInstanceId.c_str());
927
928	ComPtr<IProgress> progress;
929	CHECK_ERROR2_RET(hrc, oCloudClient,
930	StartInstance(Bstr(strInstanceId).raw(), progress.asOutParam()),
931	RTEXITCODE_FAILURE);
932	hrc = showProgress(progress);
933	CHECK_PROGRESS_ERROR_RET(progress, ("Starting the cloud instance failed"), RTEXITCODE_FAILURE);
934
935	if (SUCCEEDED(hrc))
936	RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was started\n",
937	strInstanceId.c_str(),
938	pCommonOpts->provider.pszProviderName,
939	pCommonOpts->profile.pszProfileName);
940
941	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
942	}
943
944	static RTEXITCODE pauseCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
945	{
946	HRESULT hrc = S_OK;
947
948	static const RTGETOPTDEF s_aOptions[] =
949	{
950	{ "--id", 'i', RTGETOPT_REQ_STRING },
951	{ "help", 1001, RTGETOPT_REQ_NOTHING },
952	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
953	};
954	RTGETOPTSTATE GetState;
955	RTGETOPTUNION ValueUnion;
956	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
957	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
958	if (a->argc == iFirst)
959	{
960	RTPrintf("Empty command parameter list, show help.\n");
961	printHelp(g_pStdOut);
962	return RTEXITCODE_SUCCESS;
963	}
964
965	Utf8Str strInstanceId;
966
967	int c;
968	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
969	{
970	switch (c)
971	{
972	case 'i':
973	{
974	if (strInstanceId.isNotEmpty())
975	return errorArgument("Duplicate parameter: --id");
976
977	strInstanceId = ValueUnion.psz;
978	if (strInstanceId.isEmpty())
979	return errorArgument("Empty parameter: --id");
980
981	break;
982	}
983	case 1001:
984	case 1002:
985	printHelp(g_pStdOut);
986	return RTEXITCODE_SUCCESS;
987	case VINF_GETOPT_NOT_OPTION:
988	return errorUnknownSubcommand(ValueUnion.psz);
989
990	default:
991	return errorGetOpt(c, &ValueUnion);
992	}
993	}
994
995	/* Delayed check. It allows us to print help information.*/
996	hrc = checkAndSetCommonOptions(a, pCommonOpts);
997	if (FAILED(hrc))
998	return RTEXITCODE_FAILURE;
999
1000	if (strInstanceId.isEmpty())
1001	return errorArgument("Missing parameter: --id");
1002
1003	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1004
1005	ComObjPtr<ICloudClient> oCloudClient;
1006	CHECK_ERROR2_RET(hrc, pCloudProfile,
1007	CreateCloudClient(oCloudClient.asOutParam()),
1008	RTEXITCODE_FAILURE);
1009	RTPrintf("Pausing cloud instance with id %s...\n", strInstanceId.c_str());
1010
1011	ComPtr<IProgress> progress;
1012	CHECK_ERROR2_RET(hrc, oCloudClient,
1013	PauseInstance(Bstr(strInstanceId).raw(), progress.asOutParam()),
1014	RTEXITCODE_FAILURE);
1015	hrc = showProgress(progress);
1016	CHECK_PROGRESS_ERROR_RET(progress, ("Pause the cloud instance failed"), RTEXITCODE_FAILURE);
1017
1018	if (SUCCEEDED(hrc))
1019	RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was paused\n",
1020	strInstanceId.c_str(),
1021	pCommonOpts->provider.pszProviderName,
1022	pCommonOpts->profile.pszProfileName);
1023
1024	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1025	}
1026
1027	static RTEXITCODE terminateCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1028	{
1029	HRESULT hrc = S_OK;
1030
1031	static const RTGETOPTDEF s_aOptions[] =
1032	{
1033	{ "--id", 'i', RTGETOPT_REQ_STRING },
1034	{ "help", 1001, RTGETOPT_REQ_NOTHING },
1035	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
1036	};
1037	RTGETOPTSTATE GetState;
1038	RTGETOPTUNION ValueUnion;
1039	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1040	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1041	if (a->argc == iFirst)
1042	{
1043	RTPrintf("Empty command parameter list, show help.\n");
1044	printHelp(g_pStdOut);
1045	return RTEXITCODE_SUCCESS;
1046	}
1047
1048	Utf8Str strInstanceId;
1049
1050	int c;
1051	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1052	{
1053	switch (c)
1054	{
1055	case 'i':
1056	{
1057	if (strInstanceId.isNotEmpty())
1058	return errorArgument("Duplicate parameter: --id");
1059
1060	strInstanceId = ValueUnion.psz;
1061	if (strInstanceId.isEmpty())
1062	return errorArgument("Empty parameter: --id");
1063
1064	break;
1065	}
1066	case 1001:
1067	case 1002:
1068	printHelp(g_pStdOut);
1069	return RTEXITCODE_SUCCESS;
1070	case VINF_GETOPT_NOT_OPTION:
1071	return errorUnknownSubcommand(ValueUnion.psz);
1072
1073	default:
1074	return errorGetOpt(c, &ValueUnion);
1075	}
1076	}
1077
1078	/* Delayed check. It allows us to print help information.*/
1079	hrc = checkAndSetCommonOptions(a, pCommonOpts);
1080	if (FAILED(hrc))
1081	return RTEXITCODE_FAILURE;
1082
1083	if (strInstanceId.isEmpty())
1084	return errorArgument("Missing parameter: --id");
1085
1086
1087	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1088
1089	ComObjPtr<ICloudClient> oCloudClient;
1090	CHECK_ERROR2_RET(hrc, pCloudProfile,
1091	CreateCloudClient(oCloudClient.asOutParam()),
1092	RTEXITCODE_FAILURE);
1093	RTPrintf("Terminating cloud instance with id %s...\n", strInstanceId.c_str());
1094
1095	ComPtr<IProgress> progress;
1096	CHECK_ERROR2_RET(hrc, oCloudClient,
1097	TerminateInstance(Bstr(strInstanceId).raw(), progress.asOutParam()),
1098	RTEXITCODE_FAILURE);
1099	hrc = showProgress(progress);
1100	CHECK_PROGRESS_ERROR_RET(progress, ("Termination the cloud instance failed"), RTEXITCODE_FAILURE);
1101
1102	if (SUCCEEDED(hrc))
1103	RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was terminated\n",
1104	strInstanceId.c_str(),
1105	pCommonOpts->provider.pszProviderName,
1106	pCommonOpts->profile.pszProfileName);
1107
1108	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1109	}
1110
1111	static RTEXITCODE handleCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1112	{
1113	enum
1114	{
1115	kCloudInstanceIota = 1000,
1116	kCloudInstance_Create,
1117	kCloudInstance_Info,
1118	kCloudInstance_Pause,
1119	kCloudInstance_Start,
1120	kCloudInstance_Terminate,
1121	kCloudInstance_Update,
1122	};
1123
1124	static const RTGETOPTDEF s_aOptions[] =
1125	{
1126	{ "create", kCloudInstance_Create, RTGETOPT_REQ_NOTHING },
1127	{ "info", kCloudInstance_Info, RTGETOPT_REQ_NOTHING },
1128	{ "pause", kCloudInstance_Pause, RTGETOPT_REQ_NOTHING },
1129	{ "start", kCloudInstance_Start, RTGETOPT_REQ_NOTHING },
1130	{ "terminate", kCloudInstance_Terminate, RTGETOPT_REQ_NOTHING },
1131	{ "update", kCloudInstance_Update, RTGETOPT_REQ_NOTHING },
1132
1133	{ "help", 'h', RTGETOPT_REQ_NOTHING },
1134	{ "-?", 'h', RTGETOPT_REQ_NOTHING },
1135	{ "-help", 'h', RTGETOPT_REQ_NOTHING },
1136	{ "--help", 'h', RTGETOPT_REQ_NOTHING },
1137	};
1138
1139	if (a->argc == iFirst)
1140	{
1141	RTPrintf("Empty command parameter list, show help.\n");
1142	printHelp(g_pStdOut);
1143	return RTEXITCODE_SUCCESS;
1144	}
1145
1146	RTGETOPTSTATE GetState;
1147	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1148	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1149
1150	int c;
1151	RTGETOPTUNION ValueUnion;
1152	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1153	{
1154	switch (c)
1155	{
1156	/* Sub-commands: */
1157	case kCloudInstance_Create:
1158	setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_CREATE);
1159	return createCloudInstance(a, GetState.iNext, pCommonOpts);
1160
1161	case kCloudInstance_Start:
1162	setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_START);
1163	return startCloudInstance(a, GetState.iNext, pCommonOpts);
1164
1165	case kCloudInstance_Pause:
1166	setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_PAUSE);
1167	return pauseCloudInstance(a, GetState.iNext, pCommonOpts);
1168
1169	case kCloudInstance_Info:
1170	setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_INFO);
1171	return showCloudInstanceInfo(a, GetState.iNext, pCommonOpts);
1172
1173	case kCloudInstance_Update:
1174	// setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_UPDATE);
1175	return updateCloudInstance(a, GetState.iNext, pCommonOpts);
1176
1177	case kCloudInstance_Terminate:
1178	setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_TERMINATE);
1179	return terminateCloudInstance(a, GetState.iNext, pCommonOpts);
1180
1181	case 'h':
1182	printHelp(g_pStdOut);
1183	return RTEXITCODE_SUCCESS;
1184
1185	case VINF_GETOPT_NOT_OPTION:
1186	return errorUnknownSubcommand(ValueUnion.psz);
1187
1188	default:
1189	return errorGetOpt(c, &ValueUnion);
1190	}
1191	}
1192
1193	return errorNoSubcommand();
1194	}
1195
1196
1197	static RTEXITCODE createCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1198	{
1199	HRESULT hrc = S_OK;
1200
1201	static const RTGETOPTDEF s_aOptions[] =
1202	{
1203	{ "--object-name", 'o', RTGETOPT_REQ_STRING },
1204	{ "--bucket-name", 'b', RTGETOPT_REQ_STRING },
1205	{ "--compartment-id", 'c', RTGETOPT_REQ_STRING },
1206	{ "--instance-id", 'i', RTGETOPT_REQ_STRING },
1207	{ "--display-name", 'd', RTGETOPT_REQ_STRING },
1208	{ "--launch-mode", 'm', RTGETOPT_REQ_STRING },
1209	{ "help", 1001, RTGETOPT_REQ_NOTHING },
1210	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
1211	};
1212	RTGETOPTSTATE GetState;
1213	RTGETOPTUNION ValueUnion;
1214	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1215	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1216	if (a->argc == iFirst)
1217	{
1218	RTPrintf("Empty command parameter list, show help.\n");
1219	printHelp(g_pStdOut);
1220	return RTEXITCODE_SUCCESS;
1221	}
1222
1223	Utf8Str strCompartmentId;
1224	Utf8Str strInstanceId;
1225	Utf8Str strDisplayName;
1226	Utf8Str strBucketName;
1227	Utf8Str strObjectName;
1228	com::SafeArray<BSTR> parameters;
1229
1230	int c;
1231	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1232	{
1233	switch (c)
1234	{
1235	case 'c':
1236	strCompartmentId=ValueUnion.psz;
1237	Bstr(Utf8Str("compartment-id=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1238	break;
1239	case 'i':
1240	strInstanceId=ValueUnion.psz;
1241	Bstr(Utf8Str("instance-id=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1242	break;
1243	case 'd':
1244	strDisplayName=ValueUnion.psz;
1245	Bstr(Utf8Str("display-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1246	break;
1247	case 'o':
1248	strObjectName=ValueUnion.psz;
1249	Bstr(Utf8Str("object-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1250	break;
1251	case 'b':
1252	strBucketName=ValueUnion.psz;
1253	Bstr(Utf8Str("bucket-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1254	break;
1255	case 'm':
1256	strBucketName=ValueUnion.psz;
1257	Bstr(Utf8Str("launch-mode=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1258	break;
1259	case 1001:
1260	case 1002:
1261	printHelp(g_pStdOut);
1262	return RTEXITCODE_SUCCESS;
1263	case VINF_GETOPT_NOT_OPTION:
1264	return errorUnknownSubcommand(ValueUnion.psz);
1265	default:
1266	return errorGetOpt(c, &ValueUnion);
1267	}
1268	}
1269
1270	/* Delayed check. It allows us to print help information.*/
1271	hrc = checkAndSetCommonOptions(a, pCommonOpts);
1272	if (FAILED(hrc))
1273	return RTEXITCODE_FAILURE;
1274
1275	if (strInstanceId.isNotEmpty() && strObjectName.isNotEmpty())
1276	return errorArgument("Conflicting parameters: --instance-id and --object-name can't be used together. Choose one.");
1277
1278	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1279
1280	ComObjPtr<ICloudClient> oCloudClient;
1281	CHECK_ERROR2_RET(hrc, pCloudProfile,
1282	CreateCloudClient(oCloudClient.asOutParam()),
1283	RTEXITCODE_FAILURE);
1284	if (strInstanceId.isNotEmpty())
1285	RTPrintf("Creating cloud image with name \'%s\' from the instance \'%s\'...\n",
1286	strDisplayName.c_str(), strInstanceId.c_str());
1287	else
1288	RTPrintf("Creating cloud image with name \'%s\' from the object \'%s\' in the bucket \'%s\'...\n",
1289	strDisplayName.c_str(), strObjectName.c_str(), strBucketName.c_str());
1290
1291	ComPtr<IProgress> progress;
1292	CHECK_ERROR2_RET(hrc, oCloudClient,
1293	CreateImage(ComSafeArrayAsInParam(parameters), progress.asOutParam()),
1294	RTEXITCODE_FAILURE);
1295	hrc = showProgress(progress);
1296	CHECK_PROGRESS_ERROR_RET(progress, ("Creating cloud image failed"), RTEXITCODE_FAILURE);
1297
1298	if (SUCCEEDED(hrc))
1299	RTPrintf("Cloud image was created successfully\n");
1300
1301	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1302	}
1303
1304
1305	static RTEXITCODE exportCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1306	{
1307	HRESULT hrc = S_OK;
1308
1309	static const RTGETOPTDEF s_aOptions[] =
1310	{
1311	{ "--id", 'i', RTGETOPT_REQ_STRING },
1312	{ "--bucket-name", 'b', RTGETOPT_REQ_STRING },
1313	{ "--object-name", 'o', RTGETOPT_REQ_STRING },
1314	{ "--display-name", 'd', RTGETOPT_REQ_STRING },
1315	{ "--launch-mode", 'm', RTGETOPT_REQ_STRING },
1316	{ "help", 1001, RTGETOPT_REQ_NOTHING },
1317	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
1318	};
1319	RTGETOPTSTATE GetState;
1320	RTGETOPTUNION ValueUnion;
1321	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1322	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1323	if (a->argc == iFirst)
1324	{
1325	RTPrintf("Empty command parameter list, show help.\n");
1326	printHelp(g_pStdOut);
1327	return RTEXITCODE_SUCCESS;
1328	}
1329
1330	Utf8Str strImageId; /* XXX: this is vbox "image", i.e. medium */
1331	Utf8Str strBucketName;
1332	Utf8Str strObjectName;
1333	Utf8Str strDisplayName;
1334	Utf8Str strLaunchMode;
1335	com::SafeArray<BSTR> parameters;
1336
1337	int c;
1338	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1339	{
1340	switch (c)
1341	{
1342	case 'b': /* --bucket-name */
1343	{
1344	if (strBucketName.isNotEmpty())
1345	return errorArgument("Duplicate parameter: --bucket-name");
1346
1347	strBucketName = ValueUnion.psz;
1348	if (strBucketName.isEmpty())
1349	return errorArgument("Empty parameter: --bucket-name");
1350
1351	break;
1352	}
1353
1354	case 'o': /* --object-name */
1355	{
1356	if (strObjectName.isNotEmpty())
1357	return errorArgument("Duplicate parameter: --object-name");
1358
1359	strObjectName = ValueUnion.psz;
1360	if (strObjectName.isEmpty())
1361	return errorArgument("Empty parameter: --object-name");
1362
1363	break;
1364	}
1365
1366	case 'i': /* --id */
1367	{
1368	if (strImageId.isNotEmpty())
1369	return errorArgument("Duplicate parameter: --id");
1370
1371	strImageId = ValueUnion.psz;
1372	if (strImageId.isEmpty())
1373	return errorArgument("Empty parameter: --id");
1374
1375	break;
1376	}
1377
1378	case 'd': /* --display-name */
1379	{
1380	if (strDisplayName.isNotEmpty())
1381	return errorArgument("Duplicate parameter: --display-name");
1382
1383	strDisplayName = ValueUnion.psz;
1384	if (strDisplayName.isEmpty())
1385	return errorArgument("Empty parameter: --display-name");
1386
1387	break;
1388	}
1389
1390	case 'm': /* --launch-mode */
1391	{
1392	if (strLaunchMode.isNotEmpty())
1393	return errorArgument("Duplicate parameter: --launch-mode");
1394
1395	strLaunchMode = ValueUnion.psz;
1396	if (strLaunchMode.isEmpty())
1397	return errorArgument("Empty parameter: --launch-mode");
1398
1399	break;
1400	}
1401
1402	case 1001:
1403	case 1002:
1404	printHelp(g_pStdOut);
1405	return RTEXITCODE_SUCCESS;
1406
1407	case VINF_GETOPT_NOT_OPTION:
1408	return errorUnknownSubcommand(ValueUnion.psz);
1409
1410	default:
1411	return errorGetOpt(c, &ValueUnion);
1412	}
1413	}
1414
1415	/* Delayed check. It allows us to print help information.*/
1416	hrc = checkAndSetCommonOptions(a, pCommonOpts);
1417	if (FAILED(hrc))
1418	return RTEXITCODE_FAILURE;
1419
1420	if (strImageId.isNotEmpty())
1421	BstrFmt("image-id=%s", strImageId.c_str()).detachTo(parameters.appendedRaw());
1422	else
1423	return errorArgument("Missing parameter: --id");
1424
1425	if (strBucketName.isNotEmpty())
1426	BstrFmt("bucket-name=%s", strBucketName.c_str()).detachTo(parameters.appendedRaw());
1427	else
1428	return errorArgument("Missing parameter: --bucket-name");
1429
1430	if (strObjectName.isNotEmpty())
1431	BstrFmt("object-name=%s", strObjectName.c_str()).detachTo(parameters.appendedRaw());
1432
1433	if (strDisplayName.isNotEmpty())
1434	BstrFmt("display-name=%s", strDisplayName.c_str()).detachTo(parameters.appendedRaw());
1435
1436	if (strLaunchMode.isNotEmpty())
1437	BstrFmt("launch-mode=%s", strLaunchMode.c_str()).detachTo(parameters.appendedRaw());
1438
1439
1440	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1441
1442	ComObjPtr<ICloudClient> oCloudClient;
1443	CHECK_ERROR2_RET(hrc, pCloudProfile,
1444	CreateCloudClient(oCloudClient.asOutParam()),
1445	RTEXITCODE_FAILURE);
1446
1447	if (strObjectName.isNotEmpty())
1448	RTPrintf("Exporting image \'%s\' to the Cloud with name \'%s\'...\n",
1449	strImageId.c_str(), strObjectName.c_str());
1450	else
1451	RTPrintf("Exporting image \'%s\' to the Cloud with default name\n",
1452	strImageId.c_str());
1453
1454	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
1455	SafeIfaceArray<IMedium> aImageList;
1456	CHECK_ERROR2_RET(hrc, pVirtualBox,
1457	COMGETTER(HardDisks)(ComSafeArrayAsOutParam(aImageList)),
1458	RTEXITCODE_FAILURE);
1459
1460	ComPtr<IMedium> pImage;
1461	size_t cImages = aImageList.size();
1462	bool fFound = false;
1463	for (size_t i = 0; i < cImages; ++i)
1464	{
1465	pImage = aImageList[i];
1466	Bstr bstrImageId;
1467	hrc = pImage->COMGETTER(Id)(bstrImageId.asOutParam());
1468	if (FAILED(hrc))
1469	continue;
1470
1471	com::Guid imageId(bstrImageId);
1472
1473	if (!imageId.isValid() \|\| imageId.isZero())
1474	continue;
1475
1476	if (!strImageId.compare(imageId.toString()))
1477	{
1478	fFound = true;
1479	RTPrintf("Image %s was found\n", strImageId.c_str());
1480	break;
1481	}
1482	}
1483
1484	if (!fFound)
1485	{
1486	RTPrintf("Process of exporting the image to the Cloud was interrupted. The image wasn't found.\n");
1487	return RTEXITCODE_FAILURE;
1488	}
1489
1490	ComPtr<IProgress> progress;
1491	CHECK_ERROR2_RET(hrc, oCloudClient,
1492	ExportImage(pImage, ComSafeArrayAsInParam(parameters), progress.asOutParam()),
1493	RTEXITCODE_FAILURE);
1494	hrc = showProgress(progress);
1495	CHECK_PROGRESS_ERROR_RET(progress, ("Export the image to the Cloud failed"), RTEXITCODE_FAILURE);
1496
1497	if (SUCCEEDED(hrc))
1498	RTPrintf("Export the image to the Cloud was successfull\n");
1499
1500	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1501	}
1502
1503	static RTEXITCODE importCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1504	{
1505	HRESULT hrc = S_OK;
1506
1507	static const RTGETOPTDEF s_aOptions[] =
1508	{
1509	{ "--id", 'i', RTGETOPT_REQ_STRING },
1510	{ "--bucket-name", 'b', RTGETOPT_REQ_STRING },
1511	{ "--object-name", 'o', RTGETOPT_REQ_STRING },
1512	{ "help", 1001, RTGETOPT_REQ_NOTHING },
1513	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
1514	};
1515	RTGETOPTSTATE GetState;
1516	RTGETOPTUNION ValueUnion;
1517	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1518	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1519	if (a->argc == iFirst)
1520	{
1521	RTPrintf("Empty command parameter list, show help.\n");
1522	printHelp(g_pStdOut);
1523	return RTEXITCODE_SUCCESS;
1524	}
1525
1526	Utf8Str strImageId;
1527	Utf8Str strCompartmentId;
1528	Utf8Str strBucketName;
1529	Utf8Str strObjectName;
1530	Utf8Str strDisplayName;
1531	com::SafeArray<BSTR> parameters;
1532
1533	int c;
1534	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1535	{
1536	switch (c)
1537	{
1538	case 'i':
1539	strImageId=ValueUnion.psz;
1540	break;
1541	case 'b':
1542	strBucketName=ValueUnion.psz;
1543	Bstr(Utf8Str("bucket-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1544	break;
1545	case 'o':
1546	strObjectName=ValueUnion.psz;
1547	Bstr(Utf8Str("object-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1548	break;
1549	case 1001:
1550	case 1002:
1551	printHelp(g_pStdOut);
1552	return RTEXITCODE_SUCCESS;
1553	case VINF_GETOPT_NOT_OPTION:
1554	return errorUnknownSubcommand(ValueUnion.psz);
1555	default:
1556	return errorGetOpt(c, &ValueUnion);
1557	}
1558	}
1559
1560	/* Delayed check. It allows us to print help information.*/
1561	hrc = checkAndSetCommonOptions(a, pCommonOpts);
1562	if (FAILED(hrc))
1563	return RTEXITCODE_FAILURE;
1564
1565	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1566
1567	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
1568	ComObjPtr<ICloudClient> oCloudClient;
1569	CHECK_ERROR2_RET(hrc, pCloudProfile,
1570	CreateCloudClient(oCloudClient.asOutParam()),
1571	RTEXITCODE_FAILURE);
1572	RTPrintf("Creating an object \'%s\' from the cloud image \'%s\'...\n", strObjectName.c_str(), strImageId.c_str());
1573
1574	ComPtr<IProgress> progress;
1575	CHECK_ERROR2_RET(hrc, oCloudClient,
1576	ImportImage(Bstr(strImageId).raw(), ComSafeArrayAsInParam(parameters), progress.asOutParam()),
1577	RTEXITCODE_FAILURE);
1578	hrc = showProgress(progress);
1579	CHECK_PROGRESS_ERROR_RET(progress, ("Cloud image import failed"), RTEXITCODE_FAILURE);
1580
1581	if (SUCCEEDED(hrc))
1582	{
1583	RTPrintf("Cloud image was imported successfully. Find the downloaded object with the name %s "
1584	"in the system temp folder (find the possible environment variables like TEMP, TMP and etc.)\n",
1585	strObjectName.c_str());
1586	}
1587
1588	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1589	}
1590
1591	static RTEXITCODE showCloudImageInfo(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1592	{
1593	HRESULT hrc = S_OK;
1594
1595	static const RTGETOPTDEF s_aOptions[] =
1596	{
1597	{ "--id", 'i', RTGETOPT_REQ_STRING },
1598	{ "help", 1001, RTGETOPT_REQ_NOTHING },
1599	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
1600	};
1601	RTGETOPTSTATE GetState;
1602	RTGETOPTUNION ValueUnion;
1603	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1604	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1605	if (a->argc == iFirst)
1606	{
1607	RTPrintf("Empty command parameter list, show help.\n");
1608	printHelp(g_pStdOut);
1609	return RTEXITCODE_SUCCESS;
1610	}
1611
1612	Utf8Str strImageId;
1613
1614	int c;
1615	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1616	{
1617	switch (c)
1618	{
1619	case 'i':
1620	strImageId = ValueUnion.psz;
1621	break;
1622	case 1001:
1623	case 1002:
1624	printHelp(g_pStdOut);
1625	return RTEXITCODE_SUCCESS;
1626	case VINF_GETOPT_NOT_OPTION:
1627	return errorUnknownSubcommand(ValueUnion.psz);
1628	default:
1629	return errorGetOpt(c, &ValueUnion);
1630	}
1631	}
1632
1633	/* Delayed check. It allows us to print help information.*/
1634	hrc = checkAndSetCommonOptions(a, pCommonOpts);
1635	if (FAILED(hrc))
1636	return RTEXITCODE_FAILURE;
1637
1638	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1639
1640	ComObjPtr<ICloudClient> oCloudClient;
1641	CHECK_ERROR2_RET(hrc, pCloudProfile,
1642	CreateCloudClient(oCloudClient.asOutParam()),
1643	RTEXITCODE_FAILURE);
1644	RTPrintf("Getting information about the cloud image with id \'%s\'...\n", strImageId.c_str());
1645
1646	ComPtr<IStringArray> infoArray;
1647	com::SafeArray<BSTR> pStrInfoArray;
1648	ComPtr<IProgress> pProgress;
1649
1650	RTPrintf("Reply is in the form \'image property\' = \'value\'\n");
1651	CHECK_ERROR2_RET(hrc, oCloudClient,
1652	GetImageInfo(Bstr(strImageId).raw(),
1653	infoArray.asOutParam(),
1654	pProgress.asOutParam()),
1655	RTEXITCODE_FAILURE);
1656
1657	hrc = showProgress(pProgress);
1658	CHECK_PROGRESS_ERROR_RET(pProgress, ("Getting information about the cloud image failed"), RTEXITCODE_FAILURE);
1659
1660	CHECK_ERROR2_RET(hrc,
1661	infoArray, COMGETTER(Values)(ComSafeArrayAsOutParam(pStrInfoArray)),
1662	RTEXITCODE_FAILURE);
1663
1664	RTPrintf("General information about the image:\n");
1665	size_t cParamNames = pStrInfoArray.size();
1666	for (size_t k = 0; k < cParamNames; k++)
1667	{
1668	Utf8Str data(pStrInfoArray[k]);
1669	RTPrintf("\t%s\n", data.c_str());
1670	}
1671
1672	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1673	}
1674
1675	static RTEXITCODE updateCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1676	{
1677	RT_NOREF(a);
1678	RT_NOREF(iFirst);
1679	RT_NOREF(pCommonOpts);
1680	return RTEXITCODE_SUCCESS;
1681	}
1682
1683	static RTEXITCODE deleteCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1684	{
1685	HRESULT hrc = S_OK;
1686
1687	static const RTGETOPTDEF s_aOptions[] =
1688	{
1689	{ "--id", 'i', RTGETOPT_REQ_STRING },
1690	{ "help", 1001, RTGETOPT_REQ_NOTHING },
1691	{ "--help", 1002, RTGETOPT_REQ_NOTHING }
1692	};
1693	RTGETOPTSTATE GetState;
1694	RTGETOPTUNION ValueUnion;
1695	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1696	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1697	if (a->argc == iFirst)
1698	{
1699	RTPrintf("Empty command parameter list, show help.\n");
1700	printHelp(g_pStdOut);
1701	return RTEXITCODE_SUCCESS;
1702	}
1703
1704	Utf8Str strImageId;
1705
1706	int c;
1707	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1708	{
1709	switch (c)
1710	{
1711	case 'i':
1712	{
1713	if (strImageId.isNotEmpty())
1714	return errorArgument("Duplicate parameter: --id");
1715
1716	strImageId = ValueUnion.psz;
1717	if (strImageId.isEmpty())
1718	return errorArgument("Empty parameter: --id");
1719
1720	break;
1721	}
1722
1723	case 1001:
1724	case 1002:
1725	printHelp(g_pStdOut);
1726	return RTEXITCODE_SUCCESS;
1727	case VINF_GETOPT_NOT_OPTION:
1728	return errorUnknownSubcommand(ValueUnion.psz);
1729
1730	default:
1731	return errorGetOpt(c, &ValueUnion);
1732	}
1733	}
1734
1735	/* Delayed check. It allows us to print help information.*/
1736	hrc = checkAndSetCommonOptions(a, pCommonOpts);
1737	if (FAILED(hrc))
1738	return RTEXITCODE_FAILURE;
1739
1740	if (strImageId.isEmpty())
1741	return errorArgument("Missing parameter: --id");
1742
1743
1744	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1745
1746	ComObjPtr<ICloudClient> oCloudClient;
1747	CHECK_ERROR2_RET(hrc, pCloudProfile,
1748	CreateCloudClient(oCloudClient.asOutParam()),
1749	RTEXITCODE_FAILURE);
1750	RTPrintf("Deleting cloud image with id %s...\n", strImageId.c_str());
1751
1752	ComPtr<IProgress> progress;
1753	CHECK_ERROR2_RET(hrc, oCloudClient,
1754	DeleteImage(Bstr(strImageId).raw(), progress.asOutParam()),
1755	RTEXITCODE_FAILURE);
1756	hrc = showProgress(progress);
1757	CHECK_PROGRESS_ERROR_RET(progress, ("Deleting cloud image failed"), RTEXITCODE_FAILURE);
1758
1759	if (SUCCEEDED(hrc))
1760	RTPrintf("Cloud image with was deleted successfully\n");
1761
1762	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1763	}
1764
1765	static RTEXITCODE handleCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1766	{
1767	enum
1768	{
1769	kCloudImageIota = 1000,
1770	kCloudImage_Create,
1771	kCloudImage_Delete,
1772	kCloudImage_Export,
1773	kCloudImage_Import,
1774	kCloudImage_Info,
1775	kCloudImage_Update,
1776	};
1777
1778	static const RTGETOPTDEF s_aOptions[] =
1779	{
1780	{ "create", kCloudImage_Create, RTGETOPT_REQ_NOTHING },
1781	{ "delete", kCloudImage_Delete, RTGETOPT_REQ_NOTHING },
1782	{ "export", kCloudImage_Export, RTGETOPT_REQ_NOTHING },
1783	{ "import", kCloudImage_Import, RTGETOPT_REQ_NOTHING },
1784	{ "info", kCloudImage_Info, RTGETOPT_REQ_NOTHING },
1785	{ "update", kCloudImage_Update, RTGETOPT_REQ_NOTHING },
1786
1787	{ "help", 'h', RTGETOPT_REQ_NOTHING },
1788	{ "-?", 'h', RTGETOPT_REQ_NOTHING },
1789	{ "-help", 'h', RTGETOPT_REQ_NOTHING },
1790	{ "--help", 'h', RTGETOPT_REQ_NOTHING },
1791	};
1792
1793	if (a->argc == iFirst)
1794	{
1795	RTPrintf("Empty command parameter list, show help.\n");
1796	printHelp(g_pStdOut);
1797	return RTEXITCODE_SUCCESS;
1798	}
1799
1800	RTGETOPTSTATE GetState;
1801	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1802	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1803
1804	int c;
1805	RTGETOPTUNION ValueUnion;
1806	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1807	{
1808	switch (c)
1809	{
1810	/* Sub-commands: */
1811	case kCloudImage_Create:
1812	setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_CREATE);
1813	return createCloudImage(a, GetState.iNext, pCommonOpts);
1814
1815	case kCloudImage_Export:
1816	setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_EXPORT);
1817	return exportCloudImage(a, GetState.iNext, pCommonOpts);
1818
1819	case kCloudImage_Import:
1820	setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_IMPORT);
1821	return importCloudImage(a, GetState.iNext, pCommonOpts);
1822
1823	case kCloudImage_Info:
1824	setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_INFO);
1825	return showCloudImageInfo(a, GetState.iNext, pCommonOpts);
1826
1827	case kCloudImage_Update:
1828	// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_UPDATE);
1829	return updateCloudImage(a, GetState.iNext, pCommonOpts);
1830
1831	case kCloudImage_Delete:
1832	setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_DELETE);
1833	return deleteCloudImage(a, GetState.iNext, pCommonOpts);
1834
1835	case 'h':
1836	printHelp(g_pStdOut);
1837	return RTEXITCODE_SUCCESS;
1838
1839	case VINF_GETOPT_NOT_OPTION:
1840	return errorUnknownSubcommand(ValueUnion.psz);
1841
1842	default:
1843	return errorGetOpt(c, &ValueUnion);
1844	}
1845	}
1846
1847	return errorNoSubcommand();
1848	}
1849
1850	#ifdef VBOX_WITH_CLOUD_NET
1851	struct CloudNetworkOptions
1852	{
1853	BOOL fEnable;
1854	BOOL fDisable;
1855	Bstr strNetworkId;
1856	Bstr strNetworkName;
1857	};
1858	typedef struct CloudNetworkOptions CLOUDNETOPT;
1859	typedef CLOUDNETOPT *PCLOUDNETOPT;
1860
1861	static RTEXITCODE createUpdateCloudNetworkCommon(ComPtr<ICloudNetwork> cloudNetwork, CLOUDNETOPT& options, PCLOUDCOMMONOPT pCommonOpts)
1862	{
1863	HRESULT hrc = S_OK;
1864
1865	Bstr strProvider = pCommonOpts->provider.pszProviderName;
1866	Bstr strProfile = pCommonOpts->profile.pszProfileName;
1867
1868	if (options.fEnable)
1869	{
1870	CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE);
1871	}
1872	if (options.fDisable)
1873	{
1874	CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE);
1875	}
1876	if (options.strNetworkId.isNotEmpty())
1877	{
1878	CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(NetworkId)(options.strNetworkId.raw()), RTEXITCODE_FAILURE);
1879	}
1880	if (strProvider.isNotEmpty())
1881	{
1882	CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Provider)(strProvider.raw()), RTEXITCODE_FAILURE);
1883	}
1884	if (strProfile.isNotEmpty())
1885	{
1886	CHECK_ERROR2_RET(hrc, cloudNetwork, COMSETTER(Profile)(strProfile.raw()), RTEXITCODE_FAILURE);
1887	}
1888
1889	return RTEXITCODE_SUCCESS;
1890	}
1891
1892
1893	static RTEXITCODE createCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1894	{
1895	HRESULT hrc = S_OK;
1896	hrc = checkAndSetCommonOptions(a, pCommonOpts);
1897	if (FAILED(hrc))
1898	return RTEXITCODE_FAILURE;
1899
1900	/* Required parameters, the rest is handled in update */
1901	static const RTGETOPTDEF s_aOptions[] =
1902	{
1903	{ "--disable", 'd', RTGETOPT_REQ_NOTHING },
1904	{ "--enable", 'e', RTGETOPT_REQ_NOTHING },
1905	{ "--network-id", 'i', RTGETOPT_REQ_STRING },
1906	{ "--name", 'n', RTGETOPT_REQ_STRING },
1907	};
1908
1909	RTGETOPTSTATE GetState;
1910	RTGETOPTUNION ValueUnion;
1911	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1912	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1913
1914	CLOUDNETOPT options;
1915	options.fEnable = FALSE;
1916	options.fDisable = FALSE;
1917
1918	int c;
1919	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1920	{
1921	switch (c)
1922	{
1923	case 'd':
1924	options.fDisable = TRUE;
1925	break;
1926	case 'e':
1927	options.fEnable = TRUE;
1928	break;
1929	case 'i':
1930	options.strNetworkId=ValueUnion.psz;
1931	break;
1932	case 'n':
1933	options.strNetworkName=ValueUnion.psz;
1934	break;
1935	case VINF_GETOPT_NOT_OPTION:
1936	return errorUnknownSubcommand(ValueUnion.psz);
1937	default:
1938	return errorGetOpt(c, &ValueUnion);
1939	}
1940	}
1941
1942	if (options.strNetworkName.isEmpty())
1943	return errorArgument("Missing --name parameter");
1944	if (options.strNetworkId.isEmpty())
1945	return errorArgument("Missing --network-id parameter");
1946
1947	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
1948
1949	ComPtr<ICloudNetwork> cloudNetwork;
1950	CHECK_ERROR2_RET(hrc, pVirtualBox,
1951	CreateCloudNetwork(options.strNetworkName.raw(), cloudNetwork.asOutParam()),
1952	RTEXITCODE_FAILURE);
1953
1954	/* Fill out the created network */
1955	RTEXITCODE rc = createUpdateCloudNetworkCommon(cloudNetwork, options, pCommonOpts);
1956	if (RT_SUCCESS(rc))
1957	RTPrintf("Cloud network was created successfully\n");
1958
1959	return rc;
1960	}
1961
1962
1963	static RTEXITCODE showCloudNetworkInfo(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1964	{
1965	RT_NOREF(pCommonOpts);
1966	HRESULT hrc = S_OK;
1967	static const RTGETOPTDEF s_aOptions[] =
1968	{
1969	{ "--name", 'n', RTGETOPT_REQ_STRING },
1970	};
1971	RTGETOPTSTATE GetState;
1972	RTGETOPTUNION ValueUnion;
1973	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1974	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1975
1976	Bstr strNetworkName;
1977
1978	int c;
1979	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1980	{
1981	switch (c)
1982	{
1983	case 'n':
1984	strNetworkName=ValueUnion.psz;
1985	break;
1986	case VINF_GETOPT_NOT_OPTION:
1987	return errorUnknownSubcommand(ValueUnion.psz);
1988	default:
1989	return errorGetOpt(c, &ValueUnion);
1990	}
1991	}
1992
1993	if (strNetworkName.isEmpty())
1994	return errorArgument("Missing --name parameter");
1995
1996	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
1997	ComPtr<ICloudNetwork> cloudNetwork;
1998	CHECK_ERROR2_RET(hrc, pVirtualBox,
1999	FindCloudNetworkByName(strNetworkName.raw(), cloudNetwork.asOutParam()),
2000	RTEXITCODE_FAILURE);
2001
2002	RTPrintf("Name: %ls\n", strNetworkName.raw());
2003	BOOL fEnabled = FALSE;
2004	cloudNetwork->COMGETTER(Enabled)(&fEnabled);
2005	RTPrintf("State: %s\n", fEnabled ? "Enabled" : "Disabled");
2006	Bstr Provider;
2007	cloudNetwork->COMGETTER(Provider)(Provider.asOutParam());
2008	RTPrintf("CloudProvider: %ls\n", Provider.raw());
2009	Bstr Profile;
2010	cloudNetwork->COMGETTER(Profile)(Profile.asOutParam());
2011	RTPrintf("CloudProfile: %ls\n", Profile.raw());
2012	Bstr NetworkId;
2013	cloudNetwork->COMGETTER(NetworkId)(NetworkId.asOutParam());
2014	RTPrintf("CloudNetworkId: %ls\n", NetworkId.raw());
2015	Bstr netName = BstrFmt("cloud-%ls", strNetworkName.raw());
2016	RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
2017
2018	return RTEXITCODE_SUCCESS;
2019	}
2020
2021
2022	static RTEXITCODE updateCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
2023	{
2024	HRESULT hrc = S_OK;
2025
2026	static const RTGETOPTDEF s_aOptions[] =
2027	{
2028	{ "--disable", 'd', RTGETOPT_REQ_NOTHING },
2029	{ "--enable", 'e', RTGETOPT_REQ_NOTHING },
2030	{ "--network-id", 'i', RTGETOPT_REQ_STRING },
2031	{ "--name", 'n', RTGETOPT_REQ_STRING },
2032	};
2033
2034	RTGETOPTSTATE GetState;
2035	RTGETOPTUNION ValueUnion;
2036	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2037	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2038
2039	CLOUDNETOPT options;
2040	options.fEnable = FALSE;
2041	options.fDisable = FALSE;
2042
2043	int c;
2044	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2045	{
2046	switch (c)
2047	{
2048	case 'd':
2049	options.fDisable = TRUE;
2050	break;
2051	case 'e':
2052	options.fEnable = TRUE;
2053	break;
2054	case 'i':
2055	options.strNetworkId=ValueUnion.psz;
2056	break;
2057	case 'n':
2058	options.strNetworkName=ValueUnion.psz;
2059	break;
2060	case VINF_GETOPT_NOT_OPTION:
2061	return errorUnknownSubcommand(ValueUnion.psz);
2062	default:
2063	return errorGetOpt(c, &ValueUnion);
2064	}
2065	}
2066
2067	if (options.strNetworkName.isEmpty())
2068	return errorArgument("Missing --name parameter");
2069
2070	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
2071	ComPtr<ICloudNetwork> cloudNetwork;
2072	CHECK_ERROR2_RET(hrc, pVirtualBox,
2073	FindCloudNetworkByName(options.strNetworkName.raw(), cloudNetwork.asOutParam()),
2074	RTEXITCODE_FAILURE);
2075
2076	RTEXITCODE rc = createUpdateCloudNetworkCommon(cloudNetwork, options, pCommonOpts);
2077	if (RT_SUCCESS(rc))
2078	RTPrintf("Cloud network %ls was updated successfully\n", options.strNetworkName.raw());
2079
2080	return rc;
2081	}
2082
2083
2084	static RTEXITCODE deleteCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
2085	{
2086	RT_NOREF(pCommonOpts);
2087	HRESULT hrc = S_OK;
2088	static const RTGETOPTDEF s_aOptions[] =
2089	{
2090	{ "--name", 'n', RTGETOPT_REQ_STRING },
2091	};
2092	RTGETOPTSTATE GetState;
2093	RTGETOPTUNION ValueUnion;
2094	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2095	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2096
2097	Bstr strNetworkName;
2098
2099	int c;
2100	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2101	{
2102	switch (c)
2103	{
2104	case 'n':
2105	strNetworkName=ValueUnion.psz;
2106	break;
2107	case VINF_GETOPT_NOT_OPTION:
2108	return errorUnknownSubcommand(ValueUnion.psz);
2109	default:
2110	return errorGetOpt(c, &ValueUnion);
2111	}
2112	}
2113
2114	if (strNetworkName.isEmpty())
2115	return errorArgument("Missing --name parameter");
2116
2117	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
2118	ComPtr<ICloudNetwork> cloudNetwork;
2119	CHECK_ERROR2_RET(hrc, pVirtualBox,
2120	FindCloudNetworkByName(strNetworkName.raw(), cloudNetwork.asOutParam()),
2121	RTEXITCODE_FAILURE);
2122
2123	CHECK_ERROR2_RET(hrc, pVirtualBox,
2124	RemoveCloudNetwork(cloudNetwork),
2125	RTEXITCODE_FAILURE);
2126
2127	if (SUCCEEDED(hrc))
2128	RTPrintf("Cloud network %ls was deleted successfully\n", strNetworkName.raw());
2129
2130	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2131	}
2132
2133
2134	static bool errorOccured(HRESULT hrc, const char *pszFormat, ...)
2135	{
2136	if (FAILED(hrc))
2137	{
2138	va_list va;
2139	va_start(va, pszFormat);
2140	Utf8Str strError(pszFormat, va);
2141	va_end(va);
2142	RTStrmPrintf(g_pStdErr, "%s (rc=%x)\n", strError.c_str(), hrc);
2143	RTStrmFlush(g_pStdErr);
2144	return true;
2145	}
2146	return false;
2147	}
2148
2149
2150	static int composeTemplatePath(const char *pcszTemplate, Bstr& strFullPath)
2151	{
2152	com::Utf8Str strTemplatePath;
2153	int rc = RTPathAppPrivateNoArchCxx(strTemplatePath);
2154	if (RT_SUCCESS(rc))
2155	rc = RTPathAppendCxx(strTemplatePath, "UnattendedTemplates");
2156	if (RT_SUCCESS(rc))
2157	rc = RTPathAppendCxx(strTemplatePath, pcszTemplate);
2158	if (RT_FAILURE(rc))
2159	{
2160	RTStrmPrintf(g_pStdErr, "Failed to compose path to the unattended installer script templates (%Rrc)", rc);
2161	RTStrmFlush(g_pStdErr);
2162	}
2163	else
2164	strFullPath = strTemplatePath;
2165
2166	return rc;
2167	}
2168
2169	/**
2170	* @returns COM status code.
2171	* @retval S_OK if url needs proxy.
2172	* @retval S_FALSE if noproxy for the URL.
2173	*/
2174	static HRESULT getSystemProxyForUrl(const com::Utf8Str &strUrl, Bstr &strProxy)
2175	{
2176	/** @todo r=bird: LogRel is pointless here. */
2177	#ifndef VBOX_WITH_PROXY_INFO
2178	RT_NOREF(strUrl, strProxy);
2179	LogRel(("CLOUD-NET: Proxy support is disabled. Using direct connection.\n"));
2180	return S_FALSE;
2181	#else /* VBOX_WITH_PROXY_INFO */
2182	HRESULT hrc = E_FAIL;
2183	RTHTTP hHttp;
2184	int rc = RTHttpCreate(&hHttp);
2185	if (RT_SUCCESS(rc))
2186	{
2187	rc = RTHttpUseSystemProxySettings(hHttp);
2188	if (RT_SUCCESS(rc))
2189	{
2190	RTHTTPPROXYINFO proxy;
2191	rc = RTHttpQueryProxyInfoForUrl(hHttp, strUrl.c_str(), &proxy);
2192	if (RT_SUCCESS(rc))
2193	{
2194	const char *pcszProxyScheme = "";
2195	switch (proxy.enmProxyType)
2196	{
2197	case RTHTTPPROXYTYPE_NOPROXY:
2198	pcszProxyScheme = NULL;
2199	hrc = S_FALSE;
2200	break;
2201	case RTHTTPPROXYTYPE_HTTP:
2202	pcszProxyScheme = "http://";
2203	break;
2204	case RTHTTPPROXYTYPE_HTTPS:
2205	pcszProxyScheme = "https://";
2206	break;
2207	case RTHTTPPROXYTYPE_SOCKS4:
2208	pcszProxyScheme = "socks4://";
2209	break;
2210	case RTHTTPPROXYTYPE_SOCKS5:
2211	pcszProxyScheme = "socks://";
2212	break;
2213	case RTHTTPPROXYTYPE_INVALID:
2214	case RTHTTPPROXYTYPE_UNKNOWN:
2215	case RTHTTPPROXYTYPE_END:
2216	case RTHTTPPROXYTYPE_32BIT_HACK:
2217	break;
2218	}
2219	if (pcszProxyScheme && *pcszProxyScheme != '\0')
2220	{
2221	if (proxy.pszProxyUsername \|\| proxy.pszProxyPassword)
2222	LogRel(("CLOUD-NET: Warning! Code doesn't yet handle proxy user or password. Sorry.\n"));
2223	if (proxy.uProxyPort != UINT32_MAX)
2224	strProxy.printf("%s%s:%d", pcszProxyScheme, proxy.pszProxyHost, proxy.uProxyPort);
2225	else
2226	strProxy.printf("%s%s", pcszProxyScheme, proxy.pszProxyHost);
2227	hrc = S_OK;
2228	}
2229	else if (pcszProxyScheme)
2230	{
2231	LogRel(("CLOUD-NET: Unknown proxy type %d. Using direct connection.\n", proxy.enmProxyType));
2232	AssertFailed();
2233	}
2234	RTHttpFreeProxyInfo(&proxy);
2235	}
2236	else
2237	LogRel(("CLOUD-NET: Failed to get proxy for %s (rc=%Rrc)\n", strUrl.c_str(), rc));
2238	}
2239	else
2240	LogRel(("CLOUD-NET: Failed to use system proxy (rc=%Rrc)\n", rc));
2241	RTHttpDestroy(hHttp);
2242	}
2243	else
2244	LogRel(("CLOUD-NET: Failed to create HTTP context (rc=%Rrc)\n", rc));
2245	return hrc;
2246	#endif /* VBOX_WITH_PROXY_INFO */
2247	}
2248
2249	static HRESULT localGatewayImagePath(const Bstr &aDefaultMachineFolder, Bstr &aLgwImage)
2250	{
2251	com::Utf8Str strPath(aDefaultMachineFolder);
2252	int rc = RTPathAppendCxx(strPath, "gateways");
2253	if (RT_SUCCESS(rc))
2254	rc = RTPathAppendCxx(strPath, "lgw.vdi");
2255	if (RT_SUCCESS(rc))
2256	aLgwImage = strPath;
2257
2258	return rc;
2259	}
2260
2261	static HRESULT createLocalGatewayImage(ComPtr<IVirtualBox> virtualBox, const Bstr& aGatewayIso, const Bstr& aGuestAdditionsIso, const Bstr& aProxy)
2262	{
2263	/* Check if the image already exists. */
2264	HRESULT hrc;
2265
2266	Bstr strGatewayVM = "lgw";
2267	Bstr strUser = "vbox";
2268	Bstr strPassword = "vbox";
2269
2270	Bstr strInstallerScript;
2271	Bstr strPostInstallScript;
2272
2273	if (RT_FAILURE(composeTemplatePath("lgw_ks.cfg", strInstallerScript)))
2274	return E_FAIL;
2275	if (RT_FAILURE(composeTemplatePath("lgw_postinstall.sh", strPostInstallScript)))
2276	return E_FAIL;
2277
2278	ComPtr<ISystemProperties> systemProperties;
2279	ProxyMode_T enmProxyMode;
2280	Bstr strProxy;
2281	ComPtr<IMedium> hd;
2282	Bstr defaultMachineFolder;
2283	Bstr guestAdditionsISO;
2284	hrc = virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
2285	if (errorOccured(hrc, "Failed to obtain system properties."))
2286	return hrc;
2287	if (aProxy.isNotEmpty())
2288	strProxy = aProxy;
2289	else
2290	{
2291	hrc = systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
2292	if (errorOccured(hrc, "Failed to obtain proxy mode."))
2293	return hrc;
2294	switch (enmProxyMode)
2295	{
2296	case ProxyMode_NoProxy:
2297	strProxy.setNull();
2298	break;
2299	case ProxyMode_Manual:
2300	hrc = systemProperties->COMGETTER(ProxyURL)(strProxy.asOutParam());
2301	if (errorOccured(hrc, "Failed to obtain proxy URL."))
2302	return hrc;
2303	break;
2304	case ProxyMode_System:
2305	hrc = getSystemProxyForUrl("https://dl.fedoraproject.org", strProxy);
2306	if (FAILED(hrc))
2307	errorOccured(hrc, "Failed to get system proxy for https://dl.fedoraproject.org. Will use direct connection.");
2308	break;
2309	default: /* To get rid of ProxyMode_32BitHack 'warning' */
2310	AssertFailed();
2311	break;
2312	}
2313
2314	}
2315	hrc = systemProperties->COMGETTER(DefaultMachineFolder)(defaultMachineFolder.asOutParam());
2316	if (errorOccured(hrc, "Failed to obtain default machine folder."))
2317	return hrc;
2318	if (aGuestAdditionsIso.isEmpty())
2319	{
2320	hrc = systemProperties->COMGETTER(DefaultAdditionsISO)(guestAdditionsISO.asOutParam());
2321	if (errorOccured(hrc, "Failed to obtain default guest additions ISO path."))
2322	return hrc;
2323	if (guestAdditionsISO.isEmpty())
2324	{
2325	errorOccured(E_INVALIDARG, "The default guest additions ISO path is empty nor it is provided as --guest-additions-iso parameter. Cannot proceed without it.");
2326	return E_INVALIDARG;
2327	}
2328	}
2329	else
2330	guestAdditionsISO = aGuestAdditionsIso;
2331
2332	Bstr strGatewayImage;
2333	int rc = localGatewayImagePath(defaultMachineFolder, strGatewayImage);
2334	if (RT_FAILURE(rc))
2335	{
2336	RTStrmPrintf(g_pStdErr, "Failed to compose a path to the local gateway image (%Rrc)", rc);
2337	RTStrmFlush(g_pStdErr);
2338	return E_FAIL;
2339	}
2340	hrc = virtualBox->OpenMedium(strGatewayImage.raw(), DeviceType_HardDisk, AccessMode_ReadWrite, FALSE, hd.asOutParam());
2341	/* If the image is already in place, there is nothing for us to do. */
2342	if (SUCCEEDED(hrc))
2343	{
2344	RTPrintf("Local gateway image already exists, skipping image preparation step.\n");
2345	return hrc;
2346	}
2347
2348	RTPrintf("Preparing unattended install of temporary local gateway machine from %ls...\n", aGatewayIso.raw());
2349	/* The image does not exist, let's try to open the provided ISO file. */
2350	ComPtr<IMedium> iso;
2351	hrc = virtualBox->OpenMedium(aGatewayIso.raw(), DeviceType_DVD, AccessMode_ReadOnly, FALSE, iso.asOutParam());
2352	if (errorOccured(hrc, "Failed to open %ls.", aGatewayIso.raw()))
2353	return hrc;
2354
2355	ComPtr<IMachine> machine;
2356	SafeArray<IN_BSTR> groups;
2357	groups.push_back(Bstr("/gateways").mutableRaw());
2358	hrc = virtualBox->CreateMachine(NULL, strGatewayVM.raw(), ComSafeArrayAsInParam(groups), Bstr("Oracle_64").raw(), Bstr("").raw(), machine.asOutParam());
2359	if (errorOccured(hrc, "Failed to create '%ls'.", strGatewayVM.raw()))
2360	return hrc;
2361	/* Initial configuration */
2362	hrc = machine->ApplyDefaults(NULL);
2363	if (errorOccured(hrc, "Failed to apply defaults to '%ls'.", strGatewayVM.raw()))
2364	return hrc;
2365
2366	hrc = machine->COMSETTER(CPUCount)(2);
2367	if (errorOccured(hrc, "Failed to adjust CPU count for '%ls'.", strGatewayVM.raw()))
2368	return hrc;
2369
2370	hrc = machine->COMSETTER(MemorySize)(512/MB/);
2371	if (errorOccured(hrc, "Failed to adjust memory size for '%ls'.", strGatewayVM.raw()))
2372	return hrc;
2373
2374	/* No need for audio -- disable it. */
2375	ComPtr<IAudioAdapter> audioAdapter;
2376	hrc = machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2377	if (errorOccured(hrc, "Failed to set attachment type for the second network adapter."))
2378	return hrc;
2379
2380	hrc = audioAdapter->COMSETTER(Enabled)(FALSE);
2381	if (errorOccured(hrc, "Failed to disable the audio adapter."))
2382	return hrc;
2383	audioAdapter.setNull();
2384
2385	hrc = virtualBox->RegisterMachine(machine);
2386	if (errorOccured(hrc, "Failed to register '%ls'.", strGatewayVM.raw()))
2387	return hrc;
2388
2389	hrc = virtualBox->CreateMedium(Bstr("VDI").raw(), strGatewayImage.raw(), AccessMode_ReadWrite, DeviceType_HardDisk, hd.asOutParam());
2390	if (errorOccured(hrc, "Failed to create %ls.", strGatewayImage.raw()))
2391	return hrc;
2392
2393	ComPtr<IProgress> progress;
2394	com::SafeArray<MediumVariant_T> mediumVariant;
2395	mediumVariant.push_back(MediumVariant_Standard);
2396
2397	/* Kick off the creation of a dynamic growing disk image with the given capacity. */
2398	hrc = hd->CreateBaseStorage(8ll * 1000 * 1000 * 1000 /* 8GB */,
2399	ComSafeArrayAsInParam(mediumVariant),
2400	progress.asOutParam());
2401	if (errorOccured(hrc, "Failed to create base storage for local gateway image."))
2402	return hrc;
2403
2404	hrc = showProgress(progress);
2405	CHECK_PROGRESS_ERROR_RET(progress, ("Failed to create base storage for local gateway image."), hrc);
2406
2407	ComPtr<ISession> session;
2408	hrc = session.createInprocObject(CLSID_Session);
2409	hrc = machine->LockMachine(session, LockType_Write);
2410	if (errorOccured(hrc, "Failed to lock '%ls' for modifications.", strGatewayVM.raw()))
2411	return hrc;
2412
2413	ComPtr<IMachine> sessionMachine;
2414	hrc = session->COMGETTER(Machine)(sessionMachine.asOutParam());
2415	if (errorOccured(hrc, "Failed to obtain a mutable machine."))
2416	return hrc;
2417
2418	hrc = sessionMachine->AttachDevice(Bstr("SATA").raw(), 0, 0, DeviceType_HardDisk, hd);
2419	if (errorOccured(hrc, "Failed to attach HD to '%ls'.", strGatewayVM.raw()))
2420	return hrc;
2421
2422	hrc = sessionMachine->AttachDevice(Bstr("IDE").raw(), 0, 0, DeviceType_DVD, iso);
2423	if (errorOccured(hrc, "Failed to attach ISO to '%ls'.", strGatewayVM.raw()))
2424	return hrc;
2425
2426	/* Save settings */
2427	hrc = sessionMachine->SaveSettings();
2428	if (errorOccured(hrc, "Failed to save '%ls' settings.", strGatewayVM.raw()))
2429	return hrc;
2430	session->UnlockMachine();
2431
2432	/* Prepare unattended install */
2433	ComPtr<IUnattended> unattended;
2434	hrc = virtualBox->CreateUnattendedInstaller(unattended.asOutParam());
2435	if (errorOccured(hrc, "Failed to create unattended installer."))
2436	return hrc;
2437
2438	hrc = unattended->COMSETTER(Machine)(machine);
2439	if (errorOccured(hrc, "Failed to set machine for the unattended installer."))
2440	return hrc;
2441
2442	hrc = unattended->COMSETTER(IsoPath)(aGatewayIso.raw());
2443	if (errorOccured(hrc, "Failed to set machine for the unattended installer."))
2444	return hrc;
2445
2446	hrc = unattended->COMSETTER(User)(strUser.raw());
2447	if (errorOccured(hrc, "Failed to set user for the unattended installer."))
2448	return hrc;
2449
2450	hrc = unattended->COMSETTER(Password)(strPassword.raw());
2451	if (errorOccured(hrc, "Failed to set password for the unattended installer."))
2452	return hrc;
2453
2454	hrc = unattended->COMSETTER(FullUserName)(strUser.raw());
2455	if (errorOccured(hrc, "Failed to set full user name for the unattended installer."))
2456	return hrc;
2457
2458	hrc = unattended->COMSETTER(InstallGuestAdditions)(TRUE);
2459	if (errorOccured(hrc, "Failed to enable guest addtions for the unattended installer."))
2460	return hrc;
2461
2462	hrc = unattended->COMSETTER(AdditionsIsoPath)(guestAdditionsISO.raw());
2463	if (errorOccured(hrc, "Failed to set guest addtions ISO path for the unattended installer."))
2464	return hrc;
2465
2466	hrc = unattended->COMSETTER(ScriptTemplatePath)(strInstallerScript.raw());
2467	if (errorOccured(hrc, "Failed to set script template for the unattended installer."))
2468	return hrc;
2469
2470	hrc = unattended->COMSETTER(PostInstallScriptTemplatePath)(strPostInstallScript.raw());
2471	if (errorOccured(hrc, "Failed to set post install script template for the unattended installer."))
2472	return hrc;
2473
2474	if (strProxy.isNotEmpty())
2475	{
2476	hrc = unattended->COMSETTER(Proxy)(strProxy.raw());
2477	if (errorOccured(hrc, "Failed to set post install script template for the unattended installer."))
2478	return hrc;
2479	}
2480
2481	hrc = unattended->Prepare();
2482	if (errorOccured(hrc, "Failed to prepare unattended installation."))
2483	return hrc;
2484
2485	hrc = unattended->ConstructMedia();
2486	if (errorOccured(hrc, "Failed to construct media for unattended installation."))
2487	return hrc;
2488
2489	hrc = unattended->ReconfigureVM();
2490	if (errorOccured(hrc, "Failed to reconfigure %ls for unattended installation.", strGatewayVM.raw()))
2491	return hrc;
2492
2493	#define SHOW_ATTR(a_Attr, a_szText, a_Type, a_szFmt) do { \
2494	a_Type Value; \
2495	HRESULT hrc2 = unattended->COMGETTER(a_Attr)(&Value); \
2496	if (SUCCEEDED(hrc2)) \
2497	RTPrintf(" %32s = " a_szFmt "\n", a_szText, Value); \
2498	else \
2499	RTPrintf(" %32s = failed: %Rhrc\n", a_szText, hrc2); \
2500	} while (0)
2501	#define SHOW_STR_ATTR(a_Attr, a_szText) do { \
2502	Bstr bstrString; \
2503	HRESULT hrc2 = unattended->COMGETTER(a_Attr)(bstrString.asOutParam()); \
2504	if (SUCCEEDED(hrc2)) \
2505	RTPrintf(" %32s = %ls\n", a_szText, bstrString.raw()); \
2506	else \
2507	RTPrintf(" %32s = failed: %Rhrc\n", a_szText, hrc2); \
2508	} while (0)
2509
2510	SHOW_STR_ATTR(IsoPath, "isoPath");
2511	SHOW_STR_ATTR(User, "user");
2512	SHOW_STR_ATTR(Password, "password");
2513	SHOW_STR_ATTR(FullUserName, "fullUserName");
2514	SHOW_STR_ATTR(ProductKey, "productKey");
2515	SHOW_STR_ATTR(AdditionsIsoPath, "additionsIsoPath");
2516	SHOW_ATTR( InstallGuestAdditions, "installGuestAdditions", BOOL, "%RTbool");
2517	SHOW_STR_ATTR(ValidationKitIsoPath, "validationKitIsoPath");
2518	SHOW_ATTR( InstallTestExecService, "installTestExecService", BOOL, "%RTbool");
2519	SHOW_STR_ATTR(Locale, "locale");
2520	SHOW_STR_ATTR(Country, "country");
2521	SHOW_STR_ATTR(TimeZone, "timeZone");
2522	SHOW_STR_ATTR(Proxy, "proxy");
2523	SHOW_STR_ATTR(Hostname, "hostname");
2524	SHOW_STR_ATTR(PackageSelectionAdjustments, "packageSelectionAdjustments");
2525	SHOW_STR_ATTR(AuxiliaryBasePath, "auxiliaryBasePath");
2526	SHOW_ATTR( ImageIndex, "imageIndex", ULONG, "%u");
2527	SHOW_STR_ATTR(ScriptTemplatePath, "scriptTemplatePath");
2528	SHOW_STR_ATTR(PostInstallScriptTemplatePath, "postInstallScriptTemplatePath");
2529	SHOW_STR_ATTR(PostInstallCommand, "postInstallCommand");
2530	SHOW_STR_ATTR(ExtraInstallKernelParameters, "extraInstallKernelParameters");
2531	SHOW_STR_ATTR(Language, "language");
2532	SHOW_STR_ATTR(DetectedOSTypeId, "detectedOSTypeId");
2533	SHOW_STR_ATTR(DetectedOSVersion, "detectedOSVersion");
2534	SHOW_STR_ATTR(DetectedOSFlavor, "detectedOSFlavor");
2535	SHOW_STR_ATTR(DetectedOSLanguages, "detectedOSLanguages");
2536	SHOW_STR_ATTR(DetectedOSHints, "detectedOSHints");
2537
2538	#undef SHOW_STR_ATTR
2539	#undef SHOW_ATTR
2540
2541	/* 'unattended' is no longer needed. */
2542	unattended.setNull();
2543
2544	RTPrintf("Performing unattended install of temporary local gateway...\n");
2545
2546	hrc = machine->LaunchVMProcess(session, Bstr("gui").raw(), ComSafeArrayNullInParam(), progress.asOutParam());
2547	if (errorOccured(hrc, "Failed to launch '%ls'.", strGatewayVM.raw()))
2548	return hrc;
2549
2550	hrc = progress->WaitForCompletion(-1);
2551	if (errorOccured(hrc, "Failed to launch '%ls'.", strGatewayVM.raw()))
2552	return hrc;
2553
2554	unsigned i = 0;
2555	const char progressChars[] = { '\|', '/', '-', '\\'};
2556	MachineState_T machineState;
2557	uint64_t u64Started = RTTimeMilliTS();
2558	do
2559	{
2560	RTThreadSleep(1000); /* One second */
2561	hrc = machine->COMGETTER(State)(&machineState);
2562	if (errorOccured(hrc, "Failed to get machine state."))
2563	break;
2564	RTPrintf("\r%c", progressChars[i++ % sizeof(progressChars)]);
2565	if (machineState == MachineState_Aborted)
2566	{
2567	errorOccured(E_ABORT, "Temporary local gateway VM has aborted.");
2568	return E_ABORT;
2569	}
2570	}
2571	while (machineState != MachineState_PoweredOff && RTTimeMilliTS() - u64Started < 40 * 60 * 1000);
2572
2573	if (machineState != MachineState_PoweredOff)
2574	{
2575	errorOccured(E_ABORT, "Timed out (40min) while waiting for unattended install to finish.");
2576	return E_ABORT;
2577	}
2578	/* Machine will still be immutable for a short while after powering off, let's wait a little. */
2579	RTThreadSleep(5000); /* Five seconds */
2580
2581	RTPrintf("\rDone.\n");
2582
2583	hrc = machine->LockMachine(session, LockType_Write);
2584	if (errorOccured(hrc, "Failed to lock '%ls' for modifications.", strGatewayVM.raw()))
2585	return hrc;
2586
2587	RTPrintf("Detaching local gateway image...\n");
2588	hrc = session->COMGETTER(Machine)(sessionMachine.asOutParam());
2589	if (errorOccured(hrc, "Failed to obtain a mutable machine."))
2590	return hrc;
2591
2592	hrc = sessionMachine->DetachDevice(Bstr("SATA").raw(), 0, 0);
2593	if (errorOccured(hrc, "Failed to detach HD to '%ls'.", strGatewayVM.raw()))
2594	return hrc;
2595
2596	/* Remove the image from the media registry. */
2597	hd->Close();
2598
2599	/* Save settings */
2600	hrc = sessionMachine->SaveSettings();
2601	if (errorOccured(hrc, "Failed to save '%ls' settings.", strGatewayVM.raw()))
2602	return hrc;
2603	session->UnlockMachine();
2604
2605	#if 0
2606	/** @todo Unregistering the temporary VM makes the image mutable again. Find out the way around it! */
2607	RTPrintf("Unregistering temporary local gateway machine...\n");
2608	SafeIfaceArray<IMedium> media;
2609	hrc = machine->Unregister(CleanupMode_DetachAllReturnNone, ComSafeArrayAsOutParam(media));
2610	if (errorOccured(hrc, "Failed to unregister '%ls'.", strGatewayVM.raw()))
2611	return hrc;
2612	hrc = machine->DeleteConfig(ComSafeArrayAsInParam(media), progress.asOutParam());
2613	if (errorOccured(hrc, "Failed to delete config for '%ls'.", strGatewayVM.raw()))
2614	return hrc;
2615	hrc = progress->WaitForCompletion(-1);
2616	if (errorOccured(hrc, "Failed to delete config for '%ls'.", strGatewayVM.raw()))
2617	return hrc;
2618	#endif
2619
2620	RTPrintf("Making local gateway image immutable...\n");
2621	hrc = virtualBox->OpenMedium(strGatewayImage.raw(), DeviceType_HardDisk, AccessMode_ReadWrite, FALSE, hd.asOutParam());
2622	if (errorOccured(hrc, "Failed to open '%ls'.", strGatewayImage.raw()))
2623	return hrc;
2624	hd->COMSETTER(Type)(MediumType_Immutable);
2625	if (errorOccured(hrc, "Failed to make '%ls' immutable.", strGatewayImage.raw()))
2626	return hrc;
2627
2628	return S_OK;
2629	}
2630
2631
2632	static RTEXITCODE setupCloudNetworkEnv(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
2633	{
2634	RT_NOREF(pCommonOpts);
2635	HRESULT hrc = S_OK;
2636	static const RTGETOPTDEF s_aOptions[] =
2637	{
2638	{ "--gateway-os-name", 'n', RTGETOPT_REQ_STRING },
2639	{ "--gateway-os-version", 'v', RTGETOPT_REQ_STRING },
2640	{ "--gateway-shape", 's', RTGETOPT_REQ_STRING },
2641	{ "--tunnel-network-name", 't', RTGETOPT_REQ_STRING },
2642	{ "--tunnel-network-range", 'r', RTGETOPT_REQ_STRING },
2643	{ "--guest-additions-iso", 'a', RTGETOPT_REQ_STRING },
2644	{ "--local-gateway-iso", 'l', RTGETOPT_REQ_STRING },
2645	{ "--proxy", 'p', RTGETOPT_REQ_STRING },
2646	{ "--compartment-id", 'c', RTGETOPT_REQ_STRING }
2647	};
2648	RTGETOPTSTATE GetState;
2649	RTGETOPTUNION ValueUnion;
2650	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2651	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2652
2653	Bstr strGatewayOsName;
2654	Bstr strGatewayOsVersion;
2655	Bstr strGatewayShape;
2656	Bstr strTunnelNetworkName;
2657	Bstr strTunnelNetworkRange;
2658	Bstr strLocalGatewayIso;
2659	Bstr strGuestAdditionsIso;
2660	Bstr strProxy;
2661	Bstr strCompartmentId;
2662
2663	int c;
2664	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2665	{
2666	switch (c)
2667	{
2668	case 'n':
2669	strGatewayOsName=ValueUnion.psz;
2670	break;
2671	case 'v':
2672	strGatewayOsVersion=ValueUnion.psz;
2673	break;
2674	case 's':
2675	strGatewayShape=ValueUnion.psz;
2676	break;
2677	case 't':
2678	strTunnelNetworkName=ValueUnion.psz;
2679	break;
2680	case 'r':
2681	strTunnelNetworkRange=ValueUnion.psz;
2682	break;
2683	case 'l':
2684	strLocalGatewayIso=ValueUnion.psz;
2685	break;
2686	case 'a':
2687	strGuestAdditionsIso=ValueUnion.psz;
2688	break;
2689	case 'p':
2690	strProxy=ValueUnion.psz;
2691	break;
2692	case 'c':
2693	strCompartmentId=ValueUnion.psz;
2694	break;
2695	case VINF_GETOPT_NOT_OPTION:
2696	return errorUnknownSubcommand(ValueUnion.psz);
2697	default:
2698	return errorGetOpt(c, &ValueUnion);
2699	}
2700	}
2701
2702	/* Delayed check. It allows us to print help information.*/
2703	hrc = checkAndSetCommonOptions(a, pCommonOpts);
2704	if (FAILED(hrc))
2705	return RTEXITCODE_FAILURE;
2706
2707	if (strLocalGatewayIso.isEmpty())
2708	return errorArgument("Missing --local-gateway-iso parameter");
2709
2710	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
2711
2712	hrc = createLocalGatewayImage(pVirtualBox, strLocalGatewayIso, strGuestAdditionsIso, strProxy);
2713	if (FAILED(hrc))
2714	return RTEXITCODE_FAILURE;
2715
2716	RTPrintf("Setting up tunnel network in the cloud...\n");
2717
2718	ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
2719
2720	/* Use user-specified profile instead of default one. */
2721	if (strCompartmentId.isNotEmpty())
2722	{
2723	CHECK_ERROR2_RET(hrc, pCloudProfile,
2724	SetProperty(Bstr("compartment").raw(), Bstr(strCompartmentId).raw()),
2725	RTEXITCODE_FAILURE);
2726	}
2727
2728	ComObjPtr<ICloudClient> oCloudClient;
2729	CHECK_ERROR2_RET(hrc, pCloudProfile,
2730	CreateCloudClient(oCloudClient.asOutParam()),
2731	RTEXITCODE_FAILURE);
2732
2733	ComPtr<ICloudNetworkEnvironmentInfo> cloudNetworkEnv;
2734	ComPtr<IProgress> progress;
2735	CHECK_ERROR2_RET(hrc, oCloudClient,
2736	SetupCloudNetworkEnvironment(strTunnelNetworkName.raw(), strTunnelNetworkRange.raw(),
2737	strGatewayOsName.raw(), strGatewayOsVersion.raw(), strGatewayShape.raw(),
2738	cloudNetworkEnv.asOutParam(), progress.asOutParam()),
2739	RTEXITCODE_FAILURE);
2740
2741	hrc = showProgress(progress);
2742	CHECK_PROGRESS_ERROR_RET(progress, ("Setting up cloud network environment failed"), RTEXITCODE_FAILURE);
2743
2744	Bstr tunnelNetworkId;
2745	hrc = cloudNetworkEnv->COMGETTER(TunnelNetworkId)(tunnelNetworkId.asOutParam());
2746	RTPrintf("Cloud network environment was set up successfully. Tunnel network id is: %ls\n", tunnelNetworkId.raw());
2747
2748	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2749	}
2750
2751
2752	static RTEXITCODE handleCloudNetwork(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
2753	{
2754	enum
2755	{
2756	kCloudNetworkIota = 1000,
2757	kCloudNetwork_Create,
2758	kCloudNetwork_Delete,
2759	kCloudNetwork_Info,
2760	kCloudNetwork_Setup,
2761	kCloudNetwork_Update,
2762	};
2763
2764	static const RTGETOPTDEF s_aOptions[] =
2765	{
2766	{ "create", kCloudNetwork_Create, RTGETOPT_REQ_NOTHING },
2767	{ "delete", kCloudNetwork_Delete, RTGETOPT_REQ_NOTHING },
2768	{ "info", kCloudNetwork_Info, RTGETOPT_REQ_NOTHING },
2769	{ "setup", kCloudNetwork_Setup, RTGETOPT_REQ_NOTHING },
2770	{ "update", kCloudNetwork_Update, RTGETOPT_REQ_NOTHING },
2771	};
2772
2773	if (a->argc < 1)
2774	return errorNoSubcommand();
2775
2776	RTGETOPTSTATE GetState;
2777	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2778	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2779
2780	int c;
2781	RTGETOPTUNION ValueUnion;
2782	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2783	{
2784	switch (c)
2785	{
2786	/* Sub-commands: */
2787	case kCloudNetwork_Create:
2788	return createCloudNetwork(a, GetState.iNext, pCommonOpts);
2789
2790	case kCloudNetwork_Info:
2791	return showCloudNetworkInfo(a, GetState.iNext, pCommonOpts);
2792
2793	case kCloudNetwork_Update:
2794	return updateCloudNetwork(a, GetState.iNext, pCommonOpts);
2795
2796	case kCloudNetwork_Delete:
2797	return deleteCloudNetwork(a, GetState.iNext, pCommonOpts);
2798
2799	case kCloudNetwork_Setup:
2800	return setupCloudNetworkEnv(a, GetState.iNext, pCommonOpts);
2801
2802	case VINF_GETOPT_NOT_OPTION:
2803	return errorUnknownSubcommand(ValueUnion.psz);
2804
2805	default:
2806	return errorGetOpt(c, &ValueUnion);
2807	}
2808	}
2809
2810	return errorNoSubcommand();
2811	}
2812	#endif /* VBOX_WITH_CLOUD_NET */
2813
2814
2815	RTEXITCODE handleCloud(HandlerArg *a)
2816	{
2817	enum
2818	{
2819	kCloudIota = 1000,
2820	kCloud_Image,
2821	kCloud_Instance,
2822	kCloud_List,
2823	kCloud_Machine,
2824	kCloud_Network,
2825	kCloud_Object,
2826	kCloud_ShowVMInfo,
2827	kCloud_Volume,
2828	};
2829
2830	static const RTGETOPTDEF s_aOptions[] =
2831	{
2832	/* common options */
2833	{ "--provider", 'v', RTGETOPT_REQ_STRING },
2834	{ "--profile", 'f', RTGETOPT_REQ_STRING },
2835
2836	{ "image", kCloud_Image, RTGETOPT_REQ_NOTHING },
2837	{ "instance", kCloud_Instance, RTGETOPT_REQ_NOTHING },
2838	{ "list", kCloud_List, RTGETOPT_REQ_NOTHING },
2839	{ "machine", kCloud_Machine, RTGETOPT_REQ_NOTHING },
2840	{ "network", kCloud_Network, RTGETOPT_REQ_NOTHING },
2841	{ "object", kCloud_Object, RTGETOPT_REQ_NOTHING },
2842	{ "showvminfo", kCloud_ShowVMInfo, RTGETOPT_REQ_NOTHING },
2843	{ "volume", kCloud_Volume, RTGETOPT_REQ_NOTHING },
2844	};
2845
2846	if (a->argc < 1)
2847	return errorNoSubcommand();
2848
2849	RTGETOPTSTATE GetState;
2850	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
2851	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2852
2853	CLOUDCOMMONOPT commonOpts = { {NULL, NULL}, {NULL, NULL} };
2854	int c;
2855	RTGETOPTUNION ValueUnion;
2856	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2857	{
2858	switch (c)
2859	{
2860	case 'v': // --provider
2861	commonOpts.provider.pszProviderName = ValueUnion.psz;
2862	break;
2863
2864	case 'f': // --profile
2865	commonOpts.profile.pszProfileName = ValueUnion.psz;
2866	break;
2867
2868	/* Sub-commands: */
2869	case kCloud_List:
2870	return handleCloudLists(a, GetState.iNext, &commonOpts);
2871
2872	case kCloud_Image:
2873	return handleCloudImage(a, GetState.iNext, &commonOpts);
2874
2875	case kCloud_Instance:
2876	return handleCloudInstance(a, GetState.iNext, &commonOpts);
2877
2878	#ifdef VBOX_WITH_CLOUD_NET
2879	case kCloud_Network:
2880	return handleCloudNetwork(a, GetState.iNext, &commonOpts);
2881	#endif /* VBOX_WITH_CLOUD_NET */
2882
2883	/* "cloud machine ..." handling is in VBoxManageCloudMachine.cpp */
2884	case kCloud_Machine:
2885	return handleCloudMachine(a, GetState.iNext,
2886	commonOpts.provider.pszProviderName,
2887	commonOpts.profile.pszProfileName);
2888
2889	/* ... including aliases that mimic the local vm commands */
2890	case kCloud_ShowVMInfo:
2891	return handleCloudShowVMInfo(a, GetState.iNext,
2892	commonOpts.provider.pszProviderName,
2893	commonOpts.profile.pszProfileName);
2894
2895	case VINF_GETOPT_NOT_OPTION:
2896	return errorUnknownSubcommand(ValueUnion.psz);
2897
2898	default:
2899	return errorGetOpt(c, &ValueUnion);
2900	}
2901	}
2902
2903	return errorNoSubcommand();
2904	}

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageCloud.cpp@ 91999

Download in other formats: