VBoxManageMetrics.cpp@ 43629

Last change on this file since 43629 was 43629, checked in by vboxsync, 12 years ago
Main/Metrics: Linux fs/disk metrics, VBoxManage filtering + minor fixes (#6345)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.7 KB

Line
1	/* $Id: VBoxManageMetrics.cpp 43629 2012-10-12 09:26:07Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'metrics' command.
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 Oracle Corporation
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
18	#ifndef VBOX_ONLY_DOCS
19
20	/*******************************************************************************
21	* Header Files *
22	*******************************************************************************/
23	#include <VBox/com/com.h>
24	#include <VBox/com/array.h>
25	#include <VBox/com/ErrorInfo.h>
26	#include <VBox/com/errorprint.h>
27	#include <VBox/com/VirtualBox.h>
28
29	#include <iprt/asm.h>
30	#include <iprt/stream.h>
31	#include <iprt/string.h>
32	#include <iprt/time.h>
33	#include <iprt/thread.h>
34	#include <VBox/log.h>
35
36	#include <set>
37	#include <utility>
38
39	#include "VBoxManage.h"
40	using namespace com;
41
42
43	// funcs
44	///////////////////////////////////////////////////////////////////////////////
45
46
47	static int parseFilterParameters(int argc, char *argv[],
48	ComPtr<IVirtualBox> aVirtualBox,
49	ComSafeArrayOut(BSTR, outMetrics),
50	ComSafeArrayOut(IUnknown *, outObjects))
51	{
52	HRESULT rc = S_OK;
53	com::SafeArray<BSTR> retMetrics(1);
54	com::SafeIfaceArray <IUnknown> retObjects;
55
56	Bstr metricNames, baseNames;
57
58	/* Metric list */
59	if (argc > 1)
60	metricNames = argv[1];
61	else
62	{
63	metricNames = L"*";
64	baseNames = L"*";
65	}
66	metricNames.cloneTo(&retMetrics[0]);
67
68	/* Object name */
69	if (argc > 0 && strcmp(argv[0], "*"))
70	{
71	if (!strcmp(argv[0], "host"))
72	{
73	ComPtr<IHost> host;
74	CHECK_ERROR(aVirtualBox, COMGETTER(Host)(host.asOutParam()));
75	retObjects.reset(1);
76	host.queryInterfaceTo(&retObjects[0]);
77	}
78	else
79	{
80	ComPtr <IMachine> machine;
81	rc = aVirtualBox->FindMachine(Bstr(argv[0]).raw(),
82	machine.asOutParam());
83	if (SUCCEEDED (rc))
84	{
85	retObjects.reset(1);
86	machine.queryInterfaceTo(&retObjects[0]);
87	}
88	else
89	{
90	errorArgument("Invalid machine name: '%s'", argv[0]);
91	return rc;
92	}
93	}
94
95	}
96
97	retMetrics.detachTo(ComSafeArrayOutArg(outMetrics));
98	retObjects.detachTo(ComSafeArrayOutArg(outObjects));
99
100	return rc;
101	}
102
103	static Bstr toBaseName(Utf8Str& aFullName)
104	{
105	char *pszRaw = aFullName.mutableRaw();
106	char *pszSlash = strrchr(pszRaw, '/');
107	if (pszSlash)
108	{
109	*pszSlash = 0;
110	aFullName.jolt();
111	}
112	return Bstr(aFullName);
113	}
114
115	static Bstr getObjectName(ComPtr<IVirtualBox> aVirtualBox,
116	ComPtr<IUnknown> aObject)
117	{
118	HRESULT rc;
119
120	ComPtr<IHost> host = aObject;
121	if (!host.isNull())
122	return Bstr("host");
123
124	ComPtr<IMachine> machine = aObject;
125	if (!machine.isNull())
126	{
127	Bstr name;
128	CHECK_ERROR(machine, COMGETTER(Name)(name.asOutParam()));
129	if (SUCCEEDED(rc))
130	return name;
131	}
132	return Bstr("unknown");
133	}
134
135	static void listAffectedMetrics(ComPtr<IVirtualBox> aVirtualBox,
136	ComSafeArrayIn(IPerformanceMetric*, aMetrics))
137	{
138	HRESULT rc;
139	com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics));
140	if (metrics.size())
141	{
142	ComPtr<IUnknown> object;
143	Bstr metricName;
144	RTPrintf("The following metrics were modified:\n\n"
145	"Object Metric\n"
146	"---------- --------------------\n");
147	for (size_t i = 0; i < metrics.size(); i++)
148	{
149	CHECK_ERROR(metrics[i], COMGETTER(Object)(object.asOutParam()));
150	CHECK_ERROR(metrics[i], COMGETTER(MetricName)(metricName.asOutParam()));
151	RTPrintf("%-10ls %-20ls\n",
152	getObjectName(aVirtualBox, object).raw(), metricName.raw());
153	}
154	RTPrintf("\n");
155	}
156	else
157	{
158	RTMsgError("No metrics match the specified filter!");
159	}
160	}
161
162	/**
163	* list
164	*/
165	static int handleMetricsList(int argc, char *argv[],
166	ComPtr<IVirtualBox> aVirtualBox,
167	ComPtr<IPerformanceCollector> performanceCollector)
168	{
169	HRESULT rc;
170	com::SafeArray<BSTR> metrics;
171	com::SafeIfaceArray<IUnknown> objects;
172
173	rc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox,
174	ComSafeArrayAsOutParam(metrics),
175	ComSafeArrayAsOutParam(objects));
176	if (FAILED(rc))
177	return 1;
178
179	com::SafeIfaceArray<IPerformanceMetric> metricInfo;
180
181	CHECK_ERROR(performanceCollector,
182	GetMetrics(ComSafeArrayAsInParam(metrics),
183	ComSafeArrayAsInParam(objects),
184	ComSafeArrayAsOutParam(metricInfo)));
185
186	ComPtr<IUnknown> object;
187	Bstr metricName, unit, description;
188	ULONG period, count;
189	LONG minimum, maximum;
190	RTPrintf(
191	"Object Metric Unit Minimum Maximum Period Count Description\n"
192	"---------- -------------------- ---- ---------- ---------- ---------- ---------- -----------\n");
193	for (size_t i = 0; i < metricInfo.size(); i++)
194	{
195	CHECK_ERROR(metricInfo[i], COMGETTER(Object)(object.asOutParam()));
196	CHECK_ERROR(metricInfo[i], COMGETTER(MetricName)(metricName.asOutParam()));
197	CHECK_ERROR(metricInfo[i], COMGETTER(Period)(&period));
198	CHECK_ERROR(metricInfo[i], COMGETTER(Count)(&count));
199	CHECK_ERROR(metricInfo[i], COMGETTER(MinimumValue)(&minimum));
200	CHECK_ERROR(metricInfo[i], COMGETTER(MaximumValue)(&maximum));
201	CHECK_ERROR(metricInfo[i], COMGETTER(Unit)(unit.asOutParam()));
202	CHECK_ERROR(metricInfo[i], COMGETTER(Description)(description.asOutParam()));
203	RTPrintf("%-10ls %-20ls %-4ls %10d %10d %10u %10u %ls\n",
204	getObjectName(aVirtualBox, object).raw(), metricName.raw(), unit.raw(),
205	minimum, maximum, period, count, description.raw());
206	}
207
208	return 0;
209	}
210
211	/**
212	* Metrics setup
213	*/
214	static int handleMetricsSetup(int argc, char *argv[],
215	ComPtr<IVirtualBox> aVirtualBox,
216	ComPtr<IPerformanceCollector> performanceCollector)
217	{
218	HRESULT rc;
219	com::SafeArray<BSTR> metrics;
220	com::SafeIfaceArray<IUnknown> objects;
221	uint32_t period = 1, samples = 1;
222	bool listMatches = false;
223	int i;
224
225	for (i = 1; i < argc; i++)
226	{
227	if ( !strcmp(argv[i], "--period")
228	\|\| !strcmp(argv[i], "-period"))
229	{
230	if (argc <= i + 1)
231	return errorArgument("Missing argument to '%s'", argv[i]);
232	if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &period)
233	\|\| !period)
234	return errorArgument("Invalid value for 'period' parameter: '%s'", argv[i]);
235	}
236	else if ( !strcmp(argv[i], "--samples")
237	\|\| !strcmp(argv[i], "-samples"))
238	{
239	if (argc <= i + 1)
240	return errorArgument("Missing argument to '%s'", argv[i]);
241	if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &samples)
242	\|\| !samples)
243	return errorArgument("Invalid value for 'samples' parameter: '%s'", argv[i]);
244	}
245	else if ( !strcmp(argv[i], "--list")
246	\|\| !strcmp(argv[i], "-list"))
247	listMatches = true;
248	else
249	break; /* The rest of params should define the filter */
250	}
251
252	rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
253	ComSafeArrayAsOutParam(metrics),
254	ComSafeArrayAsOutParam(objects));
255	if (FAILED(rc))
256	return 1;
257
258	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
259	CHECK_ERROR(performanceCollector,
260	SetupMetrics(ComSafeArrayAsInParam(metrics),
261	ComSafeArrayAsInParam(objects), period, samples,
262	ComSafeArrayAsOutParam(affectedMetrics)));
263	if (FAILED(rc))
264	return 2;
265
266	if (listMatches)
267	listAffectedMetrics(aVirtualBox,
268	ComSafeArrayAsInParam(affectedMetrics));
269
270	return 0;
271	}
272
273	/**
274	* metrics query
275	*/
276	static int handleMetricsQuery(int argc, char *argv[],
277	ComPtr<IVirtualBox> aVirtualBox,
278	ComPtr<IPerformanceCollector> performanceCollector)
279	{
280	HRESULT rc;
281	com::SafeArray<BSTR> metrics;
282	com::SafeIfaceArray<IUnknown> objects;
283
284	rc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox,
285	ComSafeArrayAsOutParam(metrics),
286	ComSafeArrayAsOutParam(objects));
287	if (FAILED(rc))
288	return 1;
289
290	com::SafeArray<BSTR> retNames;
291	com::SafeIfaceArray<IUnknown> retObjects;
292	com::SafeArray<BSTR> retUnits;
293	com::SafeArray<ULONG> retScales;
294	com::SafeArray<ULONG> retSequenceNumbers;
295	com::SafeArray<ULONG> retIndices;
296	com::SafeArray<ULONG> retLengths;
297	com::SafeArray<LONG> retData;
298	CHECK_ERROR (performanceCollector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
299	ComSafeArrayAsInParam(objects),
300	ComSafeArrayAsOutParam(retNames),
301	ComSafeArrayAsOutParam(retObjects),
302	ComSafeArrayAsOutParam(retUnits),
303	ComSafeArrayAsOutParam(retScales),
304	ComSafeArrayAsOutParam(retSequenceNumbers),
305	ComSafeArrayAsOutParam(retIndices),
306	ComSafeArrayAsOutParam(retLengths),
307	ComSafeArrayAsOutParam(retData)) );
308
309	RTPrintf("Object Metric Values\n"
310	"---------- -------------------- --------------------------------------------\n");
311	for (unsigned i = 0; i < retNames.size(); i++)
312	{
313	Bstr metricUnit(retUnits[i]);
314	Bstr metricName(retNames[i]);
315	RTPrintf("%-10ls %-20ls ", getObjectName(aVirtualBox, retObjects[i]).raw(), metricName.raw());
316	const char *separator = "";
317	for (unsigned j = 0; j < retLengths[i]; j++)
318	{
319	if (retScales[i] == 1)
320	RTPrintf("%s%d %ls", separator, retData[retIndices[i] + j], metricUnit.raw());
321	else
322	RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[i] + j] / retScales[i],
323	(retData[retIndices[i] + j] * 100 / retScales[i]) % 100, metricUnit.raw());
324	separator = ", ";
325	}
326	RTPrintf("\n");
327	}
328
329	return 0;
330	}
331
332	static void getTimestamp(char *pts, size_t tsSize)
333	{
334	*pts = 0;
335	AssertReturnVoid(tsSize >= 13); /* 3+3+3+3+1 */
336	RTTIMESPEC TimeSpec;
337	RTTIME Time;
338	RTTimeExplode(&Time, RTTimeNow(&TimeSpec));
339	pts += RTStrFormatNumber(pts, Time.u8Hour, 10, 2, 0, RTSTR_F_ZEROPAD);
340	*pts++ = ':';
341	pts += RTStrFormatNumber(pts, Time.u8Minute, 10, 2, 0, RTSTR_F_ZEROPAD);
342	*pts++ = ':';
343	pts += RTStrFormatNumber(pts, Time.u8Second, 10, 2, 0, RTSTR_F_ZEROPAD);
344	*pts++ = '.';
345	pts += RTStrFormatNumber(pts, Time.u32Nanosecond / 1000000, 10, 3, 0, RTSTR_F_ZEROPAD);
346	*pts = 0;
347	}
348
349	/** Used by the handleMetricsCollect loop. */
350	static bool volatile g_fKeepGoing = true;
351
352	#ifdef RT_OS_WINDOWS
353	/**
354	* Handler routine for catching Ctrl-C, Ctrl-Break and closing of
355	* the console.
356	*
357	* @returns true if handled, false if not handled.
358	* @param dwCtrlType The type of control signal.
359	*
360	* @remarks This is called on a new thread.
361	*/
362	static BOOL WINAPI ctrlHandler(DWORD dwCtrlType)
363	{
364	switch (dwCtrlType)
365	{
366	/* Ctrl-C or Ctrl-Break or Close */
367	case CTRL_C_EVENT:
368	case CTRL_BREAK_EVENT:
369	case CTRL_CLOSE_EVENT:
370	/* Let's shut down gracefully. */
371	ASMAtomicWriteBool(&g_fKeepGoing, false);
372	return TRUE;
373	}
374	/* Don't care about the rest -- let it die a horrible death. */
375	return FALSE;
376	}
377	#endif /* RT_OS_WINDOWS */
378
379	/**
380	* collect
381	*/
382	static int handleMetricsCollect(int argc, char *argv[],
383	ComPtr<IVirtualBox> aVirtualBox,
384	ComPtr<IPerformanceCollector> performanceCollector)
385	{
386	HRESULT rc;
387	com::SafeArray<BSTR> metrics;
388	com::SafeIfaceArray<IUnknown> objects;
389	uint32_t period = 1, samples = 1;
390	bool isDetached = false, listMatches = false;
391	int i;
392	for (i = 1; i < argc; i++)
393	{
394	if ( !strcmp(argv[i], "--period")
395	\|\| !strcmp(argv[i], "-period"))
396	{
397	if (argc <= i + 1)
398	return errorArgument("Missing argument to '%s'", argv[i]);
399	if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &period)
400	\|\| !period)
401	return errorArgument("Invalid value for 'period' parameter: '%s'", argv[i]);
402	}
403	else if ( !strcmp(argv[i], "--samples")
404	\|\| !strcmp(argv[i], "-samples"))
405	{
406	if (argc <= i + 1)
407	return errorArgument("Missing argument to '%s'", argv[i]);
408	if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &samples)
409	\|\| !samples)
410	return errorArgument("Invalid value for 'samples' parameter: '%s'", argv[i]);
411	}
412	else if ( !strcmp(argv[i], "--list")
413	\|\| !strcmp(argv[i], "-list"))
414	listMatches = true;
415	else if ( !strcmp(argv[i], "--detach")
416	\|\| !strcmp(argv[i], "-detach"))
417	isDetached = true;
418	else
419	break; /* The rest of params should define the filter */
420	}
421
422	rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
423	ComSafeArrayAsOutParam(metrics),
424	ComSafeArrayAsOutParam(objects));
425	if (FAILED(rc))
426	return 1;
427
428	com::SafeIfaceArray<IPerformanceMetric> metricInfo;
429
430	CHECK_ERROR(performanceCollector,
431	GetMetrics(ComSafeArrayAsInParam(metrics),
432	ComSafeArrayAsInParam(objects),
433	ComSafeArrayAsOutParam(metricInfo)));
434
435	std::set<std::pair<ComPtr<IUnknown>,Bstr> > baseMetrics;
436	ComPtr<IUnknown> objectFiltered;
437	Bstr metricNameFiltered;
438	for (i = 0; i < (int)metricInfo.size(); i++)
439	{
440	CHECK_ERROR(metricInfo[i], COMGETTER(Object)(objectFiltered.asOutParam()));
441	CHECK_ERROR(metricInfo[i], COMGETTER(MetricName)(metricNameFiltered.asOutParam()));
442	Utf8Str baseMetricName(metricNameFiltered);
443	baseMetrics.insert(std::make_pair(objectFiltered, toBaseName(baseMetricName)));
444	}
445	com::SafeArray<BSTR> baseMetricsFiltered(baseMetrics.size());
446	com::SafeIfaceArray<IUnknown> objectsFiltered(baseMetrics.size());
447	std::set<std::pair<ComPtr<IUnknown>,Bstr> >::iterator it;
448	i = 0;
449	for (it = baseMetrics.begin(); it != baseMetrics.end(); ++it)
450	{
451	it->first.queryInterfaceTo(&objectsFiltered[i]);
452	Bstr(it->second).detachTo(&baseMetricsFiltered[i++]);
453	}
454	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
455	CHECK_ERROR(performanceCollector,
456	SetupMetrics(ComSafeArrayAsInParam(baseMetricsFiltered),
457	ComSafeArrayAsInParam(objectsFiltered), period, samples,
458	ComSafeArrayAsOutParam(affectedMetrics)));
459	if (FAILED(rc))
460	return 2;
461
462	if (listMatches)
463	listAffectedMetrics(aVirtualBox,
464	ComSafeArrayAsInParam(affectedMetrics));
465	if (!affectedMetrics.size())
466	return 1;
467
468	if (isDetached)
469	{
470	RTMsgWarning("The background process holding collected metrics will shutdown\n"
471	"in few seconds, discarding all collected data and parameters.");
472	return 0;
473	}
474
475	#ifdef RT_OS_WINDOWS
476	SetConsoleCtrlHandler(ctrlHandler, true);
477	#endif /* RT_OS_WINDOWS */
478
479	RTPrintf("Time stamp Object Metric Value\n");
480
481	while (g_fKeepGoing)
482	{
483	RTPrintf("------------ ---------- -------------------- --------------------\n");
484	RTThreadSleep(period * 1000); // Sleep for 'period' seconds
485	char ts[15];
486
487	getTimestamp(ts, sizeof(ts));
488	com::SafeArray<BSTR> retNames;
489	com::SafeIfaceArray<IUnknown> retObjects;
490	com::SafeArray<BSTR> retUnits;
491	com::SafeArray<ULONG> retScales;
492	com::SafeArray<ULONG> retSequenceNumbers;
493	com::SafeArray<ULONG> retIndices;
494	com::SafeArray<ULONG> retLengths;
495	com::SafeArray<LONG> retData;
496	CHECK_ERROR (performanceCollector, QueryMetricsData(ComSafeArrayAsInParam(metrics),
497	ComSafeArrayAsInParam(objects),
498	ComSafeArrayAsOutParam(retNames),
499	ComSafeArrayAsOutParam(retObjects),
500	ComSafeArrayAsOutParam(retUnits),
501	ComSafeArrayAsOutParam(retScales),
502	ComSafeArrayAsOutParam(retSequenceNumbers),
503	ComSafeArrayAsOutParam(retIndices),
504	ComSafeArrayAsOutParam(retLengths),
505	ComSafeArrayAsOutParam(retData)) );
506	for (unsigned j = 0; j < retNames.size(); j++)
507	{
508	Bstr metricUnit(retUnits[j]);
509	Bstr metricName(retNames[j]);
510	RTPrintf("%-12s %-10ls %-20ls ", ts, getObjectName(aVirtualBox, retObjects[j]).raw(), metricName.raw());
511	const char *separator = "";
512	for (unsigned k = 0; k < retLengths[j]; k++)
513	{
514	if (retScales[j] == 1)
515	RTPrintf("%s%d %ls", separator, retData[retIndices[j] + k], metricUnit.raw());
516	else
517	RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[j] + k] / retScales[j],
518	(retData[retIndices[j] + k] * 100 / retScales[j]) % 100, metricUnit.raw());
519	separator = ", ";
520	}
521	RTPrintf("\n");
522	}
523	RTStrmFlush(g_pStdOut);
524	}
525
526	#ifdef RT_OS_WINDOWS
527	SetConsoleCtrlHandler(ctrlHandler, false);
528	#endif /* RT_OS_WINDOWS */
529
530	return 0;
531	}
532
533	/**
534	* Enable metrics
535	*/
536	static int handleMetricsEnable(int argc, char *argv[],
537	ComPtr<IVirtualBox> aVirtualBox,
538	ComPtr<IPerformanceCollector> performanceCollector)
539	{
540	HRESULT rc;
541	com::SafeArray<BSTR> metrics;
542	com::SafeIfaceArray<IUnknown> objects;
543	bool listMatches = false;
544	int i;
545
546	for (i = 1; i < argc; i++)
547	{
548	if ( !strcmp(argv[i], "--list")
549	\|\| !strcmp(argv[i], "-list"))
550	listMatches = true;
551	else
552	break; /* The rest of params should define the filter */
553	}
554
555	rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
556	ComSafeArrayAsOutParam(metrics),
557	ComSafeArrayAsOutParam(objects));
558	if (FAILED(rc))
559	return 1;
560
561	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
562	CHECK_ERROR(performanceCollector,
563	EnableMetrics(ComSafeArrayAsInParam(metrics),
564	ComSafeArrayAsInParam(objects),
565	ComSafeArrayAsOutParam(affectedMetrics)));
566	if (FAILED(rc))
567	return 2;
568
569	if (listMatches)
570	listAffectedMetrics(aVirtualBox,
571	ComSafeArrayAsInParam(affectedMetrics));
572
573	return 0;
574	}
575
576	/**
577	* Disable metrics
578	*/
579	static int handleMetricsDisable(int argc, char *argv[],
580	ComPtr<IVirtualBox> aVirtualBox,
581	ComPtr<IPerformanceCollector> performanceCollector)
582	{
583	HRESULT rc;
584	com::SafeArray<BSTR> metrics;
585	com::SafeIfaceArray<IUnknown> objects;
586	bool listMatches = false;
587	int i;
588
589	for (i = 1; i < argc; i++)
590	{
591	if ( !strcmp(argv[i], "--list")
592	\|\| !strcmp(argv[i], "-list"))
593	listMatches = true;
594	else
595	break; /* The rest of params should define the filter */
596	}
597
598	rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox,
599	ComSafeArrayAsOutParam(metrics),
600	ComSafeArrayAsOutParam(objects));
601	if (FAILED(rc))
602	return 1;
603
604	com::SafeIfaceArray<IPerformanceMetric> affectedMetrics;
605	CHECK_ERROR(performanceCollector,
606	DisableMetrics(ComSafeArrayAsInParam(metrics),
607	ComSafeArrayAsInParam(objects),
608	ComSafeArrayAsOutParam(affectedMetrics)));
609	if (FAILED(rc))
610	return 2;
611
612	if (listMatches)
613	listAffectedMetrics(aVirtualBox,
614	ComSafeArrayAsInParam(affectedMetrics));
615
616	return 0;
617	}
618
619
620	int handleMetrics(HandlerArg *a)
621	{
622	int rc;
623
624	/* at least one option: subcommand name */
625	if (a->argc < 1)
626	return errorSyntax(USAGE_METRICS, "Subcommand missing");
627
628	ComPtr<IPerformanceCollector> performanceCollector;
629	CHECK_ERROR(a->virtualBox, COMGETTER(PerformanceCollector)(performanceCollector.asOutParam()));
630
631	if (!strcmp(a->argv[0], "list"))
632	rc = handleMetricsList(a->argc, a->argv, a->virtualBox, performanceCollector);
633	else if (!strcmp(a->argv[0], "setup"))
634	rc = handleMetricsSetup(a->argc, a->argv, a->virtualBox, performanceCollector);
635	else if (!strcmp(a->argv[0], "query"))
636	rc = handleMetricsQuery(a->argc, a->argv, a->virtualBox, performanceCollector);
637	else if (!strcmp(a->argv[0], "collect"))
638	rc = handleMetricsCollect(a->argc, a->argv, a->virtualBox, performanceCollector);
639	else if (!strcmp(a->argv[0], "enable"))
640	rc = handleMetricsEnable(a->argc, a->argv, a->virtualBox, performanceCollector);
641	else if (!strcmp(a->argv[0], "disable"))
642	rc = handleMetricsDisable(a->argc, a->argv, a->virtualBox, performanceCollector);
643	else
644	return errorSyntax(USAGE_METRICS, "Invalid subcommand '%s'", a->argv[0]);
645
646	return rc;
647	}
648
649	#endif /* VBOX_ONLY_DOCS */
650

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageMetrics.cpp@ 43629

Download in other formats: