internal void WriteErrorCallbackInternal( CimOperationCallbackProcessingContext callbackProcessingContext, MI_Operation operationHandle, MI_Instance instanceHandle, out MI_OperationCallback_ResponseType response) { response = MI_OperationCallback_ResponseType.Yes; if (_writeErrorCallback != null) { Debug.Assert(instanceHandle != null, "Caller should verify instance != null"); CimInstance cimInstance = null; try { if (!instanceHandle.IsNull) { cimInstance = new CimInstance(instanceHandle.Clone()); var callbacksReceiverBase = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext; CimResponseType userResponse = CimResponseType.None; callbacksReceiverBase.CallIntoUserCallback( callbackProcessingContext, delegate { userResponse = _writeErrorCallback(cimInstance); }); response = (MI_OperationCallback_ResponseType)userResponse; } } finally { if (cimInstance != null) { cimInstance.Dispose(); } } } }
private void OnErrorInternal(CimOperationCallbackProcessingContext callbackProcessingContext, Exception exception) { this.CallIntoUserCallback( callbackProcessingContext, () => this._observer.OnError(exception), suppressFurtherUserCallbacks: true); }
internal void CallIntoUserCallback( CimOperationCallbackProcessingContext callbackProcessingContext, Action userCallback, bool serializeCallbacks = false, bool suppressFurtherUserCallbacks = false) { Debug.Assert(callbackProcessingContext != null, "Caller should make sure callbackProcessingContext != null"); Debug.Assert(userCallback != null, "Caller should make sure userCallback != null"); lock (this._suppressFurtherUserCallbacksLock) { if (this._suppressFurtherUserCallbacks) { return; } if (suppressFurtherUserCallbacks) { this._suppressFurtherUserCallbacks = true; } // need to call user callback inside the lock: // reason1: OnNext/OnError/OnComplete need to be serialized/sequentialized (especially wrt to calls to OnError resulting from async ReportInternalError) // reason2: extendedSemanticsCallbacks cannot be called after OnError(internalError) and there is a race-condition if callback is done outside the lock // (we could also use ReaderWriterLockSlim to allow multiple concurrent callbacks up to the last OnCompleted/OnError, but while this // fullfills IObservable/IObserver serialization/seqeuntialization contract wrt OnNext/OnError/OnCompleted, this at the same time // would unnecessarily weaken the serialization/sequeintializtaion contract for extended semantics callbacks) callbackProcessingContext.InUserCode = true; this.CallUnderOriginalExecutionContext(userCallback); callbackProcessingContext.InUserCode = false; } }
private void ProcessEndOfResultsWorker( CimOperationCallbackProcessingContext callbackProcessingContext, CimOperation cimOperation, Exception exception) { if (exception == null) { this.OnCompletedInternal(callbackProcessingContext); } else { CancellationMode cancellationMode = cimOperation.CancellationMode; switch (cancellationMode) { case CancellationMode.NoCancellationOccured: case CancellationMode.IgnoreCancellationRequests: this.OnErrorInternal(callbackProcessingContext, exception); break; case CancellationMode.ThrowOperationCancelledException: this.OnErrorInternal(callbackProcessingContext, new OperationCanceledException(exception.Message, exception)); break; case CancellationMode.SilentlyStopProducingResults: break; default: Debug.Assert(false, "Unrecognized CancellationMode"); break; } } }
private void ReportInternalErrorCore(CimOperationCallbackProcessingContext callbackProcessingContext, Exception internalError) { Debug.Assert(internalError != null, "Caller should make sure internalError != null"); this.InvokeWhenOperationIsSet( delegate(CimOperation cimOperation) { lock (this._suppressFurtherUserCallbacksLock) { try { cimOperation.Cancel(CancellationMode.SilentlyStopProducingResults); } catch (Exception internalErrorWhileCancellingOperation) { Exception originalInternalError = internalError; internalError = new AggregateException(originalInternalError, internalErrorWhileCancellingOperation); } this.ReportInternalError(callbackProcessingContext, internalError); this._suppressFurtherUserCallbacks = true; } }); }
private void OnCompletedInternal(CimOperationCallbackProcessingContext callbackProcessingContext) { this.CallIntoUserCallback( callbackProcessingContext, this._observer.OnCompleted, suppressFurtherUserCallbacks: true); }
internal void ClassCallback( CimOperationCallbackProcessingContext callbackProcessingContext, MI_Operation operationHandle, MI_Class ClassHandle, bool moreResults, MI_Result operationResult, String errorMessage, MI_Instance errorDetailsHandle) { CimClass currentItem = null; if ((ClassHandle != null) && (!ClassHandle.IsNull)) { if (!_shortenLifetimeOfResults) { ClassHandle = ClassHandle.Clone(); } currentItem = new CimClass(ClassHandle); } try { this.ProcessNativeCallback(callbackProcessingContext, currentItem, moreResults, operationResult, errorMessage, errorDetailsHandle); } finally { if (_shortenLifetimeOfResults) { if (currentItem != null) { currentItem.Dispose(); } } } }
internal void ProcessNativeCallback( CimOperationCallbackProcessingContext callbackProcessingContext, T currentItem, bool moreResults, MI_Result operationResult, string errorMessage, MI_Instance errorDetailsHandle) { Debug.Assert(callbackProcessingContext != null, "We should never get called with a null callbackProcessingContext"); if (!moreResults) { this.DisposeOperationWhenPossible(); } if ((currentItem == null) && (operationResult == MI_Result.MI_RESULT_OK)) { // process the ACK message if and only if operationResult == OK if (this._reportOperationStarted) { this.OnNextInternal(callbackProcessingContext, currentItem); } } else if (currentItem != null) { Debug.Assert(operationResult == MI_Result.MI_RESULT_OK, "Assumming that instances are reported back only on success"); this.OnNextInternal(callbackProcessingContext, currentItem); } CimException exception = CimException.GetExceptionIfMiResultFailure(operationResult, errorMessage, errorDetailsHandle); if (exception != null) { Debug.Assert(operationResult != MI_Result.MI_RESULT_OK, "Assumming that exceptions are reported back only on failure"); Debug.Assert(!moreResults, "Assumming that an error means end of results"); // this throw-catch is needed to fill-out 1) WER data and 2) exception's stack trace try { throw exception; } catch (CimException filledOutException) { exception = filledOutException; } } if (!moreResults) { this.InvokeWhenOperationIsSet( cimOperation => this.ProcessEndOfResultsWorker(callbackProcessingContext, cimOperation, exception)); } }
internal void WriteMessageCallbackInternal( CimOperationCallbackProcessingContext callbackProcessingContext, MI_Operation operationHandle, UInt32 channel, string message) { if (_writeMessageCallback != null) { var callbacksReceiverBase = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext; callbacksReceiverBase.CallIntoUserCallback( callbackProcessingContext, () => _writeMessageCallback(channel, message)); } }
internal override void ReportInternalError(CimOperationCallbackProcessingContext callbackProcessingContext, Exception internalError) { lock (_internalErrorWhileProcessingAsyncCallbackLock) { if (this._internalErrorWhileProcessingAsyncCallback == null) { this._internalErrorWhileProcessingAsyncCallback = internalError; } else { Exception originalInternalError = this._internalErrorWhileProcessingAsyncCallback; this._internalErrorWhileProcessingAsyncCallback = new AggregateException( originalInternalError, internalError); } } }
private void WriteProgressCallbackInternal( CimOperationCallbackProcessingContext callbackProcessingContext, MI_Operation operationHandle, string activity, string currentOperation, string statusDescription, UInt32 percentageCompleted, UInt32 secondsRemaining) { if (_writeProgressCallback != null) { var callbacksReceiverBase = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext; callbacksReceiverBase.CallIntoUserCallback( callbackProcessingContext, () => _writeProgressCallback(activity, currentOperation, statusDescription, percentageCompleted, secondsRemaining)); } }
internal void PromptUserCallbackInternal( CimOperationCallbackProcessingContext callbackProcessingContext, MI_Operation operationHandle, string message, MI_PromptType promptType, out MI_OperationCallback_ResponseType response) { response = MI_OperationCallback_ResponseType.Yes; if (_promptUserCallback != null) { var callbacksReceiverBase = (CimAsyncCallbacksReceiverBase)callbackProcessingContext.ManagedOperationContext; CimResponseType userResponse = CimResponseType.None; callbacksReceiverBase.CallIntoUserCallback( callbackProcessingContext, delegate { userResponse = _promptUserCallback(message, (CimPromptType)promptType); }); response = (MI_OperationCallback_ResponseType)userResponse; } }
internal void InstanceResultCallback( CimOperationCallbackProcessingContext callbackProcessingContext, MI_Operation operationHandle, MI_Instance instanceHandle, bool moreResults, MI_Result operationResult, String errorMessage, MI_Instance errorDetailsHandle) { CimMethodResult currentItem = null; if ((instanceHandle != null) && (!instanceHandle.IsNull)) { if (!_shortenLifetimeOfResults) { instanceHandle = instanceHandle.Clone(); } var backingInstance = new CimInstance(instanceHandle); backingInstance.SetCimSessionComputerName(this._CimSessionComputerName); backingInstance.SetCimSessionInstanceId(this._CimSessionInstanceID); currentItem = new CimMethodResult(backingInstance); } try { this.ProcessNativeCallback(callbackProcessingContext, currentItem, moreResults, operationResult, errorMessage, errorDetailsHandle); } finally { if (_shortenLifetimeOfResults) { if (currentItem != null) { currentItem.Dispose(); } } } }
internal void IndicationResultCallback( CimOperationCallbackProcessingContext callbackProcessingContext, MI_Operation operationHandle, MI_Instance instanceHandle, String bookMark, String machineID, bool moreResults, MI_Result operationResult, String errorMessage, MI_Instance errorDetailsHandle) { CimSubscriptionResult currentItem = null; if ((instanceHandle != null) && (!instanceHandle.IsNull)) { if (!_shortenLifetimeOfResults) { instanceHandle = instanceHandle.Clone(); } currentItem = new CimSubscriptionResult(instanceHandle, bookMark, machineID); } try { this.ProcessNativeCallback(callbackProcessingContext, currentItem, moreResults, operationResult, errorMessage, errorDetailsHandle); } finally { if (_shortenLifetimeOfResults) { if (currentItem != null) { currentItem.Dispose(); } } } }
private void OnNextInternal(CimOperationCallbackProcessingContext callbackProcessingContext, T item) { this.CallIntoUserCallback( callbackProcessingContext, () => this._observer.OnNext(item)); }
internal abstract void ReportInternalError(CimOperationCallbackProcessingContext callbackProcessingContext, Exception internalError);
internal override void ReportInternalError(CimOperationCallbackProcessingContext callbackProcessingContext, Exception internalError) { this.OnErrorInternal(callbackProcessingContext, internalError); }