protected override bool PreNewActionEvent(CmdletActionEventArgs args) { DebugHelper.WriteLogEx(); if (args.Action as CimWriteResultObject != null) { CimWriteResultObject action = args.Action as CimWriteResultObject; CimInstance result = action.Result as CimInstance; if (result != null) { object[] className = new object[2]; className[0] = result.CimSystemProperties.ClassName; className[1] = result.CimSystemProperties.Namespace; DebugHelper.WriteLog("Going to read CimInstance classname = {0}; namespace = {1}", 1, className); this.NewCimInstanceOperation.GetCimInstance(result, base.ContextObject); return(false); } else { return(true); } } else { return(true); } }
protected override void PreOperationDeleteEvent(OperationEventArgs args) { object[] objArray = new object[1]; objArray[0] = args.success; DebugHelper.WriteLogEx("test connection result {0}", 0, objArray); if (args.success) { CimWriteResultObject cimWriteResultObject = new CimWriteResultObject(base.CimSession, base.ContextObject); base.FireNewActionEvent(cimWriteResultObject); } }
/// <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); } } } }
protected override bool PreNewActionEvent(CmdletActionEventArgs args) { WildcardPattern wildcardPattern; DebugHelper.WriteLogEx(); if (args.Action as CimWriteResultObject != null) { CimWriteResultObject action = args.Action as CimWriteResultObject; CimClass result = action.Result as CimClass; if (result != null) { object[] className = new object[1]; className[0] = result.CimSystemProperties.ClassName; DebugHelper.WriteLog("class name = {0}", 1, className); CimGetCimClassContext contextObject = base.ContextObject as CimGetCimClassContext; if (WildcardPattern.ContainsWildcardCharacters(contextObject.ClassName)) { wildcardPattern = new WildcardPattern(contextObject.ClassName, WildcardOptions.IgnoreCase); if (!wildcardPattern.IsMatch(result.CimSystemProperties.ClassName)) { return(false); } } if (contextObject.PropertyName != null) { wildcardPattern = new WildcardPattern(contextObject.PropertyName, WildcardOptions.IgnoreCase); bool flag = false; if (result.CimClassProperties != null) { foreach (CimPropertyDeclaration cimClassProperty in result.CimClassProperties) { object[] name = new object[1]; name[0] = cimClassProperty.Name; DebugHelper.WriteLog("--- property name : {0}", 1, name); if (!wildcardPattern.IsMatch(cimClassProperty.Name)) { continue; } flag = true; break; } } if (!flag) { object[] propertyName = new object[1]; propertyName[0] = contextObject.PropertyName; DebugHelper.WriteLog("Property name does not match: {0}", 1, propertyName); return(flag); } } if (contextObject.MethodName != null) { wildcardPattern = new WildcardPattern(contextObject.MethodName, WildcardOptions.IgnoreCase); bool flag1 = false; if (result.CimClassMethods != null) { foreach (CimMethodDeclaration cimClassMethod in result.CimClassMethods) { object[] objArray = new object[1]; objArray[0] = cimClassMethod.Name; DebugHelper.WriteLog("--- method name : {0}", 1, objArray); if (!wildcardPattern.IsMatch(cimClassMethod.Name)) { continue; } flag1 = true; break; } } if (!flag1) { object[] methodName = new object[1]; methodName[0] = contextObject.MethodName; DebugHelper.WriteLog("Method name does not match: {0}", 1, methodName); return(flag1); } } if (contextObject.QualifierName != null) { wildcardPattern = new WildcardPattern(contextObject.QualifierName, WildcardOptions.IgnoreCase); bool flag2 = false; if (result.CimClassQualifiers != null) { foreach (CimQualifier cimClassQualifier in result.CimClassQualifiers) { object[] name1 = new object[1]; name1[0] = cimClassQualifier.Name; DebugHelper.WriteLog("--- qualifier name : {0}", 1, name1); if (!wildcardPattern.IsMatch(cimClassQualifier.Name)) { continue; } flag2 = true; break; } } if (!flag2) { object[] qualifierName = new object[1]; qualifierName[0] = contextObject.QualifierName; DebugHelper.WriteLog("Qualifer name does not match: {0}", 1, qualifierName); return(flag2); } } object[] className1 = new object[1]; className1[0] = result.CimSystemProperties.ClassName; DebugHelper.WriteLog("CimClass '{0}' is qulified.", 1, className1); return(true); } else { return(true); } } else { return(true); } }
/// <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> /// Called after operation delete event /// </summary> /// <param name="args"></param> protected override void PreOperationDeleteEvent(OperationEventArgs args) { DebugHelper.WriteLogEx("test connection result {0}", 0, args.success); if (args.success) { // test connection success, write session object to pipeline CimWriteResultObject result = new CimWriteResultObject(this.CimSession, this.ContextObject); this.FireNewActionEvent(result); } }
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; } }
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; } } }