/// <summary>
/// Create a new <see cref="CimSession"/> base on given cmdlet
/// and its parameter.
/// </summary>
/// <param name="cmdlet"></param>
/// <param name="sessionOptions"></param>
/// <param name="credential"></param>
internal void NewCimSession(NewCimSessionCommand cmdlet,
CimSessionOptions sessionOptions,
CimCredential credential)
{
DebugHelper.WriteLogEx();
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
foreach (string computerName in computerNames)
{
CimSessionProxy proxy;
if (sessionOptions == null)
{
DebugHelper.WriteLog("Create CimSessionOption due to NewCimSessionCommand has null sessionoption", 1);
sessionOptions = CimSessionProxy.CreateCimSessionOption(computerName,
cmdlet.OperationTimeoutSec, credential);
}
proxy = new CimSessionProxyTestConnection(computerName, sessionOptions);
string computerNameValue = (computerName == ConstValue.NullComputerName) ? ConstValue.LocalhostComputerName : computerName;
CimSessionWrapper wrapper = new CimSessionWrapper(0, Guid.Empty, cmdlet.Name, computerNameValue, proxy.CimSession, proxy.Protocol);
CimTestCimSessionContext context = new CimTestCimSessionContext(proxy, wrapper);
proxy.ContextObject = context;
// Skip test the connection if user intend to
if (cmdlet.SkipTestConnection.IsPresent)
{
AddSessionToCache(proxy.CimSession, context, new CmdletOperationBase(cmdlet));
}
else
{
// CimSession will be returned as part of TestConnection
this.cimTestSession.TestCimSession(computerName, proxy);
}
}
}
/// <summary>
/// <para>
/// Base on parametersetName to retrieve ciminstances
/// </para>
/// </summary>
/// <param name="cmdlet"><see cref="GetCimInstanceCommand"/> object</param>
public void RemoveCimInstance(RemoveCimInstanceCommand cmdlet)
{
DebugHelper.WriteLogEx();
IEnumerable <string> computerNames = ConstValue.GetComputerNames(
GetComputerName(cmdlet));
List <CimSessionProxy> proxys = new List <CimSessionProxy>();
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.CimInstanceComputerSet:
foreach (string computerName in computerNames)
{
proxys.Add(CreateSessionProxy(computerName, cmdlet.CimInstance, cmdlet));
}
break;
case CimBaseCommand.CimInstanceSessionSet:
foreach (CimSession session in GetCimSession(cmdlet))
{
proxys.Add(CreateSessionProxy(session, cmdlet));
}
break;
default:
break;
}
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.CimInstanceComputerSet:
case CimBaseCommand.CimInstanceSessionSet:
string nameSpace = null;
if (cmdlet.ResourceUri != null)
{
nameSpace = GetCimInstanceParameter(cmdlet).CimSystemProperties.Namespace;
}
else
{
nameSpace = ConstValue.GetNamespace(GetCimInstanceParameter(cmdlet).CimSystemProperties.Namespace);
}
string target = cmdlet.CimInstance.ToString();
foreach (CimSessionProxy proxy in proxys)
{
if (!cmdlet.ShouldProcess(target, action))
{
return;
}
proxy.DeleteInstanceAsync(nameSpace, cmdlet.CimInstance);
}
break;
case CimBaseCommand.QueryComputerSet:
case CimBaseCommand.QuerySessionSet:
GetCimInstanceInternal(cmdlet);
break;
default:
break;
}
}
/// <summary>
/// <para>
/// Base on parametersetName to retrieve <see cref="CimClass"/>
/// </para>
/// </summary>
/// <param name="cmdlet"><see cref="GetCimClassCommand"/> object.</param>
public void GetCimClass(GetCimClassCommand cmdlet)
{
List <CimSessionProxy> proxys = new List <CimSessionProxy>();
string nameSpace = ConstValue.GetNamespace(cmdlet.Namespace);
string className = (cmdlet.ClassName == null) ? @"*" : cmdlet.ClassName;
CimGetCimClassContext context = new CimGetCimClassContext(
cmdlet.ClassName,
cmdlet.MethodName,
cmdlet.PropertyName,
cmdlet.QualifierName);
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.ComputerSetName:
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(
cmdlet.ComputerName);
foreach (string computerName in computerNames)
{
CimSessionProxy proxy = CreateSessionProxy(computerName, cmdlet);
proxy.ContextObject = context;
proxys.Add(proxy);
}
}
break;
case CimBaseCommand.SessionSetName:
{
foreach (CimSession session in cmdlet.CimSession)
{
CimSessionProxy proxy = CreateSessionProxy(session, cmdlet);
proxy.ContextObject = context;
proxys.Add(proxy);
}
}
break;
default:
return;
}
if (WildcardPattern.ContainsWildcardCharacters(className))
{
// retrieve all classes and then filter based on
// classname, propertyname, methodname, and qualifiername
foreach (CimSessionProxy proxy in proxys)
{
proxy.EnumerateClassesAsync(nameSpace);
}
}
else
{
foreach (CimSessionProxy proxy in proxys)
{
proxy.GetClassAsync(nameSpace, className);
}
}
}
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>
/// <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);
}
}
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>
/// <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 set ciminstances
/// </para>
/// </summary>
/// <param name="cmdlet"><see cref="SetCimInstanceCommand"/> object</param>
public void SetCimInstance(SetCimInstanceCommand cmdlet)
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(
GetComputerName(cmdlet));
List <CimSessionProxy> proxys = new List <CimSessionProxy>();
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.CimInstanceComputerSet:
foreach (string computerName in computerNames)
{
// create CimSessionProxySetCimInstance object internally
proxys.Add(CreateSessionProxy(computerName, cmdlet.CimInstance, cmdlet, cmdlet.PassThru));
}
break;
case CimBaseCommand.CimInstanceSessionSet:
foreach (CimSession session in GetCimSession(cmdlet))
{
// create CimSessionProxySetCimInstance object internally
proxys.Add(CreateSessionProxy(session, cmdlet, cmdlet.PassThru));
}
break;
default:
break;
}
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.CimInstanceComputerSet:
case CimBaseCommand.CimInstanceSessionSet:
string nameSpace = ConstValue.GetNamespace(GetCimInstanceParameter(cmdlet).CimSystemProperties.Namespace);
string target = cmdlet.CimInstance.ToString();
foreach (CimSessionProxy proxy in proxys)
{
if (!cmdlet.ShouldProcess(target, action))
{
return;
}
Exception exception = null;
CimInstance instance = cmdlet.CimInstance;
// For CimInstance parameter sets, Property is an optional parameter
if (cmdlet.Property != null)
{
if (!SetProperty(cmdlet.Property, ref instance, ref exception))
{
cmdlet.ThrowTerminatingError(exception, action);
return;
}
}
proxy.ModifyInstanceAsync(nameSpace, instance);
}
break;
case CimBaseCommand.QueryComputerSet:
case CimBaseCommand.QuerySessionSet:
GetCimInstanceInternal(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 List <CimSessionProxy>();
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 CimInvokeCimMethodContext(
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;
}
}
/// <summary>
/// <para>
/// Base on parametersetName to create ciminstances,
/// either remotely or locally
/// </para>
/// </summary>
/// <param name="cmdlet"><see cref="GetCimInstanceCommand"/> object.</param>
public void NewCimInstance(NewCimInstanceCommand cmdlet)
{
DebugHelper.WriteLogEx();
string nameSpace;
CimInstance cimInstance = null;
try
{
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.ClassNameComputerSet:
case CimBaseCommand.ClassNameSessionSet:
{
nameSpace = ConstValue.GetNamespace(cmdlet.Namespace);
cimInstance = CreateCimInstance(cmdlet.ClassName,
nameSpace,
cmdlet.Key,
cmdlet.Property,
cmdlet);
}
break;
case CimBaseCommand.ResourceUriSessionSet:
case CimBaseCommand.ResourceUriComputerSet:
{
nameSpace = cmdlet.Namespace; // passing null is ok for resourceUri set
cimInstance = CreateCimInstance("DummyClass",
nameSpace,
cmdlet.Key,
cmdlet.Property,
cmdlet);
}
break;
case CimBaseCommand.CimClassComputerSet:
case CimBaseCommand.CimClassSessionSet:
{
nameSpace = ConstValue.GetNamespace(cmdlet.CimClass.CimSystemProperties.Namespace);
cimInstance = CreateCimInstance(cmdlet.CimClass,
cmdlet.Property,
cmdlet);
}
break;
default:
return;
}
}
catch (ArgumentNullException e)
{
cmdlet.ThrowTerminatingError(e, action);
return;
}
catch (ArgumentException e)
{
cmdlet.ThrowTerminatingError(e, action);
return;
}
// return if create client only ciminstance
if (cmdlet.ClientOnly)
{
cmdlet.CmdletOperation.WriteObject(cimInstance, null);
return;
}
string target = cimInstance.ToString();
if (!cmdlet.ShouldProcess(target, action))
{
return;
}
// create ciminstance on server
List <CimSessionProxy> proxys = new();
switch (cmdlet.ParameterSetName)
{
case CimBaseCommand.ClassNameComputerSet:
case CimBaseCommand.CimClassComputerSet:
case CimBaseCommand.ResourceUriComputerSet:
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(
cmdlet.ComputerName);
foreach (string computerName in computerNames)
{
proxys.Add(CreateSessionProxy(computerName, cmdlet));
}
}
break;
case CimBaseCommand.CimClassSessionSet:
case CimBaseCommand.ClassNameSessionSet:
case CimBaseCommand.ResourceUriSessionSet:
foreach (CimSession session in cmdlet.CimSession)
{
proxys.Add(CreateSessionProxy(session, cmdlet));
}
break;
}
foreach (CimSessionProxy proxy in proxys)
{
proxy.ContextObject = new CimNewCimInstanceContext(proxy, nameSpace);
proxy.CreateInstanceAsync(nameSpace, cimInstance);
}
}
public void RemoveCimInstance(RemoveCimInstanceCommand cmdlet)
{
string @namespace;
DebugHelper.WriteLogEx();
IEnumerable <string> computerNames = ConstValue.GetComputerNames(CimGetInstance.GetComputerName(cmdlet));
List <CimSessionProxy> cimSessionProxies = new List <CimSessionProxy>();
string parameterSetName = cmdlet.ParameterSetName;
string str = parameterSetName;
if (parameterSetName != null)
{
if (str == "CimInstanceComputerSet")
{
foreach (string computerName in computerNames)
{
cimSessionProxies.Add(base.CreateSessionProxy(computerName, cmdlet.CimInstance, cmdlet));
}
}
else
{
if (str == "CimInstanceSessionSet")
{
CimSession[] cimSession = CimGetInstance.GetCimSession(cmdlet);
for (int i = 0; i < (int)cimSession.Length; i++)
{
CimSession cimSession1 = cimSession[i];
cimSessionProxies.Add(base.CreateSessionProxy(cimSession1, cmdlet));
}
}
}
}
string parameterSetName1 = cmdlet.ParameterSetName;
string str1 = parameterSetName1;
if (parameterSetName1 != null)
{
if (str1 == "CimInstanceComputerSet" || str1 == "CimInstanceSessionSet")
{
if (cmdlet.ResourceUri == null)
{
@namespace = ConstValue.GetNamespace(CimGetInstance.GetCimInstanceParameter(cmdlet).CimSystemProperties.Namespace);
}
else
{
@namespace = CimGetInstance.GetCimInstanceParameter(cmdlet).CimSystemProperties.Namespace;
}
string str2 = cmdlet.CimInstance.ToString();
foreach (CimSessionProxy cimSessionProxy in cimSessionProxies)
{
if (cmdlet.ShouldProcess(str2, "Remove-CimInstance"))
{
cimSessionProxy.DeleteInstanceAsync(@namespace, cmdlet.CimInstance);
}
else
{
return;
}
}
}
else
{
if (str1 == "QueryComputerSet" || str1 == "QuerySessionSet")
{
base.GetCimInstanceInternal(cmdlet);
}
else
{
return;
}
}
}
}
public void InvokeCimMethod(InvokeCimMethodCommand cmdlet)
{
string @namespace;
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
List <CimSessionProxy> cimSessionProxies = new List <CimSessionProxy>();
object[] methodName = new object[1];
methodName[0] = cmdlet.MethodName;
string str = string.Format(CultureInfo.CurrentUICulture, "Invoke-CimMethod: {0}", methodName);
string parameterSetName = cmdlet.ParameterSetName;
string str1 = parameterSetName;
if (parameterSetName != null)
{
switch (str1)
{
case "CimInstanceComputerSet":
{
IEnumerator <string> enumerator = computerNames.GetEnumerator();
using (enumerator)
{
while (enumerator.MoveNext())
{
string current = enumerator.Current;
cimSessionProxies.Add(this.CreateSessionProxy(current, cmdlet.CimInstance, cmdlet));
}
}
}
break;
case "ClassNameComputerSet":
case "CimClassComputerSet":
case "ResourceUriComputerSet":
case "QueryComputerSet":
{
IEnumerator <string> enumerator1 = computerNames.GetEnumerator();
using (enumerator1)
{
while (enumerator1.MoveNext())
{
string current1 = enumerator1.Current;
cimSessionProxies.Add(this.CreateSessionProxy(current1, cmdlet));
}
}
}
break;
case "ClassNameSessionSet":
case "CimClassSessionSet":
case "QuerySessionSet":
case "CimInstanceSessionSet":
case "ResourceUriSessionSet":
{
CimSession[] cimSession = cmdlet.CimSession;
for (int i = 0; i < (int)cimSession.Length; i++)
{
CimSession cimSession1 = cimSession[i];
CimSessionProxy cimSessionProxy = this.CreateSessionProxy(cimSession1, cmdlet);
cimSessionProxies.Add(cimSessionProxy);
}
}
break;
}
}
CimMethodParametersCollection cimMethodParametersCollection = this.CreateParametersCollection(cmdlet.Arguments, cmdlet.CimClass, cmdlet.CimInstance, cmdlet.MethodName);
string parameterSetName1 = cmdlet.ParameterSetName;
string str2 = parameterSetName1;
if (parameterSetName1 != null)
{
if (str2 == "ClassNameComputerSet" || str2 == "ClassNameSessionSet" || str2 == "ResourceUriSessionSet" || str2 == "ResourceUriComputerSet")
{
object[] className = new object[1];
className[0] = cmdlet.ClassName;
string str3 = string.Format(CultureInfo.CurrentUICulture, "{0}", className);
if (cmdlet.ResourceUri == null)
{
@namespace = ConstValue.GetNamespace(cmdlet.Namespace);
}
else
{
@namespace = cmdlet.Namespace;
}
List <CimSessionProxy> .Enumerator enumerator2 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
CimSessionProxy cimSessionProxy1 = enumerator2.Current;
if (cmdlet.ShouldProcess(str3, str))
{
cimSessionProxy1.InvokeMethodAsync(@namespace, cmdlet.ClassName, cmdlet.MethodName, cimMethodParametersCollection);
}
else
{
return;
}
}
return;
}
finally
{
enumerator2.Dispose();
}
}
else if (str2 == "CimClassComputerSet" || str2 == "CimClassSessionSet")
{
object[] objArray = new object[1];
objArray[0] = cmdlet.CimClass.CimSystemProperties.ClassName;
string str4 = string.Format(CultureInfo.CurrentUICulture, "{0}", objArray);
@namespace = ConstValue.GetNamespace(cmdlet.CimClass.CimSystemProperties.Namespace);
List <CimSessionProxy> .Enumerator enumerator3 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
CimSessionProxy current2 = enumerator3.Current;
if (cmdlet.ShouldProcess(str4, str))
{
current2.InvokeMethodAsync(@namespace, cmdlet.CimClass.CimSystemProperties.ClassName, cmdlet.MethodName, cimMethodParametersCollection);
}
else
{
return;
}
}
return;
}
finally
{
enumerator3.Dispose();
}
}
else if (str2 == "QueryComputerSet" || str2 == "QuerySessionSet")
{
@namespace = ConstValue.GetNamespace(cmdlet.Namespace);
List <CimSessionProxy> .Enumerator enumerator4 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator4.MoveNext())
{
CimSessionProxy cimSessionProxy2 = enumerator4.Current;
CimInvokeCimMethod.CimInvokeCimMethodContext cimInvokeCimMethodContext = new CimInvokeCimMethod.CimInvokeCimMethodContext(@namespace, cmdlet.MethodName, cimMethodParametersCollection, cimSessionProxy2);
cimSessionProxy2.ContextObject = cimInvokeCimMethodContext;
cimSessionProxy2.QueryInstancesAsync(@namespace, ConstValue.GetQueryDialectWithDefault(cmdlet.QueryDialect), cmdlet.Query);
}
return;
}
finally
{
enumerator4.Dispose();
}
}
else if (str2 == "CimInstanceComputerSet" || str2 == "CimInstanceSessionSet")
{
string str5 = cmdlet.CimInstance.ToString();
if (cmdlet.ResourceUri == null)
{
@namespace = ConstValue.GetNamespace(cmdlet.CimInstance.CimSystemProperties.Namespace);
}
else
{
@namespace = cmdlet.Namespace;
}
List <CimSessionProxy> .Enumerator enumerator5 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator5.MoveNext())
{
CimSessionProxy current3 = enumerator5.Current;
if (cmdlet.ShouldProcess(str5, str))
{
current3.InvokeMethodAsync(@namespace, cmdlet.CimInstance, cmdlet.MethodName, cimMethodParametersCollection);
}
else
{
return;
}
}
return;
}
finally
{
enumerator5.Dispose();
}
}
return;
}
}
public void SetCimInstance(SetCimInstanceCommand cmdlet)
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(CimGetInstance.GetComputerName(cmdlet));
List <CimSessionProxy> cimSessionProxies = new List <CimSessionProxy>();
string parameterSetName = cmdlet.ParameterSetName;
string str = parameterSetName;
if (parameterSetName != null)
{
if (str == "CimInstanceComputerSet")
{
foreach (string computerName in computerNames)
{
cimSessionProxies.Add(base.CreateSessionProxy(computerName, cmdlet.CimInstance, cmdlet, cmdlet.PassThru));
}
}
else
{
if (str == "CimInstanceSessionSet")
{
CimSession[] cimSession = CimGetInstance.GetCimSession(cmdlet);
for (int i = 0; i < (int)cimSession.Length; i++)
{
CimSession cimSession1 = cimSession[i];
cimSessionProxies.Add(base.CreateSessionProxy(cimSession1, cmdlet, cmdlet.PassThru));
}
}
}
}
string parameterSetName1 = cmdlet.ParameterSetName;
string str1 = parameterSetName1;
if (parameterSetName1 != null)
{
if (str1 == "CimInstanceComputerSet" || str1 == "CimInstanceSessionSet")
{
string @namespace = ConstValue.GetNamespace(CimGetInstance.GetCimInstanceParameter(cmdlet).CimSystemProperties.Namespace);
string str2 = cmdlet.CimInstance.ToString();
foreach (CimSessionProxy cimSessionProxy in cimSessionProxies)
{
if (cmdlet.ShouldProcess(str2, "Set-CimInstance"))
{
Exception exception = null;
CimInstance cimInstance = cmdlet.CimInstance;
if (cmdlet.Property == null || this.SetProperty(cmdlet.Property, ref cimInstance, ref exception))
{
cimSessionProxy.ModifyInstanceAsync(@namespace, cimInstance);
}
else
{
cmdlet.ThrowTerminatingError(exception, "Set-CimInstance");
return;
}
}
else
{
return;
}
}
}
else
{
if (str1 == "QueryComputerSet" || str1 == "QuerySessionSet")
{
base.GetCimInstanceInternal(cmdlet);
}
else
{
return;
}
}
}
}
public void GetCimClass(GetCimClassCommand cmdlet)
{
string className;
List <CimSessionProxy> cimSessionProxies = new List <CimSessionProxy>();
string @namespace = ConstValue.GetNamespace(cmdlet.Namespace);
if (cmdlet.ClassName == null)
{
className = "*";
}
else
{
className = cmdlet.ClassName;
}
string str = className;
CimGetCimClassContext cimGetCimClassContext = new CimGetCimClassContext(cmdlet.ClassName, cmdlet.MethodName, cmdlet.PropertyName, cmdlet.QualifierName);
string parameterSetName = cmdlet.ParameterSetName;
string str1 = parameterSetName;
if (parameterSetName == null)
{
return;
}
else
{
if (str1 == "ComputerSet")
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
foreach (string computerName in computerNames)
{
CimSessionProxy cimSessionProxy = this.CreateSessionProxy(computerName, cmdlet);
cimSessionProxy.ContextObject = cimGetCimClassContext;
cimSessionProxies.Add(cimSessionProxy);
}
}
else
{
if (str1 == "SessionSet")
{
CimSession[] cimSession = cmdlet.CimSession;
for (int i = 0; i < (int)cimSession.Length; i++)
{
CimSession cimSession1 = cimSession[i];
CimSessionProxy cimSessionProxy1 = this.CreateSessionProxy(cimSession1, cmdlet);
cimSessionProxy1.ContextObject = cimGetCimClassContext;
cimSessionProxies.Add(cimSessionProxy1);
}
}
else
{
return;
}
}
if (!WildcardPattern.ContainsWildcardCharacters(str))
{
foreach (CimSessionProxy cimSessionProxy2 in cimSessionProxies)
{
cimSessionProxy2.GetClassAsync(@namespace, str);
}
}
else
{
foreach (CimSessionProxy cimSessionProxy3 in cimSessionProxies)
{
cimSessionProxy3.EnumerateClassesAsync(@namespace);
}
}
return;
}
}
protected void GetCimInstanceInternal(CimBaseCommand cmdlet)
{
string @namespace;
IEnumerable <string> computerNames = ConstValue.GetComputerNames(CimGetInstance.GetComputerName(cmdlet));
List <CimSessionProxy> cimSessionProxies = new List <CimSessionProxy>();
bool flag = cmdlet is GetCimInstanceCommand;
string parameterSetName = cmdlet.ParameterSetName;
string str = parameterSetName;
if (parameterSetName != null)
{
switch (str)
{
case "CimInstanceComputerSet":
{
IEnumerator <string> enumerator = computerNames.GetEnumerator();
using (enumerator)
{
while (enumerator.MoveNext())
{
string current = enumerator.Current;
CimInstance cimInstanceParameter = CimGetInstance.GetCimInstanceParameter(cmdlet);
CimSessionProxy cimSessionProxy = this.CreateSessionProxy(current, cimInstanceParameter, cmdlet);
if (flag)
{
this.SetPreProcess(cimSessionProxy, cmdlet as GetCimInstanceCommand);
}
cimSessionProxies.Add(cimSessionProxy);
}
}
}
break;
case "ClassNameComputerSet":
case "QueryComputerSet":
case "ResourceUriComputerSet":
{
IEnumerator <string> enumerator1 = computerNames.GetEnumerator();
using (enumerator1)
{
while (enumerator1.MoveNext())
{
string current1 = enumerator1.Current;
CimSessionProxy cimSessionProxy1 = this.CreateSessionProxy(current1, cmdlet);
if (flag)
{
this.SetPreProcess(cimSessionProxy1, cmdlet as GetCimInstanceCommand);
}
cimSessionProxies.Add(cimSessionProxy1);
}
break;
}
}
case "ClassNameSessionSet":
case "CimInstanceSessionSet":
case "QuerySessionSet":
case "ResourceUriSessionSet":
{
CimSession[] cimSession = CimGetInstance.GetCimSession(cmdlet);
for (int i = 0; i < (int)cimSession.Length; i++)
{
CimSession cimSession1 = cimSession[i];
CimSessionProxy cimSessionProxy2 = this.CreateSessionProxy(cimSession1, cmdlet);
if (flag)
{
this.SetPreProcess(cimSessionProxy2, cmdlet as GetCimInstanceCommand);
}
cimSessionProxies.Add(cimSessionProxy2);
}
}
break;
}
}
string parameterSetName1 = cmdlet.ParameterSetName;
string str1 = parameterSetName1;
if (parameterSetName1 != null)
{
if (str1 == "ClassNameComputerSet" || str1 == "ClassNameSessionSet")
{
@namespace = ConstValue.GetNamespace(CimGetInstance.GetNamespace(cmdlet));
if (!CimGetInstance.IsClassNameQuerySet(cmdlet))
{
List <CimSessionProxy> .Enumerator enumerator2 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
CimSessionProxy current2 = enumerator2.Current;
current2.EnumerateInstancesAsync(@namespace, CimGetInstance.GetClassName(cmdlet));
}
return;
}
finally
{
enumerator2.Dispose();
}
}
else
{
string str2 = CimGetInstance.CreateQuery(cmdlet);
object[] objArray = new object[1];
objArray[0] = str2;
DebugHelper.WriteLogEx("Query = {0}", 1, objArray);
List <CimSessionProxy> .Enumerator enumerator3 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
CimSessionProxy current3 = enumerator3.Current;
current3.QueryInstancesAsync(@namespace, ConstValue.GetQueryDialectWithDefault(CimGetInstance.GetQueryDialect(cmdlet)), str2);
}
return;
}
finally
{
enumerator3.Dispose();
}
}
}
else if (str1 == "CimInstanceComputerSet" || str1 == "CimInstanceSessionSet")
{
CimInstance cimInstance = CimGetInstance.GetCimInstanceParameter(cmdlet);
@namespace = ConstValue.GetNamespace(cimInstance.CimSystemProperties.Namespace);
List <CimSessionProxy> .Enumerator enumerator4 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator4.MoveNext())
{
CimSessionProxy cimSessionProxy3 = enumerator4.Current;
cimSessionProxy3.GetInstanceAsync(@namespace, cimInstance);
}
return;
}
finally
{
enumerator4.Dispose();
}
}
else if (str1 == "QueryComputerSet" || str1 == "QuerySessionSet")
{
@namespace = ConstValue.GetNamespace(CimGetInstance.GetNamespace(cmdlet));
List <CimSessionProxy> .Enumerator enumerator5 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator5.MoveNext())
{
CimSessionProxy current4 = enumerator5.Current;
current4.QueryInstancesAsync(@namespace, ConstValue.GetQueryDialectWithDefault(CimGetInstance.GetQueryDialect(cmdlet)), CimGetInstance.GetQuery(cmdlet));
}
return;
}
finally
{
enumerator5.Dispose();
}
}
else if (str1 == "ResourceUriSessionSet" || str1 == "ResourceUriComputerSet")
{
List <CimSessionProxy> .Enumerator enumerator6 = cimSessionProxies.GetEnumerator();
try
{
while (enumerator6.MoveNext())
{
CimSessionProxy cimSessionProxy4 = enumerator6.Current;
cimSessionProxy4.EnumerateInstancesAsync(CimGetInstance.GetNamespace(cmdlet), CimGetInstance.GetClassName(cmdlet));
}
return;
}
finally
{
enumerator6.Dispose();
}
}
return;
}
}
public void NewCimInstance(NewCimInstanceCommand cmdlet)
{
string @namespace;
DebugHelper.WriteLogEx();
CimInstance cimInstance = null;
try
{
string parameterSetName = cmdlet.ParameterSetName;
string str = parameterSetName;
if (parameterSetName != null)
{
if (str == "ClassNameComputerSet" || str == "ClassNameSessionSet")
{
@namespace = ConstValue.GetNamespace(cmdlet.Namespace);
cimInstance = this.CreateCimInstance(cmdlet.ClassName, @namespace, cmdlet.Key, cmdlet.Property, cmdlet);
}
else if (str == "ResourceUriSessionSet" || str == "ResourceUriComputerSet")
{
@namespace = cmdlet.Namespace;
cimInstance = this.CreateCimInstance("DummyClass", @namespace, cmdlet.Key, cmdlet.Property, cmdlet);
}
else if (str == "CimClassComputerSet" || str == "CimClassSessionSet")
{
@namespace = ConstValue.GetNamespace(cmdlet.CimClass.CimSystemProperties.Namespace);
cimInstance = this.CreateCimInstance(cmdlet.CimClass, cmdlet.Property, cmdlet);
}
else
{
return;
}
goto Label0;
}
}
catch (ArgumentNullException argumentNullException1)
{
ArgumentNullException argumentNullException = argumentNullException1;
cmdlet.ThrowTerminatingError(argumentNullException, "New-CimInstance");
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
cmdlet.ThrowTerminatingError(argumentException, "New-CimInstance");
}
return;
Label0:
if (!cmdlet.ClientOnly)
{
string str1 = cimInstance.ToString();
if (cmdlet.ShouldProcess(str1, "New-CimInstance"))
{
List <CimSessionProxy> cimSessionProxies = new List <CimSessionProxy>();
string parameterSetName1 = cmdlet.ParameterSetName;
string str2 = parameterSetName1;
if (parameterSetName1 != null)
{
if (str2 == "ClassNameComputerSet" || str2 == "CimClassComputerSet" || str2 == "ResourceUriComputerSet")
{
IEnumerable <string> computerNames = ConstValue.GetComputerNames(cmdlet.ComputerName);
foreach (string computerName in computerNames)
{
cimSessionProxies.Add(this.CreateSessionProxy(computerName, cmdlet));
}
}
else
{
if (str2 == "CimClassSessionSet" || str2 == "ClassNameSessionSet" || str2 == "ResourceUriSessionSet")
{
CimSession[] cimSession = cmdlet.CimSession;
for (int i = 0; i < (int)cimSession.Length; i++)
{
CimSession cimSession1 = cimSession[i];
cimSessionProxies.Add(this.CreateSessionProxy(cimSession1, cmdlet));
}
}
}
}
foreach (CimSessionProxy cimSessionProxy in cimSessionProxies)
{
cimSessionProxy.ContextObject = new CimNewCimInstanceContext(cimSessionProxy, @namespace);
cimSessionProxy.CreateInstanceAsync(@namespace, cimInstance);
}
return;
}
else
{
return;
}
}
else
{
cmdlet.CmdletOperation.WriteObject(cimInstance, null);
return;
}
}
