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