tstAPI.cpp@ 10878

Last change on this file since 10878 was 10878, checked in by vboxsync, 16 years ago
PerfAPI: Linux implementation ready
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.9 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
34	using 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
50	void queryMetrics (ComPtr <IPerformanceCollector> collector,
51	ComSafeArrayIn (IUnknown *, objects));
52
53	// funcs
54	///////////////////////////////////////////////////////////////////////////////
55
56	HRESULT readAndChangeMachineSettings (IMachine machine, IMachine readonlyMachine = 0)
57	{
58	HRESULT rc = S_OK;
59
60	Bstr name;
61	printf ("Getting machine name...\n");
62	CHECK_RC_RET (machine->COMGETTER(Name) (name.asOutParam()));
63	printf ("Name: {%ls}\n", name.raw());
64
65	printf("Getting machine GUID...\n");
66	Guid guid;
67	CHECK_RC (machine->COMGETTER(Id) (guid.asOutParam()));
68	if (SUCCEEDED (rc) && !guid.isEmpty()) {
69	printf ("Guid::toString(): {%s}\n", (const char *) guid.toString());
70	} else {
71	printf ("WARNING: there's no GUID!");
72	}
73
74	ULONG memorySize;
75	printf ("Getting memory size...\n");
76	CHECK_RC_RET (machine->COMGETTER(MemorySize) (&memorySize));
77	printf ("Memory size: %d\n", memorySize);
78
79	MachineState_T machineState;
80	printf ("Getting machine state...\n");
81	CHECK_RC_RET (machine->COMGETTER(State) (&machineState));
82	printf ("Machine state: %d\n", machineState);
83
84	BOOL modified;
85	printf ("Are any settings modified?...\n");
86	CHECK_RC (machine->COMGETTER(SettingsModified) (&modified));
87	if (SUCCEEDED (rc))
88	printf ("%s\n", modified ? "yes" : "no");
89
90	ULONG memorySizeBig = memorySize * 10;
91	printf("Changing memory size to %d...\n", memorySizeBig);
92	CHECK_RC (machine->COMSETTER(MemorySize) (memorySizeBig));
93
94	if (SUCCEEDED (rc))
95	{
96	printf ("Are any settings modified now?...\n");
97	CHECK_RC_RET (machine->COMGETTER(SettingsModified) (&modified));
98	printf ("%s\n", modified ? "yes" : "no");
99	ASSERT_RET (modified, 0);
100
101	ULONG memorySizeGot;
102	printf ("Getting memory size again...\n");
103	CHECK_RC_RET (machine->COMGETTER(MemorySize) (&memorySizeGot));
104	printf ("Memory size: %d\n", memorySizeGot);
105	ASSERT_RET (memorySizeGot == memorySizeBig, 0);
106
107	if (readonlyMachine)
108	{
109	printf ("Getting memory size of the counterpart readonly machine...\n");
110	ULONG memorySizeRO;
111	readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
112	printf ("Memory size: %d\n", memorySizeRO);
113	ASSERT_RET (memorySizeRO != memorySizeGot, 0);
114	}
115
116	printf ("Discarding recent changes...\n");
117	CHECK_RC_RET (machine->DiscardSettings());
118	printf ("Are any settings modified after discarding?...\n");
119	CHECK_RC_RET (machine->COMGETTER(SettingsModified) (&modified));
120	printf ("%s\n", modified ? "yes" : "no");
121	ASSERT_RET (!modified, 0);
122
123	printf ("Getting memory size once more...\n");
124	CHECK_RC_RET (machine->COMGETTER(MemorySize) (&memorySizeGot));
125	printf ("Memory size: %d\n", memorySizeGot);
126	ASSERT_RET (memorySizeGot == memorySize, 0);
127
128	memorySize = memorySize > 128 ? memorySize / 2 : memorySize * 2;
129	printf("Changing memory size to %d...\n", memorySize);
130	CHECK_RC_RET (machine->COMSETTER(MemorySize) (memorySize));
131	}
132
133	Bstr desc;
134	printf ("Getting description...\n");
135	CHECK_ERROR_RET (machine, COMGETTER(Description) (desc.asOutParam()), rc);
136	printf ("Description is: \"%ls\"\n", desc.raw());
137
138	desc = L"This is an exemplary description (changed).";
139	printf ("Setting description to \"%ls\"...\n", desc.raw());
140	CHECK_ERROR_RET (machine, COMSETTER(Description) (desc), rc);
141
142	printf ("Saving machine settings...\n");
143	CHECK_RC (machine->SaveSettings());
144	if (SUCCEEDED (rc))
145	{
146	printf ("Are any settings modified after saving?...\n");
147	CHECK_RC_RET (machine->COMGETTER(SettingsModified) (&modified));
148	printf ("%s\n", modified ? "yes" : "no");
149	ASSERT_RET (!modified, 0);
150
151	if (readonlyMachine) {
152	printf ("Getting memory size of the counterpart readonly machine...\n");
153	ULONG memorySizeRO;
154	readonlyMachine->COMGETTER(MemorySize) (&memorySizeRO);
155	printf ("Memory size: %d\n", memorySizeRO);
156	ASSERT_RET (memorySizeRO == memorySize, 0);
157	}
158	}
159
160	Bstr extraDataKey = L"Blafasel";
161	Bstr extraData;
162	printf ("Getting extra data key {%ls}...\n", extraDataKey.raw());
163	CHECK_RC_RET (machine->GetExtraData (extraDataKey, extraData.asOutParam()));
164	if (!extraData.isEmpty()) {
165	printf ("Extra data value: {%ls}\n", extraData.raw());
166	} else {
167	if (extraData.isNull())
168	printf ("No extra data exists\n");
169	else
170	printf ("Extra data is empty\n");
171	}
172
173	if (extraData.isEmpty())
174	extraData = L"Das ist die Berliner Luft, Luft, Luft...";
175	else
176	extraData.setNull();
177	printf (
178	"Setting extra data key {%ls} to {%ls}...\n",
179	extraDataKey.raw(), extraData.raw()
180	);
181	CHECK_RC (machine->SetExtraData (extraDataKey, extraData));
182
183	if (SUCCEEDED (rc)) {
184	printf ("Getting extra data key {%ls} again...\n", extraDataKey.raw());
185	CHECK_RC_RET (machine->GetExtraData (extraDataKey, extraData.asOutParam()));
186	if (!extraData.isEmpty()) {
187	printf ("Extra data value: {%ls}\n", extraData.raw());
188	} else {
189	if (extraData.isNull())
190	printf ("No extra data exists\n");
191	else
192	printf ("Extra data is empty\n");
193	}
194	}
195
196	return rc;
197	}
198
199	// main
200	///////////////////////////////////////////////////////////////////////////////
201
202	int main(int argc, char *argv[])
203	{
204	/*
205	* Initialize the VBox runtime without loading
206	* the support driver.
207	*/
208	RTR3Init(false);
209
210	HRESULT rc;
211
212	{
213	char homeDir [RTPATH_MAX];
214	GetVBoxUserHomeDirectory (homeDir, sizeof (homeDir));
215	printf ("VirtualBox Home Directory = '%s'\n", homeDir);
216	}
217
218	printf ("Initializing COM...\n");
219
220	CHECK_RC_RET (com::Initialize());
221
222	do
223	{
224	// scopes all the stuff till shutdown
225	////////////////////////////////////////////////////////////////////////////
226
227	ComPtr <IVirtualBox> virtualBox;
228	ComPtr <ISession> session;
229
230	#if 0
231	// Utf8Str test
232	////////////////////////////////////////////////////////////////////////////
233
234	Utf8Str nullUtf8Str;
235	printf ("nullUtf8Str='%s'\n", nullUtf8Str.raw());
236
237	Utf8Str simpleUtf8Str = "simpleUtf8Str";
238	printf ("simpleUtf8Str='%s'\n", simpleUtf8Str.raw());
239
240	Utf8Str utf8StrFmt = Utf8StrFmt ("[0=%d]%s[1=%d]",
241	0, "utf8StrFmt", 1);
242	printf ("utf8StrFmt='%s'\n", utf8StrFmt.raw());
243
244	#endif
245
246	printf ("Creating VirtualBox object...\n");
247	CHECK_RC (virtualBox.createLocalObject (CLSID_VirtualBox));
248	if (FAILED (rc))
249	{
250	CHECK_ERROR_NOCALL();
251	break;
252	}
253
254	printf ("Creating Session object...\n");
255	CHECK_RC (session.createInprocObject (CLSID_Session));
256	if (FAILED (rc))
257	{
258	CHECK_ERROR_NOCALL();
259	break;
260	}
261
262	#if 0
263	// IUnknown identity test
264	////////////////////////////////////////////////////////////////////////////
265	{
266	{
267	ComPtr <IVirtualBox> virtualBox2;
268
269	printf ("Creating one more VirtualBox object...\n");
270	CHECK_RC (virtualBox2.createLocalObject (CLSID_VirtualBox));
271	if (FAILED (rc))
272	{
273	CHECK_ERROR_NOCALL();
274	break;
275	}
276
277	printf ("IVirtualBox(virualBox)=%p IVirtualBox(virualBox2)=%p\n",
278	(IVirtualBox ) virtualBox, (IVirtualBox ) virtualBox2);
279	Assert ((IVirtualBox ) virtualBox == (IVirtualBox ) virtualBox2);
280
281	ComPtr <IUnknown> unk (virtualBox);
282	ComPtr <IUnknown> unk2;
283	unk2 = virtualBox2;
284
285	printf ("IUnknown(virualBox)=%p IUnknown(virualBox2)=%p\n",
286	(IUnknown ) unk, (IUnknown ) unk2);
287	Assert ((IUnknown ) unk == (IUnknown ) unk2);
288
289	ComPtr <IVirtualBox> vb = unk;
290	ComPtr <IVirtualBox> vb2 = unk;
291
292	printf ("IVirtualBox(IUnknown(virualBox))=%p IVirtualBox(IUnknown(virualBox2))=%p\n",
293	(IVirtualBox ) vb, (IVirtualBox ) vb2);
294	Assert ((IVirtualBox ) vb == (IVirtualBox ) vb2);
295	}
296
297	{
298	ComPtr <IHost> host;
299	CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host)(host.asOutParam()));
300	printf (" IHost(host)=%p\n", (IHost *) host);
301	ComPtr <IUnknown> unk = host;
302	printf (" IUnknown(host)=%p\n", (IUnknown *) unk);
303	ComPtr <IHost> host_copy = unk;
304	printf (" IHost(host_copy)=%p\n", (IHost *) host_copy);
305	ComPtr <IUnknown> unk_copy = host_copy;
306	printf (" IUnknown(host_copy)=%p\n", (IUnknown *) unk_copy);
307	Assert ((IUnknown ) unk == (IUnknown ) unk_copy);
308
309	/* query IUnknown on IUnknown */
310	ComPtr <IUnknown> unk_copy_copy;
311	unk_copy.queryInterfaceTo (unk_copy_copy.asOutParam());
312	printf (" IUnknown(unk_copy)=%p\n", (IUnknown *) unk_copy_copy);
313	Assert ((IUnknown ) unk_copy == (IUnknown ) unk_copy_copy);
314	/* query IUnknown on IUnknown in the opposite direction */
315	unk_copy_copy.queryInterfaceTo (unk_copy.asOutParam());
316	printf (" IUnknown(unk_copy_copy)=%p\n", (IUnknown *) unk_copy);
317	Assert ((IUnknown ) unk_copy == (IUnknown ) unk_copy_copy);
318
319	/* query IUnknown again after releasing all previous IUnknown instances
320	* but keeping IHost -- it should remain the same (Identity Rule) */
321	IUnknown *oldUnk = unk;
322	unk.setNull();
323	unk_copy.setNull();
324	unk_copy_copy.setNull();
325	unk = host;
326	printf (" IUnknown(host)=%p\n", (IUnknown *) unk);
327	Assert (oldUnk == (IUnknown *) unk);
328	}
329
330	// printf ("Will be now released (press Enter)...");
331	// getchar();
332	}
333	#endif
334
335	// create the event queue
336	// (here it is necessary only to process remaining XPCOM/IPC events
337	// after the session is closed)
338	EventQueue eventQ;
339
340	#if 0
341	// the simplest COM API test
342	////////////////////////////////////////////////////////////////////////////
343	{
344	Bstr version;
345	CHECK_ERROR_BREAK (virtualBox, COMGETTER(Version) (version.asOutParam()));
346	printf ("VirtualBox version = %ls\n", version.raw());
347	}
348	#endif
349
350	#if 1
351	// Array test
352	////////////////////////////////////////////////////////////////////////////
353	{
354	printf ("Calling IVirtualBox::Machines...\n");
355
356	com::SafeIfaceArray <IMachine> machines;
357	CHECK_ERROR_BREAK (virtualBox,
358	COMGETTER(Machines2) (ComSafeArrayAsOutParam (machines)));
359
360	printf ("%u machines registered (machines.isNull()=%d).\n",
361	machines.size(), machines.isNull());
362
363	for (size_t i = 0; i < machines.size(); ++ i)
364	{
365	Bstr name;
366	CHECK_ERROR_BREAK (machines [i], COMGETTER(Name) (name.asOutParam()));
367	printf ("machines[%u]='%s'\n", i, Utf8Str (name).raw());
368	}
369	}
370	#endif
371
372	#if 0
373	// some outdated stuff
374	////////////////////////////////////////////////////////////////////////////
375
376	printf("Getting IHost interface...\n");
377	IHost *host;
378	rc = virtualBox->GetHost(&host);
379	if (SUCCEEDED(rc))
380	{
381	IHostDVDDriveCollection *dvdColl;
382	rc = host->GetHostDVDDrives(&dvdColl);
383	if (SUCCEEDED(rc))
384	{
385	IHostDVDDrive *dvdDrive = NULL;
386	dvdColl->GetNextHostDVDDrive(dvdDrive, &dvdDrive);
387	while (dvdDrive)
388	{
389	BSTR driveName;
390	char *driveNameUtf8;
391	dvdDrive->GetDriveName(&driveName);
392	RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
393	printf("Host DVD drive name: %s\n", driveNameUtf8);
394	RTStrFree(driveNameUtf8);
395	SysFreeString(driveName);
396	IHostDVDDrive *dvdDriveTemp = dvdDrive;
397	dvdColl->GetNextHostDVDDrive(dvdDriveTemp, &dvdDrive);
398	dvdDriveTemp->Release();
399	}
400	dvdColl->Release();
401	} else
402	{
403	printf("Could not get host DVD drive collection\n");
404	}
405
406	IHostFloppyDriveCollection *floppyColl;
407	rc = host->GetHostFloppyDrives(&floppyColl);
408	if (SUCCEEDED(rc))
409	{
410	IHostFloppyDrive *floppyDrive = NULL;
411	floppyColl->GetNextHostFloppyDrive(floppyDrive, &floppyDrive);
412	while (floppyDrive)
413	{
414	BSTR driveName;
415	char *driveNameUtf8;
416	floppyDrive->GetDriveName(&driveName);
417	RTUtf16ToUtf8((PCRTUTF16)driveName, &driveNameUtf8);
418	printf("Host floppy drive name: %s\n", driveNameUtf8);
419	RTStrFree(driveNameUtf8);
420	SysFreeString(driveName);
421	IHostFloppyDrive *floppyDriveTemp = floppyDrive;
422	floppyColl->GetNextHostFloppyDrive(floppyDriveTemp, &floppyDrive);
423	floppyDriveTemp->Release();
424	}
425	floppyColl->Release();
426	} else
427	{
428	printf("Could not get host floppy drive collection\n");
429	}
430	host->Release();
431	} else
432	{
433	printf("Call failed\n");
434	}
435	printf ("\n");
436	#endif
437
438	#if 0
439	// IVirtualBoxErrorInfo test
440	////////////////////////////////////////////////////////////////////////////
441	{
442	// RPC calls
443
444	// call a method that will definitely fail
445	Guid uuid;
446	ComPtr <IHardDisk> hardDisk;
447	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
448	printf ("virtualBox->GetHardDisk(null-uuid)=%08X\n", rc);
449
450	// {
451	// com::ErrorInfo info (virtualBox);
452	// PRINT_ERROR_INFO (info);
453	// }
454
455	// call a method that will definitely succeed
456	Bstr version;
457	rc = virtualBox->COMGETTER(Version) (version.asOutParam());
458	printf ("virtualBox->COMGETTER(Version)=%08X\n", rc);
459
460	{
461	com::ErrorInfo info (virtualBox);
462	PRINT_ERROR_INFO (info);
463	}
464
465	// Local calls
466
467	// call a method that will definitely fail
468	ComPtr <IMachine> machine;
469	rc = session->COMGETTER(Machine)(machine.asOutParam());
470	printf ("session->COMGETTER(Machine)=%08X\n", rc);
471
472	// {
473	// com::ErrorInfo info (virtualBox);
474	// PRINT_ERROR_INFO (info);
475	// }
476
477	// call a method that will definitely succeed
478	SessionState_T state;
479	rc = session->COMGETTER(State) (&state);
480	printf ("session->COMGETTER(State)=%08X\n", rc);
481
482	{
483	com::ErrorInfo info (virtualBox);
484	PRINT_ERROR_INFO (info);
485	}
486	}
487	#endif
488
489	#if 0
490	// register the existing hard disk image
491	///////////////////////////////////////////////////////////////////////////
492	do
493	{
494	ComPtr <IHardDisk> hd;
495	Bstr src = L"E:\\develop\\innotek\\images\\NewHardDisk.vdi";
496	printf ("Opening the existing hard disk '%ls'...\n", src.raw());
497	CHECK_ERROR_BREAK (virtualBox, OpenHardDisk (src, hd.asOutParam()));
498	printf ("Enter to continue...\n");
499	getchar();
500	printf ("Registering the existing hard disk '%ls'...\n", src.raw());
501	CHECK_ERROR_BREAK (virtualBox, RegisterHardDisk (hd));
502	printf ("Enter to continue...\n");
503	getchar();
504	}
505	while (FALSE);
506	printf ("\n");
507	#endif
508
509	#if 0
510	// find and unregister the existing hard disk image
511	///////////////////////////////////////////////////////////////////////////
512	do
513	{
514	ComPtr <IVirtualDiskImage> vdi;
515	Bstr src = L"CreatorTest.vdi";
516	printf ("Unregistering the hard disk '%ls'...\n", src.raw());
517	CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
518	ComPtr <IHardDisk> hd = vdi;
519	Guid id;
520	CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
521	CHECK_ERROR_BREAK (virtualBox, UnregisterHardDisk (id, hd.asOutParam()));
522	}
523	while (FALSE);
524	printf ("\n");
525	#endif
526
527	#if 0
528	// clone the registered hard disk
529	///////////////////////////////////////////////////////////////////////////
530	do
531	{
532	#if defined RT_OS_LINUX
533	Bstr src = L"/mnt/hugaida/common/develop/innotek/images/freedos-linux.vdi";
534	#else
535	Bstr src = L"E:/develop/innotek/images/freedos.vdi";
536	#endif
537	Bstr dst = L"./clone.vdi";
538	RTPrintf ("Cloning '%ls' to '%ls'...\n", src.raw(), dst.raw());
539	ComPtr <IVirtualDiskImage> vdi;
540	CHECK_ERROR_BREAK (virtualBox, FindVirtualDiskImage (src, vdi.asOutParam()));
541	ComPtr <IHardDisk> hd = vdi;
542	ComPtr <IProgress> progress;
543	CHECK_ERROR_BREAK (hd, CloneToImage (dst, vdi.asOutParam(), progress.asOutParam()));
544	RTPrintf ("Waiting for completion...\n");
545	CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
546	ProgressErrorInfo ei (progress);
547	if (FAILED (ei.getResultCode()))
548	{
549	PRINT_ERROR_INFO (ei);
550	}
551	else
552	{
553	vdi->COMGETTER(FilePath) (dst.asOutParam());
554	RTPrintf ("Actual clone path is '%ls'\n", dst.raw());
555	}
556	}
557	while (FALSE);
558	printf ("\n");
559	#endif
560
561	#if 0
562	// find a registered hard disk by location
563	///////////////////////////////////////////////////////////////////////////
564	do
565	{
566	ComPtr <IHardDisk> hd;
567	static const wchar_t *Names[] =
568	{
569	#ifndef RT_OS_LINUX
570	L"E:/Develop/innotek/images/thinker/freedos.vdi",
571	L"E:/Develop/innotek/images/thinker/fReeDoS.vDI",
572	L"E:/Develop/innotek/images/vmdk/haiku.vmdk",
573	#else
574	L"/mnt/host/common/Develop/innotek/images/maggot/freedos.vdi",
575	L"/mnt/host/common/Develop/innotek/images/maggot/fReeDoS.vDI",
576	#endif
577	};
578	for (size_t i = 0; i < ELEMENTS (Names); ++ i)
579	{
580	Bstr src = Names [i];
581	printf ("Searching for hard disk '%ls'...\n", src.raw());
582	rc = virtualBox->FindHardDisk (src, hd.asOutParam());
583	if (SUCCEEDED (rc))
584	{
585	Guid id;
586	Bstr location;
587	CHECK_ERROR_BREAK (hd, COMGETTER(Id) (id.asOutParam()));
588	CHECK_ERROR_BREAK (hd, COMGETTER(Location) (location.asOutParam()));
589	printf ("Found, UUID={%Vuuid}, location='%ls'.\n",
590	id.raw(), location.raw());
591	}
592	else
593	{
594	PRINT_ERROR_INFO (com::ErrorInfo (virtualBox));
595	}
596	}
597	}
598	while (FALSE);
599	printf ("\n");
600	#endif
601
602	#if 0
603	// access the machine in read-only mode
604	///////////////////////////////////////////////////////////////////////////
605	do
606	{
607	ComPtr <IMachine> machine;
608	Bstr name = argc > 1 ? argv [1] : "dos";
609	printf ("Getting a machine object named '%ls'...\n", name.raw());
610	CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
611	printf ("Accessing the machine in read-only mode:\n");
612	readAndChangeMachineSettings (machine);
613	#if 0
614	if (argc != 2)
615	{
616	printf ("Error: a string has to be supplied!\n");
617	}
618	else
619	{
620	Bstr secureLabel = argv[1];
621	machine->COMSETTER(ExtraData)(L"VBoxSDL/SecureLabel", secureLabel);
622	}
623	#endif
624	}
625	while (0);
626	printf ("\n");
627	#endif
628
629	#if 0
630	// create a new machine (w/o registering it)
631	///////////////////////////////////////////////////////////////////////////
632	do
633	{
634	ComPtr <IMachine> machine;
635	#if defined (RT_OS_LINUX)
636	Bstr baseDir = L"/tmp/vbox";
637	#else
638	Bstr baseDir = L"C:\\vbox";
639	#endif
640	Bstr name = L"machina";
641
642	printf ("Creating a new machine object (base dir '%ls', name '%ls')...\n",
643	baseDir.raw(), name.raw());
644	CHECK_ERROR_BREAK (virtualBox, CreateMachine (baseDir, name,
645	machine.asOutParam()));
646
647	printf ("Getting name...\n");
648	CHECK_ERROR_BREAK (machine, COMGETTER(Name) (name.asOutParam()));
649	printf ("Name: {%ls}\n", name.raw());
650
651	BOOL modified = FALSE;
652	printf ("Are any settings modified?...\n");
653	CHECK_ERROR_BREAK (machine, COMGETTER(SettingsModified) (&modified));
654	printf ("%s\n", modified ? "yes" : "no");
655
656	ASSERT_BREAK (modified == TRUE);
657
658	name = L"Kakaya prekrasnaya virtual'naya mashina!";
659	printf ("Setting new name ({%ls})...\n", name.raw());
660	CHECK_ERROR_BREAK (machine, COMSETTER(Name) (name));
661
662	printf ("Setting memory size to 111...\n");
663	CHECK_ERROR_BREAK (machine, COMSETTER(MemorySize) (111));
664
665	Bstr desc = L"This is an exemplary description.";
666	printf ("Setting description to \"%ls\"...\n", desc.raw());
667	CHECK_ERROR_BREAK (machine, COMSETTER(Description) (desc));
668
669	ComPtr <IGuestOSType> guestOSType;
670	Bstr type = L"os2warp45";
671	CHECK_ERROR_BREAK (virtualBox, GetGuestOSType (type, guestOSType.asOutParam()));
672
673	printf ("Saving new machine settings...\n");
674	CHECK_ERROR_BREAK (machine, SaveSettings());
675
676	printf ("Accessing the newly created machine:\n");
677	readAndChangeMachineSettings (machine);
678	}
679	while (FALSE);
680	printf ("\n");
681	#endif
682
683	#if 0
684	// enumerate host DVD drives
685	///////////////////////////////////////////////////////////////////////////
686	do
687	{
688	ComPtr <IHost> host;
689	CHECK_RC_BREAK (virtualBox->COMGETTER(Host) (host.asOutParam()));
690
691	{
692	ComPtr <IHostDVDDriveCollection> coll;
693	CHECK_RC_BREAK (host->COMGETTER(DVDDrives) (coll.asOutParam()));
694	ComPtr <IHostDVDDriveEnumerator> enumerator;
695	CHECK_RC_BREAK (coll->Enumerate (enumerator.asOutParam()));
696	BOOL hasmore;
697	while (SUCCEEDED (enumerator->HasMore (&hasmore)) && hasmore)
698	{
699	ComPtr <IHostDVDDrive> drive;
700	CHECK_RC_BREAK (enumerator->GetNext (drive.asOutParam()));
701	Bstr name;
702	CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
703	printf ("Host DVD drive: name={%ls}\n", name.raw());
704	}
705	CHECK_RC_BREAK (rc);
706
707	ComPtr <IHostDVDDrive> drive;
708	CHECK_ERROR (enumerator, GetNext (drive.asOutParam()));
709	CHECK_ERROR (coll, GetItemAt (1000, drive.asOutParam()));
710	CHECK_ERROR (coll, FindByName (Bstr ("R:"), drive.asOutParam()));
711	if (SUCCEEDED (rc))
712	{
713	Bstr name;
714	CHECK_RC_BREAK (drive->COMGETTER(Name) (name.asOutParam()));
715	printf ("Found by name: name={%ls}\n", name.raw());
716	}
717	}
718	}
719	while (FALSE);
720	printf ("\n");
721	#endif
722
723	#if 0
724	// enumerate hard disks & dvd images
725	///////////////////////////////////////////////////////////////////////////
726	do
727	{
728	{
729	ComPtr <IHardDiskCollection> coll;
730	CHECK_RC_BREAK (virtualBox->COMGETTER(HardDisks) (coll.asOutParam()));
731	ComPtr <IHardDiskEnumerator> enumerator;
732	CHECK_RC_BREAK (coll->Enumerate (enumerator.asOutParam()));
733	BOOL hasmore;
734	while (SUCCEEDED (enumerator->HasMore (&hasmore)) && hasmore)
735	{
736	ComPtr <IHardDisk> disk;
737	CHECK_RC_BREAK (enumerator->GetNext (disk.asOutParam()));
738	Guid id;
739	CHECK_RC_BREAK (disk->COMGETTER(Id) (id.asOutParam()));
740	Bstr path;
741	CHECK_RC_BREAK (disk->COMGETTER(FilePath) (path.asOutParam()));
742	printf ("Hard Disk: id={%s}, path={%ls}\n",
743	id.toString().raw(), path.raw());
744	Guid mid;
745	CHECK_RC_BREAK (
746	virtualBox->GetHardDiskUsage (id, ResourceUsage_All,
747	mid.asOutParam())
748	);
749	if (mid.isEmpty())
750	printf (" not used\n");
751	else
752	printf (" used by VM: {%s}\n", mid.toString().raw());
753	}
754	CHECK_RC_BREAK (rc);
755	}
756
757	{
758	ComPtr <IDVDImageCollection> coll;
759	CHECK_RC_BREAK (virtualBox->COMGETTER(DVDImages) (coll.asOutParam()));
760	ComPtr <IDVDImageEnumerator> enumerator;
761	CHECK_RC_BREAK (coll->Enumerate (enumerator.asOutParam()));
762	BOOL hasmore;
763	while (SUCCEEDED (enumerator->HasMore (&hasmore)) && hasmore)
764	{
765	ComPtr <IDVDImage> image;
766	CHECK_RC_BREAK (enumerator->GetNext (image.asOutParam()));
767	Guid id;
768	CHECK_RC_BREAK (image->COMGETTER(Id) (id.asOutParam()));
769	Bstr path;
770	CHECK_RC_BREAK (image->COMGETTER(FilePath) (path.asOutParam()));
771	printf ("CD/DVD Image: id={%s}, path={%ls}\n",
772	id.toString().raw(), path.raw());
773	Bstr mIDs;
774	CHECK_RC_BREAK (
775	virtualBox->GetDVDImageUsage (id, ResourceUsage_All,
776	mIDs.asOutParam())
777	);
778	if (mIDs.isNull())
779	printf (" not used\n");
780	else
781	printf (" used by VMs: {%ls}\n", mIDs.raw());
782	}
783	CHECK_RC_BREAK (rc);
784	}
785	}
786	while (FALSE);
787	printf ("\n");
788	#endif
789
790	#if 0
791	// open a (direct) session
792	///////////////////////////////////////////////////////////////////////////
793	do
794	{
795	ComPtr <IMachine> machine;
796	Bstr name = argc > 1 ? argv [1] : "dos";
797	printf ("Getting a machine object named '%ls'...\n", name.raw());
798	CHECK_ERROR_BREAK (virtualBox, FindMachine (name, machine.asOutParam()));
799	Guid guid;
800	CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
801	printf ("Opening a session for this machine...\n");
802	CHECK_RC_BREAK (virtualBox->OpenSession (session, guid));
803	#if 1
804	ComPtr <IMachine> sessionMachine;
805	printf ("Getting sessioned machine object...\n");
806	CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
807	printf ("Accessing the machine within the session:\n");
808	readAndChangeMachineSettings (sessionMachine, machine);
809	#if 0
810	printf ("\n");
811	printf ("Enabling the VRDP server (must succeed even if the VM is saved):\n");
812	ComPtr <IVRDPServer> vrdp;
813	CHECK_ERROR_BREAK (sessionMachine, COMGETTER(VRDPServer) (vrdp.asOutParam()));
814	if (FAILED (vrdp->COMSETTER(Enabled) (TRUE)))
815	{
816	PRINT_ERROR_INFO (com::ErrorInfo (vrdp));
817	}
818	else
819	{
820	BOOL enabled = FALSE;
821	CHECK_ERROR_BREAK (vrdp, COMGETTER(Enabled) (&enabled));
822	printf ("VRDP server is %s\n", enabled ? "enabled" : "disabled");
823	}
824	#endif
825	#endif
826	#if 0
827	ComPtr <IConsole> console;
828	printf ("Getting the console object...\n");
829	CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
830	printf ("Discarding the current machine state...\n");
831	ComPtr <IProgress> progress;
832	CHECK_ERROR_BREAK (console, DiscardCurrentState (progress.asOutParam()));
833	printf ("Waiting for completion...\n");
834	CHECK_ERROR_BREAK (progress, WaitForCompletion (-1));
835	ProgressErrorInfo ei (progress);
836	if (FAILED (ei.getResultCode()))
837	{
838	PRINT_ERROR_INFO (ei);
839
840	ComPtr <IUnknown> initiator;
841	CHECK_ERROR_BREAK (progress, COMGETTER(Initiator) (initiator.asOutParam()));
842
843	printf ("initiator(unk) = %p\n", (IUnknown *) initiator);
844	printf ("console(unk) = %p\n", (IUnknown ) ComPtr <IUnknown> ((IConsole ) console));
845	printf ("console = %p\n", (IConsole *) console);
846	}
847	#endif
848	printf("Press enter to close session...");
849	getchar();
850	session->Close();
851	}
852	while (FALSE);
853	printf ("\n");
854	#endif
855
856	#if 0
857	// open a remote session
858	///////////////////////////////////////////////////////////////////////////
859	do
860	{
861	ComPtr <IMachine> machine;
862	Bstr name = L"dos";
863	printf ("Getting a machine object named '%ls'...\n", name.raw());
864	CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
865	Guid guid;
866	CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
867	printf ("Opening a remote session for this machine...\n");
868	ComPtr <IProgress> progress;
869	CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, Bstr("gui"),
870	NULL, progress.asOutParam()));
871	printf ("Waiting for the session to open...\n");
872	CHECK_RC_BREAK (progress->WaitForCompletion (-1));
873	ComPtr <IMachine> sessionMachine;
874	printf ("Getting sessioned machine object...\n");
875	CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
876	ComPtr <IConsole> console;
877	printf ("Getting console object...\n");
878	CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
879	printf ("Press enter to pause the VM execution in the remote session...");
880	getchar();
881	CHECK_RC (console->Pause());
882	printf ("Press enter to close this session...");
883	getchar();
884	session->Close();
885	}
886	while (FALSE);
887	printf ("\n");
888	#endif
889
890	#if 0
891	// open an existing remote session
892	///////////////////////////////////////////////////////////////////////////
893	do
894	{
895	ComPtr <IMachine> machine;
896	Bstr name = "dos";
897	printf ("Getting a machine object named '%ls'...\n", name.raw());
898	CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
899	Guid guid;
900	CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
901	printf ("Opening an existing remote session for this machine...\n");
902	CHECK_RC_BREAK (virtualBox->OpenExistingSession (session, guid));
903	ComPtr <IMachine> sessionMachine;
904	printf ("Getting sessioned machine object...\n");
905	CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
906
907	#if 0
908	Bstr extraDataKey = "VBoxSDL/SecureLabel";
909	Bstr extraData = "Das kommt jetzt noch viel krasser vom total konkreten API!";
910	CHECK_RC (sessionMachine->SetExtraData (extraDataKey, extraData));
911	#endif
912	#if 0
913	ComPtr <IConsole> console;
914	printf ("Getting console object...\n");
915	CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
916	printf ("Press enter to pause the VM execution in the remote session...");
917	getchar();
918	CHECK_RC (console->Pause());
919	printf ("Press enter to close this session...");
920	getchar();
921	#endif
922	session->Close();
923	}
924	while (FALSE);
925	printf ("\n");
926	#endif
927
928	#ifdef VBOX_WITH_RESOURCE_USAGE_API
929	do {
930	// Get collector
931	ComPtr <IPerformanceCollector> collector;
932	CHECK_ERROR_BREAK (virtualBox,
933	COMGETTER(PerformanceCollector) (collector.asOutParam()));
934
935
936	// Fill base metrics array
937	Bstr baseMetricNames[] = { L"CPU/Load,RAM/Usage" };
938	com::SafeArray<BSTR> baseMetrics (1);
939	baseMetricNames[0].cloneTo (&baseMetrics [0]);
940
941	// Get host
942	ComPtr <IHost> host;
943	CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
944
945	// Get machine
946	ComPtr <IMachine> machine;
947	Bstr name = argc > 1 ? argv [1] : "dsl";
948	printf ("Getting a machine object named '%ls'...\n", name.raw());
949	CHECK_RC_BREAK (virtualBox->FindMachine (name, machine.asOutParam()));
950
951	// Open session
952	Guid guid;
953	CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
954	printf ("Opening a remote session for this machine...\n");
955	ComPtr <IProgress> progress;
956	CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, Bstr("gui"),
957	NULL, progress.asOutParam()));
958	printf ("Waiting for the session to open...\n");
959	CHECK_RC_BREAK (progress->WaitForCompletion (-1));
960	ComPtr <IMachine> sessionMachine;
961	printf ("Getting sessioned machine object...\n");
962	CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
963
964	// Setup base metrics
965	// Note that one needs to set up metrics after a session is open for a machine.
966	com::SafeIfaceArray<IUnknown> objects(2);
967	host.queryInterfaceTo(&objects[0]);
968	sessionMachine.queryInterfaceTo(&objects[1]);
969	CHECK_ERROR_BREAK (collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
970	ComSafeArrayAsInParam(objects), 1u, 10u) );
971
972	// Get console
973	ComPtr <IConsole> console;
974	printf ("Getting console object...\n");
975	CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
976
977	RTThreadSleep(5000); // Sleep for 5 seconds
978
979	printf("Metrics collected with DSL machine running: --------------------\n");
980	queryMetrics(collector, ComSafeArrayAsInParam(objects));
981
982	// Pause
983	//printf ("Press enter to pause the VM execution in the remote session...");
984	//getchar();
985	CHECK_RC (console->Pause());
986
987	RTThreadSleep(5000); // Sleep for 5 seconds
988
989	printf("Metrics collected with DSL machine paused: ---------------------\n");
990	queryMetrics(collector, ComSafeArrayAsInParam(objects));
991
992	// Power off
993	printf ("Press enter to power off VM...");
994	getchar();
995	CHECK_RC (console->PowerDown());
996	printf ("Press enter to close this session...");
997	getchar();
998	session->Close();
999	} while (false);
1000	#endif /* VBOX_WITH_RESOURCE_USAGE_API */
1001
1002	printf ("Press enter to release Session and VirtualBox instances...");
1003	getchar();
1004
1005	// end "all-stuff" scope
1006	////////////////////////////////////////////////////////////////////////////
1007	}
1008	while (0);
1009
1010	printf("Press enter to shutdown COM...");
1011	getchar();
1012
1013	com::Shutdown();
1014
1015	printf ("tstAPI FINISHED.\n");
1016
1017	return rc;
1018	}
1019
1020	#ifdef VBOX_WITH_RESOURCE_USAGE_API
1021	void queryMetrics (ComPtr <IPerformanceCollector> collector,
1022	ComSafeArrayIn (IUnknown *, objects))
1023	{
1024	HRESULT rc;
1025
1026	//Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
1027	Bstr metricNames[] = { L"*" };
1028	com::SafeArray<BSTR> metrics (1);
1029	metricNames[0].cloneTo (&metrics [0]);
1030	com::SafeArray<BSTR> retNames;
1031	com::SafeIfaceArray<IUnknown> retObjects;
1032	com::SafeArray<ULONG> retIndices;
1033	com::SafeArray<ULONG> retLengths;
1034	com::SafeArray<LONG> retData;
1035	CHECK_ERROR (collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
1036	ComSafeArrayInArg(objects),
1037	ComSafeArrayAsOutParam(retNames),
1038	ComSafeArrayAsOutParam(retObjects),
1039	ComSafeArrayAsOutParam(retIndices),
1040	ComSafeArrayAsOutParam(retLengths),
1041	ComSafeArrayAsOutParam(retData)) );
1042	for (unsigned i = 0; i < retNames.size(); i++)
1043	{
1044	// Get info for the metric
1045	com::SafeArray<BSTR> nameOfMetric(1);
1046	Bstr tmpName(retNames[i]);
1047	tmpName.detachTo (&nameOfMetric[0]);
1048	com::SafeIfaceArray<IUnknown> anObject(1);
1049	ComPtr<IUnknown> tmpObject(retObjects[i]);
1050	tmpObject.queryInterfaceTo(&anObject[0]);
1051	com::SafeIfaceArray <IPerformanceMetric> metricInfo;
1052	CHECK_RC_BREAK (collector->GetMetrics( ComSafeArrayAsInParam(nameOfMetric),
1053	ComSafeArrayAsInParam(anObject),
1054	ComSafeArrayAsOutParam(metricInfo) ));
1055	BSTR metricUnitBSTR;
1056	CHECK_RC_BREAK (metricInfo[0]->COMGETTER(Unit) (&metricUnitBSTR));
1057	Bstr metricUnit(metricUnitBSTR);
1058	Bstr metricName(retNames[i]);
1059	LONG minVal, maxVal;
1060	CHECK_RC_BREAK (metricInfo[0]->COMGETTER(MinimumValue) (&minVal));
1061	CHECK_RC_BREAK (metricInfo[0]->COMGETTER(MaximumValue) (&maxVal));
1062	printf("obj(%p) %ls (min=%lu max=%lu)", anObject[0], metricName.raw(), minVal, maxVal);
1063	for (unsigned j = 0; j < retLengths[i]; j++)
1064	{
1065	printf(", %d %ls", retData[retIndices[i] + j] / (strcmp((const char *)metricUnit.raw(), "%")?1:1000), metricUnit.raw());
1066	}
1067	printf("\n");
1068	}
1069	}
1070	#endif /* VBOX_WITH_RESOURCE_USAGE_API */

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

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

Download in other formats: