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);
}
