ProgressImpl.cpp@ 102797

Last change on this file since 102797 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.5 KB

Line
1	/* $Id: ProgressImpl.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VirtualBox Progress COM class implementation
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 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	#define LOG_GROUP LOG_GROUP_MAIN_PROGRESS
29	#include <iprt/types.h>
30
31	#if defined(VBOX_WITH_XPCOM)
32	#include <nsIServiceManager.h>
33	#include <nsIExceptionService.h>
34	#include <nsCOMPtr.h>
35	#endif /* defined(VBOX_WITH_XPCOM) */
36
37	#include "ProgressImpl.h"
38
39	#if !defined(VBOX_COM_INPROC)
40	# include "VirtualBoxImpl.h"
41	#endif
42	#include "VirtualBoxErrorInfoImpl.h"
43
44	#include <iprt/time.h>
45	#include <iprt/semaphore.h>
46	#include <iprt/cpp/utils.h>
47
48	#include <iprt/errcore.h>
49
50	#include "AutoCaller.h"
51	#include "LoggingNew.h"
52	#include "VBoxEvents.h"
53
54
55	Progress::Progress()
56	#if !defined(VBOX_COM_INPROC)
57	: mParent(NULL)
58	#endif
59	{
60	}
61
62	Progress::~Progress()
63	{
64	}
65
66
67	HRESULT Progress::FinalConstruct()
68	{
69	mCancelable = FALSE;
70	mCompleted = FALSE;
71	mCanceled = FALSE;
72	mResultCode = S_OK;
73
74	m_cOperations
75	= m_ulTotalOperationsWeight
76	= m_ulOperationsCompletedWeight
77	= m_ulCurrentOperation
78	= m_ulCurrentOperationWeight
79	= m_ulOperationPercent
80	= m_cMsTimeout
81	= 0;
82
83	// get creation timestamp
84	m_ullTimestamp = RTTimeMilliTS();
85
86	m_pfnCancelCallback = NULL;
87	m_pvCancelUserArg = NULL;
88
89	mCompletedSem = NIL_RTSEMEVENTMULTI;
90	mWaitersCount = 0;
91
92	return Progress::BaseFinalConstruct();
93	}
94
95	void Progress::FinalRelease()
96	{
97	uninit();
98	BaseFinalRelease();
99	}
100
101	// public initializer/uninitializer for internal purposes only
102	////////////////////////////////////////////////////////////////////////////////
103
104	/**
105	* Initializes the normal progress object. With this variant, one can have
106	* an arbitrary number of sub-operation which IProgress can analyze to
107	* have a weighted progress computed.
108	*
109	* For example, say that one IProgress is supposed to track the cloning
110	* of two hard disk images, which are 100 MB and 1000 MB in size, respectively,
111	* and each of these hard disks should be one sub-operation of the IProgress.
112	*
113	* Obviously the progress would be misleading if the progress displayed 50%
114	* after the smaller image was cloned and would then take much longer for
115	* the second half.
116	*
117	* With weighted progress, one can invoke the following calls:
118	*
119	* 1) create progress object with cOperations = 2 and ulTotalOperationsWeight =
120	* 1100 (100 MB plus 1100, but really the weights can be any ULONG); pass
121	* in ulFirstOperationWeight = 100 for the first sub-operation
122	*
123	* 2) Then keep calling setCurrentOperationProgress() with a percentage
124	* for the first image; the total progress will increase up to a value
125	* of 9% (100MB / 1100MB * 100%).
126	*
127	* 3) Then call setNextOperation with the second weight (1000 for the megabytes
128	* of the second disk).
129	*
130	* 4) Then keep calling setCurrentOperationProgress() with a percentage for
131	* the second image, where 100% of the operation will then yield a 100%
132	* progress of the entire task.
133	*
134	* Weighting is optional; you can simply assign a weight of 1 to each operation
135	* and pass ulTotalOperationsWeight == cOperations to this constructor (but
136	* for that variant and for backwards-compatibility a simpler constructor exists
137	* in ProgressImpl.h as well).
138	*
139	* Even simpler, if you need no sub-operations at all, pass in cOperations =
140	* ulTotalOperationsWeight = ulFirstOperationWeight = 1.
141	*
142	* @param aParent Parent object (only for server-side Progress objects).
143	* @param aInitiator Initiator of the task (for server-side objects. Can be
144	* NULL which means initiator = parent, otherwise must not
145	* be NULL).
146	* @param aDescription Overall task description.
147	* @param aCancelable Flag whether the task maybe canceled.
148	* @param cOperations Number of operations within this task (at least 1).
149	* @param ulTotalOperationsWeight Total weight of operations; must be the sum of ulFirstOperationWeight and
150	* what is later passed with each subsequent setNextOperation() call.
151	* @param aFirstOperationDescription Description of the first operation.
152	* @param ulFirstOperationWeight Weight of first sub-operation.
153	*/
154	HRESULT Progress::init(
155	#if !defined(VBOX_COM_INPROC)
156	VirtualBox *aParent,
157	#endif
158	IUnknown *aInitiator,
159	const Utf8Str &aDescription,
160	BOOL aCancelable,
161	ULONG cOperations,
162	ULONG ulTotalOperationsWeight,
163	const Utf8Str &aFirstOperationDescription,
164	ULONG ulFirstOperationWeight)
165	{
166	LogFlowThisFunc(("aDescription=\"%s\", cOperations=%d, ulTotalOperationsWeight=%d, aFirstOperationDescription=\"%s\", ulFirstOperationWeight=%d\n",
167	aDescription.c_str(),
168	cOperations,
169	ulTotalOperationsWeight,
170	aFirstOperationDescription.c_str(),
171	ulFirstOperationWeight));
172
173	AssertReturn(ulTotalOperationsWeight >= 1, E_INVALIDARG);
174
175	/* Enclose the state transition NotReady->InInit->Ready */
176	AutoInitSpan autoInitSpan(this);
177	AssertReturn(autoInitSpan.isOk(), E_FAIL);
178
179	HRESULT hrc = unconst(pEventSource).createObject();
180	if (FAILED(hrc))
181	return hrc;
182
183	hrc = pEventSource->init();
184	if (FAILED(hrc))
185	return hrc;
186
187	#if !defined(VBOX_COM_INPROC)
188	AssertReturn(aParent, E_INVALIDARG);
189	#else
190	AssertReturn(aInitiator, E_INVALIDARG);
191	#endif
192
193	#if !defined(VBOX_COM_INPROC)
194	/* share parent weakly */
195	unconst(mParent) = aParent;
196	#endif
197
198	#if !defined(VBOX_COM_INPROC)
199	/* assign (and therefore addref) initiator only if it is not VirtualBox
200	* (to avoid cycling); otherwise mInitiator will remain null which means
201	* that it is the same as the parent */
202	if (aInitiator)
203	{
204	ComObjPtr<VirtualBox> pVirtualBox(mParent);
205	if (!(pVirtualBox == aInitiator))
206	unconst(mInitiator) = aInitiator;
207	}
208	#else
209	unconst(mInitiator) = aInitiator;
210	#endif
211
212	unconst(mId).create();
213
214	#if !defined(VBOX_COM_INPROC)
215	/* add to the global collection of progress operations (note: after
216	* creating mId) */
217	mParent->i_addProgress(this);
218	#endif
219
220	unconst(mDescription) = aDescription;
221
222	mCancelable = aCancelable;
223
224	m_cOperations = cOperations;
225	m_ulTotalOperationsWeight = ulTotalOperationsWeight;
226	m_ulOperationsCompletedWeight = 0;
227	m_ulCurrentOperation = 0;
228	m_operationDescription = aFirstOperationDescription;
229	m_ulCurrentOperationWeight = ulFirstOperationWeight;
230	m_ulOperationPercent = 0;
231
232	int vrc = RTSemEventMultiCreate(&mCompletedSem);
233	ComAssertRCRet(vrc, E_FAIL);
234
235	RTSemEventMultiReset(mCompletedSem);
236
237	/* Confirm a successful initialization. */
238	autoInitSpan.setSucceeded();
239
240	return S_OK;
241	}
242
243	/**
244	* Initializes the sub-progress object that represents a specific operation of
245	* the whole task.
246	*
247	* Objects initialized with this method are then combined together into the
248	* single task using a Progress instance, so it doesn't require the
249	* parent, initiator, description and doesn't create an ID. Note that calling
250	* respective getter methods on an object initialized with this method is
251	* useless. Such objects are used only to provide a separate wait semaphore and
252	* store individual operation descriptions.
253	*
254	* @param aCancelable Flag whether the task maybe canceled.
255	* @param aOperationCount Number of sub-operations within this task (at least 1).
256	* @param aOperationDescription Description of the individual operation.
257	*/
258	HRESULT Progress::init(BOOL aCancelable,
259	ULONG aOperationCount,
260	const Utf8Str &aOperationDescription)
261	{
262	LogFlowThisFunc(("aOperationDescription=\"%s\"\n", aOperationDescription.c_str()));
263
264	/* Enclose the state transition NotReady->InInit->Ready */
265	AutoInitSpan autoInitSpan(this);
266	AssertReturn(autoInitSpan.isOk(), E_FAIL);
267
268	mCancelable = aCancelable;
269
270	// for this variant we assume for now that all operations are weighed "1"
271	// and equal total weight = operation count
272	m_cOperations = aOperationCount;
273	m_ulTotalOperationsWeight = aOperationCount;
274	m_ulOperationsCompletedWeight = 0;
275	m_ulCurrentOperation = 0;
276	m_operationDescription = aOperationDescription;
277	m_ulCurrentOperationWeight = 1;
278	m_ulOperationPercent = 0;
279
280	int vrc = RTSemEventMultiCreate(&mCompletedSem);
281	ComAssertRCRet(vrc, E_FAIL);
282
283	RTSemEventMultiReset(mCompletedSem);
284
285	/* Confirm a successful initialization. */
286	autoInitSpan.setSucceeded();
287
288	return S_OK;
289	}
290
291
292	/**
293	* Uninitializes the instance and sets the ready flag to FALSE.
294	*
295	* Called either from FinalRelease() or by the parent when it gets destroyed.
296	*/
297	void Progress::uninit()
298	{
299	LogFlowThisFunc(("\n"));
300
301	/* Enclose the state transition Ready->InUninit->NotReady */
302	AutoUninitSpan autoUninitSpan(this);
303	if (autoUninitSpan.uninitDone())
304	return;
305
306	/* wake up all threads still waiting on occasion */
307	if (mWaitersCount > 0)
308	{
309	LogFlow(("WARNING: There are still %d threads waiting for '%s' completion!\n",
310	mWaitersCount, mDescription.c_str()));
311	RTSemEventMultiSignal(mCompletedSem);
312	}
313
314	RTSemEventMultiDestroy(mCompletedSem);
315
316	/* release initiator (effective only if mInitiator has been assigned in init()) */
317	unconst(mInitiator).setNull();
318
319	#if !defined(VBOX_COM_INPROC)
320	if (mParent)
321	{
322	/* remove the added progress on failure to complete the initialization */
323	if (autoUninitSpan.initFailed() && mId.isValid() && !mId.isZero())
324	mParent->i_removeProgress(mId.ref());
325
326	unconst(mParent) = NULL;
327	}
328	#endif
329	}
330
331
332	// public methods only for internal purposes
333	////////////////////////////////////////////////////////////////////////////////
334
335	/**
336	* Marks the whole task as complete and sets the result code.
337	*
338	* If the result code indicates a failure (\|FAILED(@a aResultCode)\|) then this
339	* method will import the error info from the current thread and assign it to
340	* the errorInfo attribute (it will return an error if no info is available in
341	* such case).
342	*
343	* If the result code indicates a success (\|SUCCEEDED(@a aResultCode)\|) then
344	* the current operation is set to the last.
345	*
346	* Note that this method may be called only once for the given Progress object.
347	* Subsequent calls will assert.
348	*
349	* @param aResultCode Operation result code.
350	*/
351	HRESULT Progress::i_notifyComplete(HRESULT aResultCode)
352	{
353	HRESULT hrc;
354	ComPtr<IVirtualBoxErrorInfo> errorInfo;
355	if (FAILED(aResultCode))
356	{
357	/* try to import error info from the current thread */
358	#if !defined(VBOX_WITH_XPCOM)
359	ComPtr<IErrorInfo> err;
360	hrc = ::GetErrorInfo(0, err.asOutParam());
361	if (hrc == S_OK && err)
362	hrc = err.queryInterfaceTo(errorInfo.asOutParam());
363	#else /* !defined(VBOX_WITH_XPCOM) */
364	nsCOMPtr<nsIExceptionService> es;
365	es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &hrc);
366	if (NS_SUCCEEDED(hrc))
367	{
368	nsCOMPtr <nsIExceptionManager> em;
369	hrc = es->GetCurrentExceptionManager(getter_AddRefs(em));
370	if (NS_SUCCEEDED(hrc))
371	{
372	ComPtr<nsIException> ex;
373	hrc = em->GetCurrentException(ex.asOutParam());
374	if (NS_SUCCEEDED(hrc) && ex)
375	hrc = ex.queryInterfaceTo(errorInfo.asOutParam());
376	}
377	}
378	#endif /* !defined(VBOX_WITH_XPCOM) */
379	}
380
381	return i_notifyCompleteWorker(aResultCode, errorInfo);
382	}
383
384	/**
385	* Wrapper around Progress:notifyCompleteV.
386	*/
387	HRESULT Progress::i_notifyComplete(HRESULT aResultCode,
388	const GUID &aIID,
389	const char *pcszComponent,
390	const char *aText,
391	...)
392	{
393	va_list va;
394	va_start(va, aText);
395	HRESULT hrc = i_notifyCompleteV(aResultCode, aIID, pcszComponent, aText, va);
396	va_end(va);
397	return hrc;
398	}
399
400	/**
401	* Marks the operation as complete and attaches full error info.
402	*
403	* @param aResultCode Operation result (error) code, must not be S_OK.
404	* @param aIID IID of the interface that defines the error.
405	* @param pcszComponent Name of the component that generates the error.
406	* @param aText Error message (must not be null), an RTStrPrintf-like
407	* format string in UTF-8 encoding.
408	* @param va List of arguments for the format string.
409	*/
410	HRESULT Progress::i_notifyCompleteV(HRESULT aResultCode,
411	const GUID &aIID,
412	const char *pcszComponent,
413	const char *aText,
414	va_list va)
415	{
416	/* expected to be used only in case of error */
417	Assert(FAILED(aResultCode));
418
419	Utf8Str text(aText, va);
420	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
421	HRESULT hrc = errorInfo.createObject();
422	AssertComRCReturnRC(hrc);
423	errorInfo->init(aResultCode, aIID, pcszComponent, text);
424
425	return i_notifyCompleteWorker(aResultCode, errorInfo);
426	}
427
428	/**
429	* Wrapper around Progress:notifyCompleteBothV.
430	*/
431	HRESULT Progress::i_notifyCompleteBoth(HRESULT aResultCode,
432	int vrc,
433	const GUID &aIID,
434	const char *pcszComponent,
435	const char *aText,
436	...)
437	{
438	va_list va;
439	va_start(va, aText);
440	HRESULT hrc = i_notifyCompleteBothV(aResultCode, vrc, aIID, pcszComponent, aText, va);
441	va_end(va);
442	return hrc;
443	}
444
445	/**
446	* Marks the operation as complete and attaches full error info.
447	*
448	* @param aResultCode Operation result (error) code, must not be S_OK.
449	* @param vrc VBox status code to associate with the error.
450	* @param aIID IID of the interface that defines the error.
451	* @param pszComponent Name of the component that generates the error.
452	* @param pszFormat Error message (must not be null), an RTStrPrintf-like
453	* format string in UTF-8 encoding.
454	* @param va List of arguments for the format string.
455	*/
456	HRESULT Progress::i_notifyCompleteBothV(HRESULT aResultCode,
457	int vrc,
458	const GUID &aIID,
459	const char *pszComponent,
460	const char *pszFormat,
461	va_list va)
462	{
463	/* expected to be used only in case of error */
464	Assert(FAILED(aResultCode));
465
466	Utf8Str text(pszFormat, va);
467	ComObjPtr<VirtualBoxErrorInfo> errorInfo;
468	HRESULT hrc = errorInfo.createObject();
469	AssertComRCReturnRC(hrc);
470	errorInfo->initEx(aResultCode, vrc, aIID, pszComponent, text);
471
472	return i_notifyCompleteWorker(aResultCode, errorInfo);
473	}
474
475	/**
476	* Sets the cancelation callback, checking for cancelation first.
477	*
478	* @returns Success indicator.
479	* @retval true on success.
480	* @retval false if the progress object has already been canceled or is in an
481	* invalid state
482	*
483	* @param pfnCallback The function to be called upon cancelation.
484	* @param pvUser The callback argument.
485	*/
486	bool Progress::i_setCancelCallback(void (pfnCallback)(void ), void *pvUser)
487	{
488	AutoCaller autoCaller(this);
489	AssertReturn(autoCaller.isOk(), false);
490
491	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
492
493	i_checkForAutomaticTimeout();
494	if (mCanceled)
495	return false;
496
497	m_pvCancelUserArg = pvUser;
498	m_pfnCancelCallback = pfnCallback;
499	return true;
500	}
501
502	/**
503	* @callback_method_impl{FNRTPROGRESS,
504	* Works the progress of the current operation.}
505	*/
506	/static/ DECLCALLBACK(int) Progress::i_iprtProgressCallback(unsigned uPercentage, void *pvUser)
507	{
508	Progress pThis = (Progress )pvUser;
509
510	/*
511	* Same as setCurrentOperationProgress, except we don't fail on mCompleted.
512	*/
513	AutoWriteLock alock(pThis COMMA_LOCKVAL_SRC_POS);
514	int vrc = VINF_SUCCESS;
515	if (!pThis->mCompleted)
516	{
517	pThis->i_checkForAutomaticTimeout();
518	if (!pThis->mCanceled)
519	{
520	if (uPercentage > pThis->m_ulOperationPercent)
521	pThis->setCurrentOperationProgress(uPercentage);
522	}
523	else
524	{
525	Assert(pThis->mCancelable);
526	vrc = VERR_CANCELLED;
527	}
528	}
529	/* else ignored */
530	return vrc;
531	}
532
533	/**
534	* @callback_method_impl{FNVDPROGRESS,
535	* Progress::i_iprtProgressCallback with parameters switched around.}
536	*/
537	/static/ DECLCALLBACK(int) Progress::i_vdProgressCallback(void *pvUser, unsigned uPercentage)
538	{
539	return i_iprtProgressCallback(uPercentage, pvUser);
540	}
541
542
543	// IProgress properties
544	/////////////////////////////////////////////////////////////////////////////
545
546	HRESULT Progress::getId(com::Guid &aId)
547	{
548	/* mId is constant during life time, no need to lock */
549	aId = mId;
550
551	return S_OK;
552	}
553
554	HRESULT Progress::getDescription(com::Utf8Str &aDescription)
555	{
556	/* mDescription is constant during life time, no need to lock */
557	aDescription = mDescription;
558
559	return S_OK;
560	}
561	HRESULT Progress::getInitiator(ComPtr<IUnknown> &aInitiator)
562	{
563	/* mInitiator/mParent are constant during life time, no need to lock */
564	#if !defined(VBOX_COM_INPROC)
565	if (mInitiator)
566	mInitiator.queryInterfaceTo(aInitiator.asOutParam());
567	else
568	{
569	ComObjPtr<VirtualBox> pVirtualBox(mParent);
570	pVirtualBox.queryInterfaceTo(aInitiator.asOutParam());
571	}
572	#else
573	mInitiator.queryInterfaceTo(aInitiator.asOutParam());
574	#endif
575
576	return S_OK;
577	}
578
579	HRESULT Progress::getCancelable(BOOL *aCancelable)
580	{
581	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
582
583	*aCancelable = mCancelable;
584
585	return S_OK;
586	}
587
588	HRESULT Progress::getPercent(ULONG *aPercent)
589	{
590	/* i_checkForAutomaticTimeout requires a write lock. */
591	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
592
593	if (mCompleted && SUCCEEDED(mResultCode))
594	*aPercent = 100;
595	else
596	{
597	ULONG ulPercent = (ULONG)i_calcTotalPercent();
598	// do not report 100% until we're really really done with everything
599	// as the Qt GUI dismisses progress dialogs in that case
600	if ( ulPercent == 100
601	&& ( m_ulOperationPercent < 100
602	\|\| (m_ulCurrentOperation < m_cOperations -1)
603	)
604	)
605	*aPercent = 99;
606	else
607	*aPercent = ulPercent;
608	}
609
610	i_checkForAutomaticTimeout();
611
612	return S_OK;
613	}
614
615	HRESULT Progress::getTimeRemaining(LONG *aTimeRemaining)
616	{
617	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
618
619	if (mCompleted)
620	*aTimeRemaining = 0;
621	else
622	{
623	double dPercentDone = i_calcTotalPercent();
624	if (dPercentDone < 1)
625	*aTimeRemaining = -1; // unreliable, or avoid division by 0 below
626	else
627	{
628	uint64_t ullTimeNow = RTTimeMilliTS();
629	uint64_t ullTimeElapsed = ullTimeNow - m_ullTimestamp;
630	uint64_t ullTimeTotal = (uint64_t)((double)ullTimeElapsed * 100 / dPercentDone);
631	uint64_t ullTimeRemaining = (ullTimeTotal < ullTimeElapsed) ? 0 : ullTimeTotal - ullTimeElapsed;
632
633	// LogFunc(("dPercentDone = %RI32, ullTimeNow = %RI64, ullTimeElapsed = %RI64, ullTimeTotal = %RI64, ullTimeRemaining = %RI64\n",
634	// (uint32_t)dPercentDone, ullTimeNow, ullTimeElapsed, ullTimeTotal, ullTimeRemaining));
635
636	aTimeRemaining = (LONG)(RT_MIN(ullTimeRemaining, RT_MS_1HOUR_6424*365) / 1000);
637	}
638	}
639
640	return S_OK;
641	}
642
643	HRESULT Progress::getCompleted(BOOL *aCompleted)
644	{
645	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
646
647	*aCompleted = mCompleted;
648
649	return S_OK;
650	}
651
652	HRESULT Progress::getCanceled(BOOL *aCanceled)
653	{
654	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
655
656	*aCanceled = mCanceled;
657
658	return S_OK;
659	}
660
661	HRESULT Progress::getResultCode(LONG *aResultCode)
662	{
663	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
664
665	if (!mCompleted)
666	return setError(E_FAIL, tr("Result code is not available, operation is still in progress"));
667
668	*aResultCode = (LONG)mResultCode;
669
670	return S_OK;
671	}
672
673	HRESULT Progress::getErrorInfo(ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
674	{
675	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
676
677	if (!mCompleted)
678	return setError(E_FAIL, tr("Error info is not available, operation is still in progress"));
679
680	mErrorInfo.queryInterfaceTo(aErrorInfo.asOutParam());
681
682	return S_OK;
683	}
684
685	HRESULT Progress::getOperationCount(ULONG *aOperationCount)
686	{
687	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
688
689	*aOperationCount = m_cOperations;
690
691	return S_OK;
692	}
693
694	HRESULT Progress::getOperation(ULONG *aOperation)
695	{
696	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
697
698	*aOperation = m_ulCurrentOperation;
699
700	return S_OK;
701	}
702
703	HRESULT Progress::getOperationDescription(com::Utf8Str &aOperationDescription)
704	{
705	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
706
707	aOperationDescription = m_operationDescription;
708
709	return S_OK;
710	}
711
712	HRESULT Progress::getOperationPercent(ULONG *aOperationPercent)
713	{
714	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
715
716	if (mCompleted && SUCCEEDED(mResultCode))
717	*aOperationPercent = 100;
718	else
719	*aOperationPercent = m_ulOperationPercent;
720
721	return S_OK;
722	}
723
724	HRESULT Progress::getOperationWeight(ULONG *aOperationWeight)
725	{
726	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
727
728	*aOperationWeight = m_ulCurrentOperationWeight;
729
730	return S_OK;
731	}
732
733	HRESULT Progress::getTimeout(ULONG *aTimeout)
734	{
735	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
736
737	*aTimeout = m_cMsTimeout;
738
739	return S_OK;
740	}
741
742	HRESULT Progress::setTimeout(ULONG aTimeout)
743	{
744	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
745
746	if (!mCancelable)
747	return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
748	m_cMsTimeout = aTimeout;
749
750	return S_OK;
751	}
752
753	HRESULT Progress::getEventSource(ComPtr<IEventSource> &aEventSource)
754	{
755	/* event source is const, no need to lock */
756	pEventSource.queryInterfaceTo(aEventSource.asOutParam());
757	return S_OK;
758	}
759
760
761	// IProgress methods
762	/////////////////////////////////////////////////////////////////////////////
763
764	/**
765	* @note XPCOM: when this method is not called on the main XPCOM thread, it
766	* simply blocks the thread until mCompletedSem is signalled. If the
767	* thread has its own event queue (hmm, what for?) that it must run, then
768	* calling this method will definitely freeze event processing.
769	*/
770	HRESULT Progress::waitForCompletion(LONG aTimeout)
771	{
772	LogFlowThisFuncEnter();
773	LogFlowThisFunc(("aTimeout=%d\n", aTimeout));
774
775	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
776
777	/* if we're already completed, take a shortcut */
778	if (!mCompleted && aTimeout != 0)
779	{
780	RTMSINTERVAL cMsWait = aTimeout < 0 ? RT_INDEFINITE_WAIT : (RTMSINTERVAL)aTimeout;
781	uint64_t msLast = aTimeout < 0 ? 0 : RTTimeMilliTS();
782
783	for (;;)
784	{
785	mWaitersCount++;
786	alock.release();
787	int vrc = RTSemEventMultiWait(mCompletedSem, cMsWait);
788	alock.acquire();
789	mWaitersCount--;
790
791	/* the last waiter resets the semaphore */
792	if (mWaitersCount == 0)
793	RTSemEventMultiReset(mCompletedSem);
794
795	if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
796	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Failed to wait for the task completion (%Rrc)"), vrc);
797
798	if (mCompleted)
799	break;
800
801	if (aTimeout >= 0)
802	{
803	uint64_t msNow = RTTimeMilliTS();
804	uint64_t cMsElapsed = msNow - msLast;
805	if (cMsWait <= cMsElapsed)
806	break;
807	cMsWait -= (RTMSINTERVAL)cMsElapsed;
808	msLast = msNow;
809	}
810	}
811	}
812
813	LogFlowThisFuncLeave();
814	return S_OK;
815	}
816
817	/**
818	* @note XPCOM: when this method is not called on the main XPCOM thread, it
819	* simply blocks the thread until mCompletedSem is signalled. If the
820	* thread has its own event queue (hmm, what for?) that it must run, then
821	* calling this method will definitely freeze event processing.
822	*/
823	HRESULT Progress::waitForOperationCompletion(ULONG aOperation, LONG aTimeout)
824
825	{
826	LogFlowThisFuncEnter();
827	LogFlowThisFunc(("aOperation=%d, aTimeout=%d\n", aOperation, aTimeout));
828
829	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
830
831	CheckComArgExpr(aOperation, aOperation < m_cOperations);
832
833	/* if we're already completed or if the given operation is already done,
834	* then take a shortcut */
835	if ( !mCompleted
836	&& aOperation >= m_ulCurrentOperation
837	&& aTimeout != 0)
838	{
839	RTMSINTERVAL cMsWait = aTimeout < 0 ? RT_INDEFINITE_WAIT : (RTMSINTERVAL)aTimeout;
840	uint64_t msLast = aTimeout < 0 ? 0 : RTTimeMilliTS();
841
842	for (;;)
843	{
844	mWaitersCount ++;
845	alock.release();
846	int vrc = RTSemEventMultiWait(mCompletedSem, cMsWait);
847	alock.acquire();
848	mWaitersCount--;
849
850	/* the last waiter resets the semaphore */
851	if (mWaitersCount == 0)
852	RTSemEventMultiReset(mCompletedSem);
853
854	if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
855	return setErrorBoth(E_FAIL, vrc, tr("Failed to wait for the operation completion (%Rrc)"), vrc);
856
857	if (mCompleted \|\| aOperation >= m_ulCurrentOperation)
858	break;
859
860	if (aTimeout >= 0)
861	{
862	uint64_t msNow = RTTimeMilliTS();
863	uint64_t cMsElapsed = msNow - msLast;
864	if (cMsWait <= cMsElapsed)
865	break;
866	cMsWait -= (RTMSINTERVAL)cMsElapsed;
867	msLast = msNow;
868	}
869	}
870	}
871
872	LogFlowThisFuncLeave();
873	return S_OK;
874	}
875
876	HRESULT Progress::cancel()
877	{
878	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
879
880	if (!mCancelable)
881	return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Operation cannot be canceled"));
882
883	if (!mCanceled)
884	{
885	LogThisFunc(("Canceling\n"));
886	mCanceled = TRUE;
887	if (m_pfnCancelCallback)
888	m_pfnCancelCallback(m_pvCancelUserArg);
889
890	}
891	else
892	LogThisFunc(("Already canceled\n"));
893
894	return S_OK;
895	}
896
897
898	// IInternalProgressControl methods
899	/////////////////////////////////////////////////////////////////////////////
900
901	/**
902	* Updates the percentage value of the current operation.
903	*
904	* @param aPercent New percentage value of the operation in progress
905	* (in range [0, 100]).
906	*/
907	HRESULT Progress::setCurrentOperationProgress(ULONG aPercent)
908	{
909	AssertMsgReturn(aPercent <= 100, ("%u\n", aPercent), E_INVALIDARG);
910
911	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
912
913	i_checkForAutomaticTimeout();
914	if (mCancelable && mCanceled)
915	AssertReturn(!mCompleted, E_FAIL);
916	AssertReturn(!mCompleted && !mCanceled, E_FAIL);
917
918	if (m_ulOperationPercent != aPercent)
919	{
920	m_ulOperationPercent = aPercent;
921	ULONG actualPercent = 0;
922	getPercent(&actualPercent);
923	::FireProgressPercentageChangedEvent(pEventSource, mId.toString(), (LONG)actualPercent);
924	}
925
926	return S_OK;
927	}
928
929	HRESULT Progress::waitForOtherProgressCompletion(const ComPtr<IProgress> &aProgressOther,
930	ULONG aTimeoutMS)
931	{
932	LogFlowThisFuncEnter();
933
934	/* Note: no locking needed, because we just use public methods. */
935
936	BOOL fCancelable = FALSE;
937	BOOL fCompleted = FALSE;
938	BOOL fCanceled = FALSE;
939	ULONG prevPercent = UINT32_MAX;
940	ULONG currentPercent = 0;
941	ULONG cOp = 0;
942	/* Is the async process cancelable? */
943	HRESULT hrc = aProgressOther->COMGETTER(Cancelable)(&fCancelable);
944	if (FAILED(hrc)) return hrc;
945
946	uint64_t u64StopTime = UINT64_MAX;
947	if (aTimeoutMS > 0)
948	u64StopTime = RTTimeMilliTS() + aTimeoutMS;
949	/* Loop as long as the sync process isn't completed. */
950	while (SUCCEEDED(aProgressOther->COMGETTER(Completed(&fCompleted))))
951	{
952	/* We can forward any cancel request to the async process only when
953	* it is cancelable. */
954	if (fCancelable)
955	{
956	hrc = COMGETTER(Canceled)(&fCanceled);
957	if (FAILED(hrc)) return hrc;
958	if (fCanceled)
959	{
960	hrc = aProgressOther->Cancel();
961	if (FAILED(hrc)) return hrc;
962	}
963	}
964	/* Even if the user canceled the process, we have to wait until the
965	async task has finished his work (cleanup and such). Otherwise there
966	will be sync trouble (still wrong state, dead locks, ...) on the
967	used objects. So just do nothing, but wait for the complete
968	notification. */
969	if (!fCanceled)
970	{
971	/* Check if the current operation has changed. It is also possible that
972	* in the meantime more than one async operation was finished. So we
973	* have to loop as long as we reached the same operation count. */
974	ULONG curOp;
975	for (;;)
976	{
977	hrc = aProgressOther->COMGETTER(Operation(&curOp));
978	if (FAILED(hrc)) return hrc;
979	if (cOp != curOp)
980	{
981	Bstr bstr;
982	ULONG currentWeight;
983	hrc = aProgressOther->COMGETTER(OperationDescription(bstr.asOutParam()));
984	if (FAILED(hrc)) return hrc;
985	hrc = aProgressOther->COMGETTER(OperationWeight(&currentWeight));
986	if (FAILED(hrc)) return hrc;
987	hrc = SetNextOperation(bstr.raw(), currentWeight);
988	if (FAILED(hrc)) return hrc;
989	++cOp;
990	}
991	else
992	break;
993	}
994
995	hrc = aProgressOther->COMGETTER(OperationPercent(&currentPercent));
996	if (FAILED(hrc)) return hrc;
997	if (currentPercent != prevPercent)
998	{
999	prevPercent = currentPercent;
1000	hrc = SetCurrentOperationProgress(currentPercent);
1001	if (FAILED(hrc)) return hrc;
1002	}
1003	}
1004	if (fCompleted)
1005	break;
1006
1007	if (aTimeoutMS != 0)
1008	{
1009	/* Make sure the loop is not too tight */
1010	uint64_t u64Now = RTTimeMilliTS();
1011	uint64_t u64RemainingMS = u64StopTime - u64Now;
1012	if (u64RemainingMS < 10)
1013	u64RemainingMS = 10;
1014	else if (u64RemainingMS > 200)
1015	u64RemainingMS = 200;
1016	hrc = aProgressOther->WaitForCompletion((LONG)u64RemainingMS);
1017	if (FAILED(hrc)) return hrc;
1018
1019	if (RTTimeMilliTS() >= u64StopTime)
1020	return VBOX_E_TIMEOUT;
1021	}
1022	else
1023	{
1024	/* Make sure the loop is not too tight */
1025	hrc = aProgressOther->WaitForCompletion(200);
1026	if (FAILED(hrc)) return hrc;
1027	}
1028	}
1029
1030	/* Transfer error information if applicable and report the error status
1031	* back to the caller to make this as easy as possible. */
1032	LONG iRc;
1033	hrc = aProgressOther->COMGETTER(ResultCode)(&iRc);
1034	if (FAILED(hrc)) return hrc;
1035	if (FAILED((HRESULT)iRc))
1036	{
1037	setError(ProgressErrorInfo(aProgressOther));
1038	hrc = (HRESULT)iRc;
1039	}
1040
1041	LogFlowThisFuncLeave();
1042	return hrc;
1043	}
1044
1045	/**
1046	* Signals that the current operation is successfully completed and advances to
1047	* the next operation. The operation percentage is reset to 0.
1048	*
1049	* @param aNextOperationDescription Description of the next operation.
1050	* @param aNextOperationsWeight Weight of the next operation.
1051	*
1052	* @note The current operation must not be the last one.
1053	*/
1054	HRESULT Progress::setNextOperation(const com::Utf8Str &aNextOperationDescription, ULONG aNextOperationsWeight)
1055	{
1056	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1057
1058	if (mCanceled)
1059	return E_FAIL;
1060	AssertReturn(!mCompleted, E_FAIL);
1061	AssertReturn(m_ulCurrentOperation + 1 < m_cOperations, E_FAIL);
1062
1063	++m_ulCurrentOperation;
1064	m_ulOperationsCompletedWeight += m_ulCurrentOperationWeight;
1065
1066	m_operationDescription = aNextOperationDescription;
1067	m_ulCurrentOperationWeight = aNextOperationsWeight;
1068	m_ulOperationPercent = 0;
1069
1070	LogThisFunc(("%s: aNextOperationsWeight = %d; m_ulCurrentOperation is now %d, m_ulOperationsCompletedWeight is now %d\n",
1071	m_operationDescription.c_str(), aNextOperationsWeight, m_ulCurrentOperation, m_ulOperationsCompletedWeight));
1072
1073	/* wake up all waiting threads */
1074	if (mWaitersCount > 0)
1075	RTSemEventMultiSignal(mCompletedSem);
1076
1077	ULONG actualPercent = 0;
1078	getPercent(&actualPercent);
1079	::FireProgressPercentageChangedEvent(pEventSource, mId.toString(), (LONG)actualPercent);
1080
1081	return S_OK;
1082	}
1083
1084	/**
1085	* Notify the progress object that we're almost at the point of no return.
1086	*
1087	* This atomically checks for and disables cancelation. Calls to
1088	* IProgress::Cancel() made after a successful call to this method will fail
1089	* and the user can be told. While this isn't entirely clean behavior, it
1090	* prevents issues with an irreversible actually operation succeeding while the
1091	* user believe it was rolled back.
1092	*
1093	* @returns COM error status.
1094	* @retval S_OK on success.
1095	* @retval E_FAIL if the progress object has already been canceled or is in an
1096	* invalid state
1097	*/
1098	HRESULT Progress::notifyPointOfNoReturn(void)
1099	{
1100	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1101
1102	if (mCanceled)
1103	{
1104	LogThisFunc(("returns failure\n"));
1105	return E_FAIL;
1106	}
1107
1108	mCancelable = FALSE;
1109	LogThisFunc(("returns success\n"));
1110	return S_OK;
1111	}
1112
1113	/**
1114	* Marks the operation as complete and attaches full error info.
1115	*
1116	* This is where the actual work is done, the related methods all end up here.
1117	*
1118	* @param aResultCode Operation result (error) code, must not be S_OK.
1119	* @param aErrorInfo List of arguments for the format string.
1120	*/
1121	HRESULT Progress::notifyComplete(LONG aResultCode, const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
1122	{
1123	return i_notifyCompleteWorker((HRESULT)aResultCode, aErrorInfo);
1124	}
1125
1126
1127	// private internal helpers
1128	/////////////////////////////////////////////////////////////////////////////
1129
1130	/**
1131	* Marks the operation as complete and attaches full error info.
1132	*
1133	* This is where the actual work is done, the related methods all end up here.
1134	*
1135	* @param aResultCode Operation result (error) code, must not be S_OK.
1136	* @param aErrorInfo List of arguments for the format string.
1137	*
1138	* @note This is just notifyComplete with the correct aResultCode type.
1139	*/
1140	HRESULT Progress::i_notifyCompleteWorker(HRESULT aResultCode, const ComPtr<IVirtualBoxErrorInfo> &aErrorInfo)
1141	{
1142	LogThisFunc(("aResultCode=%Rhrc\n", aResultCode));
1143	/* on failure we expect error info, on success there must be none */
1144	AssertMsg(FAILED(aResultCode) ^ aErrorInfo.isNull(),
1145	("No error info but trying to set a failed result (%08X/%Rhrc)!\n", aResultCode, aResultCode));
1146
1147	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1148
1149	AssertReturn(mCompleted == FALSE, E_FAIL);
1150
1151	if (mCanceled && SUCCEEDED(aResultCode))
1152	aResultCode = E_FAIL;
1153
1154	mCompleted = TRUE;
1155	mResultCode = aResultCode;
1156	if (SUCCEEDED(aResultCode))
1157	{
1158	m_ulCurrentOperation = m_cOperations - 1; /* last operation */
1159	m_ulOperationPercent = 100;
1160	}
1161	mErrorInfo = aErrorInfo;
1162
1163	#if !defined(VBOX_COM_INPROC)
1164	/* remove from the global collection of pending progress operations */
1165	if (mParent)
1166	mParent->i_removeProgress(mId.ref());
1167	#endif
1168
1169	/* wake up all waiting threads */
1170	if (mWaitersCount > 0)
1171	RTSemEventMultiSignal(mCompletedSem);
1172
1173	::FireProgressTaskCompletedEvent(pEventSource, mId.toString());
1174
1175	return S_OK;
1176	}
1177
1178	/**
1179	* Internal helper to compute the total percent value based on the member values and
1180	* returns it as a "double". This is used both by GetPercent (which returns it as a
1181	* rounded ULONG) and GetTimeRemaining().
1182	*
1183	* Requires locking by the caller!
1184	*
1185	* @return fractional percentage as a double value.
1186	*/
1187	double Progress::i_calcTotalPercent()
1188	{
1189	// avoid division by zero
1190	if (m_ulTotalOperationsWeight == 0)
1191	return 0.0;
1192
1193	double dPercent = ( (double)m_ulOperationsCompletedWeight // weight of operations that have been completed
1194	+ ((double)m_ulOperationPercent *
1195	(double)m_ulCurrentOperationWeight / 100.0) // plus partial weight of the current operation
1196	) * 100.0 / (double)m_ulTotalOperationsWeight;
1197
1198	return dPercent;
1199	}
1200
1201	/**
1202	* Internal helper for automatically timing out the operation.
1203	*
1204	* The caller must hold the object write lock.
1205	*/
1206	void Progress::i_checkForAutomaticTimeout(void)
1207	{
1208	AssertReturnVoid(isWriteLockOnCurrentThread());
1209
1210	if ( m_cMsTimeout
1211	&& mCancelable
1212	&& !mCanceled
1213	&& RTTimeMilliTS() - m_ullTimestamp > m_cMsTimeout)
1214	Cancel();
1215	}

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

source: vbox/trunk/src/VBox/Main/src-all/ProgressImpl.cpp@ 102797

Download in other formats: