tstAPI.cpp revision d99197f8edcfa672509d9418fa6441c0c66af33c
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/** @file
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * tstAPI - test program for our COM/XPCOM interface
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/*
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Copyright (C) 2006-2009 Sun Microsystems, Inc.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * available from http://www.virtualbox.org. This file is free software;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * you can redistribute it and/or modify it under the terms of the GNU
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * General Public License (GPL) as published by the Free Software
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * additional information or have any questions.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <stdio.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <stdlib.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#include <VBox/com/com.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <VBox/com/string.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <VBox/com/array.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <VBox/com/Guid.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <VBox/com/ErrorInfo.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <VBox/com/errorprint.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <VBox/com/EventQueue.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#include <VBox/com/VirtualBox.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncusing namespace com;
28626a5957b49791b505bf66131448a847043763vboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync#define LOG_ENABLED
ae6cc8f82ba26e3940022ea7d26078bec3d2a05fvboxsync#define LOG_GROUP LOG_GROUP_MAIN
2f827df539da232220444c27f2b207a707a045b0vboxsync#define LOG_INSTANCE NULL
2f827df539da232220444c27f2b207a707a045b0vboxsync#include <VBox/log.h>
2f827df539da232220444c27f2b207a707a045b0vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <iprt/initterm.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <iprt/path.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <iprt/param.h>
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync#include <iprt/stream.h>
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync#include <iprt/thread.h>
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync// forward declarations
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync///////////////////////////////////////////////////////////////////////////////
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsyncstatic Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync ComPtr<IUnknown> aObject);
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsyncstatic void queryMetrics (ComPtr<IVirtualBox> aVirtualBox,
2f827df539da232220444c27f2b207a707a045b0vboxsync ComPtr<IPerformanceCollector> collector,
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync ComSafeArrayIn (IUnknown *, objects));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsyncstatic void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync ComSafeArrayIn(IPerformanceMetric*, aMetrics));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync// funcs
2f827df539da232220444c27f2b207a707a045b0vboxsync///////////////////////////////////////////////////////////////////////////////
2f827df539da232220444c27f2b207a707a045b0vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncHRESULT readAndChangeMachineSettings (IMachine *machine, IMachine *readonlyMachine = 0)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync HRESULT rc = S_OK;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Bstr name;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Getting machine name...\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CHECK_ERROR_RET (machine, COMGETTER(Name) (name.asOutParam()), rc);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Name: {%ls}\n", name.raw());
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf("Getting machine GUID...\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Bstr guid;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CHECK_ERROR (machine, COMGETTER(Id) (guid.asOutParam()));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (SUCCEEDED(rc) && !guid.isEmpty()) {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Guid::toString(): {%s}\n", Utf8Str(guid).c_str());
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync } else {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("WARNING: there's no GUID!");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ULONG memorySize;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Getting memory size...\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CHECK_ERROR_RET (machine, COMGETTER(MemorySize) (&memorySize), rc);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Memory size: %d\n", memorySize);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync MachineState_T machineState;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Getting machine state...\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CHECK_ERROR_RET (machine, COMGETTER(State) (&machineState), rc);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Machine state: %d\n", machineState);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync BOOL modified;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Are any settings modified?...\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CHECK_ERROR (machine, COMGETTER(SettingsModified) (&modified));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (SUCCEEDED(rc))
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("%s\n", modified ? "yes" : "no");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ULONG memorySizeBig = memorySize * 10;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf("Changing memory size to %d...\n", memorySizeBig);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CHECK_ERROR (machine, COMSETTER(MemorySize) (memorySizeBig));
7f9e93577d96c7f2a6977229c1baab57d5ec94e4vboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync if (SUCCEEDED(rc))
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("Are any settings modified now?...\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR_RET (machine, COMGETTER(SettingsModified) (&modified), rc);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("%s\n", modified ? "yes" : "no");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ASSERT_RET (modified, 0);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ULONG memorySizeGot;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Getting memory size again...\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR_RET (machine, COMGETTER(MemorySize) (&memorySizeGot), rc);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Memory size: %d\n", memorySizeGot);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ASSERT_RET (memorySizeGot == memorySizeBig, 0);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync if (readonlyMachine)
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync {
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync RTPrintf ("Getting memory size of the counterpart readonly machine...\n");
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync ULONG memorySizeRO;
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync RTPrintf ("Memory size: %d\n", memorySizeRO);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync ASSERT_RET (memorySizeRO != memorySizeGot, 0);
5b0adfbdd9550a026f5d6209743504562f791f97vboxsync }
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync
f2e1f71feb5d4ec79d46defcd71de0763234b1e2vboxsync RTPrintf ("Discarding recent changes...\n");
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync CHECK_ERROR_RET (machine, DiscardSettings(), rc);
f2e1f71feb5d4ec79d46defcd71de0763234b1e2vboxsync RTPrintf ("Are any settings modified after discarding?...\n");
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync CHECK_ERROR_RET (machine, COMGETTER(SettingsModified) (&modified), rc);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync RTPrintf ("%s\n", modified ? "yes" : "no");
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync ASSERT_RET (!modified, 0);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync RTPrintf ("Getting memory size once more...\n");
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync CHECK_ERROR_RET (machine, COMGETTER(MemorySize) (&memorySizeGot), rc);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync RTPrintf ("Memory size: %d\n", memorySizeGot);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ASSERT_RET (memorySizeGot == memorySize, 0);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync memorySize = memorySize > 128 ? memorySize / 2 : memorySize * 2;
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync RTPrintf("Changing memory size to %d...\n", memorySize);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR_RET (machine, COMSETTER(MemorySize) (memorySize), rc);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Bstr desc;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Getting description...\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR_RET (machine, COMGETTER(Description) (desc.asOutParam()), rc);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Description is: \"%ls\"\n", desc.raw());
2f827df539da232220444c27f2b207a707a045b0vboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync desc = L"This is an exemplary description (changed).";
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Setting description to \"%ls\"...\n", desc.raw());
2f827df539da232220444c27f2b207a707a045b0vboxsync CHECK_ERROR_RET (machine, COMSETTER(Description) (desc), rc);
2f827df539da232220444c27f2b207a707a045b0vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Saving machine settings...\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR (machine, SaveSettings());
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync if (SUCCEEDED(rc))
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Are any settings modified after saving?...\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR_RET (machine, COMGETTER(SettingsModified) (&modified), rc);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("%s\n", modified ? "yes" : "no");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ASSERT_RET (!modified, 0);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync if (readonlyMachine) {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Getting memory size of the counterpart readonly machine...\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ULONG memorySizeRO;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Memory size: %d\n", memorySizeRO);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ASSERT_RET (memorySizeRO == memorySize, 0);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync Bstr extraDataKey = L"Blafasel";
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Bstr extraData;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Getting extra data key {%ls}...\n", extraDataKey.raw());
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR_RET (machine, GetExtraData (extraDataKey, extraData.asOutParam()), rc);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync if (!extraData.isEmpty()) {
2f827df539da232220444c27f2b207a707a045b0vboxsync RTPrintf ("Extra data value: {%ls}\n", extraData.raw());
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync } else {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("No extra data exists\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync if (extraData.isEmpty())
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync extraData = L"Das ist die Berliner Luft, Luft, Luft...";
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync else
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync extraData.setNull();
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf (
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync "Setting extra data key {%ls} to {%ls}...\n",
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync extraDataKey.raw(), extraData.raw()
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync );
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync CHECK_ERROR (machine, SetExtraData (extraDataKey, extraData));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
523f2a6676210ab8601d3fdb2fdabe7dcdea7d4cvboxsync if (SUCCEEDED(rc)) {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("Getting extra data key {%ls} again...\n", extraDataKey.raw());
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync CHECK_ERROR_RET (machine, GetExtraData (extraDataKey, extraData.asOutParam()), rc);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (!extraData.isEmpty()) {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("Extra data value: {%ls}\n", extraData.raw());
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync } else {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("No extra data exists\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync return rc;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync// main
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync///////////////////////////////////////////////////////////////////////////////
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsyncint main(int argc, char *argv[])
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync{
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /*
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Initialize the VBox runtime without loading
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * the support driver.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTR3Init();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
515bedd29819574258817b27cd304587d407810fvboxsync HRESULT rc;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync char homeDir [RTPATH_MAX];
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync GetVBoxUserHomeDirectory (homeDir, sizeof (homeDir));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("VirtualBox Home Directory = '%s'\n", homeDir);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
2f827df539da232220444c27f2b207a707a045b0vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf ("Initializing COM...\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync rc = com::Initialize();
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync if (FAILED(rc))
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf("ERROR: failed to initialize COM!\n");
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync return rc;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync do
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync // scopes all the stuff till shutdown
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ////////////////////////////////////////////////////////////////////////////
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ComPtr<IVirtualBox> virtualBox;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ComPtr<ISession> session;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#if 0
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync // Utf8Str test
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ////////////////////////////////////////////////////////////////////////////
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Utf8Str nullUtf8Str;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("nullUtf8Str='%s'\n", nullUtf8Str.raw());
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Utf8Str simpleUtf8Str = "simpleUtf8Str";
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("simpleUtf8Str='%s'\n", simpleUtf8Str.raw());
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Utf8Str utf8StrFmt = Utf8StrFmt ("[0=%d]%s[1=%d]",
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync 0, "utf8StrFmt", 1);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("utf8StrFmt='%s'\n", utf8StrFmt.raw());
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#endif
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("Creating VirtualBox object...\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync rc = virtualBox.createLocalObject (CLSID_VirtualBox);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (FAILED(rc))
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf("ERROR: failed to create the VirtualBox object!\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync else
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync rc = session.createInprocObject(CLSID_Session);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (FAILED(rc))
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf("ERROR: failed to create a session object!\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (FAILED (rc))
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync com::ErrorInfo info;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (!info.isFullAvailable() && !info.isBasicAvailable())
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync com::GluePrintRCMessage(rc);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync else
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync com::GluePrintErrorInfo(info);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#if 0
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync // Testing VirtualBox::COMGETTER(ProgressOperations).
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync // This is designed to be tested while running
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // "./VBoxManage clonehd src.vdi clone.vdi" in parallel.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync // It will then display the progress every 2 seconds.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ////////////////////////////////////////////////////////////////////////////
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("Testing VirtualBox::COMGETTER(ProgressOperations)...\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync for (;;) {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync com::SafeIfaceArray<IProgress> operations;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync CHECK_ERROR_BREAK (virtualBox,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync COMGETTER(ProgressOperations)(ComSafeArrayAsOutParam(operations)));
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("operations: %d\n", operations.size());
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (operations.size() == 0)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break; // No more operations left.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync for (size_t i = 0; i < operations.size(); ++i) {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync PRInt32 percent;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync operations[i]->COMGETTER(Percent)(&percent);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("operations[%u]: %ld\n", (unsigned)i, (long)percent);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTThreadSleep (2000); // msec
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#endif
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync#if 0
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // IUnknown identity test
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ////////////////////////////////////////////////////////////////////////////
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComPtr<IVirtualBox> virtualBox2;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("Creating one more VirtualBox object...\n");
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync CHECK_RC (virtualBox2.createLocalObject (CLSID_VirtualBox));
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (FAILED (rc))
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync CHECK_ERROR_NOCALL();
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("IVirtualBox(virtualBox)=%p IVirtualBox(virtualBox2)=%p\n",
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync (IVirtualBox *) virtualBox, (IVirtualBox *) virtualBox2);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Assert ((IVirtualBox *) virtualBox == (IVirtualBox *) virtualBox2);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ComPtr<IUnknown> unk (virtualBox);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ComPtr<IUnknown> unk2;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync unk2 = virtualBox2;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("IUnknown(virtualBox)=%p IUnknown(virtualBox2)=%p\n",
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync (IUnknown *) unk, (IUnknown *) unk2);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Assert ((IUnknown *) unk == (IUnknown *) unk2);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ComPtr<IVirtualBox> vb = unk;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync ComPtr<IVirtualBox> vb2 = unk;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTPrintf ("IVirtualBox(IUnknown(virtualBox))=%p IVirtualBox(IUnknown(virtualBox2))=%p\n",
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync (IVirtualBox *) vb, (IVirtualBox *) vb2);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Assert ((IVirtualBox *) vb == (IVirtualBox *) vb2);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComPtr<IHost> host;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host)(host.asOutParam()));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf (" IHost(host)=%p\n", (IHost *) host);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComPtr<IUnknown> unk = host;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf (" IUnknown(host)=%p\n", (IUnknown *) unk);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComPtr<IHost> host_copy = unk;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf (" IHost(host_copy)=%p\n", (IHost *) host_copy);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComPtr<IUnknown> unk_copy = host_copy;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf (" IUnknown(host_copy)=%p\n", (IUnknown *) unk_copy);
2f827df539da232220444c27f2b207a707a045b0vboxsync Assert ((IUnknown *) unk == (IUnknown *) unk_copy);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /* query IUnknown on IUnknown */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync ComPtr<IUnknown> unk_copy_copy;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync unk_copy.queryInterfaceTo(unk_copy_copy.asOutParam());
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf (" IUnknown(unk_copy)=%p\n", (IUnknown *) unk_copy_copy);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Assert ((IUnknown *) unk_copy == (IUnknown *) unk_copy_copy);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync /* query IUnknown on IUnknown in the opposite direction */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync unk_copy_copy.queryInterfaceTo(unk_copy.asOutParam());
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync RTPrintf (" IUnknown(unk_copy_copy)=%p\n", (IUnknown *) unk_copy);
2f827df539da232220444c27f2b207a707a045b0vboxsync Assert ((IUnknown *) unk_copy == (IUnknown *) unk_copy_copy);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync /* query IUnknown again after releasing all previous IUnknown instances
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * but keeping IHost -- it should remain the same (Identity Rule) */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync IUnknown *oldUnk = unk;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync unk.setNull();
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync unk_copy.setNull();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync unk_copy_copy.setNull();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync unk = host;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf (" IUnknown(host)=%p\n", (IUnknown *) unk);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync Assert (oldUnk == (IUnknown *) unk);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync// RTPrintf ("Will be now released (press Enter)...");
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync// getchar();
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync#endif
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync // create the event queue
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync // (here it is necessary only to process remaining XPCOM/IPC events
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync // after the session is closed)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync EventQueue eventQ;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync#if 0
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync // the simplest COM API test
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync ////////////////////////////////////////////////////////////////////////////
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync Bstr version;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync CHECK_ERROR_BREAK (virtualBox, COMGETTER(Version) (version.asOutParam()));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("VirtualBox version = %ls\n", version.raw());
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync#endif
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync#if 0
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync // Array test
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync ////////////////////////////////////////////////////////////////////////////
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("Calling IVirtualBox::Machines...\n");
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync com::SafeIfaceArray<IMachine> machines;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync CHECK_ERROR_BREAK (virtualBox,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync COMGETTER(Machines) (ComSafeArrayAsOutParam (machines)));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("%u machines registered (machines.isNull()=%d).\n",
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync machines.size(), machines.isNull());
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync for (size_t i = 0; i < machines.size(); ++ i)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync Bstr name;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync CHECK_ERROR_BREAK (machines [i], COMGETTER(Name) (name.asOutParam()));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("machines[%u]='%s'\n", i, Utf8Str (name).raw());
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync#if 0
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("Testing [out] arrays...\n");
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync com::SafeGUIDArray uuids;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync CHECK_ERROR_BREAK (virtualBox,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync COMGETTER(Uuids) (ComSafeArrayAsOutParam (uuids)));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync for (size_t i = 0; i < uuids.size(); ++ i)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("uuids[%u]=%RTuuid\n", i, &uuids [i]);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("Testing [in] arrays...\n");
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync com::SafeGUIDArray uuids (5);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync for (size_t i = 0; i < uuids.size(); ++ i)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync Guid id;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync id.create();
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync uuids [i] = id;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf ("uuids[%u]=%RTuuid\n", i, &uuids [i]);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync CHECK_ERROR_BREAK (virtualBox,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync SetUuids (ComSafeArrayAsInParam (uuids)));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync#endif
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync#endif
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#if 0
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // some outdated stuff
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ////////////////////////////////////////////////////////////////////////////
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf("Getting IHost interface...\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync IHost *host;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = virtualBox->GetHost(&host);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (SUCCEEDED(rc))
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync IHostDVDDriveCollection *dvdColl;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = host->GetHostDVDDrives(&dvdColl);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (SUCCEEDED(rc))
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync IHostDVDDrive *dvdDrive = NULL;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync dvdColl->GetNextHostDVDDrive(dvdDrive, &dvdDrive);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync while (dvdDrive)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync BSTR driveName;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync char *driveNameUtf8;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync dvdDrive->GetDriveName(&driveName);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf("Host DVD drive name: %s\n", driveNameUtf8);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTStrFree(driveNameUtf8);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync SysFreeString(driveName);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync IHostDVDDrive *dvdDriveTemp = dvdDrive;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync dvdColl->GetNextHostDVDDrive(dvdDriveTemp, &dvdDrive);
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync dvdDriveTemp->Release();
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync dvdColl->Release();
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync } else
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf("Could not get host DVD drive collection\n");
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync IHostFloppyDriveCollection *floppyColl;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync rc = host->GetHostFloppyDrives(&floppyColl);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (SUCCEEDED(rc))
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync IHostFloppyDrive *floppyDrive = NULL;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync floppyColl->GetNextHostFloppyDrive(floppyDrive, &floppyDrive);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync while (floppyDrive)
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync BSTR driveName;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync char *driveNameUtf8;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync floppyDrive->GetDriveName(&driveName);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf("Host floppy drive name: %s\n", driveNameUtf8);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTStrFree(driveNameUtf8);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync SysFreeString(driveName);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync IHostFloppyDrive *floppyDriveTemp = floppyDrive;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync floppyColl->GetNextHostFloppyDrive(floppyDriveTemp, &floppyDrive);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync floppyDriveTemp->Release();
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync floppyColl->Release();
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync } else
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTPrintf("Could not get host floppy drive collection\n");
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync host->Release();
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync } else
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf("Call failed\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("\n");
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#endif
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#if 0
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // IVirtualBoxErrorInfo test
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ////////////////////////////////////////////////////////////////////////////
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // RPC calls
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // call a method that will definitely fail
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Guid uuid;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ComPtr<IHardDisk> hardDisk;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("virtualBox->GetHardDisk(null-uuid)=%08X\n", rc);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// com::ErrorInfo info (virtualBox);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// PRINT_ERROR_INFO (info);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // call a method that will definitely succeed
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Bstr version;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = virtualBox->COMGETTER(Version) (version.asOutParam());
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("virtualBox->COMGETTER(Version)=%08X\n", rc);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync com::ErrorInfo info (virtualBox);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync PRINT_ERROR_INFO (info);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // Local calls
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // call a method that will definitely fail
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync ComPtr<IMachine> machine;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = session->COMGETTER(Machine)(machine.asOutParam());
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("session->COMGETTER(Machine)=%08X\n", rc);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// com::ErrorInfo info (virtualBox);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// PRINT_ERROR_INFO (info);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync // call a method that will definitely succeed
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync SessionState_T state;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = session->COMGETTER(State) (&state);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync RTPrintf ("session->COMGETTER(State)=%08X\n", rc);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
{
com::ErrorInfo info (virtualBox);
PRINT_ERROR_INFO (info);
}
}
#endif
#if 0
// register the existing hard disk image
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IHardDisk> hd;
Bstr src = L"E:\\develop\\innotek\\images\\NewHardDisk.vdi";
RTPrintf ("Opening the existing hard disk '%ls'...\n", src.raw());
CHECK_ERROR_BREAK (virtualBox, OpenHardDisk (src, AccessMode_ReadWrite, hd.asOutParam()));
RTPrintf ("Enter to continue...\n");
getchar();
RTPrintf ("Registering the existing hard disk '%ls'...\n", src.raw());
CHECK_ERROR_BREAK (virtualBox, RegisterHardDisk (hd));
RTPrintf ("Enter to continue...\n");
getchar();
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// find and unregister the existing hard disk image
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IVirtualDiskImage> vdi;
Bstr src = L"CreatorTest.vdi";
RTPrintf ("Unregistering the hard disk '%ls'...\n", src.raw());
CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
ComPtr<IHardDisk> hd = vdi;
Guid id;
CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
CHECK_ERROR_BREAK (virtualBox, UnregisterHardDisk (id, hd.asOutParam()));
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// clone the registered hard disk
///////////////////////////////////////////////////////////////////////////
do
{
#if defined RT_OS_LINUX
Bstr src = L"/mnt/hugaida/common/develop/innotek/images/freedos-linux.vdi";
#else
Bstr src = L"E:/develop/innotek/images/freedos.vdi";
#endif
Bstr dst = L"./clone.vdi";
RTPrintf ("Cloning '%ls' to '%ls'...\n", src.raw(), dst.raw());
ComPtr<IVirtualDiskImage> vdi;
CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
ComPtr<IHardDisk> hd = vdi;
ComPtr<IProgress> progress;
CHECK_ERROR_BREAK (hd, CloneToImage (dst, vdi.asOutParam(), progress.asOutParam()));
RTPrintf ("Waiting for completion...\n");
CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
ProgressErrorInfo ei (progress);
if (FAILED (ei.getResultCode()))
{
PRINT_ERROR_INFO (ei);
}
else
{
vdi->COMGETTER(FilePath) (dst.asOutParam());
RTPrintf ("Actual clone path is '%ls'\n", dst.raw());
}
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// find a registered hard disk by location and get properties
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IHardDisk> hd;
static const wchar_t *Names[] =
{
#ifndef RT_OS_LINUX
L"freedos.vdi",
L"MS-DOS.vmdk",
L"iscsi",
L"some/path/and/disk.vdi",
#else
L"xp.vdi",
L"Xp.vDI",
#endif
};
RTPrintf ("\n");
for (size_t i = 0; i < RT_ELEMENTS (Names); ++ i)
{
Bstr src = Names [i];
RTPrintf ("Searching for hard disk '%ls'...\n", src.raw());
rc = virtualBox->FindHardDisk (src, hd.asOutParam());
if (SUCCEEDED(rc))
{
Guid id;
Bstr location;
CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
CHECK_ERROR_BREAK (hd, COMGETTER(Location) (location.asOutParam()));
RTPrintf ("Found, UUID={%RTuuid}, location='%ls'.\n",
id.raw(), location.raw());
com::SafeArray<BSTR> names;
com::SafeArray<BSTR> values;
CHECK_ERROR_BREAK (hd, GetProperties (NULL,
ComSafeArrayAsOutParam (names),
ComSafeArrayAsOutParam (values)));
RTPrintf ("Properties:\n");
for (size_t i = 0; i < names.size(); ++ i)
RTPrintf (" %ls = %ls\n", names [i], values [i]);
if (names.size() == 0)
RTPrintf (" <none>\n");
#if 0
Bstr name ("TargetAddress");
Bstr value = Utf8StrFmt ("lalala (%llu)", RTTimeMilliTS());
RTPrintf ("Settings property %ls to %ls...\n", name.raw(), value.raw());
CHECK_ERROR (hd, SetProperty (name, value));
#endif
}
else
{
com::ErrorInfo info (virtualBox);
PRINT_ERROR_INFO (info);
}
RTPrintf ("\n");
}
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// access the machine in read-only mode
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IMachine> machine;
Bstr name = argc > 1 ? argv [1] : "dos";
RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
RTPrintf ("Accessing the machine in read-only mode:\n");
readAndChangeMachineSettings (machine);
#if 0
if (argc != 2)
{
RTPrintf ("Error: a string has to be supplied!\n");
}
else
{
Bstr secureLabel = argv[1];
machine->COMSETTER(ExtraData)(L"VBoxSDL/SecureLabel", secureLabel);
}
#endif
}
while (0);
RTPrintf ("\n");
#endif
#if 0
// create a new machine (w/o registering it)
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IMachine> machine;
#if defined (RT_OS_LINUX)
Bstr baseDir = L"/tmp/vbox";
#else
Bstr baseDir = L"C:\\vbox";
#endif
Bstr name = L"machina";
RTPrintf ("Creating a new machine object (base dir '%ls', name '%ls')...\n",
baseDir.raw(), name.raw());
CHECK_ERROR_BREAK (virtualBox, CreateMachine (baseDir, name,
machine.asOutParam()));
RTPrintf ("Getting name...\n");
CHECK_ERROR_BREAK (machine, COMGETTER(Name) (name.asOutParam()));
RTPrintf ("Name: {%ls}\n", name.raw());
BOOL modified = FALSE;
RTPrintf ("Are any settings modified?...\n");
CHECK_ERROR_BREAK (machine, COMGETTER(SettingsModified) (&modified));
RTPrintf ("%s\n", modified ? "yes" : "no");
ASSERT_BREAK (modified == TRUE);
name = L"Kakaya prekrasnaya virtual'naya mashina!";
RTPrintf ("Setting new name ({%ls})...\n", name.raw());
CHECK_ERROR_BREAK (machine, COMSETTER(Name) (name));
RTPrintf ("Setting memory size to 111...\n");
CHECK_ERROR_BREAK (machine, COMSETTER(MemorySize) (111));
Bstr desc = L"This is an exemplary description.";
RTPrintf ("Setting description to \"%ls\"...\n", desc.raw());
CHECK_ERROR_BREAK (machine, COMSETTER(Description) (desc));
ComPtr<IGuestOSType> guestOSType;
Bstr type = L"os2warp45";
CHECK_ERROR_BREAK (virtualBox, GetGuestOSType (type, guestOSType.asOutParam()));
RTPrintf ("Saving new machine settings...\n");
CHECK_ERROR_BREAK (machine, SaveSettings());
RTPrintf ("Accessing the newly created machine:\n");
readAndChangeMachineSettings (machine);
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// enumerate host DVD drives
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IHost> host;
CHECK_RC_BREAK (virtualBox->COMGETTER(Host) (host.asOutParam()));
{
ComPtr<IHostDVDDriveCollection> coll;
CHECK_RC_BREAK (host->COMGETTER(DVDDrives) (coll.asOutParam()));
ComPtr<IHostDVDDriveEnumerator> enumerator;
CHECK_RC_BREAK (coll->Enumerate (enumerator.asOutParam()));
BOOL hasmore;
while (SUCCEEDED(enumerator->HasMore (&hasmore)) && hasmore)
{
ComPtr<IHostDVDDrive> drive;
CHECK_RC_BREAK (enumerator->GetNext (drive.asOutParam()));
Bstr name;
CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
RTPrintf ("Host DVD drive: name={%ls}\n", name.raw());
}
CHECK_RC_BREAK (rc);
ComPtr<IHostDVDDrive> drive;
CHECK_ERROR (enumerator, GetNext (drive.asOutParam()));
CHECK_ERROR (coll, GetItemAt (1000, drive.asOutParam()));
CHECK_ERROR (coll, FindByName (Bstr ("R:"), drive.asOutParam()));
if (SUCCEEDED(rc))
{
Bstr name;
CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
RTPrintf ("Found by name: name={%ls}\n", name.raw());
}
}
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// check for available hd backends
///////////////////////////////////////////////////////////////////////////
{
RTPrintf("Supported hard disk backends: --------------------------\n");
ComPtr<ISystemProperties> systemProperties;
CHECK_ERROR_BREAK (virtualBox,
COMGETTER(SystemProperties) (systemProperties.asOutParam()));
com::SafeIfaceArray<IHardDiskFormat> hardDiskFormats;
CHECK_ERROR_BREAK (systemProperties,
COMGETTER(HardDiskFormats) (ComSafeArrayAsOutParam (hardDiskFormats)));
for (size_t i = 0; i < hardDiskFormats.size(); ++ i)
{
/* General information */
Bstr id;
CHECK_ERROR_BREAK (hardDiskFormats [i],
COMGETTER(Id) (id.asOutParam()));
Bstr description;
CHECK_ERROR_BREAK (hardDiskFormats [i],
COMGETTER(Id) (description.asOutParam()));
ULONG caps;
CHECK_ERROR_BREAK (hardDiskFormats [i],
COMGETTER(Capabilities) (&caps));
RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
i, id.raw(), description.raw(), caps);
/* File extensions */
com::SafeArray<BSTR> fileExtensions;
CHECK_ERROR_BREAK (hardDiskFormats [i],
COMGETTER(FileExtensions) (ComSafeArrayAsOutParam (fileExtensions)));
for (size_t a = 0; a < fileExtensions.size(); ++ a)
{
RTPrintf ("%ls", Bstr (fileExtensions [a]).raw());
if (a != fileExtensions.size()-1)
RTPrintf (",");
}
RTPrintf ("'");
/* Configuration keys */
com::SafeArray<BSTR> propertyNames;
com::SafeArray<BSTR> propertyDescriptions;
com::SafeArray<ULONG> propertyTypes;
com::SafeArray<ULONG> propertyFlags;
com::SafeArray<BSTR> propertyDefaults;
CHECK_ERROR_BREAK (hardDiskFormats [i],
DescribeProperties (ComSafeArrayAsOutParam (propertyNames),
ComSafeArrayAsOutParam (propertyDescriptions),
ComSafeArrayAsOutParam (propertyTypes),
ComSafeArrayAsOutParam (propertyFlags),
ComSafeArrayAsOutParam (propertyDefaults)));
RTPrintf (" config=(");
if (propertyNames.size() > 0)
{
for (size_t a = 0; a < propertyNames.size(); ++ a)
{
RTPrintf ("key='%ls' desc='%ls' type=", Bstr (propertyNames [a]).raw(), Bstr (propertyDescriptions [a]).raw());
switch (propertyTypes [a])
{
case DataType_Int32Type: RTPrintf ("int"); break;
case DataType_Int8Type: RTPrintf ("byte"); break;
case DataType_StringType: RTPrintf ("string"); break;
}
RTPrintf (" flags=%#04x", propertyFlags [a]);
RTPrintf (" default='%ls'", Bstr (propertyDefaults [a]).raw());
if (a != propertyNames.size()-1)
RTPrintf (",");
}
}
RTPrintf (")\n");
}
RTPrintf("-------------------------------------------------------\n");
}
#endif
#if 0
// enumerate hard disks & dvd images
///////////////////////////////////////////////////////////////////////////
do
{
{
com::SafeIfaceArray<IHardDisk> disks;
CHECK_ERROR_BREAK (virtualBox,
COMGETTER(HardDisks)(ComSafeArrayAsOutParam (disks)));
RTPrintf ("%u base hard disks registered (disks.isNull()=%d).\n",
disks.size(), disks.isNull());
for (size_t i = 0; i < disks.size(); ++ i)
{
Bstr loc;
CHECK_ERROR_BREAK (disks [i], COMGETTER(Location) (loc.asOutParam()));
Guid id;
CHECK_ERROR_BREAK (disks [i], COMGETTER(Id) (id.asOutParam()));
MediaState_T state;
CHECK_ERROR_BREAK (disks [i], COMGETTER(State) (&state));
Bstr format;
CHECK_ERROR_BREAK (disks [i], COMGETTER(Format) (format.asOutParam()));
RTPrintf (" disks[%u]: '%ls'\n"
" UUID: {%RTuuid}\n"
" State: %s\n"
" Format: %ls\n",
i, loc.raw(), id.raw(),
state == MediaState_NotCreated ? "Not Created" :
state == MediaState_Created ? "Created" :
state == MediaState_Inaccessible ? "Inaccessible" :
state == MediaState_LockedRead ? "Locked Read" :
state == MediaState_LockedWrite ? "Locked Write" :
"???",
format.raw());
if (state == MediaState_Inaccessible)
{
Bstr error;
CHECK_ERROR_BREAK (disks [i],
COMGETTER(LastAccessError)(error.asOutParam()));
RTPrintf (" Access Error: %ls\n", error.raw());
}
/* get usage */
RTPrintf (" Used by VMs:\n");
com::SafeGUIDArray ids;
CHECK_ERROR_BREAK (disks [i],
COMGETTER(MachineIds) (ComSafeArrayAsOutParam (ids)));
if (ids.size() == 0)
{
RTPrintf (" <not used>\n");
}
else
{
for (size_t j = 0; j < ids.size(); ++ j)
{
RTPrintf (" {%RTuuid}\n", &ids [j]);
}
}
}
}
{
com::SafeIfaceArray<IDVDImage> images;
CHECK_ERROR_BREAK (virtualBox,
COMGETTER(DVDImages) (ComSafeArrayAsOutParam (images)));
RTPrintf ("%u DVD images registered (images.isNull()=%d).\n",
images.size(), images.isNull());
for (size_t i = 0; i < images.size(); ++ i)
{
Bstr loc;
CHECK_ERROR_BREAK (images [i], COMGETTER(Location) (loc.asOutParam()));
Guid id;
CHECK_ERROR_BREAK (images [i], COMGETTER(Id) (id.asOutParam()));
MediaState_T state;
CHECK_ERROR_BREAK (images [i], COMGETTER(State) (&state));
RTPrintf (" images[%u]: '%ls'\n"
" UUID: {%RTuuid}\n"
" State: %s\n",
i, loc.raw(), id.raw(),
state == MediaState_NotCreated ? "Not Created" :
state == MediaState_Created ? "Created" :
state == MediaState_Inaccessible ? "Inaccessible" :
state == MediaState_LockedRead ? "Locked Read" :
state == MediaState_LockedWrite ? "Locked Write" :
"???");
if (state == MediaState_Inaccessible)
{
Bstr error;
CHECK_ERROR_BREAK (images [i],
COMGETTER(LastAccessError)(error.asOutParam()));
RTPrintf (" Access Error: %ls\n", error.raw());
}
/* get usage */
RTPrintf (" Used by VMs:\n");
com::SafeGUIDArray ids;
CHECK_ERROR_BREAK (images [i],
COMGETTER(MachineIds) (ComSafeArrayAsOutParam (ids)));
if (ids.size() == 0)
{
RTPrintf (" <not used>\n");
}
else
{
for (size_t j = 0; j < ids.size(); ++ j)
{
RTPrintf (" {%RTuuid}\n", &ids [j]);
}
}
}
}
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// open a (direct) session
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IMachine> machine;
Bstr name = argc > 1 ? argv [1] : "dos";
RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
Guid guid;
CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
RTPrintf ("Opening a session for this machine...\n");
CHECK_RC_BREAK (virtualBox->OpenSession (session, guid));
#if 1
ComPtr<IMachine> sessionMachine;
RTPrintf ("Getting sessioned machine object...\n");
CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
RTPrintf ("Accessing the machine within the session:\n");
readAndChangeMachineSettings (sessionMachine, machine);
#if 0
RTPrintf ("\n");
RTPrintf ("Enabling the VRDP server (must succeed even if the VM is saved):\n");
ComPtr<IVRDPServer> vrdp;
CHECK_ERROR_BREAK (sessionMachine, COMGETTER(VRDPServer) (vrdp.asOutParam()));
if (FAILED (vrdp->COMSETTER(Enabled) (TRUE)))
{
PRINT_ERROR_INFO (com::ErrorInfo (vrdp));
}
else
{
BOOL enabled = FALSE;
CHECK_ERROR_BREAK (vrdp, COMGETTER(Enabled) (&enabled));
RTPrintf ("VRDP server is %s\n", enabled ? "enabled" : "disabled");
}
#endif
#endif
#if 0
ComPtr<IConsole> console;
RTPrintf ("Getting the console object...\n");
CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
RTPrintf ("Discarding the current machine state...\n");
ComPtr<IProgress> progress;
CHECK_ERROR_BREAK (console, DiscardCurrentState (progress.asOutParam()));
RTPrintf ("Waiting for completion...\n");
CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
ProgressErrorInfo ei (progress);
if (FAILED (ei.getResultCode()))
{
PRINT_ERROR_INFO (ei);
ComPtr<IUnknown> initiator;
CHECK_ERROR_BREAK (progress, COMGETTER(Initiator) (initiator.asOutParam()));
RTPrintf ("initiator(unk) = %p\n", (IUnknown *) initiator);
RTPrintf ("console(unk) = %p\n", (IUnknown *) ComPtr<IUnknown> ((IConsole *) console));
RTPrintf ("console = %p\n", (IConsole *) console);
}
#endif
RTPrintf("Press enter to close session...");
getchar();
session->Close();
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// open a remote session
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IMachine> machine;
Bstr name = L"dos";
RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
Guid guid;
CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
RTPrintf ("Opening a remote session for this machine...\n");
ComPtr<IProgress> progress;
CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, Bstr("gui"),
NULL, progress.asOutParam()));
RTPrintf ("Waiting for the session to open...\n");
CHECK_RC_BREAK (progress->WaitForCompletion (-1));
ComPtr<IMachine> sessionMachine;
RTPrintf ("Getting sessioned machine object...\n");
CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
ComPtr<IConsole> console;
RTPrintf ("Getting console object...\n");
CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
RTPrintf ("Press enter to pause the VM execution in the remote session...");
getchar();
CHECK_RC (console->Pause());
RTPrintf ("Press enter to close this session...");
getchar();
session->Close();
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
// open an existing remote session
///////////////////////////////////////////////////////////////////////////
do
{
ComPtr<IMachine> machine;
Bstr name = "dos";
RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
Guid guid;
CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
RTPrintf ("Opening an existing remote session for this machine...\n");
CHECK_RC_BREAK (virtualBox->OpenExistingSession (session, guid));
ComPtr<IMachine> sessionMachine;
RTPrintf ("Getting sessioned machine object...\n");
CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
#if 0
Bstr extraDataKey = "VBoxSDL/SecureLabel";
Bstr extraData = "Das kommt jetzt noch viel krasser vom total konkreten API!";
CHECK_RC (sessionMachine->SetExtraData (extraDataKey, extraData));
#endif
#if 0
ComPtr<IConsole> console;
RTPrintf ("Getting console object...\n");
CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
RTPrintf ("Press enter to pause the VM execution in the remote session...");
getchar();
CHECK_RC (console->Pause());
RTPrintf ("Press enter to close this session...");
getchar();
#endif
session->Close();
}
while (FALSE);
RTPrintf ("\n");
#endif
#if 0
do {
// Get host
ComPtr<IHost> host;
CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
ULONG uMemSize, uMemAvail;
CHECK_ERROR_BREAK (host, COMGETTER(MemorySize) (&uMemSize));
RTPrintf("Total memory (MB): %u\n", uMemSize);
CHECK_ERROR_BREAK (host, COMGETTER(MemoryAvailable) (&uMemAvail));
RTPrintf("Free memory (MB): %u\n", uMemAvail);
} while (0);
#endif
#if 0
do {
// Get host
ComPtr<IHost> host;
CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
CHECK_ERROR_BREAK(host,
COMGETTER(NetworkInterfaces) (ComSafeArrayAsOutParam (hostNetworkInterfaces)));
if (hostNetworkInterfaces.size() > 0)
{
ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[0];
Bstr interfaceName;
networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
RTPrintf("Found %d network interfaces, testing with %lS...\n", hostNetworkInterfaces.size(), interfaceName.raw());
Guid interfaceGuid;
networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
// Find the interface by its name
networkInterface.setNull();
CHECK_ERROR_BREAK(host,
FindHostNetworkInterfaceByName (interfaceName, networkInterface.asOutParam()));
Guid interfaceGuid2;
networkInterface->COMGETTER(Id)(interfaceGuid2.asOutParam());
if (interfaceGuid2 != interfaceGuid)
RTPrintf("Failed to retrieve an interface by name %lS.\n", interfaceName.raw());
// Find the interface by its guid
networkInterface.setNull();
CHECK_ERROR_BREAK(host,
FindHostNetworkInterfaceById (interfaceGuid, networkInterface.asOutParam()));
Bstr interfaceName2;
networkInterface->COMGETTER(Name)(interfaceName2.asOutParam());
if (interfaceName != interfaceName2)
RTPrintf("Failed to retrieve an interface by GUID %lS.\n", Bstr(interfaceGuid.toString()).raw());
}
else
{
RTPrintf("No network interfaces found!\n");
}
} while (0);
#endif
#if 0 && defined (VBOX_WITH_RESOURCE_USAGE_API)
do {
// Get collector
ComPtr<IPerformanceCollector> collector;
CHECK_ERROR_BREAK (virtualBox,
COMGETTER(PerformanceCollector) (collector.asOutParam()));
// Fill base metrics array
Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
com::SafeArray<BSTR> baseMetrics (1);
baseMetricNames[0].cloneTo(&baseMetrics [0]);
// Get host
ComPtr<IHost> host;
CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
// Get machine
ComPtr<IMachine> machine;
Bstr name = argc > 1 ? argv [1] : "dsl";
Bstr sessionType = argc > 2 ? argv [2] : "vrdp";
RTPrintf ("Getting a machine object named '%ls'...\n", name.raw());
CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
// Open session
Guid guid;
CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
RTPrintf ("Opening a remote session for this machine...\n");
ComPtr<IProgress> progress;
CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, sessionType,
NULL, progress.asOutParam()));
RTPrintf ("Waiting for the session to open...\n");
CHECK_RC_BREAK (progress->WaitForCompletion (-1));
ComPtr<IMachine> sessionMachine;
RTPrintf ("Getting sessioned machine object...\n");
CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
// Setup base metrics
// Note that one needs to set up metrics after a session is open for a machine.
com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
com::SafeIfaceArray<IUnknown> objects(2);
host.queryInterfaceTo(&objects[0]);
machine.queryInterfaceTo(&objects[1]);
CHECK_ERROR_BREAK (collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
ComSafeArrayAsInParam(objects), 1u, 10u,
ComSafeArrayAsOutParam(affectedMetrics)) );
listAffectedMetrics(virtualBox,
ComSafeArrayAsInParam(affectedMetrics));
affectedMetrics.setNull();
// Get console
ComPtr<IConsole> console;
RTPrintf ("Getting console object...\n");
CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
RTThreadSleep(5000); // Sleep for 5 seconds
RTPrintf("\nMetrics collected with VM running: --------------------\n");
queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
// Pause
//RTPrintf ("Press enter to pause the VM execution in the remote session...");
//getchar();
CHECK_RC (console->Pause());
RTThreadSleep(5000); // Sleep for 5 seconds
RTPrintf("\nMetrics collected with VM paused: ---------------------\n");
queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
RTPrintf("\nDrop collected metrics: ----------------------------------------\n");
CHECK_ERROR_BREAK (collector,
SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
ComSafeArrayAsInParam(objects),
1u, 5u, ComSafeArrayAsOutParam(affectedMetrics)) );
listAffectedMetrics(virtualBox,
ComSafeArrayAsInParam(affectedMetrics));
affectedMetrics.setNull();
queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
com::SafeIfaceArray<IUnknown> vmObject(1);
machine.queryInterfaceTo(&vmObject[0]);
RTPrintf("\nDisable collection of VM metrics: ------------------------------\n");
CHECK_ERROR_BREAK (collector,
DisableMetrics(ComSafeArrayAsInParam(baseMetrics),
ComSafeArrayAsInParam(vmObject),
ComSafeArrayAsOutParam(affectedMetrics)) );
listAffectedMetrics(virtualBox,
ComSafeArrayAsInParam(affectedMetrics));
affectedMetrics.setNull();
RTThreadSleep(5000); // Sleep for 5 seconds
queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
RTPrintf("\nRe-enable collection of all metrics: ---------------------------\n");
CHECK_ERROR_BREAK (collector,
EnableMetrics(ComSafeArrayAsInParam(baseMetrics),
ComSafeArrayAsInParam(objects),
ComSafeArrayAsOutParam(affectedMetrics)) );
listAffectedMetrics(virtualBox,
ComSafeArrayAsInParam(affectedMetrics));
affectedMetrics.setNull();
RTThreadSleep(5000); // Sleep for 5 seconds
queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
// Power off
RTPrintf ("Press enter to power off VM...");
getchar();
CHECK_RC (console->PowerDown());
RTPrintf ("Press enter to close this session...");
getchar();
session->Close();
} while (false);
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
#if 0
// check of OVF appliance handling
///////////////////////////////////////////////////////////////////////////
do
{
Bstr ovf = argc > 1 ? argv [1] : "someOVF.ovf";
RTPrintf ("Try to open %ls ...\n", ovf.raw());
ComPtr<IAppliance> appliance;
CHECK_ERROR_BREAK (virtualBox,
CreateAppliance (appliance.asOutParam()));
CHECK_ERROR_BREAK (appliance,
Read (ovf));
Bstr path;
CHECK_ERROR_BREAK (appliance, COMGETTER (Path)(path.asOutParam()));
RTPrintf ("Successfully opened %ls.\n", path.raw());
CHECK_ERROR_BREAK (appliance,
Interpret());
RTPrintf ("Successfully interpreted %ls.\n", path.raw());
RTPrintf ("Appliance:\n");
// Fetch all disks
com::SafeArray<BSTR> retDisks;
CHECK_ERROR_BREAK (appliance,
COMGETTER (Disks)(ComSafeArrayAsOutParam (retDisks)));
if (retDisks.size() > 0)
{
RTPrintf ("Disks:");
for (unsigned i = 0; i < retDisks.size(); i++)
RTPrintf (" %ls", Bstr (retDisks [i]).raw());
RTPrintf ("\n");
}
/* Fetch all virtual system descriptions */
com::SafeIfaceArray<IVirtualSystemDescription> retVSD;
CHECK_ERROR_BREAK (appliance,
COMGETTER (VirtualSystemDescriptions) (ComSafeArrayAsOutParam (retVSD)));
if (retVSD.size() > 0)
{
for (unsigned i = 0; i < retVSD.size(); ++i)
{
com::SafeArray<VirtualSystemDescriptionType_T> retTypes;
com::SafeArray<BSTR> retRefValues;
com::SafeArray<BSTR> retOrigValues;
com::SafeArray<BSTR> retAutoValues;
com::SafeArray<BSTR> retConfiguration;
CHECK_ERROR_BREAK (retVSD [i],
GetDescription (ComSafeArrayAsOutParam (retTypes),
ComSafeArrayAsOutParam (retRefValues),
ComSafeArrayAsOutParam (retOrigValues),
ComSafeArrayAsOutParam (retAutoValues),
ComSafeArrayAsOutParam (retConfiguration)));
RTPrintf ("VirtualSystemDescription:\n");
for (unsigned a = 0; a < retTypes.size(); ++a)
{
RTPrintf (" %d %ls %ls %ls\n",
retTypes [a],
Bstr (retOrigValues [a]).raw(),
Bstr (retAutoValues [a]).raw(),
Bstr (retConfiguration [a]).raw());
}
/* Show warnings from interpret */
com::SafeArray<BSTR> retWarnings;
CHECK_ERROR_BREAK (retVSD [i],
GetWarnings(ComSafeArrayAsOutParam (retWarnings)));
if (retWarnings.size() > 0)
{
RTPrintf ("The following warnings occurs on interpret:\n");
for (unsigned r = 0; r < retWarnings.size(); ++r)
RTPrintf ("%ls\n", Bstr (retWarnings [r]).raw());
RTPrintf ("\n");
}
}
RTPrintf ("\n");
}
RTPrintf ("Try to import the appliance ...\n");
ComPtr<IProgress> progress;
CHECK_ERROR_BREAK (appliance,
ImportMachines (progress.asOutParam()));
CHECK_ERROR (progress, WaitForCompletion (-1));
if (SUCCEEDED(rc))
{
/* Check if the import was successfully */
progress->COMGETTER (ResultCode)(&rc);
if (FAILED (rc))
{
com::ProgressErrorInfo info (progress);
if (info.isBasicAvailable())
RTPrintf ("Error: failed to import appliance. Error message: %lS\n", info.getText().raw());
else
RTPrintf ("Error: failed to import appliance. No error message available!\n");
}else
RTPrintf ("Successfully imported the appliance.\n");
}
}
while (FALSE);
RTPrintf ("\n");
#endif
RTPrintf ("Press enter to release Session and VirtualBox instances...");
getchar();
// end "all-stuff" scope
////////////////////////////////////////////////////////////////////////////
}
while (0);
RTPrintf("Press enter to shutdown COM...");
getchar();
com::Shutdown();
RTPrintf ("tstAPI FINISHED.\n");
return rc;
}
#ifdef VBOX_WITH_RESOURCE_USAGE_API
static void queryMetrics (ComPtr<IVirtualBox> aVirtualBox,
ComPtr<IPerformanceCollector> collector,
ComSafeArrayIn (IUnknown *, objects))
{
HRESULT rc;
//Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
Bstr metricNames[] = { L"*" };
com::SafeArray<BSTR> metrics (1);
metricNames[0].cloneTo(&metrics [0]);
com::SafeArray<BSTR> retNames;
com::SafeIfaceArray<IUnknown> retObjects;
com::SafeArray<BSTR> retUnits;
com::SafeArray<ULONG> retScales;
com::SafeArray<ULONG> retSequenceNumbers;
com::SafeArray<ULONG> retIndices;
com::SafeArray<ULONG> retLengths;
com::SafeArray<LONG> retData;
CHECK_ERROR (collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
ComSafeArrayInArg(objects),
ComSafeArrayAsOutParam(retNames),
ComSafeArrayAsOutParam(retObjects),
ComSafeArrayAsOutParam(retUnits),
ComSafeArrayAsOutParam(retScales),
ComSafeArrayAsOutParam(retSequenceNumbers),
ComSafeArrayAsOutParam(retIndices),
ComSafeArrayAsOutParam(retLengths),
ComSafeArrayAsOutParam(retData)) );
RTPrintf("Object Metric Values\n"
"---------- -------------------- --------------------------------------------\n");
for (unsigned i = 0; i < retNames.size(); i++)
{
Bstr metricUnit(retUnits[i]);
Bstr metricName(retNames[i]);
RTPrintf("%-10ls %-20ls ", getObjectName(aVirtualBox, retObjects[i]).raw(), metricName.raw());
const char *separator = "";
for (unsigned j = 0; j < retLengths[i]; j++)
{
if (retScales[i] == 1)
RTPrintf("%s%d %ls", separator, retData[retIndices[i] + j], metricUnit.raw());
else
RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[i] + j] / retScales[i],
(retData[retIndices[i] + j] * 100 / retScales[i]) % 100, metricUnit.raw());
separator = ", ";
}
RTPrintf("\n");
}
}
static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
ComPtr<IUnknown> aObject)
{
HRESULT rc;
ComPtr<IHost> host = aObject;
if (!host.isNull())
return Bstr("host");
ComPtr<IMachine> machine = aObject;
if (!machine.isNull())
{
Bstr name;
CHECK_ERROR(machine, COMGETTER(Name)(name.asOutParam()));
if (SUCCEEDED(rc))
return name;
}
return Bstr("unknown");
}
static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
ComSafeArrayIn(IPerformanceMetric*, aMetrics))
{
HRESULT rc;
com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics));
if (metrics.size())
{
ComPtr<IUnknown> object;
Bstr metricName;
RTPrintf("The following metrics were modified:\n\n"
"Object Metric\n"
"---------- --------------------\n");
for (size_t i = 0; i < metrics.size(); i++)
{
CHECK_ERROR(metrics[i], COMGETTER(Object)(object.asOutParam()));
CHECK_ERROR(metrics[i], COMGETTER(MetricName)(metricName.asOutParam()));
RTPrintf("%-10ls %-20ls\n",
getObjectName(aVirtualBox, object).raw(), metricName.raw());
}
RTPrintf("\n");
}
else
{
RTPrintf("No metrics match the specified filter!\n");
}
}
#endif /* VBOX_WITH_RESOURCE_USAGE_API */
/* vim: set shiftwidth=4 tabstop=4 expandtab: */