/// <summary>
/// <para>
/// Process remaining actions until all operations are completed or
/// current cmdlet is terminated by user.
/// </para>
/// </summary>
/// <param name="cmdletOperation">
/// Wrapper of cmdlet, <seealso cref="CmdletOperationBase"/> for details.
/// </param>
public void ProcessRemainActions(CmdletOperationBase cmdletOperation)
{
DebugHelper.WriteLogEx();
while (true)
{
ProcessActions(cmdletOperation);
if (!this.IsActive())
{
DebugHelper.WriteLogEx("Either disposed or all operations completed.", 2);
break;
}
try
{
this.moreActionEvent.Wait();
this.moreActionEvent.Reset();
}
catch (ObjectDisposedException ex)
{
// This might happen if this object is being disposed,
// while another thread is processing the remaining actions
DebugHelper.WriteLogEx("moreActionEvent was disposed: {0}.", 2, ex);
break;
}
}
ProcessActions(cmdletOperation);
}
/// <summary>
/// <para>
/// process all actions in the action queue
/// </para>
/// </summary>
/// <param name="cmdletOperation">
/// Wrapper of cmdlet, <seealso cref="CmdletOperationBase"/> for details.
/// </param>
public void ProcessActions(CmdletOperationBase cmdletOperation)
{
if (!this.actionQueue.IsEmpty)
{
CimBaseAction action;
while (GetActionAndRemove(out action))
{
action.Execute(cmdletOperation);
if (this.Disposed)
{
break;
}
}
}
}
/// <summary>
/// <para>
/// Write progress record to powershell
/// </para>
/// </summary>
/// <param name="cmdlet"></param>
public override void Execute(CmdletOperationBase cmdlet)
{
DebugHelper.WriteLog(
"...Activity {0}: id={1}, remain seconds ={2}, percentage completed = {3}",
4,
this.Activity,
this.ActivityID,
this.SecondsRemaining,
this.PercentageCompleted);
ValidationHelper.ValidateNoNullArgument(cmdlet, "cmdlet");
ProgressRecord record = new(
this.ActivityID,
this.Activity,
this.StatusDescription);
record.Activity = this.Activity;
record.ParentActivityId = 0;
record.SecondsRemaining = (int)this.SecondsRemaining;
record.PercentComplete = (int)this.PercentageCompleted;
cmdlet.WriteProgress(record);
}
/// <summary>
/// <para>
/// Write message to the target channel
/// </para>
/// </summary>
/// <param name="cmdlet"></param>
public override void Execute(CmdletOperationBase cmdlet)
{
ValidationHelper.ValidateNoNullArgument(cmdlet, "cmdlet");
switch ((CimWriteMessageChannel)Channel)
{
case CimWriteMessageChannel.Verbose:
cmdlet.WriteVerbose(Message);
break;
case CimWriteMessageChannel.Warning:
cmdlet.WriteWarning(Message);
break;
case CimWriteMessageChannel.Debug:
cmdlet.WriteDebug(Message);
break;
default:
break;
}
}
/// <summary>
/// <para>
/// Write error to pipeline
/// </para>
/// </summary>
/// <param name="cmdlet"></param>
public override void Execute(CmdletOperationBase cmdlet)
{
Debug.Assert(cmdlet != null, "Caller should verify that cmdlet != null");
try
{
Exception errorException = (Error != null) ? new CimException(Error) : this.Exception;
// PS engine takes care of handling error action
cmdlet.WriteError(ErrorToErrorRecord.ErrorRecordFromAnyException(this.CimInvocationContext, errorException, this.ResultContext));
// if user wants to continue, we will get here
this.responseType = CimResponseType.Yes;
}
catch
{
this.responseType = CimResponseType.NoToAll;
throw;
}
finally
{
// unblocking the waiting thread
this.OnComplete();
}
}
/// <summary>
/// <para>
/// Invoke cimmethod on given <see cref="CimInstance"/>
/// </para>
/// </summary>
/// <param name="cimInstance"></param>
public void InvokeCimMethodOnCimInstance(CimInstance cimInstance, XOperationContextBase context, CmdletOperationBase operation)
{
DebugHelper.WriteLogEx();
CimInvokeCimMethodContext cimInvokeCimMethodContext = context as CimInvokeCimMethodContext;
Debug.Assert(cimInvokeCimMethodContext != null, "CimInvokeCimMethod::InvokeCimMethodOnCimInstance should has CimInvokeCimMethodContext != NULL.");
string action = string.Format(CultureInfo.CurrentUICulture, actionTemplate, cimInvokeCimMethodContext.MethodName);
if (!operation.ShouldProcess(cimInstance.ToString(), action))
{
return;
}
CimSessionProxy proxy = CreateCimSessionProxy(cimInvokeCimMethodContext.Proxy);
proxy.InvokeMethodAsync(
cimInvokeCimMethodContext.Namespace,
cimInstance,
cimInvokeCimMethodContext.MethodName,
cimInvokeCimMethodContext.ParametersCollection);
}
/// <summary>
/// <para>
/// Prompt user with the given message and prepared whatif message.
/// </para>
/// </summary>
/// <param name="cmdlet">
/// cmdlet wrapper object, to which write result.
/// <see cref="CmdletOperationBase"/> for details.
/// </param>
public override void Execute(CmdletOperationBase cmdlet)
{
ValidationHelper.ValidateNoNullArgument(cmdlet, "cmdlet");
bool yestoall = false;
bool notoall = false;
bool result = false;
switch (this.prompt)
{
case CimPromptType.Critical:
// NOTES: prepare the whatif message and caption
try
{
result = cmdlet.ShouldContinue(Message, "caption", ref yestoall, ref notoall);
if (yestoall)
{
this.responseType = CimResponseType.YesToAll;
}
else if (notoall)
{
this.responseType = CimResponseType.NoToAll;
}
else if (result)
{
this.responseType = CimResponseType.Yes;
}
else if (!result)
{
this.responseType = CimResponseType.No;
}
}
catch
{
this.responseType = CimResponseType.NoToAll;
throw;
}
finally
{
// unblocking the waiting thread
this.OnComplete();
}
break;
case CimPromptType.Normal:
try
{
result = cmdlet.ShouldProcess(Message);
if (result)
{
this.responseType = CimResponseType.Yes;
}
else if (!result)
{
this.responseType = CimResponseType.No;
}
}
catch
{
this.responseType = CimResponseType.NoToAll;
throw;
}
finally
{
// unblocking the waiting thread
this.OnComplete();
}
break;
default:
break;
}
this.OnComplete();
}
/// <summary>
/// <para>
/// Add session to global cache,
/// </para>
/// </summary>
/// <param name="cimSession"></param>
/// <param name="context"></param>
/// <param name="cmdlet"></param>
internal void AddSessionToCache(CimSession cimSession, XOperationContextBase context, CmdletOperationBase cmdlet)
{
DebugHelper.WriteLogEx();
CimTestCimSessionContext testCimSessionContext = context as CimTestCimSessionContext;
uint sessionId = this.sessionState.GenerateSessionId();
string originalSessionName = testCimSessionContext.CimSessionWrapper.Name;
string sessionName = (originalSessionName != null) ? originalSessionName : string.Format(CultureInfo.CurrentUICulture, @"{0}{1}", CimSessionState.CimSessionClassName, sessionId);
// detach CimSession from the proxy object
CimSession createdCimSession = testCimSessionContext.Proxy.Detach();
PSObject psObject = this.sessionState.AddObjectToCache(
createdCimSession,
sessionId,
createdCimSession.InstanceId,
sessionName,
testCimSessionContext.CimSessionWrapper.ComputerName,
testCimSessionContext.Proxy.Protocol);
cmdlet.WriteObject(psObject, null);
}
/// <summary>
/// <para>
/// Process remaining actions until all operations are completed or
/// current cmdlet is terminated by user.
/// </para>
/// </summary>
/// <param name="cmdletOperation">
/// Wrapper of cmdlet, <seealso cref="CmdletOperationBase"/> for details.
/// </param>
public void ProcessRemainActions(CmdletOperationBase cmdletOperation)
{
this.cimTestSession.ProcessRemainActions(cmdletOperation);
}
/// <summary>
/// <para>
/// Execute the write operation to given cmdlet object
/// </para>
/// </summary>
/// <param name="cmdlet">
/// cmdlet wrapper object, to which write result.
/// <see cref="CmdletOperationBase"/> for details.
/// </param>
public virtual void Execute(CmdletOperationBase cmdlet)
{
}
/// <summary>
/// <para>
/// Write result object to ps pipeline
/// </para>
/// </summary>
/// <param name="cmdlet"></param>
public override void Execute(CmdletOperationBase cmdlet)
{
ValidationHelper.ValidateNoNullArgument(cmdlet, "cmdlet");
cmdlet.WriteObject(result, this.Context);
}
/// <summary>
/// <para>
/// Remove <see cref="CimInstance"/> from namespace specified in cmdlet
/// </para>
/// </summary>
/// <param name="cimInstance"></param>
internal void RemoveCimInstance(CimInstance cimInstance, XOperationContextBase context, CmdletOperationBase cmdlet)
{
DebugHelper.WriteLogEx();
string target = cimInstance.ToString();
if (!cmdlet.ShouldProcess(target, action))
{
return;
}
CimRemoveCimInstanceContext removeContext = context as CimRemoveCimInstanceContext;
Debug.Assert(removeContext != null, "CimRemoveCimInstance::RemoveCimInstance should has CimRemoveCimInstanceContext != NULL.");
CimSessionProxy proxy = CreateCimSessionProxy(removeContext.Proxy);
proxy.DeleteInstanceAsync(removeContext.Namespace, cimInstance);
}
/// <summary>
/// <para>
/// Write result object to ps pipeline
/// </para>
/// </summary>
/// <param name="cmdlet"></param>
public override void Execute(CmdletOperationBase cmdlet)
{
ValidationHelper.ValidateNoNullArgument(cmdlet, "cmdlet");
cmdlet.WriteObject(result, this.Context);
}
/// <summary>
/// <para>
/// Set <see cref="CimInstance"/> with properties specified in cmdlet
/// </para>
/// </summary>
/// <param name="cimInstance"></param>
public void SetCimInstance(CimInstance cimInstance, CimSetCimInstanceContext context, CmdletOperationBase cmdlet)
{
DebugHelper.WriteLog("CimSetCimInstance::SetCimInstance", 4);
if (!cmdlet.ShouldProcess(cimInstance.ToString(), action))
{
return;
}
Exception exception = null;
if (!SetProperty(context.Property, ref cimInstance, ref exception))
{
cmdlet.ThrowTerminatingError(exception, action);
return;
}
CimSessionProxy proxy = CreateCimSessionProxy(context.Proxy, context.PassThru);
proxy.ModifyInstanceAsync(cimInstance.CimSystemProperties.Namespace, cimInstance);
}
