tstAPI.cpp@ 10771

Last change on this file since 10771 was 10753, checked in by vboxsync, 16 years ago
Stubs for all platforms. Implementation of host CPU load and RAM usage counters for Windows. Locking. Fixes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.4 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	#if 0
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	// Setup base metrics
952	com::SafeIfaceArray<IUnknown> objects(2);
953	host.queryInterfaceTo(&objects[0]);
954	machine.queryInterfaceTo(&objects[1]);
955	CHECK_ERROR_BREAK (collector, SetupMetrics(ComSafeArrayAsInParam(baseMetrics),
956	ComSafeArrayAsInParam(objects), 1u, 10u) );
957
958	// Open session
959	Guid guid;
960	CHECK_RC_BREAK (machine->COMGETTER(Id) (guid.asOutParam()));
961	printf ("Opening a remote session for this machine...\n");
962	ComPtr <IProgress> progress;
963	CHECK_RC_BREAK (virtualBox->OpenRemoteSession (session, guid, Bstr("gui"),
964	NULL, progress.asOutParam()));
965	printf ("Waiting for the session to open...\n");
966	CHECK_RC_BREAK (progress->WaitForCompletion (-1));
967	ComPtr <IMachine> sessionMachine;
968	printf ("Getting sessioned machine object...\n");
969	CHECK_RC_BREAK (session->COMGETTER(Machine) (sessionMachine.asOutParam()));
970
971	// Get console
972	ComPtr <IConsole> console;
973	printf ("Getting console object...\n");
974	CHECK_RC_BREAK (session->COMGETTER(Console) (console.asOutParam()));
975
976	RTThreadSleep(3000); // Sleep for 10 seconds
977
978	printf("Metrics collected with DSL machine running: --------------------\n");
979	queryMetrics(collector, ComSafeArrayAsInParam(objects));
980
981	// Pause
982	printf ("Press enter to pause the VM execution in the remote session...");
983	getchar();
984	CHECK_RC (console->Pause());
985
986	RTThreadSleep(3000); // Sleep for 10 seconds
987
988	printf("Metrics collected with DSL machine paused: ---------------------\n");
989	queryMetrics(collector, ComSafeArrayAsInParam(objects));
990
991	// Power off
992	printf ("Press enter to power off VM...");
993	getchar();
994	CHECK_RC (console->PowerDown());
995	printf ("Press enter to close this session...");
996	getchar();
997	session->Close();
998	} while (false);
999	#endif
1000
1001	printf ("Press enter to release Session and VirtualBox instances...");
1002	getchar();
1003
1004	// end "all-stuff" scope
1005	////////////////////////////////////////////////////////////////////////////
1006	}
1007	while (0);
1008
1009	printf("Press enter to shutdown COM...");
1010	getchar();
1011
1012	com::Shutdown();
1013
1014	printf ("tstAPI FINISHED.\n");
1015
1016	return rc;
1017	}
1018
1019	#if 0
1020	void queryMetrics (ComPtr <IPerformanceCollector> collector,
1021	ComSafeArrayIn (IUnknown *, objects))
1022	{
1023	HRESULT rc;
1024
1025	Bstr metricNames[] = { L"CPU/Load/User:avg,CPU/Load/System:avg,CPU/Load/Idle:avg,RAM/Usage/Total,RAM/Usage/Used:avg" };
1026	com::SafeArray<BSTR> metrics (1);
1027	metricNames[0].cloneTo (&metrics [0]);
1028	com::SafeArray<BSTR> retNames;
1029	com::SafeIfaceArray<IUnknown> retObjects;
1030	com::SafeArray<ULONG> retIndices;
1031	com::SafeArray<ULONG> retLengths;
1032	com::SafeArray<LONG> retData;
1033	CHECK_ERROR (collector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
1034	ComSafeArrayInArg(objects),
1035	ComSafeArrayAsOutParam(retNames),
1036	ComSafeArrayAsOutParam(retObjects),
1037	ComSafeArrayAsOutParam(retIndices),
1038	ComSafeArrayAsOutParam(retLengths),
1039	ComSafeArrayAsOutParam(retData)) );
1040	for (unsigned i = 0; i < retNames.size(); i++)
1041	{
1042	// Get info for the metric
1043	com::SafeArray<BSTR> nameOfMetric(1);
1044	Bstr (retNames[i]).cloneTo (&nameOfMetric[0]);
1045	com::SafeIfaceArray<IUnknown> anObject(1);
1046	ComPtr<IUnknown>(retObjects[i]).queryInterfaceTo(&anObject[0]);
1047	com::SafeIfaceArray <IPerformanceMetric> metricInfo;
1048	CHECK_RC_BREAK (collector->GetMetrics( ComSafeArrayAsInParam(nameOfMetric),
1049	ComSafeArrayAsInParam(anObject),
1050	ComSafeArrayAsOutParam(metricInfo) ));
1051	BSTR metricUnitBSTR;
1052	CHECK_RC_BREAK (metricInfo[0]->COMGETTER(Unit) (&metricUnitBSTR));
1053	Bstr metricUnit(metricUnitBSTR);
1054	Bstr metricName(retNames[i]);
1055	printf("%ls", metricName.raw());
1056	for (unsigned j = 0; j < retLengths[i]; j++)
1057	{
1058	printf(", %d %ls", retData[retIndices[i] + j] / (strcmp((const char *)metricUnit.raw(), "%")?1:1000), metricUnit.raw());
1059	}
1060	printf("\n");
1061	}
1062	}
1063	#endif

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

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

Download in other formats: