VBoxManageMetrics.cpp@ 38733

Last change on this file since 38733 was 33540, checked in by vboxsync, 14 years ago
*: spelling fixes, thanks Timeless!
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.8 KB

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

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

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

Download in other formats: