VirtualBox

source: vbox/trunk/src/VBox/Main/testcase/tstAPI.cpp@ 13762

Last change on this file since 13762 was 13580, checked in by vboxsync, 16 years ago

Ported s2 branch (r37120:38456).
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 46.0 KB
Line 
1/** @file
2 *
3 * tstAPI - test program for our COM/XPCOM interface
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#include <stdio.h>
23#include <stdlib.h>
24
25#include <VBox/com/com.h>
26#include <VBox/com/string.h>
27#include <VBox/com/array.h>
28#include <VBox/com/Guid.h>
29#include <VBox/com/ErrorInfo.h>
30#include <VBox/com/EventQueue.h>
31
32#include <VBox/com/VirtualBox.h>
33
34using namespace com;
35
36#define LOG_ENABLED
37#define LOG_GROUP LOG_GROUP_MAIN
38#define LOG_INSTANCE NULL
39#include <VBox/log.h>
40
41#include <iprt/runtime.h>
42#include <iprt/stream.h>
43
44#define printf RTPrintf
45
46
47// forward declarations
48///////////////////////////////////////////////////////////////////////////////
49
50static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
51 ComPtr<IUnknown> aObject);
52static void queryMetrics (ComPtr<IVirtualBox> aVirtualBox,
53 ComPtr <IPerformanceCollector> collector,
54 ComSafeArrayIn (IUnknown *, objects));
55static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
56 ComSafeArrayIn(IPerformanceMetric*, aMetrics));
57
58// funcs
59///////////////////////////////////////////////////////////////////////////////
60
61HRESULT readAndChangeMachineSettings (IMachine *machine, IMachine *readonlyMachine = 0)
62{
63 HRESULT rc = S_OK;
64
65 Bstr name;
66 printf ("Getting machine name...\n");
67 CHECK_RC_RET (machine->COMGETTER(Name) (name.asOutParam()));
68 printf ("Name: {%ls}\n", name.raw());
69
70 printf("Getting machine GUID...\n");
71 Guid guid;
72 CHECK_RC (machine->COMGETTER(Id) (guid.asOutParam()));
73 if (SUCCEEDED (rc) && !guid.isEmpty()) {
74 printf ("Guid::toString(): {%s}\n", (const char *) guid.toString());
75 } else {
76 printf ("WARNING: there's no GUID!");
77 }
78
79 ULONG memorySize;
80 printf ("Getting memory size...\n");
81 CHECK_RC_RET (machine->COMGETTER(MemorySize) (&memorySize));
82 printf ("Memory size: %d\n", memorySize);
83
84 MachineState_T machineState;
85 printf ("Getting machine state...\n");
86 CHECK_RC_RET (machine->COMGETTER(State) (&machineState));
87 printf ("Machine state: %d\n", machineState);
88
89 BOOL modified;
90 printf ("Are any settings modified?...\n");
91 CHECK_RC (machine->COMGETTER(SettingsModified) (&modified));
92 if (SUCCEEDED (rc))
93 printf ("%s\n", modified ? "yes" : "no");
94
95 ULONG memorySizeBig = memorySize * 10;
96 printf("Changing memory size to %d...\n", memorySizeBig);
97 CHECK_RC (machine->COMSETTER(MemorySize) (memorySizeBig));
98
99 if (SUCCEEDED (rc))
100 {
101 printf ("Are any settings modified now?...\n");
102 CHECK_RC_RET (machine->COMGETTER(SettingsModified) (&modified));
103 printf ("%s\n", modified ? "yes" : "no");
104 ASSERT_RET (modified, 0);
105
106 ULONG memorySizeGot;
107 printf ("Getting memory size again...\n");
108 CHECK_RC_RET (machine->COMGETTER(MemorySize) (&memorySizeGot));
109 printf ("Memory size: %d\n", memorySizeGot);
110 ASSERT_RET (memorySizeGot == memorySizeBig, 0);
111
112 if (readonlyMachine)
113 {
114 printf ("Getting memory size of the counterpart readonly machine...\n");
115 ULONG memorySizeRO;
116 readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
117 printf ("Memory size: %d\n", memorySizeRO);
118 ASSERT_RET (memorySizeRO != memorySizeGot, 0);
119 }
120
121 printf ("Discarding recent changes...\n");
122 CHECK_RC_RET (machine->DiscardSettings());
123 printf ("Are any settings modified after discarding?...\n");
124 CHECK_RC_RET (machine->COMGETTER(SettingsModified) (&modified));
125 printf ("%s\n", modified ? "yes" : "no");
126 ASSERT_RET (!modified, 0);
127
128 printf ("Getting memory size once more...\n");
129 CHECK_RC_RET (machine->COMGETTER(MemorySize) (&memorySizeGot));
130 printf ("Memory size: %d\n", memorySizeGot);
131 ASSERT_RET (memorySizeGot == memorySize, 0);
132
133 memorySize = memorySize > 128 ? memorySize / 2 : memorySize * 2;
134 printf("Changing memory size to %d...\n", memorySize);
135 CHECK_RC_RET (machine->COMSETTER(MemorySize) (memorySize));
136 }
137
138 Bstr desc;
139 printf ("Getting description...\n");
140 CHECK_ERROR_RET (machine, COMGETTER(Description) (desc.asOutParam()), rc);
141 printf ("Description is: \"%ls\"\n", desc.raw());
142
143 desc = L"This is an exemplary description (changed).";
144 printf ("Setting description to \"%ls\"...\n", desc.raw());
145 CHECK_ERROR_RET (machine, COMSETTER(Description) (desc), rc);
146
147 printf ("Saving machine settings...\n");
148 CHECK_RC (machine->SaveSettings());
149 if (SUCCEEDED (rc))
150 {
151 printf ("Are any settings modified after saving?...\n");
152 CHECK_RC_RET (machine->COMGETTER(SettingsModified) (&modified));
153 printf ("%s\n", modified ? "yes" : "no");
154 ASSERT_RET (!modified, 0);
155
156 if (readonlyMachine) {
157 printf ("Getting memory size of the counterpart readonly machine...\n");
158 ULONG memorySizeRO;
159 readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
160 printf ("Memory size: %d\n", memorySizeRO);
161 ASSERT_RET (memorySizeRO == memorySize, 0);
162 }
163 }
164
165 Bstr extraDataKey = L"Blafasel";
166 Bstr extraData;
167 printf ("Getting extra data key {%ls}...\n", extraDataKey.raw());
168 CHECK_RC_RET (machine->GetExtraData (extraDataKey, extraData.asOutParam()));
169 if (!extraData.isEmpty()) {
170 printf ("Extra data value: {%ls}\n", extraData.raw());
171 } else {
172 if (extraData.isNull())
173 printf ("No extra data exists\n");
174 else
175 printf ("Extra data is empty\n");
176 }
177
178 if (extraData.isEmpty())
179 extraData = L"Das ist die Berliner Luft, Luft, Luft...";
180 else
181 extraData.setNull();
182 printf (
183 "Setting extra data key {%ls} to {%ls}...\n",
184 extraDataKey.raw(), extraData.raw()
185 );
186 CHECK_RC (machine->SetExtraData (extraDataKey, extraData));
187
188 if (SUCCEEDED (rc)) {
189 printf ("Getting extra data key {%ls} again...\n", extraDataKey.raw());
190 CHECK_RC_RET (machine->GetExtraData (extraDataKey, extraData.asOutParam()));
191 if (!extraData.isEmpty()) {
192 printf ("Extra data value: {%ls}\n", extraData.raw());
193 } else {
194 if (extraData.isNull())
195 printf ("No extra data exists\n");
196 else
197 printf ("Extra data is empty\n");
198 }
199 }
200
201 return rc;
202}
203
204// main
205///////////////////////////////////////////////////////////////////////////////
206
207int main(int argc, char *argv[])
208{
209 /*
210 * Initialize the VBox runtime without loading
211 * the support driver.
212 */
213 RTR3Init();
214
215 HRESULT rc;
216
217 {
218 char homeDir [RTPATH_MAX];
219 GetVBoxUserHomeDirectory (homeDir, sizeof (homeDir));
220 printf ("VirtualBox Home Directory = '%s'\n", homeDir);
221 }
222
223 printf ("Initializing COM...\n");
224
225 CHECK_RC_RET (com::Initialize());
226
227 do
228 {
229 // scopes all the stuff till shutdown
230 ////////////////////////////////////////////////////////////////////////////
231
232 ComPtr <IVirtualBox> virtualBox;
233 ComPtr <ISession> session;
234
235#if 0
236 // Utf8Str test
237 ////////////////////////////////////////////////////////////////////////////
238
239 Utf8Str nullUtf8Str;
240 printf ("nullUtf8Str='%s'\n", nullUtf8Str.raw());
241
242 Utf8Str simpleUtf8Str = "simpleUtf8Str";
243 printf ("simpleUtf8Str='%s'\n", simpleUtf8Str.raw());
244
245 Utf8Str utf8StrFmt = Utf8StrFmt ("[0=%d]%s[1=%d]",
246 0, "utf8StrFmt", 1);
247 printf ("utf8StrFmt='%s'\n", utf8StrFmt.raw());
248
249#endif
250
251 printf ("Creating VirtualBox object...\n");
252 CHECK_RC (virtualBox.createLocalObject (CLSID_VirtualBox));
253 if (FAILED (rc))
254 {
255 CHECK_ERROR_NOCALL();
256 break;
257 }
258
259 printf ("Creating Session object...\n");
260 CHECK_RC (session.createInprocObject (CLSID_Session));
261 if (FAILED (rc))
262 {
263 CHECK_ERROR_NOCALL();
264 break;
265 }
266
267#if 0
268 // IUnknown identity test
269 ////////////////////////////////////////////////////////////////////////////
270 {
271 {
272 ComPtr <IVirtualBox> virtualBox2;
273
274 printf ("Creating one more VirtualBox object...\n");
275 CHECK_RC (virtualBox2.createLocalObject (CLSID_VirtualBox));
276 if (FAILED (rc))
277 {
278 CHECK_ERROR_NOCALL();
279 break;
280 }
281
282 printf ("IVirtualBox(virualBox)=%p IVirtualBox(virualBox2)=%p\n",
283 (IVirtualBox *) virtualBox, (IVirtualBox *) virtualBox2);
284 Assert ((IVirtualBox *) virtualBox == (IVirtualBox *) virtualBox2);
285
286 ComPtr <IUnknown> unk (virtualBox);
287 ComPtr <IUnknown> unk2;
288 unk2 = virtualBox2;
289
290 printf ("IUnknown(virualBox)=%p IUnknown(virualBox2)=%p\n",
291 (IUnknown *) unk, (IUnknown *) unk2);
292 Assert ((IUnknown *) unk == (IUnknown *) unk2);
293
294 ComPtr <IVirtualBox> vb = unk;
295 ComPtr <IVirtualBox> vb2 = unk;
296
297 printf ("IVirtualBox(IUnknown(virualBox))=%p IVirtualBox(IUnknown(virualBox2))=%p\n",
298 (IVirtualBox *) vb, (IVirtualBox *) vb2);
299 Assert ((IVirtualBox *) vb == (IVirtualBox *) vb2);
300 }
301
302 {
303 ComPtr <IHost> host;
304 CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host)(host.asOutParam()));
305 printf (" IHost(host)=%p\n", (IHost *) host);
306 ComPtr <IUnknown> unk = host;
307 printf (" IUnknown(host)=%p\n", (IUnknown *) unk);
308 ComPtr <IHost> host_copy = unk;
309 printf (" IHost(host_copy)=%p\n", (IHost *) host_copy);
310 ComPtr <IUnknown> unk_copy = host_copy;
311 printf (" IUnknown(host_copy)=%p\n", (IUnknown *) unk_copy);
312 Assert ((IUnknown *) unk == (IUnknown *) unk_copy);
313
314 /* query IUnknown on IUnknown */
315 ComPtr <IUnknown> unk_copy_copy;
316 unk_copy.queryInterfaceTo (unk_copy_copy.asOutParam());
317 printf (" IUnknown(unk_copy)=%p\n", (IUnknown *) unk_copy_copy);
318 Assert ((IUnknown *) unk_copy == (IUnknown *) unk_copy_copy);
319 /* query IUnknown on IUnknown in the opposite direction */
320 unk_copy_copy.queryInterfaceTo (unk_copy.asOutParam());
321 printf (" IUnknown(unk_copy_copy)=%p\n", (IUnknown *) unk_copy);
322 Assert ((IUnknown *) unk_copy == (IUnknown *) unk_copy_copy);
323
324 /* query IUnknown again after releasing all previous IUnknown instances
325 * but keeping IHost -- it should remain the same (Identity Rule) */
326 IUnknown *oldUnk = unk;
327 unk.setNull();
328 unk_copy.setNull();
329 unk_copy_copy.setNull();
330 unk = host;
331 printf (" IUnknown(host)=%p\n", (IUnknown *) unk);
332 Assert (oldUnk == (IUnknown *) unk);
333 }
334
335// printf ("Will be now released (press Enter)...");
336// getchar();
337 }
338#endif
339
340 // create the event queue
341 // (here it is necessary only to process remaining XPCOM/IPC events
342 // after the session is closed)
343 EventQueue eventQ;
344
345#if 0
346 // the simplest COM API test
347 ////////////////////////////////////////////////////////////////////////////
348 {
349 Bstr version;
350 CHECK_ERROR_BREAK (virtualBox, COMGETTER(Version) (version.asOutParam()));
351 printf ("VirtualBox version = %ls\n", version.raw());
352 }
353#endif
354
355#if 0
356 // Array test
357 ////////////////////////////////////////////////////////////////////////////
358 {
359 printf ("Calling IVirtualBox::Machines...\n");
360
361 com::SafeIfaceArray <IMachine> machines;
362 CHECK_ERROR_BREAK (virtualBox,
363 COMGETTER(Machines2) (ComSafeArrayAsOutParam (machines)));
364
365 printf ("%u machines registered (machines.isNull()=%d).\n",
366 machines.size(), machines.isNull());
367
368 for (size_t i = 0; i < machines.size(); ++ i)
369 {
370 Bstr name;
371 CHECK_ERROR_BREAK (machines [i], COMGETTER(Name) (name.asOutParam()));
372 printf ("machines[%u]='%s'\n", i, Utf8Str (name).raw());
373 }
374
375#if 0
376 {
377 printf ("Testing [out] arrays...\n");
378 com::SafeGUIDArray uuids;
379 CHECK_ERROR_BREAK (virtualBox,
380 COMGETTER(Uuids) (ComSafeArrayAsOutParam (uuids)));
381
382 for (size_t i = 0; i < uuids.size(); ++ i)
383 printf ("uuids[%u]=%Vuuid\n", i, &uuids [i]);
384 }
385
386 {
387 printf ("Testing [in] arrays...\n");
388 com::SafeGUIDArray uuids (5);
389 for (size_t i = 0; i < uuids.size(); ++ i)
390 {
391 Guid id;
392 id.create();
393 uuids [i] = id;
394 printf ("uuids[%u]=%Vuuid\n", i, &uuids [i]);
395 }
396
397 CHECK_ERROR_BREAK (virtualBox,
398 SetUuids (ComSafeArrayAsInParam (uuids)));
399 }
400#endif
401
402 }
403#endif
404
405#if 0
406 // some outdated stuff
407 ////////////////////////////////////////////////////////////////////////////
408
409 printf("Getting IHost interface...\n");
410 IHost *host;
411 rc = virtualBox->GetHost(&host);
412 if (SUCCEEDED(rc))
413 {
414 IHostDVDDriveCollection *dvdColl;
415 rc = host->GetHostDVDDrives(&dvdColl);
416 if (SUCCEEDED(rc))
417 {
418 IHostDVDDrive *dvdDrive = NULL;
419 dvdColl->GetNextHostDVDDrive(dvdDrive, &dvdDrive);
420 while (dvdDrive)
421 {
422 BSTR driveName;
423 char *driveNameUtf8;
424 dvdDrive->GetDriveName(&driveName);
425 RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
426 printf("Host DVD drive name: %s\n", driveNameUtf8);
427 RTStrFree(driveNameUtf8);
428 SysFreeString(driveName);
429 IHostDVDDrive *dvdDriveTemp = dvdDrive;
430 dvdColl->GetNextHostDVDDrive(dvdDriveTemp, &dvdDrive);
431 dvdDriveTemp->Release();
432 }
433 dvdColl->Release();
434 } else
435 {
436 printf("Could not get host DVD drive collection\n");
437 }
438
439 IHostFloppyDriveCollection *floppyColl;
440 rc = host->GetHostFloppyDrives(&floppyColl);
441 if (SUCCEEDED(rc))
442 {
443 IHostFloppyDrive *floppyDrive = NULL;
444 floppyColl->GetNextHostFloppyDrive(floppyDrive, &floppyDrive);
445 while (floppyDrive)
446 {
447 BSTR driveName;
448 char *driveNameUtf8;
449 floppyDrive->GetDriveName(&driveName);
450 RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
451 printf("Host floppy drive name: %s\n", driveNameUtf8);
452 RTStrFree(driveNameUtf8);
453 SysFreeString(driveName);
454 IHostFloppyDrive *floppyDriveTemp = floppyDrive;
455 floppyColl->GetNextHostFloppyDrive(floppyDriveTemp, &floppyDrive);
456 floppyDriveTemp->Release();
457 }
458 floppyColl->Release();
459 } else
460 {
461 printf("Could not get host floppy drive collection\n");
462 }
463 host->Release();
464 } else
465 {
466 printf("Call failed\n");
467 }
468 printf ("\n");
469#endif
470
471#if 0
472 // IVirtualBoxErrorInfo test
473 ////////////////////////////////////////////////////////////////////////////
474 {
475 // RPC calls
476
477 // call a method that will definitely fail
478 Guid uuid;
479 ComPtr <IHardDisk> hardDisk;
480 rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
481 printf ("virtualBox->GetHardDisk(null-uuid)=%08X\n", rc);
482
483// {
484// com::ErrorInfo info (virtualBox);
485// PRINT_ERROR_INFO (info);
486// }
487
488 // call a method that will definitely succeed
489 Bstr version;
490 rc = virtualBox->COMGETTER(Version) (version.asOutParam());
491 printf ("virtualBox->COMGETTER(Version)=%08X\n", rc);
492
493 {
494 com::ErrorInfo info (virtualBox);
495 PRINT_ERROR_INFO (info);
496 }
497
498 // Local calls
499
500 // call a method that will definitely fail
501 ComPtr <IMachine> machine;
502 rc = session->COMGETTER(Machine)(machine.asOutParam());
503 printf ("session->COMGETTER(Machine)=%08X\n", rc);
504
505// {
506// com::ErrorInfo info (virtualBox);
507// PRINT_ERROR_INFO (info);
508// }
509
510 // call a method that will definitely succeed
511 SessionState_T state;
512 rc = session->COMGETTER(State) (&state);
513 printf ("session->COMGETTER(State)=%08X\n", rc);
514
515 {
516 com::ErrorInfo info (virtualBox);
517 PRINT_ERROR_INFO (info);
518 }
519 }
520#endif
521
522#if 0
523 // register the existing hard disk image
524 ///////////////////////////////////////////////////////////////////////////
525 do
526 {
527 ComPtr <IHardDisk> hd;
528 Bstr src = L"E:\\develop\\innotek\\images\\NewHardDisk.vdi";
529 printf ("Opening the existing hard disk '%ls'...\n", src.raw());
530 CHECK_ERROR_BREAK (virtualBox, OpenHardDisk (src, hd.asOutParam()));
531 printf ("Enter to continue...\n");
532 getchar();
533 printf ("Registering the existing hard disk '%ls'...\n", src.raw());
534 CHECK_ERROR_BREAK (virtualBox, RegisterHardDisk (hd));
535 printf ("Enter to continue...\n");
536 getchar();
537 }
538 while (FALSE);
539 printf ("\n");
540#endif
541
542#if 0
543 // find and unregister the existing hard disk image
544 ///////////////////////////////////////////////////////////////////////////
545 do
546 {
547 ComPtr <IVirtualDiskImage> vdi;
548 Bstr src = L"CreatorTest.vdi";
549 printf ("Unregistering the hard disk '%ls'...\n", src.raw());
550 CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
551 ComPtr <IHardDisk> hd = vdi;
552 Guid id;
553 CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
554 CHECK_ERROR_BREAK (virtualBox, UnregisterHardDisk (id, hd.asOutParam()));
555 }
556 while (FALSE);
557 printf ("\n");
558#endif
559
560#if 0
561 // clone the registered hard disk
562 ///////////////////////////////////////////////////////////////////////////
563 do
564 {
565#if defined RT_OS_LINUX
566 Bstr src = L"/mnt/hugaida/common/develop/innotek/images/freedos-linux.vdi";
567#else
568 Bstr src = L"E:/develop/innotek/images/freedos.vdi";
569#endif
570 Bstr dst = L"./clone.vdi";
571 RTPrintf ("Cloning '%ls' to '%ls'...\n", src.raw(), dst.raw());
572 ComPtr <IVirtualDiskImage> vdi;
573 CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
574 ComPtr <IHardDisk> hd = vdi;
575 ComPtr <IProgress> progress;
576 CHECK_ERROR_BREAK (hd, CloneToImage (dst, vdi.asOutParam(), progress.asOutParam()));
577 RTPrintf ("Waiting for completion...\n");
578 CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
579 ProgressErrorInfo ei (progress);
580 if (FAILED (ei.getResultCode()))
581 {
582 PRINT_ERROR_INFO (ei);
583 }
584 else
585 {
586 vdi->COMGETTER(FilePath) (dst.asOutParam());
587 RTPrintf ("Actual clone path is '%ls'\n", dst.raw());
588 }
589 }
590 while (FALSE);
591 printf ("\n");
592#endif
593
594#if 0
595 // find a registered hard disk by location
596 ///////////////////////////////////////////////////////////////////////////
597 do
598 {
599 ComPtr <IHardDisk> hd;
600 static const wchar_t *Names[] =
601 {
602#ifndef RT_OS_LINUX
603 L"E:/Develop/innotek/images/thinker/freedos.vdi",
604 L"E:/Develop/innotek/images/thinker/fReeDoS.vDI",
605 L"E:/Develop/innotek/images/vmdk/haiku.vmdk",
606#else
607 L"/mnt/host/common/Develop/innotek/images/maggot/freedos.vdi",
608 L"/mnt/host/common/Develop/innotek/images/maggot/fReeDoS.vDI",
609#endif
610 };
611 for (size_t i = 0; i < ELEMENTS (Names); ++ i)
612 {
613 Bstr src = Names [i];
614 printf ("Searching for hard disk '%ls'...\n", src.raw());
615 rc = virtualBox->FindHardDisk (src, hd.asOutParam());
616 if (SUCCEEDED (rc))
617 {
618 Guid id;
619 Bstr location;
620 CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
621 CHECK_ERROR_BREAK (hd, COMGETTER(Location) (location.asOutParam()));
622 printf ("Found, UUID={%Vuuid}, location='%ls'.\n",
623 id.raw(), location.raw());
624 }
625 else
626 {
627 PRINT_ERROR_INFO (com::ErrorInfo (virtualBox));
628 }
629 }
630 }
631 while (FALSE);
632 printf ("\n");
633#endif
634
635#if 0
636 // access the machine in read-only mode
637 ///////////////////////////////////////////////////////////////////////////
638 do
639 {
640 ComPtr <IMachine> machine;
641 Bstr name = argc > 1 ? argv [1] : "dos";
642 printf ("Getting a machine object named '%ls'...\n", name.raw());
643 CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
644 printf ("Accessing the machine in read-only mode:\n");
645 readAndChangeMachineSettings (machine);
646#if 0
647 if (argc != 2)
648 {
649 printf ("Error: a string has to be supplied!\n");
650 }
651 else
652 {
653 Bstr secureLabel = argv[1];
654 machine->COMSETTER(ExtraData)(L"VBoxSDL/SecureLabel", secureLabel);
655 }
656#endif
657 }
658 while (0);
659 printf ("\n");
660#endif
661
662#if 0
663 // create a new machine (w/o registering it)
664 ///////////////////////////////////////////////////////////////////////////
665 do
666 {
667 ComPtr <IMachine> machine;
668#if defined (RT_OS_LINUX)
669 Bstr baseDir = L"/tmp/vbox";
670#else
671 Bstr baseDir = L"C:\\vbox";
672#endif
673 Bstr name = L"machina";
674
675 printf ("Creating a new machine object (base dir '%ls', name '%ls')...\n",
676 baseDir.raw(), name.raw());
677 CHECK_ERROR_BREAK (virtualBox, CreateMachine (baseDir, name,
678 machine.asOutParam()));
679
680 printf ("Getting name...\n");
681 CHECK_ERROR_BREAK (machine, COMGETTER(Name) (name.asOutParam()));
682 printf ("Name: {%ls}\n", name.raw());
683
684 BOOL modified = FALSE;
685 printf ("Are any settings modified?...\n");
686 CHECK_ERROR_BREAK (machine, COMGETTER(SettingsModified) (&modified));
687 printf ("%s\n", modified ? "yes" : "no");
688
689 ASSERT_BREAK (modified == TRUE);
690
691 name = L"Kakaya prekrasnaya virtual'naya mashina!";
692 printf ("Setting new name ({%ls})...\n", name.raw());
693 CHECK_ERROR_BREAK (machine, COMSETTER(Name) (name));
694
695 printf ("Setting memory size to 111...\n");
696 CHECK_ERROR_BREAK (machine, COMSETTER(MemorySize) (111));
697
698 Bstr desc = L"This is an exemplary description.";
699 printf ("Setting description to \"%ls\"...\n", desc.raw());
700 CHECK_ERROR_BREAK (machine, COMSETTER(Description) (desc));
701
702 ComPtr <IGuestOSType> guestOSType;
703 Bstr type = L"os2warp45";
704 CHECK_ERROR_BREAK (virtualBox, GetGuestOSType (type, guestOSType.asOutParam()));
705
706 printf ("Saving new machine settings...\n");
707 CHECK_ERROR_BREAK (machine, SaveSettings());
708
709 printf ("Accessing the newly created machine:\n");
710 readAndChangeMachineSettings (machine);
711 }
712 while (FALSE);
713 printf ("\n");
714#endif
715
716#if 0
717 // enumerate host DVD drives
718 ///////////////////////////////////////////////////////////////////////////
719 do
720 {
721 ComPtr <IHost> host;
722 CHECK_RC_BREAK (virtualBox->COMGETTER(Host) (host.asOutParam()));
723
724 {
725 ComPtr <IHostDVDDriveCollection> coll;
726 CHECK_RC_BREAK (host->COMGETTER(DVDDrives) (coll.asOutParam()));
727 ComPtr <IHostDVDDriveEnumerator> enumerator;
728 CHECK_RC_BREAK (coll->Enumerate (enumerator.asOutParam()));
729 BOOL hasmore;
730 while (SUCCEEDED (enumerator->HasMore (&hasmore)) && hasmore)
731 {
732 ComPtr <IHostDVDDrive> drive;
733 CHECK_RC_BREAK (enumerator->GetNext (drive.asOutParam()));
734 Bstr name;
735 CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
736 printf ("Host DVD drive: name={%ls}\n", name.raw());
737 }
738 CHECK_RC_BREAK (rc);
739
740 ComPtr <IHostDVDDrive> drive;
741 CHECK_ERROR (enumerator, GetNext (drive.asOutParam()));
742 CHECK_ERROR (coll, GetItemAt (1000, drive.asOutParam()));
743 CHECK_ERROR (coll, FindByName (Bstr ("R:"), drive.asOutParam()));
744 if (SUCCEEDED (rc))
745 {
746 Bstr name;
747 CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
748 printf ("Found by name: name={%ls}\n", name.raw());
749 }
750 }
751 }
752 while (FALSE);
753 printf ("\n");
754#endif
755
756#if 0
757 // check for available hd backends
758 ///////////////////////////////////////////////////////////////////////////
759 {
760 printf("Supported harddisk backends: --------------------------\n");
761 ComPtr<ISystemProperties> systemProperties;
762 CHECK_ERROR_BREAK (virtualBox,
763 COMGETTER(SystemProperties) (systemProperties.asOutParam()));
764 com::SafeIfaceArray <IHardDiskFormat> hardDiskFormats;
765 CHECK_ERROR_BREAK (systemProperties,
766 COMGETTER(HardDiskFormats) (ComSafeArrayAsOutParam (hardDiskFormats)));
767
768 for (size_t i = 0; i < hardDiskFormats.size(); ++ i)
769 {
770 Bstr id;
771 CHECK_ERROR_BREAK (hardDiskFormats [i],
772 COMGETTER(Id) (id.asOutParam()));
773
774 com::SafeArray <BSTR> fileExtensions;
775 CHECK_ERROR_BREAK (hardDiskFormats [i],
776 COMGETTER(FileExtensions) (ComSafeArrayAsOutParam (fileExtensions)));
777
778 printf ("%ls:", id.raw());
779 for (size_t a = 0; a < fileExtensions.size(); ++ a)
780 printf (" %ls", Bstr(fileExtensions [a]).raw());
781 printf ("\n");
782 }
783 printf("-------------------------------------------------------\n");
784 }
785#endif
786
787#if 0
788 // enumerate hard disks & dvd images
789 ///////////////////////////////////////////////////////////////////////////
790 do
791 {
792 {
793 com::SafeIfaceArray <IHardDisk2> disks;
794 CHECK_ERROR_BREAK (virtualBox,
795 COMGETTER(HardDisks2) (ComSafeArrayAsOutParam (disks)));
796
797 printf ("%u base hard disks registered (disks.isNull()=%d).\n",
798 disks.size(), disks.isNull());
799
800 for (size_t i = 0; i < disks.size(); ++ i)
801 {
802 Bstr loc;
803 CHECK_ERROR_BREAK (disks [i], COMGETTER(Location) (loc.asOutParam()));
804 Guid id;
805 CHECK_ERROR_BREAK (disks [i], COMGETTER(Id) (id.asOutParam()));
806 MediaState_T state;
807 CHECK_ERROR_BREAK (disks [i], COMGETTER(State) (&state));
808 Bstr format;
809 CHECK_ERROR_BREAK (disks [i], COMGETTER(Format) (format.asOutParam()));
810
811 printf (" disks[%u]: '%ls'\n"
812 " UUID: {%Vuuid}\n"
813 " State: %s\n"
814 " Format: %ls\n",
815 i, loc.raw(), id.raw(),
816 state == MediaState_NotCreated ? "Not Created" :
817 state == MediaState_Created ? "Created" :
818 state == MediaState_Inaccessible ? "Inaccessible" :
819 state == MediaState_LockedRead ? "Locked Read" :
820 state == MediaState_LockedWrite ? "Locked Write" :
821 "???",
822 format.raw());
823
824 if (state == MediaState_Inaccessible)
825 {
826 Bstr error;
827 CHECK_ERROR_BREAK (disks [i],
828 COMGETTER(LastAccessError)(error.asOutParam()));
829 printf (" Access Error: %ls\n", error.raw());
830 }
831
832 /* get usage */
833
834 printf (" Used by VMs:\n");
835
836 com::SafeGUIDArray ids;
837 CHECK_ERROR_BREAK (disks [i],
838 COMGETTER(MachineIds) (ComSafeArrayAsOutParam (ids)));
839 if (ids.size() == 0)
840 {
841 printf (" <not used>\n");
842 }
843 else
844 {
845 for (size_t j = 0; j < ids.size(); ++ j)
846 {
847 printf (" {%Vuuid}\n", &ids [i]);
848 }
849 }
850 }
851 }
852 {
853 com::SafeIfaceArray <IDVDImage2> images;
854 CHECK_ERROR_BREAK (virtualBox,
855 COMGETTER(DVDImages) (ComSafeArrayAsOutParam (images)));
856
857 printf ("%u DVD images registered (images.isNull()=%d).\n",
858 images.size(), images.isNull());
859
860 for (size_t i = 0; i < images.size(); ++ i)
861 {
862 Bstr loc;
863 CHECK_ERROR_BREAK (images [i], COMGETTER(Location) (loc.asOutParam()));
864 Guid id;
865 CHECK_ERROR_BREAK (images [i], COMGETTER(Id) (id.asOutParam()));
866 MediaState_T state;
867 CHECK_ERROR_BREAK (images [i], COMGETTER(State) (&state));
868
869 printf (" images[%u]: '%ls'\n"
870 " UUID: {%Vuuid}\n"
871 " State: %s\n",
872 i, loc.raw(), id.raw(),
873 state == MediaState_NotCreated ? "Not Created" :
874 state == MediaState_Created ? "Created" :
875 state == MediaState_Inaccessible ? "Inaccessible" :
876 state == MediaState_LockedRead ? "Locked Read" :
877 state == MediaState_LockedWrite ? "Locked Write" :
878 "???");
879
880 if (state == MediaState_Inaccessible)
881 {
882 Bstr error;
883 CHECK_ERROR_BREAK (images [i],
884 COMGETTER(LastAccessError)(error.asOutParam()));
885 printf (" Access Error: %ls\n", error.raw());
886 }
887
888 /* get usage */
889
890 printf (" Used by VMs:\n");
891
892 com::SafeGUIDArray ids;
893 CHECK_ERROR_BREAK (images [i],
894 COMGETTER(MachineIds) (ComSafeArrayAsOutParam (ids)));
895 if (ids.size() == 0)
896 {
897 printf (" <not used>\n");
898 }
899 else
900 {
901 for (size_t j = 0; j < ids.size(); ++ j)
902 {
903 printf (" {%Vuuid}\n", &ids [i]);
904 }
905 }
906 }
907 }
908 }
909 while (FALSE);
910 printf ("\n");
911#endif
912
913#if 0
914 // open a (direct) session
915 ///////////////////////////////////////////////////////////////////////////
916 do
917 {
918 ComPtr <IMachine> machine;
919 Bstr name = argc > 1 ? argv [1] : "dos";
920 printf ("Getting a machine object named '%ls'...\n", name.raw());
921 CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
922 Guid guid;
923 CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
924 printf ("Opening a session for this machine...\n");
925 CHECK_RC_BREAK (virtualBox->OpenSession (session, guid));
926#if 1
927 ComPtr <IMachine> sessionMachine;
928 printf ("Getting sessioned machine object...\n");
929 CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
930 printf ("Accessing the machine within the session:\n");
931 readAndChangeMachineSettings (sessionMachine, machine);
932#if 0
933 printf ("\n");
934 printf ("Enabling the VRDP server (must succeed even if the VM is saved):\n");
935 ComPtr <IVRDPServer> vrdp;
936 CHECK_ERROR_BREAK (sessionMachine, COMGETTER(VRDPServer) (vrdp.asOutParam()));
937 if (FAILED (vrdp->COMSETTER(Enabled) (TRUE)))
938 {
939 PRINT_ERROR_INFO (com::ErrorInfo (vrdp));
940 }
941 else
942 {
943 BOOL enabled = FALSE;
944 CHECK_ERROR_BREAK (vrdp, COMGETTER(Enabled) (&enabled));
945 printf ("VRDP server is %s\n", enabled ? "enabled" : "disabled");
946 }
947#endif
948#endif
949#if 0
950 ComPtr <IConsole> console;
951 printf ("Getting the console object...\n");
952 CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
953 printf ("Discarding the current machine state...\n");
954 ComPtr <IProgress> progress;
955 CHECK_ERROR_BREAK (console, DiscardCurrentState (progress.asOutParam()));
956 printf ("Waiting for completion...\n");
957 CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
958 ProgressErrorInfo ei (progress);
959 if (FAILED (ei.getResultCode()))
960 {
961 PRINT_ERROR_INFO (ei);
962
963 ComPtr <IUnknown> initiator;
964 CHECK_ERROR_BREAK (progress, COMGETTER(Initiator) (initiator.asOutParam()));
965
966 printf ("initiator(unk) = %p\n", (IUnknown *) initiator);
967 printf ("console(unk) = %p\n", (IUnknown *) ComPtr <IUnknown> ((IConsole *) console));
968 printf ("console = %p\n", (IConsole *) console);
969 }
970#endif
971 printf("Press enter to close session...");
972 getchar();
973 session->Close();
974 }
975 while (FALSE);
976 printf ("\n");
977#endif
978
979#if 0
980 // open a remote session
981 ///////////////////////////////////////////////////////////////////////////
982 do
983 {
984 ComPtr <IMachine> machine;
985 Bstr name = L"dos";
986 printf ("Getting a machine object named '%ls'...\n", name.raw());
987 CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
988 Guid guid;
989 CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
990 printf ("Opening a remote session for this machine...\n");
991 ComPtr <IProgress> progress;
992 CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, Bstr("gui"),
993 NULL, progress.asOutParam()));
994 printf ("Waiting for the session to open...\n");
995 CHECK_RC_BREAK (progress->WaitForCompletion (-1));
996 ComPtr <IMachine> sessionMachine;
997 printf ("Getting sessioned machine object...\n");
998 CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
999 ComPtr <IConsole> console;
1000 printf ("Getting console object...\n");
1001 CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
1002 printf ("Press enter to pause the VM execution in the remote session...");
1003 getchar();
1004 CHECK_RC (console->Pause());
1005 printf ("Press enter to close this session...");
1006 getchar();
1007 session->Close();
1008 }
1009 while (FALSE);
1010 printf ("\n");
1011#endif
1012
1013#if 0
1014 // open an existing remote session
1015 ///////////////////////////////////////////////////////////////////////////
1016 do
1017 {
1018 ComPtr <IMachine> machine;
1019 Bstr name = "dos";
1020 printf ("Getting a machine object named '%ls'...\n", name.raw());
1021 CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
1022 Guid guid;
1023 CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
1024 printf ("Opening an existing remote session for this machine...\n");
1025 CHECK_RC_BREAK (virtualBox->OpenExistingSession (session, guid));
1026 ComPtr <IMachine> sessionMachine;
1027 printf ("Getting sessioned machine object...\n");
1028 CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
1029
1030#if 0
1031 Bstr extraDataKey = "VBoxSDL/SecureLabel";
1032 Bstr extraData = "Das kommt jetzt noch viel krasser vom total konkreten API!";
1033 CHECK_RC (sessionMachine->SetExtraData (extraDataKey, extraData));
1034#endif
1035#if 0
1036 ComPtr <IConsole> console;
1037 printf ("Getting console object...\n");
1038 CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
1039 printf ("Press enter to pause the VM execution in the remote session...");
1040 getchar();
1041 CHECK_RC (console->Pause());
1042 printf ("Press enter to close this session...");
1043 getchar();
1044#endif
1045 session->Close();
1046 }
1047 while (FALSE);
1048 printf ("\n");
1049#endif
1050
1051#ifdef VBOX_WITH_RESOURCE_USAGE_API
1052 do {
1053 // Get collector
1054 ComPtr <IPerformanceCollector> collector;
1055 CHECK_ERROR_BREAK (virtualBox,
1056 COMGETTER(PerformanceCollector) (collector.asOutParam()));
1057
1058
1059 // Fill base metrics array
1060 Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
1061 com::SafeArray<BSTR> baseMetrics (1);
1062 baseMetricNames[0].cloneTo (&baseMetrics [0]);
1063
1064 // Get host
1065 ComPtr <IHost> host;
1066 CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
1067
1068 // Get machine
1069 ComPtr <IMachine> machine;
1070 Bstr name = argc > 1 ? argv [1] : "dsl";
1071 Bstr sessionType = argc > 2 ? argv [2] : "vrdp";
1072 printf ("Getting a machine object named '%ls'...\n", name.raw());
1073 CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
1074
1075 // Open session
1076 Guid guid;
1077 CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
1078 printf ("Opening a remote session for this machine...\n");
1079 ComPtr <IProgress> progress;
1080 CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, sessionType,
1081 NULL, progress.asOutParam()));
1082 printf ("Waiting for the session to open...\n");
1083 CHECK_RC_BREAK (progress->WaitForCompletion (-1));
1084 ComPtr <IMachine> sessionMachine;
1085 printf ("Getting sessioned machine object...\n");
1086 CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
1087
1088 // Setup base metrics
1089 // Note that one needs to set up metrics after a session is open for a machine.
1090 com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
1091 com::SafeIfaceArray<IUnknown> objects(2);
1092 host.queryInterfaceTo(&objects[0]);
1093 machine.queryInterfaceTo(&objects[1]);
1094 CHECK_ERROR_BREAK (collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1095 ComSafeArrayAsInParam(objects), 1u, 10u,
1096 ComSafeArrayAsOutParam(affectedMetrics)) );
1097 listAffectedMetrics(virtualBox,
1098 ComSafeArrayAsInParam(affectedMetrics));
1099 affectedMetrics.setNull();
1100
1101 // Get console
1102 ComPtr <IConsole> console;
1103 printf ("Getting console object...\n");
1104 CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
1105
1106 RTThreadSleep(5000); // Sleep for 5 seconds
1107
1108 printf("\nMetrics collected with VM running: --------------------\n");
1109 queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1110
1111 // Pause
1112 //printf ("Press enter to pause the VM execution in the remote session...");
1113 //getchar();
1114 CHECK_RC (console->Pause());
1115
1116 RTThreadSleep(5000); // Sleep for 5 seconds
1117
1118 printf("\nMetrics collected with VM paused: ---------------------\n");
1119 queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1120
1121 printf("\nDrop collected metrics: ----------------------------------------\n");
1122 CHECK_ERROR_BREAK (collector,
1123 SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
1124 ComSafeArrayAsInParam(objects),
1125 1u, 5u, ComSafeArrayAsOutParam(affectedMetrics)) );
1126 listAffectedMetrics(virtualBox,
1127 ComSafeArrayAsInParam(affectedMetrics));
1128 affectedMetrics.setNull();
1129 queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1130
1131 com::SafeIfaceArray<IUnknown> vmObject(1);
1132 machine.queryInterfaceTo(&vmObject[0]);
1133
1134 printf("\nDisable collection of VM metrics: ------------------------------\n");
1135 CHECK_ERROR_BREAK (collector,
1136 DisableMetrics(ComSafeArrayAsInParam(baseMetrics),
1137 ComSafeArrayAsInParam(vmObject),
1138 ComSafeArrayAsOutParam(affectedMetrics)) );
1139 listAffectedMetrics(virtualBox,
1140 ComSafeArrayAsInParam(affectedMetrics));
1141 affectedMetrics.setNull();
1142 RTThreadSleep(5000); // Sleep for 5 seconds
1143 queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1144
1145 printf("\nRe-enable collection of all metrics: ---------------------------\n");
1146 CHECK_ERROR_BREAK (collector,
1147 EnableMetrics(ComSafeArrayAsInParam(baseMetrics),
1148 ComSafeArrayAsInParam(objects),
1149 ComSafeArrayAsOutParam(affectedMetrics)) );
1150 listAffectedMetrics(virtualBox,
1151 ComSafeArrayAsInParam(affectedMetrics));
1152 affectedMetrics.setNull();
1153 RTThreadSleep(5000); // Sleep for 5 seconds
1154 queryMetrics(virtualBox, collector, ComSafeArrayAsInParam(objects));
1155
1156 // Power off
1157 printf ("Press enter to power off VM...");
1158 getchar();
1159 CHECK_RC (console->PowerDown());
1160 printf ("Press enter to close this session...");
1161 getchar();
1162 session->Close();
1163 } while (false);
1164#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1165
1166 printf ("Press enter to release Session and VirtualBox instances...");
1167 getchar();
1168
1169 // end "all-stuff" scope
1170 ////////////////////////////////////////////////////////////////////////////
1171 }
1172 while (0);
1173
1174 printf("Press enter to shutdown COM...");
1175 getchar();
1176
1177 com::Shutdown();
1178
1179 printf ("tstAPI FINISHED.\n");
1180
1181 return rc;
1182}
1183
1184#ifdef VBOX_WITH_RESOURCE_USAGE_API
1185static void queryMetrics (ComPtr<IVirtualBox> aVirtualBox,
1186 ComPtr <IPerformanceCollector> collector,
1187 ComSafeArrayIn (IUnknown *, objects))
1188{
1189 HRESULT rc;
1190
1191 //Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
1192 Bstr metricNames[] = { L"*" };
1193 com::SafeArray<BSTR> metrics (1);
1194 metricNames[0].cloneTo (&metrics [0]);
1195 com::SafeArray<BSTR> retNames;
1196 com::SafeIfaceArray<IUnknown> retObjects;
1197 com::SafeArray<BSTR> retUnits;
1198 com::SafeArray<ULONG> retScales;
1199 com::SafeArray<ULONG> retSequenceNumbers;
1200 com::SafeArray<ULONG> retIndices;
1201 com::SafeArray<ULONG> retLengths;
1202 com::SafeArray<LONG> retData;
1203 CHECK_ERROR (collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
1204 ComSafeArrayInArg(objects),
1205 ComSafeArrayAsOutParam(retNames),
1206 ComSafeArrayAsOutParam(retObjects),
1207 ComSafeArrayAsOutParam(retUnits),
1208 ComSafeArrayAsOutParam(retScales),
1209 ComSafeArrayAsOutParam(retSequenceNumbers),
1210 ComSafeArrayAsOutParam(retIndices),
1211 ComSafeArrayAsOutParam(retLengths),
1212 ComSafeArrayAsOutParam(retData)) );
1213 RTPrintf("Object Metric Values\n"
1214 "---------- -------------------- --------------------------------------------\n");
1215 for (unsigned i = 0; i < retNames.size(); i++)
1216 {
1217 Bstr metricUnit(retUnits[i]);
1218 Bstr metricName(retNames[i]);
1219 RTPrintf("%-10ls %-20ls ", getObjectName(aVirtualBox, retObjects[i]).raw(), metricName.raw());
1220 const char *separator = "";
1221 for (unsigned j = 0; j < retLengths[i]; j++)
1222 {
1223 if (retScales[i] == 1)
1224 RTPrintf("%s%d %ls", separator, retData[retIndices[i] + j], metricUnit.raw());
1225 else
1226 RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[i] + j] / retScales[i],
1227 (retData[retIndices[i] + j] * 100 / retScales[i]) % 100, metricUnit.raw());
1228 separator = ", ";
1229 }
1230 RTPrintf("\n");
1231 }
1232}
1233
1234static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
1235 ComPtr<IUnknown> aObject)
1236{
1237 HRESULT rc;
1238
1239 ComPtr<IHost> host = aObject;
1240 if (!host.isNull())
1241 return Bstr("host");
1242
1243 ComPtr<IMachine> machine = aObject;
1244 if (!machine.isNull())
1245 {
1246 Bstr name;
1247 CHECK_ERROR(machine, COMGETTER(Name)(name.asOutParam()));
1248 if (SUCCEEDED(rc))
1249 return name;
1250 }
1251 return Bstr("unknown");
1252}
1253
1254static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
1255 ComSafeArrayIn(IPerformanceMetric*, aMetrics))
1256{
1257 HRESULT rc;
1258 com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics));
1259 if (metrics.size())
1260 {
1261 ComPtr<IUnknown> object;
1262 Bstr metricName;
1263 RTPrintf("The following metrics were modified:\n\n"
1264 "Object Metric\n"
1265 "---------- --------------------\n");
1266 for (size_t i = 0; i < metrics.size(); i++)
1267 {
1268 CHECK_ERROR(metrics[i], COMGETTER(Object)(object.asOutParam()));
1269 CHECK_ERROR(metrics[i], COMGETTER(MetricName)(metricName.asOutParam()));
1270 RTPrintf("%-10ls %-20ls\n",
1271 getObjectName(aVirtualBox, object).raw(), metricName.raw());
1272 }
1273 RTPrintf("\n");
1274 }
1275 else
1276 {
1277 RTPrintf("No metrics match the specified filter!\n");
1278 }
1279}
1280
1281#endif /* VBOX_WITH_RESOURCE_USAGE_API */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use