VirtualBox

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

Last change on this file since 80218 was 79980, checked in by vboxsync, 6 years ago

OCI: improve parameter handling in a few more commands.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 50.2 KB
Line 
1/* $Id: VBoxManageCloud.cpp 79980 2019-07-25 13:54:08Z vboxsync $ */
2/** @file
3 * VBoxManageCloud - The cloud related commands.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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/uuid.h>
31#include <iprt/file.h>
32#include <VBox/log.h>
33
34#include "VBoxManage.h"
35
36#include <list>
37
38using namespace com;//at least for Bstr
39
40/**
41 * Common Cloud options.
42 */
43typedef struct
44{
45 struct {
46 const char *pszProviderName;
47 ComPtr<ICloudProvider> pCloudProvider;
48 }provider;
49 struct {
50 const char *pszProfileName;
51 ComPtr<ICloudProfile> pCloudProfile;
52 }profile;
53
54} CLOUDCOMMONOPT;
55typedef CLOUDCOMMONOPT *PCLOUDCOMMONOPT;
56
57static HRESULT checkAndSetCommonOptions(HandlerArg *a, PCLOUDCOMMONOPT pCommonOpts)
58{
59 HRESULT hrc = S_OK;
60
61 Bstr bstrProvider(pCommonOpts->provider.pszProviderName);
62 Bstr bstrProfile(pCommonOpts->profile.pszProfileName);
63
64 /* check for required options */
65 if (bstrProvider.isEmpty())
66 {
67 errorSyntax(USAGE_S_NEWCMD, "Parameter --provider is required");
68 return E_FAIL;
69 }
70 if (bstrProfile.isEmpty())
71 {
72 errorSyntax(USAGE_S_NEWCMD, "Parameter --profile is required");
73 return E_FAIL;
74 }
75
76 ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
77 ComPtr<ICloudProviderManager> pCloudProviderManager;
78 CHECK_ERROR2_RET(hrc, pVirtualBox,
79 COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
80 RTEXITCODE_FAILURE);
81
82 ComPtr<ICloudProvider> pCloudProvider;
83 CHECK_ERROR2_RET(hrc, pCloudProviderManager,
84 GetProviderByShortName(bstrProvider.raw(), pCloudProvider.asOutParam()),
85 RTEXITCODE_FAILURE);
86 pCommonOpts->provider.pCloudProvider = pCloudProvider;
87
88 ComPtr<ICloudProfile> pCloudProfile;
89 CHECK_ERROR2_RET(hrc, pCloudProvider,
90 GetProfileByName(bstrProfile.raw(), pCloudProfile.asOutParam()),
91 RTEXITCODE_FAILURE);
92 pCommonOpts->profile.pCloudProfile = pCloudProfile;
93
94 return hrc;
95}
96
97
98/**
99 * List all available cloud instances for the specified cloud provider.
100 * Available cloud instance is one which state whether "running" or "stopped".
101 *
102 * @returns RTEXITCODE
103 * @param a is the list of passed arguments
104 * @param iFirst is the position of the first unparsed argument in the arguments list
105 * @param pCommonOpts is a pointer to the structure CLOUDCOMMONOPT with some common
106 * arguments which have been already parsed before
107 */
108static RTEXITCODE listCloudInstances(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
109{
110 static const RTGETOPTDEF s_aOptions[] =
111 {
112 { "--compartment-id", 'c', RTGETOPT_REQ_STRING },
113 { "--state", 's', RTGETOPT_REQ_STRING }
114 };
115 RTGETOPTSTATE GetState;
116 RTGETOPTUNION ValueUnion;
117 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
118 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
119
120 Utf8Str strCompartmentId;
121 com::SafeArray<CloudMachineState_T> machineStates;
122
123 int c;
124 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
125 {
126 switch (c)
127 {
128 case 'c':
129 strCompartmentId = ValueUnion.psz;
130 break;
131
132 case 's':
133 {
134 const char * const pszState = ValueUnion.psz;
135
136 if (RTStrICmp(pszState, "creatingimage") == 0)
137 machineStates.push_back(CloudMachineState_CreatingImage);
138 else if (RTStrICmp(pszState, "paused") == 0) /* XXX */
139 machineStates.push_back(CloudMachineState_Stopped);
140 else if (RTStrICmp(pszState, "provisioning") == 0)
141 machineStates.push_back(CloudMachineState_Provisioning);
142 else if (RTStrICmp(pszState, "running") == 0)
143 machineStates.push_back(CloudMachineState_Running);
144 else if (RTStrICmp(pszState, "starting") == 0)
145 machineStates.push_back(CloudMachineState_Starting);
146 else if (RTStrICmp(pszState, "stopped") == 0)
147 machineStates.push_back(CloudMachineState_Stopped);
148 else if (RTStrICmp(pszState, "stopping") == 0)
149 machineStates.push_back(CloudMachineState_Stopping);
150 else if (RTStrICmp(pszState, "terminated") == 0)
151 machineStates.push_back(CloudMachineState_Terminated);
152 else if (RTStrICmp(pszState, "terminating") == 0)
153 machineStates.push_back(CloudMachineState_Terminating);
154 else
155 return errorArgument("Unknown cloud instance state \"%s\"", pszState);
156 break;
157 }
158
159 case VINF_GETOPT_NOT_OPTION:
160 return errorUnknownSubcommand(ValueUnion.psz);
161
162 default:
163 return errorGetOpt(c, &ValueUnion);
164 }
165 }
166
167 HRESULT hrc = S_OK;
168 ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
169
170 ComPtr<ICloudProviderManager> pCloudProviderManager;
171 CHECK_ERROR2_RET(hrc, pVirtualBox,
172 COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
173 RTEXITCODE_FAILURE);
174
175 ComPtr<ICloudProvider> pCloudProvider;
176 CHECK_ERROR2_RET(hrc, pCloudProviderManager,
177 GetProviderByShortName(Bstr(pCommonOpts->provider.pszProviderName).raw(), pCloudProvider.asOutParam()),
178 RTEXITCODE_FAILURE);
179
180 ComPtr<ICloudProfile> pCloudProfile;
181 CHECK_ERROR2_RET(hrc, pCloudProvider,
182 GetProfileByName(Bstr(pCommonOpts->profile.pszProfileName).raw(), pCloudProfile.asOutParam()),
183 RTEXITCODE_FAILURE);
184
185 if (strCompartmentId.isNotEmpty())
186 {
187 CHECK_ERROR2_RET(hrc, pCloudProfile,
188 SetProperty(Bstr("compartment").raw(), Bstr(strCompartmentId).raw()),
189 RTEXITCODE_FAILURE);
190 }
191 else
192 {
193 RTPrintf("Parameter \'compartment\' is empty or absent.\n"
194 "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
195 Bstr bStrCompartmentId;
196 CHECK_ERROR2_RET(hrc, pCloudProfile,
197 GetProperty(Bstr("compartment").raw(), bStrCompartmentId.asOutParam()),
198 RTEXITCODE_FAILURE);
199 strCompartmentId = bStrCompartmentId;
200 if (strCompartmentId.isNotEmpty())
201 RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
202 else
203 return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
204 }
205
206 Bstr bstrProfileName;
207 pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
208
209 ComObjPtr<ICloudClient> oCloudClient;
210 CHECK_ERROR2_RET(hrc, pCloudProfile,
211 CreateCloudClient(oCloudClient.asOutParam()),
212 RTEXITCODE_FAILURE);
213
214 ComPtr<IStringArray> pVMNamesHolder;
215 ComPtr<IStringArray> pVMIdsHolder;
216 com::SafeArray<BSTR> arrayVMNames;
217 com::SafeArray<BSTR> arrayVMIds;
218 ComPtr<IProgress> pProgress;
219
220 RTPrintf("Reply is in the form \'instance name\' = \'instance id\'\n");
221
222 CHECK_ERROR2_RET(hrc, oCloudClient,
223 ListInstances(ComSafeArrayAsInParam(machineStates),
224 pVMNamesHolder.asOutParam(),
225 pVMIdsHolder.asOutParam(),
226 pProgress.asOutParam()),
227 RTEXITCODE_FAILURE);
228 showProgress(pProgress);
229 CHECK_PROGRESS_ERROR_RET(pProgress, ("Failed to list instances"), RTEXITCODE_FAILURE);
230
231 CHECK_ERROR2_RET(hrc,
232 pVMNamesHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMNames)),
233 RTEXITCODE_FAILURE);
234 CHECK_ERROR2_RET(hrc,
235 pVMIdsHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMIds)),
236 RTEXITCODE_FAILURE);
237
238 RTPrintf("The list of the instances for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
239 bstrProfileName.raw(), strCompartmentId.c_str());
240 size_t cIds = arrayVMIds.size();
241 size_t cNames = arrayVMNames.size();
242 for (size_t k = 0; k < cNames; k++)
243 {
244 Bstr value;
245 if (k < cIds)
246 value = arrayVMIds[k];
247 RTPrintf("\t%ls = %ls\n", arrayVMNames[k], value.raw());
248 }
249
250 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
251}
252
253
254/**
255 * List all available cloud images for the specified cloud provider.
256 *
257 * @returns RTEXITCODE
258 * @param a is the list of passed arguments
259 * @param iFirst is the position of the first unparsed argument in the arguments list
260 * @param pCommonOpts is a pointer to the structure CLOUDCOMMONOPT with some common
261 * arguments which have been already parsed before
262 */
263static RTEXITCODE listCloudImages(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
264{
265 static const RTGETOPTDEF s_aOptions[] =
266 {
267 { "--compartment-id", 'c', RTGETOPT_REQ_STRING },
268 { "--state", 's', RTGETOPT_REQ_STRING }
269 };
270 RTGETOPTSTATE GetState;
271 RTGETOPTUNION ValueUnion;
272 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
273 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
274
275 Utf8Str strCompartmentId;
276 com::SafeArray<CloudImageState_T> imageStates;
277
278 int c;
279 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
280 {
281 switch (c)
282 {
283 case 'c':
284 strCompartmentId = ValueUnion.psz;
285 break;
286
287 case 's':
288 {
289 const char * const pszState = ValueUnion.psz;
290
291 if (RTStrICmp(pszState, "available") == 0)
292 imageStates.push_back(CloudImageState_Available);
293 else if (RTStrICmp(pszState, "deleted") == 0)
294 imageStates.push_back(CloudImageState_Deleted);
295 else if (RTStrICmp(pszState, "disabled") == 0)
296 imageStates.push_back(CloudImageState_Disabled);
297 else if (RTStrICmp(pszState, "exporting") == 0)
298 imageStates.push_back(CloudImageState_Exporting);
299 else if (RTStrICmp(pszState, "importing") == 0)
300 imageStates.push_back(CloudImageState_Importing);
301 else if (RTStrICmp(pszState, "provisioning") == 0)
302 imageStates.push_back(CloudImageState_Provisioning);
303 else
304 return errorArgument("Unknown cloud image state \"%s\"", pszState);
305 break;
306 }
307
308 case VINF_GETOPT_NOT_OPTION:
309 return errorUnknownSubcommand(ValueUnion.psz);
310
311 default:
312 return errorGetOpt(c, &ValueUnion);
313 }
314 }
315
316
317 HRESULT hrc = S_OK;
318 ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
319
320 ComPtr<ICloudProviderManager> pCloudProviderManager;
321 CHECK_ERROR2_RET(hrc, pVirtualBox,
322 COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
323 RTEXITCODE_FAILURE);
324
325 ComPtr<ICloudProvider> pCloudProvider;
326 CHECK_ERROR2_RET(hrc, pCloudProviderManager,
327 GetProviderByShortName(Bstr(pCommonOpts->provider.pszProviderName).raw(), pCloudProvider.asOutParam()),
328 RTEXITCODE_FAILURE);
329
330 ComPtr<ICloudProfile> pCloudProfile;
331 CHECK_ERROR2_RET(hrc, pCloudProvider,
332 GetProfileByName(Bstr(pCommonOpts->profile.pszProfileName).raw(), pCloudProfile.asOutParam()),
333 RTEXITCODE_FAILURE);
334
335 if (strCompartmentId.isNotEmpty())
336 {
337 CHECK_ERROR2_RET(hrc, pCloudProfile,
338 SetProperty(Bstr("compartment").raw(), Bstr(strCompartmentId).raw()),\
339 RTEXITCODE_FAILURE);
340 }
341 else
342 {
343 RTPrintf("Parameter \'compartment\' is empty or absent.\n"
344 "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
345 Bstr bStrCompartmentId;
346 CHECK_ERROR2_RET(hrc, pCloudProfile,
347 GetProperty(Bstr("compartment").raw(), bStrCompartmentId.asOutParam()),
348 RTEXITCODE_FAILURE);
349 strCompartmentId = bStrCompartmentId;
350 if (strCompartmentId.isNotEmpty())
351 RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
352 else
353 return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
354 }
355
356 Bstr bstrProfileName;
357 pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
358
359 ComObjPtr<ICloudClient> oCloudClient;
360 CHECK_ERROR2_RET(hrc, pCloudProfile,
361 CreateCloudClient(oCloudClient.asOutParam()),
362 RTEXITCODE_FAILURE);
363
364 ComPtr<IStringArray> pVMNamesHolder;
365 ComPtr<IStringArray> pVMIdsHolder;
366 com::SafeArray<BSTR> arrayVMNames;
367 com::SafeArray<BSTR> arrayVMIds;
368 ComPtr<IProgress> pProgress;
369
370 RTPrintf("Reply is in the form \'image name\' = \'image id\'\n");
371 CHECK_ERROR2_RET(hrc, oCloudClient,
372 ListImages(ComSafeArrayAsInParam(imageStates),
373 pVMNamesHolder.asOutParam(),
374 pVMIdsHolder.asOutParam(),
375 pProgress.asOutParam()),
376 RTEXITCODE_FAILURE);
377 showProgress(pProgress);
378 CHECK_PROGRESS_ERROR_RET(pProgress, ("Failed to list images"), RTEXITCODE_FAILURE);
379
380 CHECK_ERROR2_RET(hrc,
381 pVMNamesHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMNames)),
382 RTEXITCODE_FAILURE);
383 CHECK_ERROR2_RET(hrc,
384 pVMIdsHolder, COMGETTER(Values)(ComSafeArrayAsOutParam(arrayVMIds)),
385 RTEXITCODE_FAILURE);
386
387 RTPrintf("The list of the images for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
388 bstrProfileName.raw(), strCompartmentId.c_str());
389 size_t cNames = arrayVMNames.size();
390 size_t cIds = arrayVMIds.size();
391 for (size_t k = 0; k < cNames; k++)
392 {
393 Bstr value;
394 if (k < cIds)
395 value = arrayVMIds[k];
396 RTPrintf("\t%ls = %ls\n", arrayVMNames[k], value.raw());
397 }
398
399 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
400}
401
402/**
403 * General function which handles the "list" commands
404 *
405 * @returns RTEXITCODE
406 * @param a is the list of passed arguments
407 * @param iFirst is the position of the first unparsed argument in the arguments list
408 * @param pCommonOpts is a pointer to the structure CLOUDCOMMONOPT with some common
409 * arguments which have been already parsed before
410 */
411static RTEXITCODE handleCloudLists(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
412{
413 if (a->argc < 1)
414 return errorNoSubcommand();
415
416 static const RTGETOPTDEF s_aOptions[] =
417 {
418 { "images", 1000, RTGETOPT_REQ_NOTHING },
419 { "instances", 1001, RTGETOPT_REQ_NOTHING },
420 { "networks", 1002, RTGETOPT_REQ_NOTHING },
421 { "subnets", 1003, RTGETOPT_REQ_NOTHING },
422 { "vcns", 1004, RTGETOPT_REQ_NOTHING },
423 { "objects", 1005, RTGETOPT_REQ_NOTHING }
424 };
425
426 Bstr bstrProvider(pCommonOpts->provider.pszProviderName);
427 Bstr bstrProfile(pCommonOpts->profile.pszProfileName);
428
429 /* check for required options */
430 if (bstrProvider.isEmpty())
431 return errorSyntax(USAGE_S_NEWCMD, "Parameter --provider is required");
432 if (bstrProfile.isEmpty())
433 return errorSyntax(USAGE_S_NEWCMD, "Parameter --profile is required");
434
435 RTGETOPTSTATE GetState;
436 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
437 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
438
439 int c;
440 RTGETOPTUNION ValueUnion;
441 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
442 {
443 switch (c)
444 {
445 case 1000:
446// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_LIST);
447 return listCloudImages(a, GetState.iNext, pCommonOpts);
448 case 1001:
449// setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_LIST);
450 return listCloudInstances(a, GetState.iNext, pCommonOpts);
451 case VINF_GETOPT_NOT_OPTION:
452 return errorUnknownSubcommand(ValueUnion.psz);
453
454 default:
455 return errorGetOpt(c, &ValueUnion);
456 }
457 }
458
459 return errorNoSubcommand();
460}
461
462static RTEXITCODE createCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
463{
464 RT_NOREF(a);
465 RT_NOREF(iFirst);
466 RT_NOREF(pCommonOpts);
467 return RTEXITCODE_SUCCESS;
468}
469
470static RTEXITCODE updateCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
471{
472 RT_NOREF(a);
473 RT_NOREF(iFirst);
474 RT_NOREF(pCommonOpts);
475 return RTEXITCODE_SUCCESS;
476}
477
478static RTEXITCODE showCloudInstanceInfo(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
479{
480 HRESULT hrc = S_OK;
481
482 hrc = checkAndSetCommonOptions(a, pCommonOpts);
483 if (FAILED(hrc))
484 return RTEXITCODE_FAILURE;
485
486 static const RTGETOPTDEF s_aOptions[] =
487 {
488 { "--id", 'i', RTGETOPT_REQ_STRING }
489 };
490 RTGETOPTSTATE GetState;
491 RTGETOPTUNION ValueUnion;
492 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
493 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
494
495 Utf8Str strInstanceId;
496
497 int c;
498 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
499 {
500 switch (c)
501 {
502 case 'i':
503 {
504 if (strInstanceId.isNotEmpty())
505 return errorArgument("Duplicate parameter: --id");
506
507 strInstanceId = ValueUnion.psz;
508 if (strInstanceId.isEmpty())
509 return errorArgument("Empty parameter: --id");
510
511 break;
512 }
513
514 case VINF_GETOPT_NOT_OPTION:
515 return errorUnknownSubcommand(ValueUnion.psz);
516
517 default:
518 return errorGetOpt(c, &ValueUnion);
519 }
520 }
521
522 if (strInstanceId.isEmpty())
523 return errorArgument("Missing parameter: --id");
524
525
526 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
527
528 ComObjPtr<ICloudClient> oCloudClient;
529 CHECK_ERROR2_RET(hrc, pCloudProfile,
530 CreateCloudClient(oCloudClient.asOutParam()),
531 RTEXITCODE_FAILURE);
532 RTPrintf("Getting information about cloud instance with id %s...\n", strInstanceId.c_str());
533 RTPrintf("Reply is in the form \'setting name\' = \'value\'\n");
534
535 ComPtr<IAppliance> pAppliance;
536 CHECK_ERROR2_RET(hrc, a->virtualBox, CreateAppliance(pAppliance.asOutParam()), RTEXITCODE_FAILURE);
537
538 com::SafeIfaceArray<IVirtualSystemDescription> vsdArray;
539 ULONG requestedVSDnums = 1;
540 ULONG newVSDnums = 0;
541 CHECK_ERROR2_RET(hrc, pAppliance, CreateVirtualSystemDescriptions(requestedVSDnums, &newVSDnums), RTEXITCODE_FAILURE);
542 if (requestedVSDnums != newVSDnums)
543 return RTEXITCODE_FAILURE;
544
545 CHECK_ERROR2_RET(hrc, pAppliance, COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(vsdArray)), RTEXITCODE_FAILURE);
546 ComPtr<IVirtualSystemDescription> instanceDescription = vsdArray[0];
547
548 ComPtr<IProgress> progress;
549 CHECK_ERROR2_RET(hrc, oCloudClient,
550 GetInstanceInfo(Bstr(strInstanceId).raw(), instanceDescription, progress.asOutParam()),
551 RTEXITCODE_FAILURE);
552
553 hrc = showProgress(progress);
554 CHECK_PROGRESS_ERROR_RET(progress, ("Getting information about cloud instance failed"), RTEXITCODE_FAILURE);
555
556 RTPrintf("Cloud instance info (provider '%s'):\n",
557 pCommonOpts->provider.pszProviderName);
558
559 struct vsdHReadable {
560 VirtualSystemDescriptionType_T vsdType;
561 Utf8Str strFound;
562 Utf8Str strNotFound;
563 };
564
565 size_t vsdHReadableArraySize = 9;//the number of items in the vsdHReadableArray
566 vsdHReadable vsdHReadableArray[9] = {
567 {VirtualSystemDescriptionType_CloudDomain, "Availability domain = '%ls'\n", "Availability domain wasn't found\n"},
568 {VirtualSystemDescriptionType_Name, "Instance displayed name = '%ls'\n", "Instance displayed name wasn't found\n"},
569 {VirtualSystemDescriptionType_CloudInstanceState, "Instance state = '%ls'\n", "Instance state wasn't found\n"},
570 {VirtualSystemDescriptionType_CloudInstanceId, "Instance Id = '%ls'\n", "Instance Id wasn't found\n"},
571 {VirtualSystemDescriptionType_CloudImageId, "Bootable image Id = '%ls'\n",
572 "Image Id whom the instance is booted up wasn't found\n"},
573 {VirtualSystemDescriptionType_CloudInstanceShape, "Shape of the instance = '%ls'\n",
574 "The shape of the instance wasn't found\n"},
575 {VirtualSystemDescriptionType_OS, "Type of guest OS = '%ls'\n", "Type of guest OS wasn't found.\n"},
576 {VirtualSystemDescriptionType_Memory, "RAM = '%ls MB'\n", "Value for RAM wasn't found\n"},
577 {VirtualSystemDescriptionType_CPU, "CPUs = '%ls'\n", "Numbers of CPUs weren't found\n"}
578 };
579
580 com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
581 com::SafeArray<BSTR> aRefs;
582 com::SafeArray<BSTR> aOvfValues;
583 com::SafeArray<BSTR> aVBoxValues;
584 com::SafeArray<BSTR> aExtraConfigValues;
585
586 for (size_t i=0; i<vsdHReadableArraySize ; ++i)
587 {
588 hrc = instanceDescription->GetDescriptionByType(vsdHReadableArray[i].vsdType,
589 ComSafeArrayAsOutParam(retTypes),
590 ComSafeArrayAsOutParam(aRefs),
591 ComSafeArrayAsOutParam(aOvfValues),
592 ComSafeArrayAsOutParam(aVBoxValues),
593 ComSafeArrayAsOutParam(aExtraConfigValues));
594 if (FAILED(hrc) || aVBoxValues.size() == 0)
595 LogRel((vsdHReadableArray[i].strNotFound.c_str()));
596 else
597 RTPrintf(vsdHReadableArray[i].strFound.c_str(), aVBoxValues[0]);
598
599 retTypes.setNull();
600 aRefs.setNull();
601 aOvfValues.setNull();
602 aVBoxValues.setNull();
603 aExtraConfigValues.setNull();
604 }
605
606 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
607}
608
609static RTEXITCODE startCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
610{
611 HRESULT hrc = S_OK;
612 hrc = checkAndSetCommonOptions(a, pCommonOpts);
613 if (FAILED(hrc))
614 return RTEXITCODE_FAILURE;
615
616 static const RTGETOPTDEF s_aOptions[] =
617 {
618 { "--id", 'i', RTGETOPT_REQ_STRING }
619 };
620 RTGETOPTSTATE GetState;
621 RTGETOPTUNION ValueUnion;
622 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
623 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
624
625 Utf8Str strInstanceId;
626
627 int c;
628 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
629 {
630 switch (c)
631 {
632 case 'i':
633 {
634 if (strInstanceId.isNotEmpty())
635 return errorArgument("Duplicate parameter: --id");
636
637 strInstanceId = ValueUnion.psz;
638 if (strInstanceId.isEmpty())
639 return errorArgument("Empty parameter: --id");
640
641 break;
642 }
643
644 case VINF_GETOPT_NOT_OPTION:
645 return errorUnknownSubcommand(ValueUnion.psz);
646
647 default:
648 return errorGetOpt(c, &ValueUnion);
649 }
650 }
651
652 if (strInstanceId.isEmpty())
653 return errorArgument("Missing parameter: --id");
654
655
656 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
657
658 ComObjPtr<ICloudClient> oCloudClient;
659 CHECK_ERROR2_RET(hrc, pCloudProfile,
660 CreateCloudClient(oCloudClient.asOutParam()),
661 RTEXITCODE_FAILURE);
662 RTPrintf("Starting cloud instance with id %s...\n", strInstanceId.c_str());
663
664 ComPtr<IProgress> progress;
665 CHECK_ERROR2_RET(hrc, oCloudClient,
666 StartInstance(Bstr(strInstanceId).raw(), progress.asOutParam()),
667 RTEXITCODE_FAILURE);
668 hrc = showProgress(progress);
669 CHECK_PROGRESS_ERROR_RET(progress, ("Starting the cloud instance failed"), RTEXITCODE_FAILURE);
670
671 if (SUCCEEDED(hrc))
672 RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was started\n",
673 strInstanceId.c_str(),
674 pCommonOpts->provider.pszProviderName,
675 pCommonOpts->profile.pszProfileName);
676
677 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
678}
679
680static RTEXITCODE pauseCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
681{
682 HRESULT hrc = S_OK;
683 hrc = checkAndSetCommonOptions(a, pCommonOpts);
684
685 if (FAILED(hrc))
686 return RTEXITCODE_FAILURE;
687
688 static const RTGETOPTDEF s_aOptions[] =
689 {
690 { "--id", 'i', RTGETOPT_REQ_STRING }
691 };
692 RTGETOPTSTATE GetState;
693 RTGETOPTUNION ValueUnion;
694 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
695 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
696
697 Utf8Str strInstanceId;
698
699 int c;
700 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
701 {
702 switch (c)
703 {
704 case 'i':
705 {
706 if (strInstanceId.isNotEmpty())
707 return errorArgument("Duplicate parameter: --id");
708
709 strInstanceId = ValueUnion.psz;
710 if (strInstanceId.isEmpty())
711 return errorArgument("Empty parameter: --id");
712
713 break;
714 }
715
716 case VINF_GETOPT_NOT_OPTION:
717 return errorUnknownSubcommand(ValueUnion.psz);
718
719 default:
720 return errorGetOpt(c, &ValueUnion);
721 }
722 }
723
724 if (strInstanceId.isEmpty())
725 return errorArgument("Missing parameter: --id");
726
727
728 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
729
730 ComObjPtr<ICloudClient> oCloudClient;
731 CHECK_ERROR2_RET(hrc, pCloudProfile,
732 CreateCloudClient(oCloudClient.asOutParam()),
733 RTEXITCODE_FAILURE);
734 RTPrintf("Pausing cloud instance with id %s...\n", strInstanceId.c_str());
735
736 ComPtr<IProgress> progress;
737 CHECK_ERROR2_RET(hrc, oCloudClient,
738 PauseInstance(Bstr(strInstanceId).raw(), progress.asOutParam()),
739 RTEXITCODE_FAILURE);
740 hrc = showProgress(progress);
741 CHECK_PROGRESS_ERROR_RET(progress, ("Pause the cloud instance failed"), RTEXITCODE_FAILURE);
742
743 if (SUCCEEDED(hrc))
744 RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was paused\n",
745 strInstanceId.c_str(),
746 pCommonOpts->provider.pszProviderName,
747 pCommonOpts->profile.pszProfileName);
748
749 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
750}
751
752static RTEXITCODE terminateCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
753{
754 HRESULT hrc = S_OK;
755
756 hrc = checkAndSetCommonOptions(a, pCommonOpts);
757 if (FAILED(hrc))
758 return RTEXITCODE_FAILURE;
759
760 static const RTGETOPTDEF s_aOptions[] =
761 {
762 { "--id", 'i', RTGETOPT_REQ_STRING }
763 };
764 RTGETOPTSTATE GetState;
765 RTGETOPTUNION ValueUnion;
766 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
767 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
768
769 Utf8Str strInstanceId;
770
771 int c;
772 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
773 {
774 switch (c)
775 {
776 case 'i':
777 {
778 if (strInstanceId.isNotEmpty())
779 return errorArgument("Duplicate parameter: --id");
780
781 strInstanceId = ValueUnion.psz;
782 if (strInstanceId.isEmpty())
783 return errorArgument("Empty parameter: --id");
784
785 break;
786 }
787
788 case VINF_GETOPT_NOT_OPTION:
789 return errorUnknownSubcommand(ValueUnion.psz);
790
791 default:
792 return errorGetOpt(c, &ValueUnion);
793 }
794 }
795
796 if (strInstanceId.isEmpty())
797 return errorArgument("Missing parameter: --id");
798
799
800 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
801
802 ComObjPtr<ICloudClient> oCloudClient;
803 CHECK_ERROR2_RET(hrc, pCloudProfile,
804 CreateCloudClient(oCloudClient.asOutParam()),
805 RTEXITCODE_FAILURE);
806 RTPrintf("Terminating cloud instance with id %s...\n", strInstanceId.c_str());
807
808 ComPtr<IProgress> progress;
809 CHECK_ERROR2_RET(hrc, oCloudClient,
810 TerminateInstance(Bstr(strInstanceId).raw(), progress.asOutParam()),
811 RTEXITCODE_FAILURE);
812 hrc = showProgress(progress);
813 CHECK_PROGRESS_ERROR_RET(progress, ("Termination the cloud instance failed"), RTEXITCODE_FAILURE);
814
815 if (SUCCEEDED(hrc))
816 RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was terminated\n",
817 strInstanceId.c_str(),
818 pCommonOpts->provider.pszProviderName,
819 pCommonOpts->profile.pszProfileName);
820
821 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
822}
823
824static RTEXITCODE handleCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
825{
826 if (a->argc < 1)
827 return errorNoSubcommand();
828
829 static const RTGETOPTDEF s_aOptions[] =
830 {
831 { "create", 1000, RTGETOPT_REQ_NOTHING },
832 { "start", 1001, RTGETOPT_REQ_NOTHING },
833 { "pause", 1002, RTGETOPT_REQ_NOTHING },
834 { "info", 1003, RTGETOPT_REQ_NOTHING },
835 { "update", 1004, RTGETOPT_REQ_NOTHING },
836 { "terminate", 1005, RTGETOPT_REQ_NOTHING }
837 };
838
839 RTGETOPTSTATE GetState;
840 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
841 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
842
843 int c;
844 RTGETOPTUNION ValueUnion;
845 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
846 {
847 switch (c)
848 {
849 /* Sub-commands: */
850 case 1000:
851// setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_CREATE);
852 return createCloudInstance(a, GetState.iNext, pCommonOpts);
853 case 1001:
854 setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_START);
855 return startCloudInstance(a, GetState.iNext, pCommonOpts);
856 case 1002:
857 setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_PAUSE);
858 return pauseCloudInstance(a, GetState.iNext, pCommonOpts);
859 case 1003:
860 setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_INFO);
861 return showCloudInstanceInfo(a, GetState.iNext, pCommonOpts);
862 case 1004:
863// setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_UPDATE);
864 return updateCloudInstance(a, GetState.iNext, pCommonOpts);
865 case 1005:
866 setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_TERMINATE);
867 return terminateCloudInstance(a, GetState.iNext, pCommonOpts);
868 case VINF_GETOPT_NOT_OPTION:
869 return errorUnknownSubcommand(ValueUnion.psz);
870
871 default:
872 return errorGetOpt(c, &ValueUnion);
873 }
874 }
875
876 return errorNoSubcommand();
877}
878
879
880static RTEXITCODE createCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
881{
882 HRESULT hrc = S_OK;
883 hrc = checkAndSetCommonOptions(a, pCommonOpts);
884 if (FAILED(hrc))
885 return RTEXITCODE_FAILURE;
886
887 static const RTGETOPTDEF s_aOptions[] =
888 {
889 { "--compartment-id", 'c', RTGETOPT_REQ_STRING },
890 { "--instance-id", 'i', RTGETOPT_REQ_STRING },
891 { "--display-name", 'd', RTGETOPT_REQ_STRING }
892 };
893 RTGETOPTSTATE GetState;
894 RTGETOPTUNION ValueUnion;
895 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
896 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
897
898 Utf8Str strCompartmentId;
899 Utf8Str strInstanceId;
900 Utf8Str strDisplayName;
901 com::SafeArray<BSTR> parameters;
902
903 int c;
904 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
905 {
906 switch (c)
907 {
908 case 'c':
909 strCompartmentId=ValueUnion.psz;
910 Bstr(Utf8Str("compartment-id=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
911 break;
912 case 'i':
913 strInstanceId=ValueUnion.psz;
914 Bstr(Utf8Str("instance-id=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
915 break;
916 case 'd':
917 strDisplayName=ValueUnion.psz;
918 Bstr(Utf8Str("display-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
919 break;
920 case VINF_GETOPT_NOT_OPTION:
921 return errorUnknownSubcommand(ValueUnion.psz);
922 default:
923 return errorGetOpt(c, &ValueUnion);
924 }
925 }
926
927 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
928
929 ComObjPtr<ICloudClient> oCloudClient;
930 CHECK_ERROR2_RET(hrc, pCloudProfile,
931 CreateCloudClient(oCloudClient.asOutParam()),
932 RTEXITCODE_FAILURE);
933 RTPrintf("Creating cloud image with name \'%s\' from the instance \'%s\'...\n",
934 strDisplayName.c_str(), strInstanceId.c_str());
935
936 ComPtr<IProgress> progress;
937 CHECK_ERROR2_RET(hrc, oCloudClient,
938 CreateImage(ComSafeArrayAsInParam(parameters), progress.asOutParam()),
939 RTEXITCODE_FAILURE);
940 hrc = showProgress(progress);
941 CHECK_PROGRESS_ERROR_RET(progress, ("Creating cloud image failed"), RTEXITCODE_FAILURE);
942
943 if (SUCCEEDED(hrc))
944 RTPrintf("Cloud image was created successfully\n");
945
946 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
947}
948
949
950static RTEXITCODE exportCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
951{
952 HRESULT hrc = S_OK;
953 hrc = checkAndSetCommonOptions(a, pCommonOpts);
954 if (FAILED(hrc))
955 return RTEXITCODE_FAILURE;
956
957 static const RTGETOPTDEF s_aOptions[] =
958 {
959 { "--bucket-name", 'b', RTGETOPT_REQ_STRING },
960 { "--object-name", 'o', RTGETOPT_REQ_STRING },
961 { "--id", 'i', RTGETOPT_REQ_STRING }
962 };
963 RTGETOPTSTATE GetState;
964 RTGETOPTUNION ValueUnion;
965 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
966 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
967
968 Utf8Str strBucketName;
969 Utf8Str strObjectName;
970 Utf8Str strImageId;
971 com::SafeArray<BSTR> parameters;
972
973 int c;
974 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
975 {
976 switch (c)
977 {
978 case 'b':
979 {
980 if (strBucketName.isNotEmpty())
981 return errorArgument("Duplicate parameter: --bucket-name");
982
983 strBucketName = ValueUnion.psz;
984 if (strBucketName.isEmpty())
985 return errorArgument("Empty parameter: --bucket-name");
986
987 break;
988 }
989
990 case 'o':
991 {
992 if (strObjectName.isNotEmpty())
993 return errorArgument("Duplicate parameter: --object-name");
994
995 strObjectName = ValueUnion.psz;
996 if (strObjectName.isEmpty())
997 return errorArgument("Empty parameter: --object-name");
998
999 break;
1000 }
1001
1002 case 'i':
1003 {
1004 if (strImageId.isNotEmpty())
1005 return errorArgument("Duplicate parameter: --id");
1006
1007 strImageId = ValueUnion.psz;
1008 if (strImageId.isEmpty())
1009 return errorArgument("Empty parameter: --id");
1010
1011 break;
1012 }
1013
1014 case VINF_GETOPT_NOT_OPTION:
1015 return errorUnknownSubcommand(ValueUnion.psz);
1016
1017 default:
1018 return errorGetOpt(c, &ValueUnion);
1019 }
1020 }
1021
1022 if (strBucketName.isNotEmpty())
1023 BstrFmt("bucket-name=%s", strBucketName.c_str()).detachTo(parameters.appendedRaw());
1024 else
1025 return errorArgument("Missing parameter: --bucket-name");
1026
1027 /* API will use display name as object name if not specified */
1028 if (strObjectName.isNotEmpty())
1029 BstrFmt("object-name=%s", strObjectName.c_str()).detachTo(parameters.appendedRaw());
1030
1031 if (strImageId.isNotEmpty())
1032 BstrFmt("image-id=%s", strImageId.c_str()).detachTo(parameters.appendedRaw());
1033 else
1034 return errorArgument("Missing parameter: --id");
1035
1036
1037 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1038
1039 ComObjPtr<ICloudClient> oCloudClient;
1040 CHECK_ERROR2_RET(hrc, pCloudProfile,
1041 CreateCloudClient(oCloudClient.asOutParam()),
1042 RTEXITCODE_FAILURE);
1043
1044 if (strObjectName.isNotEmpty())
1045 RTPrintf("Exporting image \'%s\' to the Cloud with name \'%s\'...\n",
1046 strImageId.c_str(), strObjectName.c_str());
1047 else
1048 RTPrintf("Exporting image \'%s\' to the Cloud with default name\n",
1049 strImageId.c_str());
1050
1051 ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
1052 SafeIfaceArray<IMedium> aImageList;
1053 CHECK_ERROR2_RET(hrc, pVirtualBox,
1054 COMGETTER(HardDisks)(ComSafeArrayAsOutParam(aImageList)),
1055 RTEXITCODE_FAILURE);
1056
1057 ComPtr<IMedium> pImage;
1058 size_t cImages = aImageList.size();
1059 bool fFound = false;
1060 for (size_t i = 0; i < cImages; ++i)
1061 {
1062 pImage = aImageList[i];
1063 Bstr bstrImageId;
1064 hrc = pImage->COMGETTER(Id)(bstrImageId.asOutParam());
1065 if (FAILED(hrc))
1066 continue;
1067
1068 com::Guid imageId(bstrImageId);
1069
1070 if (!imageId.isValid() || imageId.isZero())
1071 continue;
1072
1073 if (!strImageId.compare(imageId.toString()))
1074 {
1075 fFound = true;
1076 RTPrintf("Image %s was found\n", strImageId.c_str());
1077 break;
1078 }
1079 }
1080
1081 if (!fFound)
1082 {
1083 RTPrintf("Process of exporting the image to the Cloud was interrupted. The image wasn't found.\n");
1084 return RTEXITCODE_FAILURE;
1085 }
1086
1087 ComPtr<IProgress> progress;
1088 CHECK_ERROR2_RET(hrc, oCloudClient,
1089 ExportImage(pImage, pVirtualBox, ComSafeArrayAsInParam(parameters), progress.asOutParam()),
1090 RTEXITCODE_FAILURE);
1091 hrc = showProgress(progress);
1092 CHECK_PROGRESS_ERROR_RET(progress, ("Export the image to the Cloud failed"), RTEXITCODE_FAILURE);
1093
1094 if (SUCCEEDED(hrc))
1095 RTPrintf("Export the image to the Cloud was successfull\n");
1096
1097 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1098}
1099
1100static RTEXITCODE importCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1101{
1102 HRESULT hrc = S_OK;
1103 hrc = checkAndSetCommonOptions(a, pCommonOpts);
1104 if (FAILED(hrc))
1105 return RTEXITCODE_FAILURE;
1106
1107 static const RTGETOPTDEF s_aOptions[] =
1108 {
1109 { "--id", 'i', RTGETOPT_REQ_STRING },
1110 { "--bucket-name", 'b', RTGETOPT_REQ_STRING },
1111 { "--object-name", 'o', RTGETOPT_REQ_STRING }
1112 };
1113 RTGETOPTSTATE GetState;
1114 RTGETOPTUNION ValueUnion;
1115 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1116 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1117
1118 Utf8Str strImageId;
1119 Utf8Str strCompartmentId;
1120 Utf8Str strBucketName;
1121 Utf8Str strObjectName;
1122 Utf8Str strDisplayName;
1123 com::SafeArray<BSTR> parameters;
1124
1125 int c;
1126 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1127 {
1128 switch (c)
1129 {
1130 case 'i':
1131 strImageId=ValueUnion.psz;
1132 break;
1133 case 'b':
1134 strBucketName=ValueUnion.psz;
1135 Bstr(Utf8Str("bucket-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1136 break;
1137 case 'o':
1138 strObjectName=ValueUnion.psz;
1139 Bstr(Utf8Str("object-name=").append(ValueUnion.psz)).detachTo(parameters.appendedRaw());
1140 break;
1141 case VINF_GETOPT_NOT_OPTION:
1142 return errorUnknownSubcommand(ValueUnion.psz);
1143 default:
1144 return errorGetOpt(c, &ValueUnion);
1145 }
1146 }
1147
1148 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1149
1150 ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
1151 ComObjPtr<ICloudClient> oCloudClient;
1152 CHECK_ERROR2_RET(hrc, pCloudProfile,
1153 CreateCloudClient(oCloudClient.asOutParam()),
1154 RTEXITCODE_FAILURE);
1155 RTPrintf("Creating an object \'%s\' from the cloud image \'%s\'...\n", strObjectName.c_str(), strImageId.c_str());
1156
1157 ComPtr<IProgress> progress;
1158 CHECK_ERROR2_RET(hrc, oCloudClient,
1159 ImportImage(Bstr(strImageId).raw(), pVirtualBox, ComSafeArrayAsInParam(parameters), progress.asOutParam()),
1160 RTEXITCODE_FAILURE);
1161 hrc = showProgress(progress);
1162 CHECK_PROGRESS_ERROR_RET(progress, ("Cloud image import failed"), RTEXITCODE_FAILURE);
1163
1164 if (SUCCEEDED(hrc))
1165 {
1166 RTPrintf("Cloud image was imported successfully. Find the downloaded object with the name %s "
1167 "in the system temp folder (find the possible environment variables like TEMP, TMP and etc.)\n",
1168 strObjectName.c_str());
1169 }
1170
1171 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1172}
1173
1174static RTEXITCODE showCloudImageInfo(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1175{
1176 HRESULT hrc = S_OK;
1177 hrc = checkAndSetCommonOptions(a, pCommonOpts);
1178 if (FAILED(hrc))
1179 return RTEXITCODE_FAILURE;
1180
1181 static const RTGETOPTDEF s_aOptions[] =
1182 {
1183 { "--id", 'i', RTGETOPT_REQ_STRING }
1184 };
1185 RTGETOPTSTATE GetState;
1186 RTGETOPTUNION ValueUnion;
1187 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1188 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1189
1190 Utf8Str strImageId;
1191
1192 int c;
1193 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1194 {
1195 switch (c)
1196 {
1197 case 'i':
1198 strImageId = ValueUnion.psz;
1199 break;
1200 case VINF_GETOPT_NOT_OPTION:
1201 return errorUnknownSubcommand(ValueUnion.psz);
1202 default:
1203 return errorGetOpt(c, &ValueUnion);
1204 }
1205 }
1206
1207 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1208
1209 ComObjPtr<ICloudClient> oCloudClient;
1210 CHECK_ERROR2_RET(hrc, pCloudProfile,
1211 CreateCloudClient(oCloudClient.asOutParam()),
1212 RTEXITCODE_FAILURE);
1213 RTPrintf("Getting information about the cloud image with id \'%s\'...\n", strImageId.c_str());
1214
1215 ComPtr<IStringArray> infoArray;
1216 com::SafeArray<BSTR> pStrInfoArray;
1217 ComPtr<IProgress> pProgress;
1218
1219 RTPrintf("Reply is in the form \'image property\' = \'value\'\n");
1220 CHECK_ERROR2_RET(hrc, oCloudClient,
1221 GetImageInfo(Bstr(strImageId).raw(),
1222 infoArray.asOutParam(),
1223 pProgress.asOutParam()),
1224 RTEXITCODE_FAILURE);
1225
1226 hrc = showProgress(pProgress);
1227 CHECK_PROGRESS_ERROR_RET(pProgress, ("Getting information about the cloud image failed"), RTEXITCODE_FAILURE);
1228
1229 CHECK_ERROR2_RET(hrc,
1230 infoArray, COMGETTER(Values)(ComSafeArrayAsOutParam(pStrInfoArray)),
1231 RTEXITCODE_FAILURE);
1232
1233 RTPrintf("General information about the image:\n");
1234 size_t cParamNames = pStrInfoArray.size();
1235 for (size_t k = 0; k < cParamNames; k++)
1236 {
1237 Utf8Str data(pStrInfoArray[k]);
1238 RTPrintf("\t%s\n", data.c_str());
1239 }
1240
1241 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1242}
1243
1244static RTEXITCODE updateCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1245{
1246 RT_NOREF(a);
1247 RT_NOREF(iFirst);
1248 RT_NOREF(pCommonOpts);
1249 return RTEXITCODE_SUCCESS;
1250}
1251
1252static RTEXITCODE deleteCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1253{
1254 HRESULT hrc = S_OK;
1255 hrc = checkAndSetCommonOptions(a, pCommonOpts);
1256 if (FAILED(hrc))
1257 return RTEXITCODE_FAILURE;
1258
1259 static const RTGETOPTDEF s_aOptions[] =
1260 {
1261 { "--id", 'i', RTGETOPT_REQ_STRING }
1262 };
1263 RTGETOPTSTATE GetState;
1264 RTGETOPTUNION ValueUnion;
1265 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1266 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1267
1268 Utf8Str strImageId;
1269
1270 int c;
1271 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1272 {
1273 switch (c)
1274 {
1275 case 'i':
1276 {
1277 if (strImageId.isNotEmpty())
1278 return errorArgument("Duplicate parameter: --id");
1279
1280 strImageId = ValueUnion.psz;
1281 if (strImageId.isEmpty())
1282 return errorArgument("Empty parameter: --id");
1283
1284 break;
1285 }
1286
1287 case VINF_GETOPT_NOT_OPTION:
1288 return errorUnknownSubcommand(ValueUnion.psz);
1289
1290 default:
1291 return errorGetOpt(c, &ValueUnion);
1292 }
1293 }
1294
1295 if (strImageId.isEmpty())
1296 return errorArgument("Missing parameter: --id");
1297
1298
1299 ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
1300
1301 ComObjPtr<ICloudClient> oCloudClient;
1302 CHECK_ERROR2_RET(hrc, pCloudProfile,
1303 CreateCloudClient(oCloudClient.asOutParam()),
1304 RTEXITCODE_FAILURE);
1305 RTPrintf("Deleting cloud image with id %s...\n", strImageId.c_str());
1306
1307 ComPtr<IProgress> progress;
1308 CHECK_ERROR2_RET(hrc, oCloudClient,
1309 DeleteImage(Bstr(strImageId).raw(), progress.asOutParam()),
1310 RTEXITCODE_FAILURE);
1311 hrc = showProgress(progress);
1312 CHECK_PROGRESS_ERROR_RET(progress, ("Deleting cloud image failed"), RTEXITCODE_FAILURE);
1313
1314 if (SUCCEEDED(hrc))
1315 RTPrintf("Cloud image with was deleted successfully\n");
1316
1317 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1318}
1319
1320static RTEXITCODE handleCloudImage(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
1321{
1322 if (a->argc < 1)
1323 return errorNoSubcommand();
1324
1325 static const RTGETOPTDEF s_aOptions[] =
1326 {
1327 { "create", 1000, RTGETOPT_REQ_NOTHING },
1328 { "export", 1001, RTGETOPT_REQ_NOTHING },
1329 { "import", 1002, RTGETOPT_REQ_NOTHING },
1330 { "info", 1003, RTGETOPT_REQ_NOTHING },
1331 { "update", 1004, RTGETOPT_REQ_NOTHING },
1332 { "delete", 1005, RTGETOPT_REQ_NOTHING }
1333 };
1334
1335 RTGETOPTSTATE GetState;
1336 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
1337 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1338
1339 int c;
1340 RTGETOPTUNION ValueUnion;
1341 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1342 {
1343 switch (c)
1344 {
1345 /* Sub-commands: */
1346 case 1000:
1347// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_CREATE);
1348 return createCloudImage(a, GetState.iNext, pCommonOpts);
1349 case 1001:
1350// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_EXPORT);
1351 return exportCloudImage(a, GetState.iNext, pCommonOpts);
1352 case 1002:
1353// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_IMPORT);
1354 return importCloudImage(a, GetState.iNext, pCommonOpts);
1355 case 1003:
1356// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_INFO);
1357 return showCloudImageInfo(a, GetState.iNext, pCommonOpts);
1358 case 1004:
1359// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_UPDATE);
1360 return updateCloudImage(a, GetState.iNext, pCommonOpts);
1361 case 1005:
1362// setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_DELETE);
1363 return deleteCloudImage(a, GetState.iNext, pCommonOpts);
1364 case VINF_GETOPT_NOT_OPTION:
1365 return errorUnknownSubcommand(ValueUnion.psz);
1366
1367 default:
1368 return errorGetOpt(c, &ValueUnion);
1369 }
1370 }
1371
1372 return errorNoSubcommand();
1373}
1374
1375RTEXITCODE handleCloud(HandlerArg *a)
1376{
1377 if (a->argc < 1)
1378 return errorNoSubcommand();
1379
1380 static const RTGETOPTDEF s_aOptions[] =
1381 {
1382 /* common options */
1383 { "--provider", 'v', RTGETOPT_REQ_STRING },
1384 { "--profile", 'f', RTGETOPT_REQ_STRING },
1385 { "list", 1000, RTGETOPT_REQ_NOTHING },
1386 { "image", 1001, RTGETOPT_REQ_NOTHING },
1387 { "instance", 1002, RTGETOPT_REQ_NOTHING },
1388 { "network", 1003, RTGETOPT_REQ_NOTHING },
1389 { "volume", 1004, RTGETOPT_REQ_NOTHING },
1390 { "object", 1005, RTGETOPT_REQ_NOTHING }
1391 };
1392
1393 RTGETOPTSTATE GetState;
1394 int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
1395 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1396
1397 CLOUDCOMMONOPT commonOpts = { {NULL, NULL}, {NULL, NULL} };
1398 int c;
1399 RTGETOPTUNION ValueUnion;
1400 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1401 {
1402 switch (c)
1403 {
1404 case 'v': // --provider
1405 commonOpts.provider.pszProviderName = ValueUnion.psz;
1406 break;
1407 case 'f': // --profile
1408 commonOpts.profile.pszProfileName = ValueUnion.psz;
1409 break;
1410 /* Sub-commands: */
1411 case 1000:
1412 return handleCloudLists(a, GetState.iNext, &commonOpts);
1413 case 1001:
1414 return handleCloudImage(a, GetState.iNext, &commonOpts);
1415 case 1002:
1416 return handleCloudInstance(a, GetState.iNext, &commonOpts);
1417 case VINF_GETOPT_NOT_OPTION:
1418 return errorUnknownSubcommand(ValueUnion.psz);
1419
1420 default:
1421 return errorGetOpt(c, &ValueUnion);
1422 }
1423 }
1424
1425 return errorNoSubcommand();
1426}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette