/// <summary> /// <para> /// Handler used to handle new action event from /// <seealso cref="CimSessionProxy"/> object. /// </para> /// </summary> /// <param name="cimSession"> /// <seealso cref="CimSession"/> object raised the event /// </param> /// <param name="actionArgs">event argument</param> private void CimIndicationHandler(object cimSession, CmdletActionEventArgs actionArgs) { DebugHelper.WriteLogEx("action is {0}. Disposed {1}", 0, actionArgs.Action, this.Disposed); if (this.Disposed) { return; } // NOTES: should move after this.Disposed, but need to log the exception CimWriteError cimWriteError = actionArgs.Action as CimWriteError; if (cimWriteError != null) { this.exception = cimWriteError.Exception; if (!this.ackedEvent.IsSet) { // an exception happened DebugHelper.WriteLogEx("an exception happened", 0); this.ackedEvent.Set(); return; } EventHandler <CimSubscriptionEventArgs> temp = this.OnNewSubscriptionResult; if (temp != null) { DebugHelper.WriteLog("Raise an exception event", 2); temp(this, new CimSubscriptionExceptionEventArgs(this.exception)); } DebugHelper.WriteLog("Got an exception: {0}", 2, exception); } CimWriteResultObject cimWriteResultObject = actionArgs.Action as CimWriteResultObject; if (cimWriteResultObject != null) { CimSubscriptionResult result = cimWriteResultObject.Result as CimSubscriptionResult; if (result != null) { EventHandler <CimSubscriptionEventArgs> temp = this.OnNewSubscriptionResult; if (temp != null) { DebugHelper.WriteLog("Raise an result event", 2); temp(this, new CimSubscriptionResultEventArgs(result)); } } else { if (!this.ackedEvent.IsSet) { // an ACK message returned DebugHelper.WriteLogEx("an ack message happened", 0); this.ackedEvent.Set(); return; } else { DebugHelper.WriteLogEx("an ack message should not happen here", 0); } } } }
/// <summary> /// <para> /// Handle async event triggered by <see cref="CimResultObserver<T>"/> /// </para> /// </summary> /// <param name="observer">object triggered the event</param> /// <param name="resultArgs">async result event argument</param> internal void ResultEventHandler( object observer, AsyncResultEventArgsBase resultArgs) { DebugHelper.WriteLogEx(); switch (resultArgs.resultType) { case AsyncResultType.Completion: { DebugHelper.WriteLog("ResultEventHandler::Completion", 4); AsyncResultCompleteEventArgs args = resultArgs as AsyncResultCompleteEventArgs; this.FireOperationDeletedEvent(args.observable, true); } break; case AsyncResultType.Exception: { AsyncResultErrorEventArgs args = resultArgs as AsyncResultErrorEventArgs; DebugHelper.WriteLog("ResultEventHandler::Exception {0}", 4, args.error); using (CimWriteError action = new CimWriteError(args.error, this.invocationContextObject, args.context)) { this.FireNewActionEvent(action); } this.FireOperationDeletedEvent(args.observable, false); } break; case AsyncResultType.Result: { AsyncResultObjectEventArgs args = resultArgs as AsyncResultObjectEventArgs; DebugHelper.WriteLog("ResultEventHandler::Result {0}", 4, args.resultObject); object resultObject = args.resultObject; if (!this.isDefaultSession) { AddShowComputerNameMarker(resultObject); } if (this.ObjectPreProcess != null) { resultObject = this.ObjectPreProcess.Process(resultObject); } #if DEBUG resultObject = PostProcessCimInstance(resultObject); #endif CimWriteResultObject action = new CimWriteResultObject(resultObject, this.ContextObject); this.FireNewActionEvent(action); } break; default: break; } }
/// <summary> /// <para> /// WriteError callback /// </para> /// </summary> /// <param name="instance"></param> /// <returns></returns> public CimResponseType WriteError(CimInstance instance) { DebugHelper.WriteLogEx("Error:{0}", 0, instance); try { CimWriteError action = new CimWriteError(instance, this.invocationContextObject); this.FireNewActionEvent(action); return action.GetResponse(); } catch (Exception ex) { DebugHelper.WriteLogEx("{0}", 0, ex); return CimResponseType.NoToAll; } }
private void CimIndicationHandler(object cimSession, CmdletActionEventArgs actionArgs) { object[] action = new object[2]; action[0] = actionArgs.Action; action[1] = base.Disposed; DebugHelper.WriteLogEx("action is {0}. Disposed {1}", 0, action); if (!base.Disposed) { CimWriteError cimWriteError = actionArgs.Action as CimWriteError; if (cimWriteError != null) { this.exception = cimWriteError.Exception; if (this.ackedEvent.IsSet) { EventHandler <CimSubscriptionEventArgs> eventHandler = this.OnNewSubscriptionResult; if (eventHandler != null) { DebugHelper.WriteLog("Raise an exception event", 2); eventHandler(this, new CimSubscriptionExceptionEventArgs(this.exception)); } object[] objArray = new object[1]; objArray[0] = this.exception; DebugHelper.WriteLog("Got an exception: {0}", 2, objArray); } else { DebugHelper.WriteLogEx("an exception happened", 0); this.ackedEvent.Set(); return; } } CimWriteResultObject cimWriteResultObject = actionArgs.Action as CimWriteResultObject; if (cimWriteResultObject != null) { CimSubscriptionResult result = cimWriteResultObject.Result as CimSubscriptionResult; if (result == null) { if (this.ackedEvent.IsSet) { DebugHelper.WriteLogEx("an ack message should not happen here", 0); } else { DebugHelper.WriteLogEx("an ack message happened", 0); this.ackedEvent.Set(); return; } } else { EventHandler <CimSubscriptionEventArgs> eventHandler1 = this.OnNewSubscriptionResult; if (eventHandler1 != null) { DebugHelper.WriteLog("Raise an result event", 2); eventHandler1(this, new CimSubscriptionResultEventArgs(result)); return; } } } return; } else { return; } }
public CimResponseType WriteError(CimInstance instance) { CimResponseType response; object[] objArray = new object[1]; objArray[0] = instance; DebugHelper.WriteLogEx("Error:{0}", 0, objArray); try { CimWriteError cimWriteError = new CimWriteError(instance, this.invocationContextObject); this.FireNewActionEvent(cimWriteError); response = cimWriteError.GetResponse(); } catch (Exception exception1) { Exception exception = exception1; object[] objArray1 = new object[1]; objArray1[0] = exception; DebugHelper.WriteLogEx("{0}", 0, objArray1); response = CimResponseType.NoToAll; } return response; }
internal void ResultEventHandler(object observer, AsyncResultEventArgsBase resultArgs) { DebugHelper.WriteLogEx(); AsyncResultType asyncResultType = resultArgs.resultType; switch (asyncResultType) { case AsyncResultType.Result: { AsyncResultObjectEventArgs asyncResultObjectEventArg = resultArgs as AsyncResultObjectEventArgs; object[] objArray = new object[1]; objArray[0] = asyncResultObjectEventArg.resultObject; DebugHelper.WriteLog("ResultEventHandler::Result {0}", 4, objArray); object obj = asyncResultObjectEventArg.resultObject; if (!this.isDefaultSession) { CimSessionProxy.AddShowComputerNameMarker(obj); } if (this.ObjectPreProcess != null) { obj = this.ObjectPreProcess.Process(obj); } CimWriteResultObject cimWriteResultObject = new CimWriteResultObject(obj, this.ContextObject); this.FireNewActionEvent(cimWriteResultObject); return; } case AsyncResultType.Exception: { AsyncResultErrorEventArgs asyncResultErrorEventArg = resultArgs as AsyncResultErrorEventArgs; object[] objArray1 = new object[1]; objArray1[0] = asyncResultErrorEventArg.error; DebugHelper.WriteLog("ResultEventHandler::Exception {0}", 4, objArray1); using (CimWriteError cimWriteError = new CimWriteError(asyncResultErrorEventArg.error, this.invocationContextObject, asyncResultErrorEventArg.context)) { this.FireNewActionEvent(cimWriteError); } this.FireOperationDeletedEvent(asyncResultErrorEventArg.observable, false); return; } case AsyncResultType.Completion: { DebugHelper.WriteLog("ResultEventHandler::Completion", 4); AsyncResultCompleteEventArgs asyncResultCompleteEventArg = resultArgs as AsyncResultCompleteEventArgs; this.FireOperationDeletedEvent(asyncResultCompleteEventArg.observable, true); return; } default: { return; } } }