Changeset 78734 in vbox for trunk/src

Timestamp:

May 24, 2019 7:28:12 PM (6 years ago)

Author:

vboxsync

Message:

bugref:9436. Added 3 commands which start/stop/terminate an instance.

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManageCloud.cpp (modified) (13 diffs)
• Main/idl/VirtualBox.xidl (modified) (4 diffs)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageCloud.cpp

@@ -43 +43 @@
 typedef struct
 {
-    const char     *pszProviderName;
-    const char     *pszProfileName;
+    struct {
+        const char     *pszProviderName;
+        ComPtr<ICloudProvider> pCloudProvider;
+    }provider;
+    struct {
+        const char     *pszProfileName;
+        ComPtr<ICloudProfile> pCloudProfile;
+    }profile;
+
 } CLOUDCOMMONOPT;
 typedef CLOUDCOMMONOPT *PCLOUDCOMMONOPT;
+
+static HRESULT checkAndSetCommonOptions(HandlerArg *a, PCLOUDCOMMONOPT pCommonOpts)
+{
+    HRESULT hrc = S_OK;
+
+    Bstr bstrProvider(pCommonOpts->provider.pszProviderName);
+    Bstr bstrProfile(pCommonOpts->profile.pszProfileName);
+
+    /* check for required options */
+    if (bstrProvider.isEmpty())
+    {
+        errorSyntax(USAGE_S_NEWCMD, "Parameter --provider is required");
+        return E_FAIL;
+    }
+    if (bstrProfile.isEmpty())
+    {
+        errorSyntax(USAGE_S_NEWCMD, "Parameter --profile is required");
+        return E_FAIL;
+    }
+
+    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
+    ComPtr<ICloudProviderManager> pCloudProviderManager;
+    CHECK_ERROR2_RET(hrc, pVirtualBox,
+                     COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
+                     RTEXITCODE_FAILURE);
+
+    ComPtr<ICloudProvider> pCloudProvider;
+    CHECK_ERROR2_RET(hrc, pCloudProviderManager,
+                     GetProviderByShortName(bstrProvider.raw(), pCloudProvider.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    pCommonOpts->provider.pCloudProvider = pCloudProvider;
+
+    ComPtr<ICloudProfile> pCloudProfile;
+    CHECK_ERROR2_RET(hrc, pCloudProvider,
+                     GetProfileByName(bstrProfile.raw(), pCloudProfile.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    pCommonOpts->profile.pCloudProfile = pCloudProfile;
+
+    return hrc;
+}
 
 /**
@@ -94 +141 @@
 
     CHECK_ERROR2_RET(hrc, pCloudProviderManager,
-                     GetProviderByShortName(Bstr(pCommonOpts->pszProviderName).raw(), pCloudProvider.asOutParam()),
+                     GetProviderByShortName(Bstr(pCommonOpts->provider.pszProviderName).raw(), pCloudProvider.asOutParam()),
                      RTEXITCODE_FAILURE);
     ComPtr<ICloudProfile> pCloudProfile;
 
     CHECK_ERROR2_RET(hrc, pCloudProvider,
-                     GetProfileByName(Bstr(pCommonOpts->pszProfileName).raw(), pCloudProfile.asOutParam()),
+                     GetProfileByName(Bstr(pCommonOpts->profile.pszProfileName).raw(), pCloudProfile.asOutParam()),
                      RTEXITCODE_FAILURE);
 
@@ -111 +158 @@
     {
         RTPrintf("Parameter \'compartment\' is empty or absent.\n"
-                 "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->pszProfileName);
+                 "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
         Bstr bStrCompartmentId;
         CHECK_ERROR2_RET(hrc, pCloudProfile,
@@ -117 +164 @@
                          RTEXITCODE_FAILURE);
         strCompartmentId = bStrCompartmentId;
-        RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
+        if (strCompartmentId.isNotEmpty())
+            RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
+        else
+            return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
     }
 
@@ -152 +202 @@
             RTEXITCODE_FAILURE);
 
-    RTPrintf("List of available instances for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
+    RTPrintf("List of running instances for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
              bstrProfileName.raw(), strCompartmentId.c_str());
     size_t cIds = arrayVMIds.size();
@@ -185 +235 @@
             RTEXITCODE_FAILURE);
 
+    RTPrintf("List of paused instances for the cloud profile \'%ls\' \nand compartment \'%s\':\n",
+             bstrProfileName.raw(), strCompartmentId.c_str());
     cNames = arrayVMNames.size();
     cIds = arrayVMIds.size();
@@ -243 +295 @@
 
     CHECK_ERROR2_RET(hrc, pCloudProviderManager,
-                     GetProviderByShortName(Bstr(pCommonOpts->pszProviderName).raw(), pCloudProvider.asOutParam()),
+                     GetProviderByShortName(Bstr(pCommonOpts->provider.pszProviderName).raw(), pCloudProvider.asOutParam()),
                      RTEXITCODE_FAILURE);
     ComPtr<ICloudProfile> pCloudProfile;
 
     CHECK_ERROR2_RET(hrc, pCloudProvider,
-                     GetProfileByName(Bstr(pCommonOpts->pszProfileName).raw(), pCloudProfile.asOutParam()),
+                     GetProfileByName(Bstr(pCommonOpts->profile.pszProfileName).raw(), pCloudProfile.asOutParam()),
                      RTEXITCODE_FAILURE);
     if (strCompartmentId.isNotEmpty())
@@ -259 +311 @@
     {
         RTPrintf("Parameter \'compartment\' is empty or absent.\n"
-                 "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->pszProfileName);
+                 "Trying to get the compartment from the passed cloud profile \'%s\'\n", pCommonOpts->profile.pszProfileName);
         Bstr bStrCompartmentId;
         CHECK_ERROR2_RET(hrc, pCloudProfile,
@@ -265 +317 @@
                          RTEXITCODE_FAILURE);
         strCompartmentId = bStrCompartmentId;
-        RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
+        if (strCompartmentId.isNotEmpty())
+            RTPrintf("Found the compartment \'%s\':\n", strCompartmentId.c_str());
+        else
+            return errorSyntax(USAGE_S_NEWCMD, "Parameter --compartment-id is required");
     }
 
@@ -339 +394 @@
     };
 
-
-    Bstr bstrProvider(pCommonOpts->pszProviderName);
-    Bstr bstrProfile(pCommonOpts->pszProfileName);
+    Bstr bstrProvider(pCommonOpts->provider.pszProviderName);
+    Bstr bstrProfile(pCommonOpts->profile.pszProfileName);
 
     /* check for required options */
     if (bstrProvider.isEmpty())
-        return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
+        return errorSyntax(USAGE_S_NEWCMD, "Parameter --provider is required");
     if (bstrProfile.isEmpty())
-        return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
+        return errorSyntax(USAGE_S_NEWCMD, "Parameter --profile is required");
 
     RTGETOPTSTATE GetState;
@@ -360 +414 @@
         {
             case 1000:
-//              setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_CREATE);
+//              setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_LIST);
                 return listCloudImages(a, GetState.iNext, pCommonOpts);
             case 1001:
-//              setCurrentSubcommand(HELP_SCOPE_CLOUDIMAGE_INFO);
+//              setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_LIST);
                 return listCloudInstances(a, GetState.iNext, pCommonOpts);
+            case VINF_GETOPT_NOT_OPTION:
+                return errorUnknownSubcommand(ValueUnion.psz);
+
+            default:
+                return errorGetOpt(c, &ValueUnion);
+        }
+    }
+
+    return errorNoSubcommand();
+}
+
+static RTEXITCODE createCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
+{
+    RT_NOREF(iFirst);
+    RT_NOREF(pCommonOpts);
+    return RTEXITCODE_SUCCESS;
+}
+
+static RTEXITCODE updateCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
+{
+    RT_NOREF(iFirst);
+    RT_NOREF(pCommonOpts);
+    return RTEXITCODE_SUCCESS;
+}
+
+static RTEXITCODE showCloudInstanceInfo(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
+{
+    HRESULT hrc = S_OK;
+
+    hrc = checkAndSetCommonOptions(a, pCommonOpts);
+    if (FAILED(hrc))
+        return RTEXITCODE_FAILURE;
+
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--id", 'i', RTGETOPT_REQ_STRING }
+    };
+    RTGETOPTSTATE GetState;
+    RTGETOPTUNION ValueUnion;
+    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
+    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
+
+    Utf8Str strInstanceId;
+    int c;
+    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
+    {
+        switch (c)
+        {
+            case 'i':
+                    strInstanceId = ValueUnion.psz;
+                break;
+            case VINF_GETOPT_NOT_OPTION:
+                return errorUnknownSubcommand(ValueUnion.psz);
+            default:
+                return errorGetOpt(c, &ValueUnion);
+        }
+    }
+
+    Bstr bstrProfileName;
+    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
+    pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
+
+    ComObjPtr<ICloudClient> oCloudClient;
+    CHECK_ERROR2_RET(hrc, pCloudProfile,
+                     CreateCloudClient(oCloudClient.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    RTPrintf("Getting information about cloud instance with id %s...\n", strInstanceId.c_str());
+    RTPrintf("Reply is in the form \'setting name\' = \'value\'\n");
+
+    ComPtr<IAppliance> pAppliance;
+    CHECK_ERROR2_RET(hrc, a->virtualBox, CreateAppliance(pAppliance.asOutParam()), RTEXITCODE_FAILURE);
+
+    com::SafeIfaceArray<IVirtualSystemDescription> vsdArray;
+    uint32_t requestedVSDnums = 1;
+    uint32_t newVSDnums = 0;
+    CHECK_ERROR2_RET(hrc, pAppliance, CreateVirtualSystemDescriptions(requestedVSDnums, &newVSDnums), RTEXITCODE_FAILURE);
+    if (requestedVSDnums != newVSDnums)
+        return RTEXITCODE_FAILURE;
+
+    CHECK_ERROR2_RET(hrc, pAppliance, COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(vsdArray)), RTEXITCODE_FAILURE);
+    ComPtr<IVirtualSystemDescription> instanceDescription = vsdArray[0];
+    CHECK_ERROR2_RET(hrc, oCloudClient,
+                     GetInstanceInfo(Bstr(strInstanceId.c_str()).raw(), instanceDescription),
+                     RTEXITCODE_FAILURE);
+    RTPrintf("Cloud instance info (provider '%s'):\n",
+             pCommonOpts->provider.pszProviderName);
+
+    struct vsdHReadable {
+        VirtualSystemDescriptionType_T vsdType;
+        Utf8Str strFound;
+        Utf8Str strNotFound;
+    };
+
+    size_t vsdHReadableArraySize = 9;//the number of items in the vsdHReadableArray
+    vsdHReadable vsdHReadableArray[vsdHReadableArraySize] = {
+        {VirtualSystemDescriptionType_CloudDomain, "Availability domain = '%ls'\n", "Availability domain wasn't found\n"},
+        {VirtualSystemDescriptionType_Name, "Instance displayed name = '%ls'\n", "Instance displayed name wasn't found\n"},
+        {VirtualSystemDescriptionType_CloudInstanceState, "Instance state = '%ls'\n", "Instance state wasn't found\n"},
+        {VirtualSystemDescriptionType_CloudInstanceId, "Instance Id = '%ls'\n", "Instance Id wasn't found\n"},
+        {VirtualSystemDescriptionType_CloudImageId, "Bootable image Id = '%ls'\n",
+            "Image Id whom the instance is booted up wasn't found\n"},
+        {VirtualSystemDescriptionType_CloudInstanceShape, "Shape of the instance = '%ls'\n",
+            "The shape of the instance wasn't found\n"},
+        {VirtualSystemDescriptionType_OS, "Type of guest OS = '%ls'\n", "Type of guest OS wasn't found.\n"},
+        {VirtualSystemDescriptionType_Memory, "RAM = '%ls MB'\n", "Value for RAM wasn't found\n"},
+        {VirtualSystemDescriptionType_CPU, "CPUs = '%ls'\n", "Numbers of CPUs weren't found\n"}
+    };
+
+    com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
+    com::SafeArray<BSTR> aRefs;
+    com::SafeArray<BSTR> aOvfValues;
+    com::SafeArray<BSTR> aVBoxValues;
+    com::SafeArray<BSTR> aExtraConfigValues;
+
+    for (size_t i=0; i<vsdHReadableArraySize ; ++i)
+    {
+        hrc = instanceDescription->GetDescriptionByType(vsdHReadableArray[i].vsdType,
+                                                        ComSafeArrayAsOutParam(retTypes),
+                                                        ComSafeArrayAsOutParam(aRefs),
+                                                        ComSafeArrayAsOutParam(aOvfValues),
+                                                        ComSafeArrayAsOutParam(aVBoxValues),
+                                                        ComSafeArrayAsOutParam(aExtraConfigValues));
+        if (FAILED(hrc) || aVBoxValues.size() == 0)
+            LogRel((vsdHReadableArray[i].strNotFound.c_str()));
+        else
+            RTPrintf(vsdHReadableArray[i].strFound.c_str(), aVBoxValues[0]);
+
+        retTypes.setNull();
+        aRefs.setNull();
+        aOvfValues.setNull();
+        aVBoxValues.setNull();
+        aExtraConfigValues.setNull();
+    }
+
+    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
+}
+
+static RTEXITCODE startCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
+{
+    HRESULT hrc = S_OK;
+    hrc = checkAndSetCommonOptions(a, pCommonOpts);
+    if (FAILED(hrc))
+        return RTEXITCODE_FAILURE;
+
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--id", 'i', RTGETOPT_REQ_STRING }
+    };
+    RTGETOPTSTATE GetState;
+    RTGETOPTUNION ValueUnion;
+    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
+    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
+
+    Utf8Str strInstanceId;
+    int c;
+    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
+    {
+        switch (c)
+        {
+            case 'i':
+                    strInstanceId = ValueUnion.psz;
+                break;
+            case VINF_GETOPT_NOT_OPTION:
+                return errorUnknownSubcommand(ValueUnion.psz);
+            default:
+                return errorGetOpt(c, &ValueUnion);
+        }
+    }
+
+    Bstr bstrProfileName;
+    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
+    pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
+
+    ComObjPtr<ICloudClient> oCloudClient;
+    CHECK_ERROR2_RET(hrc, pCloudProfile,
+                     CreateCloudClient(oCloudClient.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    RTPrintf("Starting cloud instance with id %s...\n", strInstanceId.c_str());
+
+    ComPtr<IProgress> progress;
+    CHECK_ERROR2_RET(hrc, oCloudClient,
+                     StartInstance(Bstr(strInstanceId.c_str()).raw(), progress.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    hrc = showProgress(progress);
+    CHECK_PROGRESS_ERROR_RET(progress, ("Starting the cloud instance failed"), RTEXITCODE_FAILURE);
+
+    if (SUCCEEDED(hrc))
+        RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was started\n",
+                 strInstanceId.c_str(),
+                 pCommonOpts->provider.pszProviderName,
+                 pCommonOpts->profile.pszProfileName);
+
+    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
+}
+
+static RTEXITCODE pauseCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
+{
+    HRESULT hrc = S_OK;
+    hrc = checkAndSetCommonOptions(a, pCommonOpts);
+
+    if (FAILED(hrc))
+        return RTEXITCODE_FAILURE;
+
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--id", 'i', RTGETOPT_REQ_STRING }
+    };
+    RTGETOPTSTATE GetState;
+    RTGETOPTUNION ValueUnion;
+    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
+    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
+
+    Utf8Str strInstanceId;
+    int c;
+    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
+    {
+        switch (c)
+        {
+            case 'i':
+                    strInstanceId = ValueUnion.psz;
+                break;
+            case VINF_GETOPT_NOT_OPTION:
+                return errorUnknownSubcommand(ValueUnion.psz);
+            default:
+                return errorGetOpt(c, &ValueUnion);
+        }
+    }
+
+    Bstr bstrProfileName;
+    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
+    pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
+
+    ComObjPtr<ICloudClient> oCloudClient;
+    CHECK_ERROR2_RET(hrc, pCloudProfile,
+                     CreateCloudClient(oCloudClient.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    RTPrintf("Pausing cloud instance with id %s...\n", strInstanceId.c_str());
+
+    ComPtr<IProgress> progress;
+    CHECK_ERROR2_RET(hrc, oCloudClient,
+                     PauseInstance(Bstr(strInstanceId.c_str()).raw(), progress.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    hrc = showProgress(progress);
+    CHECK_PROGRESS_ERROR_RET(progress, ("Pause the cloud instance failed"), RTEXITCODE_FAILURE);
+
+    if (SUCCEEDED(hrc))
+        RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was paused\n",
+                 strInstanceId.c_str(),
+                 pCommonOpts->provider.pszProviderName,
+                 pCommonOpts->profile.pszProfileName);
+
+    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
+}
+
+static RTEXITCODE terminateCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
+{
+    HRESULT hrc = S_OK;
+
+    hrc = checkAndSetCommonOptions(a, pCommonOpts);
+    if (FAILED(hrc))
+        return RTEXITCODE_FAILURE;
+
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "--id", 'i', RTGETOPT_REQ_STRING }
+    };
+    RTGETOPTSTATE GetState;
+    RTGETOPTUNION ValueUnion;
+    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
+    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
+
+    Utf8Str strInstanceId;
+    int c;
+    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
+    {
+        switch (c)
+        {
+            case 'i':
+                    strInstanceId = ValueUnion.psz;
+                break;
+            case VINF_GETOPT_NOT_OPTION:
+                return errorUnknownSubcommand(ValueUnion.psz);
+            default:
+                return errorGetOpt(c, &ValueUnion);
+        }
+    }
+
+    Bstr bstrProfileName;
+    ComPtr<ICloudProfile> pCloudProfile = pCommonOpts->profile.pCloudProfile;
+    pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
+
+    ComObjPtr<ICloudClient> oCloudClient;
+    CHECK_ERROR2_RET(hrc, pCloudProfile,
+                     CreateCloudClient(oCloudClient.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    RTPrintf("Terminating cloud instance with id %s...\n", strInstanceId.c_str());
+
+    ComPtr<IProgress> progress;
+    CHECK_ERROR2_RET(hrc, oCloudClient,
+                     TerminateInstance(Bstr(strInstanceId.c_str()).raw(), progress.asOutParam()),
+                     RTEXITCODE_FAILURE);
+    hrc = showProgress(progress);
+    CHECK_PROGRESS_ERROR_RET(progress, ("Termination the cloud instance failed"), RTEXITCODE_FAILURE);
+
+    if (SUCCEEDED(hrc))
+        RTPrintf("Cloud instance with id %s (provider = '%s', profile = '%s') was terminated\n",
+                 strInstanceId.c_str(),
+                 pCommonOpts->provider.pszProviderName,
+                 pCommonOpts->profile.pszProfileName);
+
+    return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
+}
+
+static RTEXITCODE handleCloudInstance(HandlerArg *a, int iFirst, PCLOUDCOMMONOPT pCommonOpts)
+{
+    if (a->argc < 1)
+        return errorNoSubcommand();
+
+    static const RTGETOPTDEF s_aOptions[] =
+    {
+        { "create",         1000, RTGETOPT_REQ_NOTHING },
+        { "start",          1001, RTGETOPT_REQ_NOTHING },
+        { "pause",          1002, RTGETOPT_REQ_NOTHING },
+        { "info",           1003, RTGETOPT_REQ_NOTHING },
+        { "update",         1004, RTGETOPT_REQ_NOTHING },
+        { "terminate",      1005, RTGETOPT_REQ_NOTHING }
+    };
+
+    RTGETOPTSTATE GetState;
+    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
+    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
+
+    int c;
+    RTGETOPTUNION ValueUnion;
+    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
+    {
+        switch (c)
+        {
+            /* Sub-commands: */
+            case 1000:
+//              setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_CREATE);
+                return createCloudInstance(a, GetState.iNext, pCommonOpts);
+            case 1001:
+                setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_START);
+                return startCloudInstance(a, GetState.iNext, pCommonOpts);
+            case 1002:
+                setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_PAUSE);
+                return pauseCloudInstance(a, GetState.iNext, pCommonOpts);
+            case 1003:
+                setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_INFO);
+                return showCloudInstanceInfo(a, GetState.iNext, pCommonOpts);
+            case 1004:
+//              setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_UPDATE);
+                return updateCloudInstance(a, GetState.iNext, pCommonOpts);
+            case 1005:
+                setCurrentSubcommand(HELP_SCOPE_CLOUDINSTANCE_TERMINATE);
+                return terminateCloudInstance(a, GetState.iNext, pCommonOpts);
             case VINF_GETOPT_NOT_OPTION:
                 return errorUnknownSubcommand(ValueUnion.psz);
@@ -398 +809 @@
     AssertRCReturn(vrc, RTEXITCODE_FAILURE);
 
-    CLOUDCOMMONOPT   CommonOpts = { NULL, NULL };
+    CLOUDCOMMONOPT   commonOpts = { {NULL, NULL}, {NULL, NULL} };
     int c;
     RTGETOPTUNION ValueUnion;
@@ -406 +817 @@
         {
             case 'v':   // --provider
-                CommonOpts.pszProviderName = ValueUnion.psz;
+                commonOpts.provider.pszProviderName = ValueUnion.psz;
                 break;
             case 'f':   // --profile
-                CommonOpts.pszProfileName = ValueUnion.psz;
+                commonOpts.profile.pszProfileName = ValueUnion.psz;
                 break;
             /* Sub-commands: */
             case 1000:
-//              setCurrentSubcommand(HELP_SCOPE_CLOUDLIST);
-                return handleCloudLists(a, GetState.iNext, &CommonOpts);
+                return handleCloudLists(a, GetState.iNext, &commonOpts);
+            case 1002:
+                return handleCloudInstance(a, GetState.iNext, &commonOpts);
             case VINF_GETOPT_NOT_OPTION:
                 return errorUnknownSubcommand(ValueUnion.psz);

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -3650 +3650 @@
   <enum
     name="VirtualSystemDescriptionType"
-    uuid="48875667-19f6-4329-a208-735adf9a47ee"
+    uuid="9eed2b05-fe6c-46a7-ad75-b039ac2919f9"
     >
     <desc>Used with <link to="IVirtualSystemDescription" /> to describe the type of
@@ -3707 +3707 @@
     <const name="CloudInstanceId" value="37" />
     <const name="CloudImageId" value="38" />
+    <const name="CloudInstanceState" value="39" />
+    <const name="CloudImageState" value="40" />
   </enum>
 
@@ -25785 +25787 @@
     name="ICloudClient" extends="$unknown"
     uuid="6d4dfab6-7718-11e9-9775-1f99c815d0b3"
-    wsmap="managed" reservedMethods="16" reservedAttributes="8"
+    wsmap="managed" reservedMethods="13" reservedAttributes="8"
     >
 
@@ -25934 +25936 @@
       </param>
       <param name="progress" type="IProgress" dir="in">
+        <desc>Progress object to track the operation completion.</desc>
+      </param>
+    </method>
+
+    <method name="startInstance">
+      <desc>
+        Start an existing instance with passed id.
+      </desc>
+      <param name="uid" type="wstring" dir="in">
+        <desc>the UUID of instance in the Cloud.</desc>
+      </param>
+      <param name="progress" type="IProgress" dir="return">
+        <desc>Progress object to track the operation completion.</desc>
+      </param>
+    </method>
+
+    <method name="pauseInstance">
+      <desc>
+        Pause an existing instance with passed id.
+      </desc>
+      <param name="uid" type="wstring" dir="in">
+        <desc>the UUID of instance in the Cloud.</desc>
+      </param>
+      <param name="progress" type="IProgress" dir="return">
+        <desc>Progress object to track the operation completion.</desc>
+      </param>
+    </method>
+
+    <method name="terminateInstance">
+      <desc>
+        Terminate an existing instance with passed id.
+      </desc>
+      <param name="uid" type="wstring" dir="in">
+        <desc>the UUID of instance in the Cloud.</desc>
+      </param>
+      <param name="progress" type="IProgress" dir="return">
         <desc>Progress object to track the operation completion.</desc>
       </param>