VBoxManageBandwidthControl.cpp@ 97405

Last change on this file since 97405 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 11.9 KB

Line
1	/* $Id: VBoxManageBandwidthControl.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* VBoxManage - The bandwidth control related commands.
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <VBox/com/com.h>
33	#include <VBox/com/array.h>
34	#include <VBox/com/ErrorInfo.h>
35	#include <VBox/com/errorprint.h>
36	#include <VBox/com/VirtualBox.h>
37
38	#include <iprt/err.h>
39	#include <iprt/path.h>
40	#include <iprt/param.h>
41	#include <iprt/string.h>
42	#include <iprt/ctype.h>
43	#include <iprt/stream.h>
44	#include <iprt/getopt.h>
45	#include <VBox/log.h>
46
47	#include "VBoxManage.h"
48	using namespace com;
49
50	DECLARE_TRANSLATION_CONTEXT(BWControl);
51
52	// funcs
53	///////////////////////////////////////////////////////////////////////////////
54
55
56	/**
57	* Parses a string in the following format "n[k\|m\|g\|K\|M\|G]". Stores the value
58	* of n expressed in bytes to *pLimit. k meas kilobit, while K means kilobyte.
59	*
60	* @returns Error message or NULL if successful.
61	* @param pcszLimit The string to parse.
62	* @param pLimit Where to store the result.
63	*/
64	static const char parseLimit(const char pcszLimit, int64_t *pLimit)
65	{
66	int iMultiplier = _1M;
67	char *pszNext = NULL;
68	int rc = RTStrToInt64Ex(pcszLimit, &pszNext, 10, pLimit);
69
70	switch (rc)
71	{
72	case VINF_SUCCESS:
73	break;
74	case VWRN_NUMBER_TOO_BIG:
75	return BWControl::tr("Limit is too big\n");
76	case VWRN_TRAILING_CHARS:
77	switch (*pszNext)
78	{
79	case 'G': iMultiplier = _1G; break;
80	case 'M': iMultiplier = _1M; break;
81	case 'K': iMultiplier = _1K; break;
82	case 'g': iMultiplier = 125000000; break;
83	case 'm': iMultiplier = 125000; break;
84	case 'k': iMultiplier = 125; break;
85	default: return BWControl::tr("Invalid unit suffix. Valid suffixes are: k, m, g, K, M, G\n");
86	}
87	break;
88	case VWRN_TRAILING_SPACES:
89	return BWControl::tr("Trailing spaces in limit!\n");
90	case VERR_NO_DIGITS:
91	return BWControl::tr("No digits in limit specifier\n");
92	default:
93	return BWControl::tr("Invalid limit specifier\n");
94	}
95	if (*pLimit < 0)
96	return BWControl::tr("Limit cannot be negative\n");
97	if (*pLimit > INT64_MAX / iMultiplier)
98	return BWControl::tr("Limit is too big\n");
99	pLimit = iMultiplier;
100
101	return NULL;
102	}
103
104	/**
105	* Handles the 'bandwidthctl myvm add' sub-command.
106	* @returns Exit code.
107	* @param a The handler argument package.
108	* @param bwCtrl Reference to the bandwidth control interface.
109	*/
110	static RTEXITCODE handleBandwidthControlAdd(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl)
111	{
112	HRESULT hrc = S_OK;
113	static const RTGETOPTDEF g_aBWCtlAddOptions[] =
114	{
115	{ "--type", 't', RTGETOPT_REQ_STRING },
116	{ "--limit", 'l', RTGETOPT_REQ_STRING }
117	};
118
119	setCurrentSubcommand(HELP_SCOPE_BANDWIDTHCTL_ADD);
120
121	Bstr name(a->argv[2]);
122	if (name.isEmpty())
123	{
124	errorArgument(BWControl::tr("Bandwidth group name must not be empty!\n"));
125	return RTEXITCODE_FAILURE;
126	}
127
128	const char *pszType = NULL;
129	int64_t cMaxBytesPerSec = INT64_MAX;
130
131	int c;
132	RTGETOPTUNION ValueUnion;
133	RTGETOPTSTATE GetState;
134	RTGetOptInit(&GetState, a->argc, a->argv, g_aBWCtlAddOptions,
135	RT_ELEMENTS(g_aBWCtlAddOptions), 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
136
137	while ( SUCCEEDED(hrc)
138	&& (c = RTGetOpt(&GetState, &ValueUnion)))
139	{
140	switch (c)
141	{
142	case 't': // bandwidth group type
143	{
144	if (ValueUnion.psz)
145	pszType = ValueUnion.psz;
146	else
147	hrc = E_FAIL;
148	break;
149	}
150
151	case 'l': // limit
152	{
153	if (ValueUnion.psz)
154	{
155	const char *pcszError = parseLimit(ValueUnion.psz, &cMaxBytesPerSec);
156	if (pcszError)
157	{
158	errorArgument(pcszError);
159	return RTEXITCODE_FAILURE;
160	}
161	}
162	else
163	hrc = E_FAIL;
164	break;
165	}
166
167	default:
168	{
169	errorGetOpt(c, &ValueUnion);
170	hrc = E_FAIL;
171	break;
172	}
173	}
174	}
175
176	BandwidthGroupType_T enmType;
177
178	if (!RTStrICmp(pszType, "disk"))
179	enmType = BandwidthGroupType_Disk;
180	else if (!RTStrICmp(pszType, "network"))
181	enmType = BandwidthGroupType_Network;
182	else
183	{
184	errorArgument(BWControl::tr("Invalid bandwidth group type\n"));
185	return RTEXITCODE_FAILURE;
186	}
187
188	CHECK_ERROR2I_RET(bwCtrl, CreateBandwidthGroup(name.raw(), enmType, (LONG64)cMaxBytesPerSec), RTEXITCODE_FAILURE);
189
190	return RTEXITCODE_SUCCESS;
191	}
192
193	/**
194	* Handles the 'bandwidthctl myvm set' sub-command.
195	* @returns Exit code.
196	* @param a The handler argument package.
197	* @param bwCtrl Reference to the bandwidth control interface.
198	*/
199	static RTEXITCODE handleBandwidthControlSet(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl)
200	{
201	HRESULT hrc = S_OK;
202	static const RTGETOPTDEF g_aBWCtlAddOptions[] =
203	{
204	{ "--limit", 'l', RTGETOPT_REQ_STRING }
205	};
206
207	setCurrentSubcommand(HELP_SCOPE_BANDWIDTHCTL_SET);
208
209	Bstr name(a->argv[2]);
210	int64_t cMaxBytesPerSec = INT64_MAX;
211
212	int c;
213	RTGETOPTUNION ValueUnion;
214	RTGETOPTSTATE GetState;
215	RTGetOptInit(&GetState, a->argc, a->argv, g_aBWCtlAddOptions,
216	RT_ELEMENTS(g_aBWCtlAddOptions), 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
217
218	while ( SUCCEEDED(hrc)
219	&& (c = RTGetOpt(&GetState, &ValueUnion)))
220	{
221	switch (c)
222	{
223	case 'l': // limit
224	{
225	if (ValueUnion.psz)
226	{
227	const char *pcszError = parseLimit(ValueUnion.psz, &cMaxBytesPerSec);
228	if (pcszError)
229	{
230	errorArgument(pcszError);
231	return RTEXITCODE_FAILURE;
232	}
233	}
234	else
235	hrc = E_FAIL;
236	break;
237	}
238
239	default:
240	{
241	errorGetOpt(c, &ValueUnion);
242	hrc = E_FAIL;
243	break;
244	}
245	}
246	}
247
248
249	if (cMaxBytesPerSec != INT64_MAX)
250	{
251	ComPtr<IBandwidthGroup> bwGroup;
252	CHECK_ERROR2I_RET(bwCtrl, GetBandwidthGroup(name.raw(), bwGroup.asOutParam()), RTEXITCODE_FAILURE);
253	if (SUCCEEDED(hrc))
254	{
255	CHECK_ERROR2I_RET(bwGroup, COMSETTER(MaxBytesPerSec)((LONG64)cMaxBytesPerSec), RTEXITCODE_FAILURE);
256	}
257	}
258
259	return RTEXITCODE_SUCCESS;
260	}
261
262	/**
263	* Handles the 'bandwidthctl myvm remove' sub-command.
264	* @returns Exit code.
265	* @param a The handler argument package.
266	* @param bwCtrl Reference to the bandwidth control interface.
267	*/
268	static RTEXITCODE handleBandwidthControlRemove(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl)
269	{
270	setCurrentSubcommand(HELP_SCOPE_BANDWIDTHCTL_REMOVE);
271
272	Bstr name(a->argv[2]);
273	CHECK_ERROR2I_RET(bwCtrl, DeleteBandwidthGroup(name.raw()), RTEXITCODE_FAILURE);
274	return RTEXITCODE_SUCCESS;
275	}
276
277	/**
278	* Handles the 'bandwidthctl myvm list' sub-command.
279	* @returns Exit code.
280	* @param a The handler argument package.
281	* @param bwCtrl Reference to the bandwidth control interface.
282	*/
283	static RTEXITCODE handleBandwidthControlList(HandlerArg *pArgs, ComPtr<IBandwidthControl> &rptrBWControl)
284	{
285	static const RTGETOPTDEF g_aOptions[] =
286	{
287	{ "--machinereadable", 'M', RTGETOPT_REQ_NOTHING },
288	};
289
290	setCurrentSubcommand(HELP_SCOPE_BANDWIDTHCTL_LIST);
291	VMINFO_DETAILS enmDetails = VMINFO_STANDARD;
292
293	int c;
294	RTGETOPTUNION ValueUnion;
295	RTGETOPTSTATE GetState;
296	RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, g_aOptions, RT_ELEMENTS(g_aOptions), 2 /iArg/, 0 /fFlags/);
297	while ((c = RTGetOpt(&GetState, &ValueUnion)))
298	{
299	switch (c)
300	{
301	case 'M':
302	enmDetails = VMINFO_MACHINEREADABLE;
303	break;
304	default:
305	return errorGetOpt(c, &ValueUnion);
306	}
307	}
308
309	if (FAILED(showBandwidthGroups(rptrBWControl, enmDetails)))
310	return RTEXITCODE_FAILURE;
311
312	return RTEXITCODE_SUCCESS;
313	}
314
315
316	/**
317	* Handles the 'bandwidthctl' command.
318	* @returns Exit code.
319	* @param a The handler argument package.
320	*/
321	RTEXITCODE handleBandwidthControl(HandlerArg *a)
322	{
323	HRESULT hrc = S_OK;
324	ComPtr<IMachine> machine;
325	ComPtr<IBandwidthControl> bwCtrl;
326
327	if (a->argc < 2)
328	return errorSyntax(BWControl::tr("Too few parameters"));
329	else if (a->argc > 7)
330	return errorSyntax(BWControl::tr("Too many parameters"));
331
332	/* try to find the given machine */
333	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
334	machine.asOutParam()), RTEXITCODE_FAILURE);
335
336	/* open a session for the VM (new or shared) */
337	CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
338	SessionType_T st;
339	CHECK_ERROR_RET(a->session, COMGETTER(Type)(&st), RTEXITCODE_FAILURE);
340	bool fRunTime = (st == SessionType_Shared);
341
342	/* get the mutable session machine */
343	a->session->COMGETTER(Machine)(machine.asOutParam());
344	hrc = machine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam());
345	if (FAILED(hrc)) goto leave; /** @todo r=andy Argh!! */
346
347	if (!strcmp(a->argv[1], "add"))
348	{
349	if (fRunTime)
350	{
351	errorArgument(BWControl::tr("Bandwidth groups cannot be created while the VM is running\n"));
352	goto leave;
353	}
354	hrc = handleBandwidthControlAdd(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
355	}
356	else if (!strcmp(a->argv[1], "remove"))
357	{
358	if (fRunTime)
359	{
360	errorArgument(BWControl::tr("Bandwidth groups cannot be deleted while the VM is running\n"));
361	goto leave;
362	}
363	hrc = handleBandwidthControlRemove(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
364	}
365	else if (!strcmp(a->argv[1], "set"))
366	hrc = handleBandwidthControlSet(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
367	else if (!strcmp(a->argv[1], "list"))
368	hrc = handleBandwidthControlList(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL;
369	else
370	{
371	errorSyntax(BWControl::tr("Invalid parameter '%s'"), a->argv[1]);
372	hrc = E_FAIL;
373	}
374
375	/* commit changes */
376	if (SUCCEEDED(hrc))
377	CHECK_ERROR(machine, SaveSettings());
378
379	leave:
380	/* it's important to always close sessions */
381	a->session->UnlockMachine();
382
383	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
384	}

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp@ 97405

Download in other formats: