/// <summary>
/// <para>
/// Set <see cref="CimSessionProxy"/> properties
/// </para>
/// </summary>
/// <param name="proxy"></param>
/// <param name="cmdlet"></param>
private void SetSessionProxyProperties(
ref CimSessionProxy proxy,
InvokeCimMethodCommand cmdlet)
{
proxy.OperationTimeout = cmdlet.OperationTimeoutSec;
if (cmdlet.ResourceUri != null)
{
proxy.ResourceUri = cmdlet.ResourceUri;
}
}
/// <summary>
/// <para>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </para>
/// </summary>
/// <param name="computerName"></param>
/// <param name="cimInstance"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
private CimSessionProxy CreateSessionProxy(
string computerName,
CimInstance cimInstance,
GetCimAssociatedInstanceCommand cmdlet)
{
CimSessionProxy proxy = CreateCimSessionProxy(computerName, cimInstance);
SetSessionProxyProperties(ref proxy, cmdlet);
return(proxy);
}
/// <summary>
/// <para>
/// Set <see cref="CimSessionProxy"/> properties
/// </para>
/// </summary>
/// <param name="proxy"></param>
/// <param name="cmdlet"></param>
private void SetSessionProxyProperties(
ref CimSessionProxy proxy,
NewCimInstanceCommand cmdlet)
{
proxy.OperationTimeout = cmdlet.OperationTimeoutSec;
if (cmdlet.ResourceUri != null)
{
proxy.ResourceUri = cmdlet.ResourceUri;
}
}
/// <summary>
/// <para>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </para>
/// </summary>
/// <param name="computerName"></param>
/// <param name="cimInstance"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
private CimSessionProxy CreateSessionProxy(
string computerName,
CimInstance cimInstance,
InvokeCimMethodCommand cmdlet)
{
CimSessionProxy proxy = CreateCimSessionProxy(computerName, cimInstance);
SetSessionProxyProperties(ref proxy, cmdlet);
return(proxy);
}
/// <summary>
/// <para>
/// Constructor
/// </para>
/// </summary>
/// <param name="theNamespace"></param>
/// <param name="theCollection"></param>
/// <param name="theProxy"></param>
internal CimInvokeCimMethodContext(string theNamespace,
string theMethodName,
CimMethodParametersCollection theCollection,
CimSessionProxy theProxy)
{
this.proxy = theProxy;
this.methodName = theMethodName;
this.collection = theCollection;
this.nameSpace = theNamespace;
}
/// <summary>
/// <para>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </para>
/// </summary>
/// <param name="computerName"></param>
/// <param name="cimInstance"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
protected CimSessionProxy CreateSessionProxy(
string computerName,
CimInstance cimInstance,
CimBaseCommand cmdlet)
{
CimSessionProxy proxy = CreateCimSessionProxy(computerName, cimInstance);
SetSessionProxyProperties(ref proxy, cmdlet);
return(proxy);
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> and set properties.
/// </summary>
/// <param name="session"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
protected CimSessionProxy CreateSessionProxy(
CimSession session,
CimBaseCommand cmdlet,
bool passThru)
{
CimSessionProxy proxy = CreateCimSessionProxy(session, passThru);
SetSessionProxyProperties(ref proxy, cmdlet);
return(proxy);
}
/// <summary>
/// <para>
/// Set <see cref="CimSessionProxy"/> properties
/// </para>
/// </summary>
/// <param name="proxy"></param>
/// <param name="cmdlet"></param>
private void SetSessionProxyProperties(
ref CimSessionProxy proxy,
GetCimAssociatedInstanceCommand cmdlet)
{
proxy.OperationTimeout = cmdlet.OperationTimeoutSec;
proxy.KeyOnly = cmdlet.KeyOnly;
if (cmdlet.ResourceUri != null)
{
proxy.ResourceUri = cmdlet.ResourceUri;
}
}
public void RegisterCimIndication(string computerName, string nameSpace, string queryDialect, string queryExpression, uint opreationTimeout)
{
object[] objArray = new object[2];
objArray[0] = queryDialect;
objArray[1] = queryExpression;
DebugHelper.WriteLogEx("queryDialect = '{0}'; queryExpression = '{1}'", 0, objArray);
this.TargetComputerName = computerName;
CimSessionProxy cimSessionProxy = this.CreateSessionProxy(computerName, opreationTimeout);
cimSessionProxy.SubscribeAsync(nameSpace, queryDialect, queryExpression);
this.WaitForAckMessage();
}
/// <summary>
/// <para>
/// Constructor
/// </para>
/// </summary>
/// <param name="theNamespace"></param>
/// <param name="theCollection"></param>
/// <param name="theProxy"></param>
internal CimSetCimInstanceContext(string theNamespace,
IDictionary theProperty,
CimSessionProxy theProxy,
string theParameterSetName,
bool passThru)
{
this.proxy = theProxy;
this.property = theProperty;
this.nameSpace = theNamespace;
this.parameterSetName = theParameterSetName;
this.passThru = passThru;
}
public void GetCimAssociatedInstance(GetCimAssociatedInstanceCommand cmdlet)
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
string @namespace = cmdlet.Namespace;
if (@namespace == null && cmdlet.ResourceUri == null)
{
@namespace = ConstValue.GetNamespace(cmdlet.CimInstance.CimSystemProperties.Namespace);
}
List <CimSessionProxy> cimSessionProxies = new List <CimSessionProxy>();
string parameterSetName = cmdlet.ParameterSetName;
string str = parameterSetName;
if (parameterSetName == null)
{
return;
}
else
{
if (str == "ComputerSet")
{
foreach (string computerName in computerNames)
{
CimSessionProxy cimSessionProxy = this.CreateSessionProxy(computerName, cmdlet.CimInstance, cmdlet);
cimSessionProxies.Add(cimSessionProxy);
}
}
else
{
if (str == "SessionSet")
{
CimSession[] cimSession = cmdlet.CimSession;
for (int i = 0; i < (int)cimSession.Length; i++)
{
CimSession cimSession1 = cimSession[i];
CimSessionProxy cimSessionProxy1 = this.CreateSessionProxy(cimSession1, cmdlet);
cimSessionProxies.Add(cimSessionProxy1);
}
}
else
{
return;
}
}
foreach (CimSessionProxy cimSessionProxy2 in cimSessionProxies)
{
cimSessionProxy2.EnumerateAssociatedInstancesAsync(@namespace, cmdlet.CimInstance, cmdlet.Association, cmdlet.ResultClassName, null, null);
}
return;
}
}
/// <summary>
/// Start an indication subscription target to the given computer.
/// </summary>
/// <param name="computerName">Null stands for localhost.</param>
/// <param name="nameSpace"></param>
/// <param name="queryDialect"></param>
/// <param name="queryExpression"></param>
/// <param name="operationTimeout"></param>
public void RegisterCimIndication(
string computerName,
string nameSpace,
string queryDialect,
string queryExpression,
UInt32 operationTimeout)
{
DebugHelper.WriteLogEx("queryDialect = '{0}'; queryExpression = '{1}'", 0, queryDialect, queryExpression);
this.TargetComputerName = computerName;
CimSessionProxy proxy = CreateSessionProxy(computerName, operationTimeout);
proxy.SubscribeAsync(nameSpace, queryDialect, queryExpression);
WaitForAckMessage();
}
/// <summary>
/// <para>
/// Add temporary <seealso cref="CimSessionProxy"/> object to cache.
/// </para>
/// </summary>
/// <param name="computerName">Computer name of the cimsession</param>
/// <param name="sessionproxy">cimsession wrapper object</param>
protected void AddCimSessionProxy(CimSessionProxy sessionproxy)
{
lock (cimSessionProxyCacheLock)
{
if (this.cimSessionProxyCache == null)
{
this.cimSessionProxyCache = new List <CimSessionProxy>();
}
if (!this.cimSessionProxyCache.Contains(sessionproxy))
{
this.cimSessionProxyCache.Add(sessionproxy);
}
}
}
/// <summary>
/// <para>
/// Base on parametersetName to retrieve associated ciminstances
/// </para>
/// </summary>
/// <param name="cmdlet"><see cref="GetCimInstanceCommand"/> object.</param>
public void GetCimAssociatedInstance(GetCimAssociatedInstanceCommand cmdlet)
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
// use the namespace from parameter
string nameSpace = cmdlet.Namespace;
if ((nameSpace == null) && (cmdlet.ResourceUri == null))
{
// try to use namespace of ciminstance, then fall back to default namespace
nameSpace = ConstValue.GetNamespace(cmdlet.CimInstance.CimSystemProperties.Namespace);
}
List <CimSessionProxy> proxys = new List <CimSessionProxy>();
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.ComputerSetName:
foreach (string computerName in computerNames)
{
CimSessionProxy proxy = CreateSessionProxy(computerName, cmdlet.CimInstance, cmdlet);
proxys.Add(proxy);
}
break;
case CimBaseCommand.SessionSetName:
foreach (CimSession session in cmdlet.CimSession)
{
CimSessionProxy proxy = CreateSessionProxy(session, cmdlet);
proxys.Add(proxy);
}
break;
default:
return;
}
foreach (CimSessionProxy proxy in proxys)
{
proxy.EnumerateAssociatedInstancesAsync(
nameSpace,
cmdlet.CimInstance,
cmdlet.Association,
cmdlet.ResultClassName,
null,
null);
}
}
/// <summary>
/// <para>
/// Set <see cref="CimSessionProxy"/> properties
/// </para>
/// </summary>
/// <param name="proxy"></param>
/// <param name="cmdlet"></param>
private void SetSessionProxyProperties(
ref CimSessionProxy proxy,
CimBaseCommand cmdlet)
{
if (cmdlet is GetCimInstanceCommand)
{
GetCimInstanceCommand getCimInstance = cmdlet as GetCimInstanceCommand;
proxy.KeyOnly = getCimInstance.KeyOnly;
proxy.Shallow = getCimInstance.Shallow;
proxy.OperationTimeout = getCimInstance.OperationTimeoutSec;
if (getCimInstance.ResourceUri != null)
{
proxy.ResourceUri = getCimInstance.ResourceUri;
}
}
else if (cmdlet is RemoveCimInstanceCommand)
{
RemoveCimInstanceCommand removeCimInstance = cmdlet as RemoveCimInstanceCommand;
proxy.OperationTimeout = removeCimInstance.OperationTimeoutSec;
if (removeCimInstance.ResourceUri != null)
{
proxy.ResourceUri = removeCimInstance.ResourceUri;
}
CimRemoveCimInstanceContext context = new CimRemoveCimInstanceContext(
ConstValue.GetNamespace(removeCimInstance.Namespace),
proxy);
proxy.ContextObject = context;
}
else if (cmdlet is SetCimInstanceCommand)
{
SetCimInstanceCommand setCimInstance = cmdlet as SetCimInstanceCommand;
proxy.OperationTimeout = setCimInstance.OperationTimeoutSec;
if (setCimInstance.ResourceUri != null)
{
proxy.ResourceUri = setCimInstance.ResourceUri;
}
CimSetCimInstanceContext context = new CimSetCimInstanceContext(
ConstValue.GetNamespace(setCimInstance.Namespace),
setCimInstance.Property,
proxy,
cmdlet.ParameterSetName,
setCimInstance.PassThru);
proxy.ContextObject = context;
}
}
internal void RemoveCimInstance(CimInstance cimInstance, XOperationContextBase context, CmdletOperationBase cmdlet)
{
DebugHelper.WriteLogEx();
string str = cimInstance.ToString();
if (cmdlet.ShouldProcess(str, "Remove-CimInstance"))
{
CimRemoveCimInstanceContext cimRemoveCimInstanceContext = context as CimRemoveCimInstanceContext;
CimSessionProxy cimSessionProxy = base.CreateCimSessionProxy(cimRemoveCimInstanceContext.Proxy);
cimSessionProxy.DeleteInstanceAsync(cimRemoveCimInstanceContext.Namespace, cimInstance);
return;
}
else
{
return;
}
}
/// <summary>
/// <para>
/// Get full <see cref="CimInstance"/> from server based on the key
/// </para>
/// </summary>
/// <param name="cimInstance"></param>
internal void GetCimInstance(CimInstance cimInstance, XOperationContextBase context)
{
DebugHelper.WriteLogEx();
CimNewCimInstanceContext newCimInstanceContext = context as CimNewCimInstanceContext;
if (newCimInstanceContext == null)
{
DebugHelper.WriteLog("Invalid (null) CimNewCimInstanceContext", 1);
return;
}
CimSessionProxy proxy = CreateCimSessionProxy(newCimInstanceContext.Proxy);
string nameSpace = (cimInstance.CimSystemProperties.Namespace == null) ? newCimInstanceContext.Namespace : cimInstance.CimSystemProperties.Namespace;
proxy.GetInstanceAsync(nameSpace, cimInstance);
}
/// <summary>
/// Start an indication subscription through a given <see cref="CimSession"/>.
/// </summary>
/// <param name="cimSession">Cannot be null</param>
/// <param name="nameSpace"></param>
/// <param name="queryDialect"></param>
/// <param name="queryExpression"></param>
/// <param name="operationTimeout"></param>
/// <exception cref="ArgumentNullException">throw if cimSession is null</exception>
public void RegisterCimIndication(
CimSession cimSession,
string nameSpace,
string queryDialect,
string queryExpression,
UInt32 operationTimeout)
{
DebugHelper.WriteLogEx("queryDialect = '{0}'; queryExpression = '{1}'", 0, queryDialect, queryExpression);
if (cimSession == null)
{
throw new ArgumentNullException(String.Format(CultureInfo.CurrentUICulture, Strings.NullArgument, @"cimSession"));
}
this.TargetComputerName = cimSession.ComputerName;
CimSessionProxy proxy = CreateSessionProxy(cimSession, operationTimeout);
proxy.SubscribeAsync(nameSpace, queryDialect, queryExpression);
WaitForAckMessage();
}
/// <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);
}
public void InvokeCimMethodOnCimInstance(CimInstance cimInstance, XOperationContextBase context, CmdletOperationBase operation)
{
DebugHelper.WriteLogEx();
CimInvokeCimMethod.CimInvokeCimMethodContext cimInvokeCimMethodContext = context as CimInvokeCimMethod.CimInvokeCimMethodContext;
object[] methodName = new object[1];
methodName[0] = cimInvokeCimMethodContext.MethodName;
string str = string.Format(CultureInfo.CurrentUICulture, "Invoke-CimMethod: {0}", methodName);
if (operation.ShouldProcess(cimInstance.ToString(), str))
{
CimSessionProxy cimSessionProxy = base.CreateCimSessionProxy(cimInvokeCimMethodContext.Proxy);
cimSessionProxy.InvokeMethodAsync(cimInvokeCimMethodContext.Namespace, cimInstance, cimInvokeCimMethodContext.MethodName, cimInvokeCimMethodContext.ParametersCollection);
return;
}
else
{
return;
}
}
/// <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);
}
public void RegisterCimIndication(CimSession cimSession, string nameSpace, string queryDialect, string queryExpression, uint opreationTimeout)
{
object[] objArray = new object[2];
objArray[0] = queryDialect;
objArray[1] = queryExpression;
DebugHelper.WriteLogEx("queryDialect = '{0}'; queryExpression = '{1}'", 0, objArray);
if (cimSession != null)
{
this.TargetComputerName = cimSession.ComputerName;
CimSessionProxy cimSessionProxy = this.CreateSessionProxy(cimSession, opreationTimeout);
cimSessionProxy.SubscribeAsync(nameSpace, queryDialect, queryExpression);
this.WaitForAckMessage();
return;
}
else
{
object[] objArray1 = new object[1];
objArray1[0] = "cimSession";
throw new ArgumentNullException(string.Format(CultureInfo.CurrentUICulture, Strings.NullArgument, objArray1));
}
}
/// <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);
}
internal void NewCimSession(NewCimSessionCommand cmdlet, CimSessionOptions sessionOptions, CimCredential credential)
{
string localhostComputerName;
DebugHelper.WriteLogEx();
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
foreach (string computerName in computerNames)
{
if (sessionOptions == null)
{
DebugHelper.WriteLog("Create CimSessionOption due to NewCimSessionCommand has null sessionoption", 1);
sessionOptions = CimSessionProxy.CreateCimSessionOption(computerName, cmdlet.OperationTimeoutSec, credential);
}
CimSessionProxy cimSessionProxyTestConnection = new CimSessionProxyTestConnection(computerName, sessionOptions);
if (computerName == ConstValue.NullComputerName)
{
localhostComputerName = ConstValue.LocalhostComputerName;
}
else
{
localhostComputerName = computerName;
}
string str = localhostComputerName;
CimSessionWrapper cimSessionWrapper = new CimSessionWrapper(0, Guid.Empty, cmdlet.Name, str, cimSessionProxyTestConnection.CimSession, cimSessionProxyTestConnection.Protocol);
CimNewSession.CimTestCimSessionContext cimTestCimSessionContext = new CimNewSession.CimTestCimSessionContext(cimSessionProxyTestConnection, cimSessionWrapper);
cimSessionProxyTestConnection.ContextObject = cimTestCimSessionContext;
SwitchParameter skipTestConnection = cmdlet.SkipTestConnection;
if (!skipTestConnection.IsPresent)
{
this.cimTestSession.TestCimSession(computerName, cimSessionProxyTestConnection);
}
else
{
this.AddSessionToCache(cimSessionProxyTestConnection.CimSession, cimTestCimSessionContext, new CmdletOperationBase(cmdlet));
}
}
}
/// <summary>
/// Subscribe event from proxy and add proxy to cache
/// </summary>
/// <param name="proxy"></param>
protected void SubscribeEventAndAddProxytoCache(CimSessionProxy proxy)
{
this.AddCimSessionProxy(proxy);
SubscribeToCimSessionProxyEvent(proxy);
}
/// <summary>
/// <para>
/// Refactor to be reused by Get-CimInstance;Remove-CimInstance;Set-CimInstance
/// </para>
/// </summary>
/// <param name="cmdlet"></param>
protected void GetCimInstanceInternal(CimBaseCommand cmdlet)
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(
GetComputerName(cmdlet));
string nameSpace;
List <CimSessionProxy> proxys = new List <CimSessionProxy>();
bool isGetCimInstanceCommand = (cmdlet is GetCimInstanceCommand);
CimInstance targetCimInstance = null;
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.CimInstanceComputerSet:
foreach (string computerName in computerNames)
{
targetCimInstance = GetCimInstanceParameter(cmdlet);
CimSessionProxy proxy = CreateSessionProxy(computerName, targetCimInstance, cmdlet);
if (isGetCimInstanceCommand)
{
this.SetPreProcess(proxy, cmdlet as GetCimInstanceCommand);
}
proxys.Add(proxy);
}
break;
case CimBaseCommand.ClassNameComputerSet:
case CimBaseCommand.QueryComputerSet:
case CimBaseCommand.ResourceUriComputerSet:
foreach (string computerName in computerNames)
{
CimSessionProxy proxy = CreateSessionProxy(computerName, cmdlet);
if (isGetCimInstanceCommand)
{
this.SetPreProcess(proxy, cmdlet as GetCimInstanceCommand);
}
proxys.Add(proxy);
}
break;
case CimBaseCommand.ClassNameSessionSet:
case CimBaseCommand.CimInstanceSessionSet:
case CimBaseCommand.QuerySessionSet:
case CimBaseCommand.ResourceUriSessionSet:
foreach (CimSession session in GetCimSession(cmdlet))
{
CimSessionProxy proxy = CreateSessionProxy(session, cmdlet);
if (isGetCimInstanceCommand)
{
this.SetPreProcess(proxy, cmdlet as GetCimInstanceCommand);
}
proxys.Add(proxy);
}
break;
default:
break;
}
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.ClassNameComputerSet:
case CimBaseCommand.ClassNameSessionSet:
nameSpace = ConstValue.GetNamespace(GetNamespace(cmdlet));
if (IsClassNameQuerySet(cmdlet))
{
string query = CreateQuery(cmdlet);
DebugHelper.WriteLogEx(@"Query = {0}", 1, query);
foreach (CimSessionProxy proxy in proxys)
{
proxy.QueryInstancesAsync(nameSpace,
ConstValue.GetQueryDialectWithDefault(GetQueryDialect(cmdlet)),
query);
}
}
else
{
foreach (CimSessionProxy proxy in proxys)
{
proxy.EnumerateInstancesAsync(nameSpace, GetClassName(cmdlet));
}
}
break;
case CimBaseCommand.CimInstanceComputerSet:
case CimBaseCommand.CimInstanceSessionSet:
{
CimInstance instance = GetCimInstanceParameter(cmdlet);
nameSpace = ConstValue.GetNamespace(instance.CimSystemProperties.Namespace);
foreach (CimSessionProxy proxy in proxys)
{
proxy.GetInstanceAsync(nameSpace, instance);
}
}
break;
case CimBaseCommand.QueryComputerSet:
case CimBaseCommand.QuerySessionSet:
nameSpace = ConstValue.GetNamespace(GetNamespace(cmdlet));
foreach (CimSessionProxy proxy in proxys)
{
proxy.QueryInstancesAsync(nameSpace,
ConstValue.GetQueryDialectWithDefault(GetQueryDialect(cmdlet)),
GetQuery(cmdlet));
}
break;
case CimBaseCommand.ResourceUriSessionSet:
case CimBaseCommand.ResourceUriComputerSet:
foreach (CimSessionProxy proxy in proxys)
{
proxy.EnumerateInstancesAsync(GetNamespace(cmdlet), GetClassName(cmdlet));
}
break;
default:
break;
}
}
/// <summary>
/// <para>
/// Base on parametersetName to retrieve ciminstances
/// </para>
/// </summary>
/// <param name="cmdlet"><see cref="GetCimInstanceCommand"/> object.</param>
public void InvokeCimMethod(InvokeCimMethodCommand cmdlet)
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
string nameSpace;
List <CimSessionProxy> proxys = new();
string action = string.Format(CultureInfo.CurrentUICulture, actionTemplate, cmdlet.MethodName);
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.CimInstanceComputerSet:
foreach (string computerName in computerNames)
{
proxys.Add(CreateSessionProxy(computerName, cmdlet.CimInstance, cmdlet));
}
break;
case CimBaseCommand.ClassNameComputerSet:
case CimBaseCommand.CimClassComputerSet:
case CimBaseCommand.ResourceUriComputerSet:
case CimBaseCommand.QueryComputerSet:
foreach (string computerName in computerNames)
{
proxys.Add(CreateSessionProxy(computerName, cmdlet));
}
break;
case CimBaseCommand.ClassNameSessionSet:
case CimBaseCommand.CimClassSessionSet:
case CimBaseCommand.QuerySessionSet:
case CimBaseCommand.CimInstanceSessionSet:
case CimBaseCommand.ResourceUriSessionSet:
foreach (CimSession session in cmdlet.CimSession)
{
CimSessionProxy proxy = CreateSessionProxy(session, cmdlet);
proxys.Add(proxy);
}
break;
default:
break;
}
CimMethodParametersCollection paramsCollection =
CreateParametersCollection(cmdlet.Arguments, cmdlet.CimClass, cmdlet.CimInstance, cmdlet.MethodName);
// Invoke methods
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.ClassNameComputerSet:
case CimBaseCommand.ClassNameSessionSet:
case CimBaseCommand.ResourceUriSessionSet:
case CimBaseCommand.ResourceUriComputerSet:
{
string target = string.Format(CultureInfo.CurrentUICulture, targetClass, cmdlet.ClassName);
if (cmdlet.ResourceUri != null)
{
nameSpace = cmdlet.Namespace;
}
else
{
nameSpace = ConstValue.GetNamespace(cmdlet.Namespace);
}
foreach (CimSessionProxy proxy in proxys)
{
if (!cmdlet.ShouldProcess(target, action))
{
return;
}
proxy.InvokeMethodAsync(
nameSpace,
cmdlet.ClassName,
cmdlet.MethodName,
paramsCollection);
}
}
break;
case CimBaseCommand.CimClassComputerSet:
case CimBaseCommand.CimClassSessionSet:
{
string target = string.Format(CultureInfo.CurrentUICulture, targetClass, cmdlet.CimClass.CimSystemProperties.ClassName);
nameSpace = ConstValue.GetNamespace(cmdlet.CimClass.CimSystemProperties.Namespace);
foreach (CimSessionProxy proxy in proxys)
{
if (!cmdlet.ShouldProcess(target, action))
{
return;
}
proxy.InvokeMethodAsync(
nameSpace,
cmdlet.CimClass.CimSystemProperties.ClassName,
cmdlet.MethodName,
paramsCollection);
}
}
break;
case CimBaseCommand.QueryComputerSet:
case CimBaseCommand.QuerySessionSet:
nameSpace = ConstValue.GetNamespace(cmdlet.Namespace);
foreach (CimSessionProxy proxy in proxys)
{
// create context object
CimInvokeCimMethodContext context = new(
nameSpace,
cmdlet.MethodName,
paramsCollection,
proxy);
proxy.ContextObject = context;
// firstly query instance and then invoke method upon returned instances
proxy.QueryInstancesAsync(nameSpace, ConstValue.GetQueryDialectWithDefault(cmdlet.QueryDialect), cmdlet.Query);
}
break;
case CimBaseCommand.CimInstanceComputerSet:
case CimBaseCommand.CimInstanceSessionSet:
{
string target = cmdlet.CimInstance.ToString();
if (cmdlet.ResourceUri != null)
{
nameSpace = cmdlet.Namespace;
}
else
{
nameSpace = ConstValue.GetNamespace(cmdlet.CimInstance.CimSystemProperties.Namespace);
}
foreach (CimSessionProxy proxy in proxys)
{
if (!cmdlet.ShouldProcess(target, action))
{
return;
}
proxy.InvokeMethodAsync(
nameSpace,
cmdlet.CimInstance,
cmdlet.MethodName,
paramsCollection);
}
}
break;
default:
break;
}
}
internal CimTestCimSessionContext(CimSessionProxy theProxy, CimSessionWrapper wrapper)
{
this.proxy = theProxy;
this.cimSessionWrapper = wrapper;
this.nameSpace = null;
}
/// <summary>
/// <para>
/// Set <see cref="CimSessionProxy"/> properties
/// </para>
/// </summary>
/// <param name="proxy"></param>
/// <param name="cmdlet"></param>
private void SetSessionProxyProperties(
ref CimSessionProxy proxy,
GetCimClassCommand cmdlet)
{
proxy.OperationTimeout = cmdlet.OperationTimeoutSec;
}
public CimSessionProxySetCimInstance(CimSessionProxy originalProxy, bool passThru) : base(originalProxy)
{
this.passThru = passThru;
}
