/// <summary>
/// Query session wrapper object
/// </summary>
/// <param name="cimsessions"></param>
/// <returns>session wrapper</returns>
internal CimSessionWrapper QuerySession(CimSession cimsession)
{
CimSessionWrapper wrapper;
this.curCimSessionWrapper.TryGetValue(cimsession, out wrapper);
return wrapper;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="session"></param>
/// <param name="observable"></param>
public CimMethodResultObserver(CimSession session, IObservable <object> observable)
: base(session, observable)
{
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </summary>
/// <param name="session"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
private CimSessionProxy CreateSessionProxy(
CimSession session,
NewCimInstanceCommand cmdlet)
{
CimSessionProxy proxy = new CimSessionProxyNewCimInstance(session, this);
this.SubscribeEventAndAddProxytoCache(proxy);
SetSessionProxyProperties(ref proxy, cmdlet);
return proxy;
}
internal CimSessionWrapper(
uint theSessionId,
Guid theInstanceId,
string theName,
string theComputerName,
CimSession theCimSession,
ProtocolType theProtocol)
{
this.sessionId = theSessionId;
this.instanceId = theInstanceId;
this.name = theName;
this.computerName = theComputerName;
this.cimSession = theCimSession;
this.psObject = null;
this.protocol = theProtocol;
}
/// <summary>
/// Create <see cref="CimSession"/> by given computer name
/// and session options.
/// Then create wrapper object.
/// </summary>
/// <param name="computerName"></param>
/// <param name="sessionOptions"></param>
public CimSessionProxyNewCimInstance(CimSession session, CimNewCimInstance operation)
: base(session)
{
this.newCimInstance = operation;
}
/// <summary>
/// <para>
/// Remove <see cref="CimSession"/> from temporary cache.
/// If CimSession already present in cache, then decrease the refcount by 1,
/// otherwise ignore.
/// If refcount became 0, call dispose on the <see cref="CimSession"/> object.
/// </para>
/// </summary>
/// <param name="session">CimSession to be added</param>
internal static void RemoveCimSessionFromTemporaryCache(CimSession session)
{
RemoveCimSessionFromTemporaryCache(session, true);
}
/// <summary>
/// Retrieve an array of new objects of type T, whose properties and fields are
/// populated from an instance of the specified WMI class on the specified CIM
/// session.
/// </summary>
/// <typeparam name="T">
/// The type of the object to be created. Must be a default-constructable
/// reference type.
/// </typeparam>
/// <param name="session">
/// The CIM session to be queried.
/// </param>
/// <param name="wmiClassName">
/// A string containing the name of the WMI class from which to populate
/// the resultant array elements.
/// </param>
/// <returns>
/// An array of new objects of type T if successful, null otherwise.
/// </returns>
/// <remarks>
/// This method matches property and field names of type T with identically
/// named properties in the WMI class instance. The WMI property is converted
/// to the type of T's property or field.
/// </remarks>
internal static T[] GetAll <T>(CimSession session, string wmiClassName) where T : class, new()
{
return(GetAll <T>(session, DefaultNamespace, wmiClassName));
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> object.
/// </summary>
/// <param name="session"></param>
protected CimSessionProxy CreateCimSessionProxy(CimSession session)
{
CimSessionProxy proxy = new CimSessionProxy(session);
this.SubscribeEventAndAddProxytoCache(proxy);
return proxy;
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </summary>
/// <param name="session"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
private CimSessionProxy CreateSessionProxy(
CimSession session,
InvokeCimMethodCommand cmdlet)
{
CimSessionProxy proxy = CreateCimSessionProxy(session);
SetSessionProxyProperties(ref proxy, cmdlet);
return proxy;
}
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;
}
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </summary>
/// <param name="session"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
private CimSessionProxy CreateSessionProxy(
CimSession session,
GetCimAssociatedInstanceCommand cmdlet)
{
CimSessionProxy proxy = CreateCimSessionProxy(session);
SetSessionProxyProperties(ref proxy, cmdlet);
return proxy;
}
internal bool IsSessionTerminated(CimSession session)
{
bool orAdd = this._sessionToIsTerminated.GetOrAdd(session, false);
return(orAdd);
}
internal static CimMethodParametersCollection InvokeMethodCore(
CimSession cimSession,
string cimNamespace,
string cimClassName,
out string cimMethodName,
out CimInstance inputInstance)
{
CimMethodParametersCollection methodParameters = new CimMethodParametersCollection();
inputInstance = null;
cimMethodName = null;
bool isStaticMethod = false;
try
{
CimClass cimClass = cimSession.GetClass(cimNamespace, cimClassName);
// Print Methods
foreach (CimMethodDeclaration methodDecl in cimClass.CimClassMethods)
{
Console.WriteLine("Method Name = " + methodDecl.Name);
}
cimMethodName = DotNetSample.GetName("Method Name");
if (cimClass.CimClassMethods[cimMethodName].Qualifiers["static"] != null)
{
isStaticMethod = true;
}
foreach (CimMethodParameterDeclaration methodParameter in cimClass.CimClassMethods[cimMethodName].Parameters)
{
bool bInQualifier = true;
try
{
CimQualifier inQualifier = methodParameter.Qualifiers["In"];
}
catch (CimException)
{
//Ignore the exception
bInQualifier = false;
}
if (bInQualifier)
{
Console.Write("Please type value for Parameter '" + methodParameter.Name + "' of Type:({0}) ", methodParameter.CimType);
string parameterValue = Console.ReadLine();
if (!String.IsNullOrEmpty(parameterValue))
{
methodParameters.Add(CimMethodParameter.Create(methodParameter.Name, parameterValue, methodParameter.CimType, 0));
}
}
}
// Get the instance if method is not static
if (!isStaticMethod)
{
// Get the instances for this class.
ArrayList list = GetAndPrintInstances(cimSession, cimNamespace, cimClassName);
if (list == null || list.Count == 0)
{
Console.WriteLine("InvokeMethodCore operation not performed");
return(null);
}
while (true)
{
Console.WriteLine("On which instance do you want to invoke the method");
string instanceId = Console.ReadLine();
int result;
if (String.IsNullOrEmpty(instanceId) || int.TryParse(instanceId, out result) == false || result >= list.Count)
{
Console.WriteLine("Please type the instance Id in the range {0} to {1}", 0, list.Count - 1);
}
else
{
inputInstance = (CimInstance)list[result];
break;
}
}
}
}
catch (CimException exception)
{
Console.WriteLine("Unable to get schema for class '" + cimClassName + "' in namespace " + cimNamespace);
PrintCimException(exception);
return(null);
}
return(methodParameters);
}
public InstanceHandler(CimSession cimSession, CimInstance cimInstance)
{
this.cimSession = cimSession;
this.cimInstance = cimInstance;
}
/// <summary>
/// An "overload" of the
/// <see cref="Microsoft.Management.Infrastructure.CimSession"/>.QueryInstances
/// method that takes only the namespace and query string as a parameters
/// </summary>
/// <param name="session">The CimSession to be queried.</param>
/// <param name="nameSpace">A string containing the namespace to run the query against.</param>
/// <param name="query">A string containing the query to be run.</param>
/// <returns>
/// An IEnumerable interface that can be used to enumerate the instances
/// </returns>
internal static IEnumerable <CimInstance> QueryInstances(this CimSession session, string nameSpace, string query)
{
return(session.QueryInstances(nameSpace, CIMHelper.DefaultQueryDialect, query));
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </summary>
/// <param name="session"></param>
/// <param name="timeout"></param>
/// <returns></returns>
private CimSessionProxy CreateSessionProxy(
CimSession session,
UInt32 timeout)
{
CimSessionProxy proxy = CreateCimSessionProxy(session);
proxy.OperationTimeout = timeout;
return proxy;
}
/// <summary>
/// Execute a CIM query and return only the first instance in the result.
/// </summary>
/// <param name="session">The CimSession to be queried.</param>
/// <param name="query">A string containing the query to be run.</param>
/// <returns>
/// A <see cref="Microsoft.Management.Infrastructure.CimInstance"/> object
/// representing the first instance in a query result if successful, null
/// otherwise.
/// </returns>
internal static CimInstance QueryFirstInstance(this CimSession session, string query)
{
return(session.QueryFirstInstance(CIMHelper.DefaultNamespace, query));
}
/// <summary>
/// <para>
/// Dispose temporary <see cref="CimSession"/>.
/// </para>
/// </summary>
private void DisposeTemporaryCimSession()
{
if (this.isTemporaryCimSession && this.session != null)
{
// remove the cimsession from temporary cache
RemoveCimSessionFromTemporaryCache(this.session);
this.isTemporaryCimSession = false;
this.session = null;
}
}
internal static T GetFirst <T>(this CimSession session, string wmiNamespace, string wmiClassName) where T : class, new()
{
return(CIMHelper.GetFirst <T>(session, wmiNamespace, wmiClassName));
}
/// <summary>
/// <para>
/// Add <see cref="CimSession"/> to temporary cache.
/// If CimSession already present in cache, then increase the refcount by 1,
/// otherwise insert it into the cache.
/// </para>
/// </summary>
/// <param name="session">CimSession to be added</param>
internal static void AddCimSessionToTemporaryCache(CimSession session)
{
if (null != session)
{
lock (temporarySessionCacheLock)
{
if (temporarySessionCache.ContainsKey(session))
{
temporarySessionCache[session]++;
DebugHelper.WriteLogEx(@"Increase cimsession ref count {0}", 1, temporarySessionCache[session]);
}
else
{
temporarySessionCache.Add(session, 1);
DebugHelper.WriteLogEx(@"Add cimsession to cache. Ref count {0}", 1, temporarySessionCache[session]);
}
}
}
}
internal static T[] GetAll <T>(this CimSession session, string wmiNamespace, string wmiClassName) where T : class, new()
{
return(Microsoft.PowerShell.Commands.CIMHelper.GetAll <T>(session, wmiNamespace, wmiClassName));
}
/// <summary>
/// Create wrapper object by given session object
/// </summary>
/// <param name="session"></param>
/// <param name="operOptions">Used when create async operation</param>
public CimSessionProxy(CimSession session, CimOperationOptions operOptions)
{
CreateSetSession(null, session, null, operOptions, false);
}
public static void ConnectingToWMI(string Computer_B)
{
//string Namespace = @"root\cimv2";
//string OSQuery = "SELECT * FROM Win32_OperatingSystem";
//CimSession mySession = CimSession.Create(Computer_B);
//IEnumerable<CimInstance> queryInstance = mySession.QueryInstances(Namespace, "WQL", OSQuery);
//foreach (CimInstance cimInstance in queryInstance)
//{
// Console.WriteLine("Process name: {0}", cimInstance.CimInstanceProperties["Name"].Value);
//}
//*************************************
//string domain = "DESKTOP-3KU7CQB";
//string username = "******";
//string password = "******";
string domain = "devstation";
string username = "******";
string password = "******";
//PerformanceCounter freeSpaceCounter = null;
//using (((WindowsIdentity)HttpContext.Current.User.Identity).Impersonate())
//{
// freeSpaceCounter = new PerformanceCounter("LogicalDisk",
// "Free Megabytes", "D:", "RemoteMachine12");
//}
ConnectionOptions con = new ConnectionOptions();
con.Username = "******";
con.Password = "******";
ManagementScope scope = new ManagementScope(@"\\" + Computer_B + @"\root\cimv2", con);
scope.Connect();
SecureString securepassword = new SecureString();
foreach (char c in password)
{
securepassword.AppendChar(c);
}
// create Credentials
CimCredential Credentials = new CimCredential(PasswordAuthenticationMechanism.Default,
Computer_B,
username,
securepassword);
// create SessionOptions using Credentials
WSManSessionOptions SessionOptions = new WSManSessionOptions();
SessionOptions.AddDestinationCredentials(Credentials);
// create Session using computer, SessionOptions
CimSession Session = CimSession.Create(Computer_B, SessionOptions);
var allVolumes = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Volume");
var allPDisks = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_DiskDrive");
// Loop through all volumes
foreach (CimInstance oneVolume in allVolumes)
{
// Show volume information
if (oneVolume.CimInstanceProperties["DriveLetter"].ToString()[0] > ' ')
{
Console.WriteLine("Volume ‘{0}’ has {1} bytes total, {2} bytes available",
oneVolume.CimInstanceProperties["DriveLetter"],
oneVolume.CimInstanceProperties["Size"],
oneVolume.CimInstanceProperties["SizeRemaining"]);
}
}
// Loop through all physical disks
foreach (CimInstance onePDisk in allPDisks)
{
// Show physical disk information
Console.WriteLine("Disk {0} is model {1}, serial number {2}",
onePDisk.CimInstanceProperties["DeviceId"],
onePDisk.CimInstanceProperties["Model"].ToString().TrimEnd(),
onePDisk.CimInstanceProperties["SerialNumber"]);
}
}
/// <summary>
/// <para>
/// Initialize
/// </para>
/// </summary>
private void Initialize(
string theComputerName,
CimSession theCimSession,
string theNameSpace,
string theQueryDialect,
string theQueryExpression,
UInt32 theOpreationTimeout)
{
enableRaisingEvents = false;
status = Status.Default;
myLock = new object();
cimRegisterCimIndication = new CimRegisterCimIndication();
cimRegisterCimIndication.OnNewSubscriptionResult += NewSubscriptionResultHandler;
this.cimSession = theCimSession;
this.nameSpace = theNameSpace;
this.queryDialect = ConstValue.GetQueryDialectWithDefault(theQueryDialect);
this.queryExpression = theQueryExpression;
this.opreationTimeout = theOpreationTimeout;
this.computerName = theComputerName;
}
private static CimSession CreateDefaultCimSession()
{
return(CimSession.Create(null));
}
/// <summary>
/// <para>
/// Remove given <see cref="CimSession"/> object from cache
/// </para>
/// </summary>
/// <param name="session"></param>
internal void RemoveOneSessionObjectFromCache(CimSession session)
{
DebugHelper.WriteLogEx();
if (!this.curCimSessionWrapper.ContainsKey(session))
{
return;
}
CimSessionWrapper wrapper = this.curCimSessionWrapper[session];
String name = wrapper.Name;
String computerName = wrapper.ComputerName;
DebugHelper.WriteLog("name {0}, computername {1}, id {2}, instanceId {3}", 1, name, computerName, wrapper.SessionId, wrapper.InstanceId);
HashSet<CimSessionWrapper> objects;
if (this.curCimSessionsByComputerName.TryGetValue(computerName, out objects))
{
objects.Remove(wrapper);
}
if (this.curCimSessionsByName.TryGetValue(name, out objects))
{
objects.Remove(wrapper);
}
RemoveSessionInternal(session, wrapper);
}
static void Main(string[] args)
{
//string computer = "ILPT2113";
//string domain = "ICERTIS.COM";
//string username = @"*****@*****.**";
string computer = "myfirstvm";
string domain = "";
string username = "******";
string plaintextpassword;
Console.WriteLine("Enter password:"******"root\cimv2", "WQL", "SELECT * FROM Win32_Directory");
var allPDisks = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_DiskDrive");
// Loop through all volumes
foreach (CimInstance oneVolume in allVolumes)
{
// Show volume information
if (oneVolume.CimInstanceProperties["DriveLetter"].ToString()[0] > ' ')
{
Console.WriteLine("Volume ‘{0}’ has {1} bytes total, {2} bytes available",
oneVolume.CimInstanceProperties["DriveLetter"],
oneVolume.CimInstanceProperties["Size"],
oneVolume.CimInstanceProperties["SizeRemaining"]);
}
}
// Loop through all physical disks
foreach (CimInstance onePDisk in allPDisks)
{
// Show physical disk information
Console.WriteLine("Disk {0} is model {1}, serial number {2}",
onePDisk.CimInstanceProperties["DeviceId"],
onePDisk.CimInstanceProperties["Model"].ToString().TrimEnd(),
onePDisk.CimInstanceProperties["SerialNumber"]);
}
Console.ReadKey();
}
internal static CimInstance CreateInstanceCore(CimSession cimSession, string cimNamespace, string cimClassName)
{
CimInstance createInstance = GetAllValues(cimSession, cimNamespace, cimClassName);
return(createInstance);
}
internal static void AssociatePSModuleInfoWithSession(PSModuleInfo moduleInfo, CimSession cimSession, Uri resourceUri, string cimNamespace)
{
AssociatePSModuleInfoWithSession(moduleInfo, (object)new Tuple <CimSession, Uri, string>(cimSession, resourceUri, cimNamespace));
}
/// <summary>
/// constructor
/// </summary>
/// <param name="session"></param>
/// <param name="observable"></param>
public IgnoreResultObserver(CimSession session, IObservable <object> observable)
: base(session, observable)
{
}
private static IEnumerable <CimModule> GetCimModules(
CimSession cimSession,
Uri resourceUri,
string cimNamespace,
string moduleNamePattern,
bool onlyManifests,
Cmdlet cmdlet,
CancellationToken cancellationToken)
{
Dbg.Assert(cimSession != null, "Caller should verify cimSession != null");
Dbg.Assert(moduleNamePattern != null, "Caller should verify that moduleNamePattern != null");
const WildcardOptions wildcardOptions = WildcardOptions.IgnoreCase | WildcardOptions.CultureInvariant;
var wildcardPattern = WildcardPattern.Get(moduleNamePattern, wildcardOptions);
string dosWildcard = WildcardPatternToDosWildcardParser.Parse(wildcardPattern);
var options = new CimOperationOptions {
CancellationToken = cancellationToken
};
options.SetCustomOption("PS_ModuleNamePattern", dosWildcard, mustComply: false);
if (resourceUri != null)
{
options.ResourceUri = resourceUri;
}
if (string.IsNullOrEmpty(cimNamespace) && (resourceUri == null))
{
cimNamespace = DiscoveryProviderNamespace;
}
// TODO/FIXME: ETW for method invocation
IEnumerable <CimInstance> syncResults = cimSession.EnumerateInstances(
cimNamespace,
DiscoveryProviderModuleClass,
options);
// TODO/FIXME: ETW for method results
IEnumerable <CimModule> cimModules = syncResults
.Select(cimInstance => new CimModule(cimInstance))
.Where(cimModule => wildcardPattern.IsMatch(cimModule.ModuleName));
if (!onlyManifests)
{
cimModules = cimModules.Select(
delegate(CimModule cimModule)
{
cimModule.FetchAllModuleFiles(cimSession, cimNamespace, options);
return(cimModule);
});
}
return(EnumerateWithCatch(
cimModules,
delegate(Exception exception)
{
ErrorRecord errorRecord = GetErrorRecordForRemoteDiscoveryProvider(exception);
if (!cmdlet.MyInvocation.ExpectingInput)
{
if (((-1) != errorRecord.FullyQualifiedErrorId.IndexOf(DiscoveryProviderNotFoundErrorId, StringComparison.OrdinalIgnoreCase)) ||
(cancellationToken.IsCancellationRequested || (exception is OperationCanceledException)) ||
(!cimSession.TestConnection()))
{
cmdlet.ThrowTerminatingError(errorRecord);
}
}
cmdlet.WriteError(errorRecord);
}));
}
/// <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="opreationTimeout"></param>
/// <exception cref="ArgumentNullException">throw if cimSession is null</exception>
public void RegisterCimIndication(
CimSession cimSession,
string nameSpace,
string queryDialect,
string queryExpression,
UInt32 opreationTimeout)
{
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, opreationTimeout);
proxy.SubscribeAsync(nameSpace, queryDialect, queryExpression);
WaitForAckMessage();
}
private void DiskScan(bool PC1, bool PC2, bool PC3)
{
var password = new SecureString();
foreach (char c in Data.rudepassword)
{
password.AppendChar(c);
}
CimCredential Credentials = new CimCredential(PasswordAuthenticationMechanism.Default, Data.domain, Data.username, password);
WSManSessionOptions SessionOptions = new WSManSessionOptions();
SessionOptions.AddDestinationCredentials(Credentials);
if (PC1)
{
try
{
CimSession Session1 = CimSession.Create(Data.computer1, SessionOptions);
var allVolumes1 = Session1.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Volume");
foreach (CimInstance oneVolume1 in allVolumes1)
{
if (oneVolume1.CimInstanceProperties["DriveLetter"].ToString() == "DriveLetter = \"C:\"")
{
Data.disk1size = String.Format("{0}", oneVolume1.CimInstanceProperties["Capacity"].Value);
Data.DD1size = Math.Round(Convert.ToDouble(Data.disk1size) / 1073741824, 2);
Data.disk1size = Data.DD1size.ToString() + " GB";
Data.disk1remain = String.Format("{0}", oneVolume1.CimInstanceProperties["FreeSpace"].Value);
Data.DD1remain = Math.Round(Convert.ToDouble(Data.disk1remain) / 1073741824, 2);
Data.disk1remain = Data.DD1remain.ToString() + " GB";
}
BarDD1.Maximum = (int)Data.DD1size;
BarDD1.Value = (int)(Data.DD1size - Data.DD1remain);
}
labelDisk1Remain.Text = Data.disk1remain;
labelDisk1Total.Text = Data.disk1size;
labelDisk1Used.Text = "Espace occupé (" + (Math.Round(((Data.DD1size - Data.DD1remain) / Data.DD1size), 2) * 100) + "%) :";
}
catch { Data.LoadPC1 = false; }
}
if (PC2)
{
try
{
CimSession Session2 = CimSession.Create(Data.computer2, SessionOptions);
var allVolumes2 = Session2.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Volume");
foreach (CimInstance oneVolume2 in allVolumes2)
{
if (oneVolume2.CimInstanceProperties["DriveLetter"].ToString() == "DriveLetter = \"C:\"")
{
Data.disk2size = String.Format("{0}", oneVolume2.CimInstanceProperties["Capacity"].Value);
Data.DD2size = Math.Round(Convert.ToDouble(Data.disk2size) / 1073741824, 2);
Data.disk2size = Data.DD2size.ToString() + " GB";
Data.disk2remain = String.Format("{0}", oneVolume2.CimInstanceProperties["FreeSpace"].Value);
Data.DD2remain = Math.Round(Convert.ToDouble(Data.disk2remain) / 1073741824, 2);
Data.disk2remain = Data.DD2remain.ToString() + " GB";
}
BarDD2.Maximum = (int)Data.DD2size;
BarDD2.Value = (int)(Data.DD2size - Data.DD2remain);
}
labelDisk2Remain.Text = Data.disk2remain;
labelDisk2Total.Text = Data.disk2size;
labelDisk2Used.Text = "Espace occupé (" + (Math.Round(((Data.DD2size - Data.DD2remain) / Data.DD2size), 2) * 100) + "%) :";
}
catch { Data.LoadPC2 = false; }
}
if (PC3)
{
try
{
CimSession Session3 = CimSession.Create(Data.computer3, SessionOptions);
var allVolumes3 = Session3.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Volume");
foreach (CimInstance oneVolume3 in allVolumes3)
{
if (oneVolume3.CimInstanceProperties["DriveLetter"].ToString() == "DriveLetter = \"C:\"")
{
Data.disk3size = String.Format("{0}", oneVolume3.CimInstanceProperties["Capacity"].Value);
Data.DD3size = Math.Round(Convert.ToDouble(Data.disk3size) / 1073741824, 2);
Data.disk3size = Data.DD3size.ToString() + " GB";
Data.disk3remain = String.Format("{0}", oneVolume3.CimInstanceProperties["FreeSpace"].Value);
Data.DD3remain = Math.Round(Convert.ToDouble(Data.disk3remain) / 1073741824, 2);
Data.disk3remain = Data.DD3remain.ToString() + " GB";
}
BarDD3.Maximum = (int)Data.DD3size;
BarDD3.Value = (int)(Data.DD3size - Data.DD3remain);
}
labelDisk3Remain.Text = Data.disk3remain;
labelDisk3Total.Text = Data.disk3size;
labelDisk3Used.Text = "Espace occupé (" + (Math.Round(((Data.DD3size - Data.DD3remain) / Data.DD3size), 2) * 100) + "%) :";
}
catch { Data.LoadPC3 = false; }
}
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> and set properties
/// </summary>
/// <param name="session"></param>
/// <param name="cmdlet"></param>
/// <returns></returns>
private CimSessionProxy CreateSessionProxy(
CimSession session,
GetCimClassCommand cmdlet)
{
CimSessionProxy proxy = new CimSessionProxyGetCimClass(session);
this.SubscribeEventAndAddProxytoCache(proxy);
SetSessionProxyProperties(ref proxy, cmdlet);
return proxy;
}
private void RamScan(bool PC1, bool PC2, bool PC3)
{
var password = new SecureString();
foreach (char c in Data.rudepassword)
{
password.AppendChar(c);
}
CimCredential Credentials = new CimCredential(PasswordAuthenticationMechanism.Default, Data.domain, Data.username, password);
WSManSessionOptions SessionOptions = new WSManSessionOptions();
SessionOptions.AddDestinationCredentials(Credentials);
if (PC1)
{
try
{
CimSession Session1 = CimSession.Create(Data.computer1, SessionOptions);
var allMemory1 = Session1.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PhysicalMemory");
Data.memory1size = 0;
foreach (CimInstance oneMemory1 in allMemory1)
{
Data.ram1size = String.Format("{0}", oneMemory1.CimInstanceProperties["Capacity"].Value);
Data.memory1size += Math.Round(Convert.ToDouble(Data.ram1size) / 1073741824, 2);
Data.ram1size = Data.memory1size.ToString() + " GB";
labelRam1Size.Text = Data.ram1size;
}
var allUsedMemory1 = Session1.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PerfFormattedData_PerfOS_Memory");
foreach (CimInstance oneUsedMemory1 in allUsedMemory1)
{
Int32.TryParse(String.Format("{0}", oneUsedMemory1.CimInstanceProperties["PercentCommittedBytesInUse"].Value), out Data.ram1percent);
}
labelRam1Used.Text = Data.ram1percent + "%";
BarRAM1.Value = Data.ram1percent;
}
catch { Data.LoadPC1 = false; }
}
if (PC2)
{
try
{
CimSession Session2 = CimSession.Create(Data.computer2, SessionOptions);
var allMemory2 = Session2.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PhysicalMemory");
Data.memory2size = 0;
foreach (CimInstance oneMemory2 in allMemory2)
{
Data.ram2size = String.Format("{0}", oneMemory2.CimInstanceProperties["Capacity"].Value);
Data.memory2size += Math.Round(Convert.ToDouble(Data.ram2size) / 1073741824, 2);
Data.ram2size = Data.memory2size.ToString() + " GB";
labelRam2Size.Text = Data.ram2size;
}
var allUsedMemory2 = Session2.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PerfFormattedData_PerfOS_Memory");
foreach (CimInstance oneUsedMemory2 in allUsedMemory2)
{
Int32.TryParse(String.Format("{0}", oneUsedMemory2.CimInstanceProperties["PercentCommittedBytesInUse"].Value), out Data.ram2percent);
}
labelRam2Used.Text = Data.ram2percent + "%";
BarRAM2.Value = Data.ram2percent;
}
catch { Data.LoadPC2 = false; }
}
if (PC3)
{
try
{
CimSession Session3 = CimSession.Create(Data.computer3, SessionOptions);
var allMemory3 = Session3.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PhysicalMemory");
Data.memory3size = 0;
foreach (CimInstance oneMemory3 in allMemory3)
{
Data.ram3size = String.Format("{0}", oneMemory3.CimInstanceProperties["Capacity"].Value);
Data.memory3size += Math.Round(Convert.ToDouble(Data.ram3size) / 1073741824, 2);
Data.ram3size = Data.memory3size.ToString() + " GB";
labelRam3Size.Text = Data.ram3size;
}
var allUsedMemory3 = Session3.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PerfFormattedData_PerfOS_Memory");
foreach (CimInstance oneUsedMemory3 in allUsedMemory3)
{
Int32.TryParse(String.Format("{0}", oneUsedMemory3.CimInstanceProperties["PercentCommittedBytesInUse"].Value), out Data.ram3percent);
}
labelRam3Used.Text = Data.ram3percent + "%";
BarRAM3.Value = Data.ram3percent;
}
catch { Data.LoadPC3 = false; }
}
}
/// <summary>
/// Create <see cref="CimSessionProxy"/> object.
/// </summary>
/// <param name="session"></param>
protected CimSessionProxy CreateCimSessionProxy(CimSession session, bool passThru)
{
CimSessionProxy proxy = new CimSessionProxySetCimInstance(session, passThru);
this.SubscribeEventAndAddProxytoCache(proxy);
return proxy;
}
private void CpuScan(bool PC1, bool PC2, bool PC3)
{
var password = new SecureString();
foreach (char c in Data.rudepassword)
{
password.AppendChar(c);
}
CimCredential Credentials = new CimCredential(PasswordAuthenticationMechanism.Default, Data.domain, Data.username, password);
WSManSessionOptions SessionOptions = new WSManSessionOptions();
SessionOptions.AddDestinationCredentials(Credentials);
if (PC1)
{
try
{
CimSession Session1 = CimSession.Create(Data.computer1, SessionOptions);
var allUsedCore1 = Session1.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PerfFormattedData_PerfOS_Processor");
foreach (CimInstance oneUsedCore1 in allUsedCore1)
{
Int32.TryParse(String.Format("{0}", oneUsedCore1.CimInstanceProperties["PercentProcessorTime"].Value), out Data.cpu1percent);
}
labelCpu1Used.Text = Data.cpu1percent + "%";
BarCPU1.Value = Data.cpu1percent;
}
catch { Data.LoadPC1 = false; }
}
if (PC2)
{
try
{
CimSession Session2 = CimSession.Create(Data.computer2, SessionOptions);
var allUsedCore2 = Session2.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PerfFormattedData_PerfOS_Processor");
foreach (CimInstance oneUsedCore2 in allUsedCore2)
{
Int32.TryParse(String.Format("{0}", oneUsedCore2.CimInstanceProperties["PercentProcessorTime"].Value), out Data.cpu2percent);
}
labelCpu2Used.Text = Data.cpu2percent + "%";
BarCPU2.Value = Data.cpu2percent;
}
catch { Data.LoadPC2 = false; }
}
if (PC3)
{
try
{
CimSession Session3 = CimSession.Create(Data.computer3, SessionOptions);
var allUsedCore3 = Session3.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PerfFormattedData_PerfOS_Processor");
foreach (CimInstance oneUsedCore3 in allUsedCore3)
{
Int32.TryParse(String.Format("{0}", oneUsedCore3.CimInstanceProperties["PercentProcessorTime"].Value), out Data.cpu3percent);
}
labelCpu3Used.Text = Data.cpu3percent + "%";
BarCPU3.Value = Data.cpu3percent;
}
catch { Data.LoadPC3 = false; }
}
}
/// <summary>
/// Create <see cref="CimSession"/> by given computer name
/// and session options.
/// Then create wrapper object.
/// </summary>
/// <param name="computerName"></param>
/// <param name="sessionOptions"></param>
public CimSessionProxyGetCimClass(CimSession session)
: base(session)
{
}
private void AppScan(bool PC1, bool PC2, bool PC3)
{
Boolean isOn = false;
var password = new SecureString();
foreach (char c in Data.rudepassword)
{
password.AppendChar(c);
}
CimCredential Credentials = new CimCredential(PasswordAuthenticationMechanism.Default, Data.domain, Data.username, password);
WSManSessionOptions SessionOptions = new WSManSessionOptions();
SessionOptions.AddDestinationCredentials(Credentials);
if (PC1)
{
try
{
CimSession Session1 = CimSession.Create(Data.computer1, SessionOptions);
var allApp1 = Session1.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Process");
isOn = false;
foreach (CimInstance oneApp1 in allApp1)
{
if (oneApp1.CimInstanceProperties["Name"].ToString() == "Name = \"VerificationSupervision.exe\"")
{
labelApp1.Text = "Online";
buttonShowStatut1.BackColor = System.Drawing.Color.Lime;
isOn = true;
}
}
if (!isOn)
{
labelApp1.Text = "Offline";
buttonShowStatut1.BackColor = System.Drawing.Color.DarkRed;
}
}
catch { Data.LoadPC1 = false; }
}
if (PC2)
{
try
{
CimSession Session2 = CimSession.Create(Data.computer2, SessionOptions);
var allApp2 = Session2.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Process");
isOn = false;
foreach (CimInstance oneApp2 in allApp2)
{
if (oneApp2.CimInstanceProperties["Name"].ToString() == "Name = \"VerificationSupervision.exe\"")
{
labelApp2.Text = "Online";
buttonShowStatut2.BackColor = System.Drawing.Color.Lime;
isOn = true;
}
}
if (!isOn)
{
labelApp2.Text = "Offline";
buttonShowStatut2.BackColor = System.Drawing.Color.DarkRed;
}
}
catch { Data.LoadPC2 = false; }
}
if (PC3)
{
try
{
CimSession Session3 = CimSession.Create(Data.computer3, SessionOptions);
var allApp3 = Session3.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Process");
isOn = false;
foreach (CimInstance oneApp3 in allApp3)
{
if (oneApp3.CimInstanceProperties["Name"].ToString() == "Name = \"VerificationSupervision.exe\"")
{
labelApp3.Text = "Online";
buttonShowStatut3.BackColor = System.Drawing.Color.Lime;
isOn = true;
}
}
if (!isOn)
{
labelApp3.Text = "Offline";
buttonShowStatut3.BackColor = System.Drawing.Color.DarkRed;
}
}
catch { Data.LoadPC3 = false; }
}
}
/// <summary>
/// Create <see cref="CimSession"/> by given computer name
/// and session options.
/// Then create wrapper object.
/// </summary>
/// <param name="computerName"></param>
/// <param name="sessionOptions"></param>
public CimSessionProxySetCimInstance(CimSession session, bool passThru)
: base(session)
{
this.passThru = passThru;
}
private protected CimInstance GetCimInstance(CimSession ses) => ses.QueryInstances(ns, dia, query).ToArray().FirstOrDefault();
/// <summary>
/// <para>Wrapper function to remove CimSession from cache</para>
/// </summary>
/// <param name="session"></param>
/// <param name="dispose">Whether need to dispose the <see cref="CimSession"/> object</param>
private static void RemoveCimSessionFromTemporaryCache(CimSession session,
bool dispose)
{
if (null != session)
{
bool removed = false;
lock (temporarySessionCacheLock)
{
if (temporarySessionCache.ContainsKey(session))
{
temporarySessionCache[session]--;
DebugHelper.WriteLogEx(@"Decrease cimsession ref count {0}", 1, temporarySessionCache[session]);
if (temporarySessionCache[session] == 0)
{
removed = true;
temporarySessionCache.Remove(session);
}
}
}
// there is a race condition that if
// one thread is waiting to add CimSession to cache,
// while current thread is removing the CimSession,
// then invalid CimSession may be added to cache.
// Ignored this scenario in CimCmdlet implementation,
// since the code inside cimcmdlet will not hit this
// scenario anyway.
if (removed && dispose)
{
DebugHelper.WriteLogEx(@"Dispose cimsession ", 1);
session.Dispose();
}
}
}
internal void MarkSessionAsConnected(CimSession connectedSession)
{
_sessionToIsConnected.TryAdd(connectedSession, true);
}
/// <summary>
/// Create wrapper object by given session object
/// </summary>
/// <param name="session"></param>
public CimSessionProxy(CimSession session)
{
CreateSetSession(null, session, null, null, false);
}
internal bool IsSessionTerminated(CimSession session)
{
bool isTerminated = _sessionToIsTerminated.GetOrAdd(session, false);
return(isTerminated);
}
/// <summary>
/// Initialize CimSessionProxy object
/// </summary>
/// <param name="computerName"></param>
/// <param name="session"></param>
/// <param name="sessionOptions"></param>
/// <param name="options"></param>
private void CreateSetSession(
string computerName,
CimSession cimSession,
CimSessionOptions sessionOptions,
CimOperationOptions operOptions,
bool temporaryCimSession)
{
DebugHelper.WriteLogEx("computername {0}; cimsession {1}; sessionOptions {2}; operationOptions {3}.", 0, computerName, cimSession, sessionOptions, operOptions);
lock (this.stateLock)
{
this.CancelOperation = null;
this.operation = null;
}
InitOption(operOptions);
this.protocol = ProtocolType.Wsman;
this.isTemporaryCimSession = temporaryCimSession;
if (cimSession != null)
{
this.session = cimSession;
CimSessionState state = CimSessionBase.GetCimSessionState();
if (state != null)
{
CimSessionWrapper wrapper = state.QuerySession(cimSession);
if (wrapper != null)
{
this.protocol = wrapper.GetProtocolType();
}
}
}
else
{
if (sessionOptions != null)
{
if (sessionOptions is DComSessionOptions)
{
string defaultComputerName = ConstValue.IsDefaultComputerName(computerName) ? ConstValue.NullComputerName : computerName;
this.session = CimSession.Create(defaultComputerName, sessionOptions);
this.protocol = ProtocolType.Dcom;
}
else
{
this.session = CimSession.Create(computerName, sessionOptions);
}
}
else
{
this.session = CreateCimSessionByComputerName(computerName);
}
this.isTemporaryCimSession = true;
}
if (this.isTemporaryCimSession)
{
AddCimSessionToTemporaryCache(this.session);
}
this.invocationContextObject = new InvocationContext(this);
DebugHelper.WriteLog("Protocol {0}, Is temporary session ? {1}", 1, this.protocol, this.isTemporaryCimSession);
}
public static void Main()
{
bool hasComputerNameChanged = true;
CimSession cimSession = null;
CimSessionOptions sessionOptions = null;
string className = null;
string computerName = @"."; //GetName("ComputerName");
if (String.IsNullOrEmpty(computerName))
{
computerName = null;
}
string namespaceName = @"root\cimv2"; //GetName("Namespace");
CurrentOperation currentOperation = GetCurrentOption(true);
while (true)
{
if (currentOperation == CurrentOperation.OperationQuit)
{
if (cimSession != null)
{
cimSession.Close();
cimSession = null;
}
return;
}
if (ClassNeeded(currentOperation))
{
className = GetName("ClassName");
}
try
{
// Create local CIM session
if (hasComputerNameChanged)
{
if (cimSession != null)
{
cimSession.Close();
}
sessionOptions = new DComSessionOptions();
sessionOptions.Timeout = new TimeSpan(
0, // Hours
2, // Minutes
0 // Seconds
);
cimSession = CimSession.Create(computerName, sessionOptions);
hasComputerNameChanged = false;
}
switch (currentOperation)
{
case CurrentOperation.EnumerateAsync:
SampleCimOperation.EnumerateASync(cimSession, namespaceName, className);
break;
case CurrentOperation.EnumerateSync:
SampleCimOperation.EnumerateSync(cimSession, namespaceName, className);
break;
case CurrentOperation.GetInstanceSync:
SampleCimOperation.GetInstanceSync(cimSession, namespaceName, className);
break;
case CurrentOperation.GetInstanceAsync:
SampleCimOperation.GetInstanceASync(cimSession, namespaceName, className);
break;
case CurrentOperation.CreateInstanceAsync:
SampleCimOperation.CreateInstanceASync(cimSession, namespaceName, className);
break;
case CurrentOperation.CreateInstanceSync:
SampleCimOperation.CreateInstanceSync(cimSession, namespaceName, className);
break;
case CurrentOperation.DeleteInstanceAsync:
SampleCimOperation.DeleteInstanceASync(cimSession, namespaceName, className);
break;
case CurrentOperation.DeleteInstanceSync:
SampleCimOperation.DeleteInstanceSync(cimSession, namespaceName, className);
break;
case CurrentOperation.ModifyInstanceAsync:
SampleCimOperation.ModifyInstanceASync(cimSession, namespaceName, className);
break;
case CurrentOperation.ModifyInstanceSync:
SampleCimOperation.ModifyInstanceSync(cimSession, namespaceName, className);
break;
case CurrentOperation.QueryInstanceAsync:
SampleCimOperation.QueryInstanceASync(cimSession, namespaceName);
break;
case CurrentOperation.QueryInstanceSync:
SampleCimOperation.QueryInstanceSync(cimSession, namespaceName);
break;
case CurrentOperation.QueryAssociationSync:
SampleCimOperation.EnumerateAssociatedInstanceSync(cimSession, namespaceName, className);
break;
case CurrentOperation.QueryAssociationAsync:
SampleCimOperation.EnumerateAssociatedInstanceASync(cimSession, namespaceName, className);
break;
case CurrentOperation.InvokeMethodSync:
SampleCimOperation.InvokeMethodSync(cimSession, namespaceName, className);
break;
case CurrentOperation.InvokeMethodAsync:
SampleCimOperation.InvokeMethodASync(cimSession, namespaceName, className);
break;
case CurrentOperation.SubscribeSync:
SampleCimOperation.SubscribeSync(cimSession, namespaceName);
break;
case CurrentOperation.SubscribeAsync:
SampleCimOperation.SubscribeASync(cimSession, namespaceName);
break;
case CurrentOperation.OperationComputerName:
computerName = GetName("ComputerName");
if (String.IsNullOrEmpty(computerName))
{
computerName = null;
}
hasComputerNameChanged = true;
break;
case CurrentOperation.OperationNamespaceName:
namespaceName = GetName("Namespace");
break;
default:
break;
}
}
catch (CimException ex)
{
Console.WriteLine(ex.Message);
}
currentOperation = GetCurrentOption(false);
}
}
/// <summary>
/// <para>
/// Constructor with given cimsession, namespace, queryExpression and timeout
/// </para>
/// </summary>
/// <param name="cimSession"></param>
/// <param name="nameSpace"></param>
/// <param name="queryExpression"></param>
/// <param name="operationTimeout"></param>
public CimIndicationWatcher(
CimSession cimSession,
string theNamespace,
string queryDialect,
string queryExpression,
UInt32 operationTimeout)
{
ValidationHelper.ValidateNoNullorWhiteSpaceArgument(queryExpression, queryExpressionParameterName);
ValidationHelper.ValidateNoNullArgument(cimSession, cimSessionParameterName);
theNamespace = ConstValue.GetNamespace(theNamespace);
Initialize(null, cimSession, theNamespace, queryDialect, queryExpression, operationTimeout);
}
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;
}
}
/// <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>
/// Constructor
/// </para>
/// </summary>
/// <param name="session"><see cref="CimSession"/> object</param>
/// <param name="cancellationDisposable"></param>
public AsyncResultCompleteEventArgs(
CimSession session,
IObservable <object> observable) :
base(session, observable, AsyncResultType.Completion)
{
}
/// <summary>
/// <para>
/// Add new CimSession object to cache
/// </para>
/// </summary>
/// <param name="session"></param>
/// <param name="sessionId"></param>
/// <param name="instanceId"></param>
/// <param name="name"></param>
/// <returns></returns>
internal PSObject AddObjectToCache(
CimSession session,
UInt32 sessionId,
Guid instanceId,
String name,
String computerName,
ProtocolType protocol)
{
CimSessionWrapper wrapper = new CimSessionWrapper(
sessionId, instanceId, name, computerName, session, protocol);
HashSet<CimSessionWrapper> objects;
if (!this.curCimSessionsByComputerName.TryGetValue(computerName, out objects))
{
objects = new HashSet<CimSessionWrapper>();
this.curCimSessionsByComputerName.Add(computerName, objects);
}
objects.Add(wrapper);
if (!this.curCimSessionsByName.TryGetValue(name, out objects))
{
objects = new HashSet<CimSessionWrapper>();
this.curCimSessionsByName.Add(name, objects);
}
objects.Add(wrapper);
this.curCimSessionsByInstanceId.Add(instanceId, wrapper);
this.curCimSessionsById.Add(sessionId, wrapper);
this.curCimSessionWrapper.Add(session, wrapper);
return wrapper.GetPSObject();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="session"><see cref="CimSession"/> object that issued the operation</param>
/// <param name="observable">Operation that can be observed</param>
public CimResultObserver(CimSession session, IObservable <object> observable)
{
this.session = session;
this.observable = observable;
}
/// <summary>
/// <para>
/// Remove given <see cref="CimSession"/> object from partial of the cache only.
/// </para>
/// </summary>
/// <param name="session"></param>
/// <param name="psObject"></param>
private void RemoveSessionInternal(CimSession session, CimSessionWrapper wrapper)
{
DebugHelper.WriteLogEx();
this.curCimSessionsByInstanceId.Remove(wrapper.InstanceId);
this.curCimSessionsById.Remove(wrapper.SessionId);
this.curCimSessionWrapper.Remove(session);
session.Dispose();
}
/// <summary>
/// constructor
/// </summary>
/// <param name="session"></param>
/// <param name="observable"></param>
public CimSubscriptionResultObserver(CimSession session, IObservable <object> observable)
: base(session, observable)
{
}
/// <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;
UInt32 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);
}
internal static CimInstance ModifyInstanceCore(CimSession cimSession, string cimNamespace, string cimClassName)
{
CimInstance modifiedInstance = null;
ArrayList list = GetAndPrintInstances(cimSession, cimNamespace, cimClassName);
if (list == null)
{
return(modifiedInstance);
}
while (true)
{
Console.Write("Which instance do you want to modify : ");
string instanceId = Console.ReadLine();
int result;
if (String.IsNullOrEmpty(instanceId) || int.TryParse(instanceId, out result) == false || result >= list.Count)
{
Console.WriteLine("Please type the instance Id in the range {0} to {1}", 0, list.Count - 1);
}
else
{
// Modify properties
Console.WriteLine("Printing non-key properties");
var keyProperties = from p in ((CimInstance)list[result]).CimInstanceProperties
where ((p.Flags & CimFlags.Key) != CimFlags.Key)
select p;
foreach (var enumeratedProperty in keyProperties)
{
Console.WriteLine(
"Name: {0}, Type: {1}, Value: {2}",
enumeratedProperty.Name,
enumeratedProperty.CimType,
enumeratedProperty.Value);
}
string propertyName;
Console.WriteLine("Please type <Name> and <Value> for the properties to be modified. When done type '<EOL>' or press enter");
while (true)
{
Console.Write("Please type Property Name to modify: ");
propertyName = Console.ReadLine();
if (String.IsNullOrEmpty(propertyName) || propertyName.Equals("<EOL>", StringComparison.OrdinalIgnoreCase))
{
break;
}
Console.Write("Please type value for Property " + propertyName + " : ");
string propertyValue = Console.ReadLine();
((CimInstance)list[result]).CimInstanceProperties[propertyName].Value = propertyValue;
}
modifiedInstance = (CimInstance)list[result];
break;
}
}
return(modifiedInstance);
}
