/// <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 List <CimSessionProxy>(); 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); } }
internal void TestCimSession(string computerName, CimSessionProxy proxy) { DebugHelper.WriteLogEx(); base.SubscribeEventAndAddProxytoCache(proxy); proxy.TestConnectionAsync(); }
/// <summary> /// Initializes a new instance of the <see cref="RemoveCimInstanceCommand"/> class. /// </summary> public RemoveCimInstanceCommand() : base(parameters, parameterSets) { DebugHelper.WriteLogEx(); }
/// <summary> /// constructor. /// </summary> public NewCimSessionOptionCommand() : base(parameters, parameterSets) { DebugHelper.WriteLogEx(); }
/// <summary> /// Create WSMANSessionOptions. /// </summary> /// <returns></returns> internal WSManSessionOptions CreateWSMANSessionOptions() { WSManSessionOptions wsmanoptions = new WSManSessionOptions(); if (this.noEncryptionSet) { wsmanoptions.NoEncryption = true; this.noEncryptionSet = false; } else { wsmanoptions.NoEncryption = false; } if (this.skipCACheckSet) { wsmanoptions.CertCACheck = false; this.skipCACheckSet = false; } else { wsmanoptions.CertCACheck = true; } if (this.skipCNCheckSet) { wsmanoptions.CertCNCheck = false; this.skipCNCheckSet = false; } else { wsmanoptions.CertCNCheck = true; } if (this.skipRevocationCheckSet) { wsmanoptions.CertRevocationCheck = false; this.skipRevocationCheckSet = false; } else { wsmanoptions.CertRevocationCheck = true; } if (this.encodeportinserviceprincipalnameSet) { wsmanoptions.EncodePortInServicePrincipalName = this.EncodePortInServicePrincipalName; this.encodeportinserviceprincipalnameSet = false; } else { wsmanoptions.EncodePortInServicePrincipalName = false; } if (this.encodingSet) { wsmanoptions.PacketEncoding = this.Encoding; } else { wsmanoptions.PacketEncoding = PacketEncoding.Utf8; } if (this.HttpPrefix != null) { wsmanoptions.HttpUrlPrefix = this.HttpPrefix; } if (this.maxenvelopesizekbSet) { wsmanoptions.MaxEnvelopeSize = this.MaxEnvelopeSizeKB; } else { wsmanoptions.MaxEnvelopeSize = 0; } if (!string.IsNullOrWhiteSpace(this.ProxyCertificateThumbprint)) { CimCredential credentials = new CimCredential(CertificateAuthenticationMechanism.Default, this.ProxyCertificateThumbprint); wsmanoptions.AddProxyCredentials(credentials); } if (this.proxyauthenticationSet) { this.proxyauthenticationSet = false; DebugHelper.WriteLogEx("create credential", 1); CimCredential credentials = CreateCimCredentials(this.ProxyCredential, this.ProxyAuthentication, @"New-CimSessionOption", @"ProxyAuthentication"); if (credentials != null) { try { DebugHelper.WriteLogEx("Add proxy credential", 1); wsmanoptions.AddProxyCredentials(credentials); } catch (Exception ex) { DebugHelper.WriteLogEx(ex.ToString(), 1); throw ex; } } } if (this.proxytypeSet) { wsmanoptions.ProxyType = this.ProxyType; this.proxytypeSet = false; } else { wsmanoptions.ProxyType = Options.ProxyType.WinHttp; } if (this.usesslSet) { wsmanoptions.UseSsl = this.UseSsl; this.usesslSet = false; } else { wsmanoptions.UseSsl = false; } wsmanoptions.DestinationPort = 0; return(wsmanoptions); }
/// <summary> /// Override the OnNext method. /// </summary> /// <param name="value"></param> public override void OnNext(CimSubscriptionResult value) { DebugHelper.WriteLogEx(); base.OnNextCore(value); }
/// <summary> /// Override the OnNext method. /// </summary> /// <param name="value"></param> public override void OnNext(CimInstance value) { DebugHelper.WriteLogEx(); }
/// <summary> /// constructor. /// </summary> public GetCimClassCommand() : base(parameters, parameterSets) { DebugHelper.WriteLogEx(); }
/// <summary> /// Get the parameter set name based on current binding results. /// </summary> /// <returns></returns> internal string GetParameterSet() { DebugHelper.WriteLogEx(); string boundParameterSetName = null; string defaultParameterSetName = null; List <string> noMandatoryParameterSet = new List <string>(); // Looking for parameter set which have mandatory parameters foreach (string parameterSetName in this.parameterSetEntries.Keys) { ParameterSetEntry entry = this.parameterSetEntries[parameterSetName]; DebugHelper.WriteLogEx( "parameterset name = {0}, {1}/{2} mandatory parameters.", 1, parameterSetName, entry.SetMandatoryParameterCount, entry.MandatoryParameterCount); // Ignore the parameter set which has no mandatory parameter firstly if (entry.MandatoryParameterCount == 0) { if (entry.IsDefaultParameterSet) { defaultParameterSetName = parameterSetName; } if (entry.IsValueSet) { noMandatoryParameterSet.Add(parameterSetName); } continue; } if ((entry.SetMandatoryParameterCount == entry.MandatoryParameterCount) && this.parametersetNamesList.Contains(parameterSetName)) { if (boundParameterSetName != null) { throw new PSArgumentException(CimCmdletStrings.UnableToResolveParameterSetName); } boundParameterSetName = parameterSetName; } } // Looking for parameter set which has no mandatory parameters if (boundParameterSetName == null) { // throw if there are > 1 parameter set if (noMandatoryParameterSet.Count > 1) { throw new PSArgumentException(CimCmdletStrings.UnableToResolveParameterSetName); } else if (noMandatoryParameterSet.Count == 1) { boundParameterSetName = noMandatoryParameterSet[0]; } } // Looking for default parameter set if (boundParameterSetName == null) { boundParameterSetName = defaultParameterSetName; } // throw if still can not find the parameter set name if (boundParameterSetName == null) { throw new PSArgumentException(CimCmdletStrings.UnableToResolveParameterSetName); } return(boundParameterSetName); }
/// <summary> /// <para> /// A given parameter's value was set by cmdlet caller, /// check and change the status of parameter set, /// throw exception if confliction occurred /// </para> /// </summary> /// <param name="parameterName"></param> /// <exception cref="PSArgumentException">Throw if conflict parameter was set.</exception> internal void SetParameter(string parameterName, bool isBeginProcess) { DebugHelper.WriteLogEx("ParameterName = {0}, isBeginProcess = {1}", 0, parameterName, isBeginProcess); if (this.parameterNamesList.Contains(parameterName)) { DebugHelper.WriteLogEx("ParameterName {0} is already bound ", 1, parameterName); return; } else { this.parameterNamesList.Add(parameterName); if (isBeginProcess) { this.parameterNamesListAtBeginProcess.Add(parameterName); } } if (this.parametersetNamesList.Count == 0) { List <string> nameset = new List <string>(); foreach (ParameterDefinitionEntry parameterDefinitionEntry in this.parameterDefinitionEntries[parameterName]) { DebugHelper.WriteLogEx("parameterset name = '{0}'; mandatory = '{1}'", 1, parameterDefinitionEntry.ParameterSetName, parameterDefinitionEntry.IsMandatory); ParameterSetEntry psEntry = this.parameterSetEntries[parameterDefinitionEntry.ParameterSetName]; if (psEntry == null) { continue; } if (parameterDefinitionEntry.IsMandatory) { psEntry.SetMandatoryParameterCount++; if (isBeginProcess) { psEntry.SetMandatoryParameterCountAtBeginProcess++; } DebugHelper.WriteLogEx("parameterset name = '{0}'; SetMandatoryParameterCount = '{1}'", 1, parameterDefinitionEntry.ParameterSetName, psEntry.SetMandatoryParameterCount); } if (!psEntry.IsValueSet) { psEntry.IsValueSet = true; if (isBeginProcess) { psEntry.IsValueSetAtBeginProcess = true; } } nameset.Add(parameterDefinitionEntry.ParameterSetName); } this.parametersetNamesList = nameset; if (isBeginProcess) { this.parametersetNamesListAtBeginProcess = nameset; } } else { List <string> nameset = new List <string>(); foreach (ParameterDefinitionEntry entry in this.parameterDefinitionEntries[parameterName]) { if (this.parametersetNamesList.Contains(entry.ParameterSetName)) { nameset.Add(entry.ParameterSetName); if (entry.IsMandatory) { ParameterSetEntry psEntry = this.parameterSetEntries[entry.ParameterSetName]; psEntry.SetMandatoryParameterCount++; if (isBeginProcess) { psEntry.SetMandatoryParameterCountAtBeginProcess++; } DebugHelper.WriteLogEx("parameterset name = '{0}'; SetMandatoryParameterCount = '{1}'", 1, entry.ParameterSetName, psEntry.SetMandatoryParameterCount); } } } if (nameset.Count == 0) { throw new PSArgumentException(CimCmdletStrings.UnableToResolveParameterSetName); } else { this.parametersetNamesList = nameset; if (isBeginProcess) { this.parametersetNamesListAtBeginProcess = nameset; } } } }
/// <summary> /// <para> /// Create <see cref="CimMethodParametersCollection"/> with given key properties. /// And/or <see cref="CimClass"/> object. /// </para> /// </summary> /// <param name="parameters"></param> /// <param name="cimClass"></param> /// <param name="cimInstance"></param> /// <param name="methodName"></param> /// <returns></returns> /// <exception cref="ArgumentNullException">See CimProperty.Create.</exception> /// <exception cref="ArgumentException">CimProperty.Create.</exception> private CimMethodParametersCollection CreateParametersCollection( IDictionary parameters, CimClass cimClass, CimInstance cimInstance, string methodName) { DebugHelper.WriteLogEx(); CimMethodParametersCollection collection = null; if (parameters == null) { return(collection); } else if (parameters.Count == 0) { return(collection); } collection = new CimMethodParametersCollection(); IDictionaryEnumerator enumerator = parameters.GetEnumerator(); while (enumerator.MoveNext()) { string parameterName = enumerator.Key.ToString(); CimFlags parameterFlags = CimFlags.In; object parameterValue = GetBaseObject(enumerator.Value); DebugHelper.WriteLog(@"Create parameter name= {0}, value= {1}, flags= {2}.", 4, parameterName, parameterValue, parameterFlags); CimMethodParameter parameter = null; CimMethodDeclaration declaration = null; string className = null; if (cimClass != null) { className = cimClass.CimSystemProperties.ClassName; declaration = cimClass.CimClassMethods[methodName]; if (declaration == null) { throw new ArgumentException(string.Format( CultureInfo.CurrentUICulture, Strings.InvalidMethod, methodName, className)); } } else if (cimInstance != null) { className = cimInstance.CimClass.CimSystemProperties.ClassName; declaration = cimInstance.CimClass.CimClassMethods[methodName]; } if (declaration != null) { CimMethodParameterDeclaration paramDeclaration = declaration.Parameters[parameterName]; if (paramDeclaration == null) { throw new ArgumentException(string.Format( CultureInfo.CurrentUICulture, Strings.InvalidMethodParameter, parameterName, methodName, className)); } parameter = CimMethodParameter.Create( parameterName, parameterValue, paramDeclaration.CimType, parameterFlags); // FIXME: check in/out qualifier // parameterFlags = paramDeclaration.Qualifiers; } else { if (parameterValue == null) { // try the best to get the type while value is null parameter = CimMethodParameter.Create( parameterName, parameterValue, CimType.String, parameterFlags); } else { CimType referenceType = CimType.Unknown; object referenceObject = GetReferenceOrReferenceArrayObject(parameterValue, ref referenceType); if (referenceObject != null) { parameter = CimMethodParameter.Create( parameterName, referenceObject, referenceType, parameterFlags); } else { parameter = CimMethodParameter.Create( parameterName, parameterValue, parameterFlags); } } } if (parameter != null) { collection.Add(parameter); } } return(collection); }
/// <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; } }