private CimInstance CreateCimInstance(CimClass cimClass, IDictionary properties, NewCimInstanceCommand cmdlet)
{
CimInstance cimInstance;
CimInstance cimInstance1 = new CimInstance(cimClass);
if (properties != null)
{
List<string> strs = new List<string>();
IEnumerator enumerator = properties.Keys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
string current = (string)enumerator.Current;
if (cimInstance1.CimInstanceProperties[current] != null)
{
object baseObject = base.GetBaseObject(properties[current]);
cimInstance1.CimInstanceProperties[current].Value = baseObject;
}
else
{
strs.Add(current);
cmdlet.ThrowInvalidProperty(strs, cmdlet.CimClass.CimSystemProperties.ClassName, "Property", "New-CimInstance", properties);
cimInstance = null;
return cimInstance;
}
}
return cimInstance1;
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
return cimInstance;
}
else
{
return cimInstance1;
}
}
/// <summary>
/// Instantiates an empty <see cref="CimInstance"/>.
/// </summary>
/// <param name="cimClass"></param>
/// <exception cref="ArgumentException">Thrown when <paramref name="cimClass"/> is null or when it doesn't follow the format specified by DSP0004</exception>
public CimInstance(CimClass cimClass)
{
if (cimClass == null)
{
throw new ArgumentNullException("cimClass");
}
MI_Instance tmpHandle;
MI_Result result = CimApplication.Handle.NewInstanceFromClass(cimClass.CimSystemProperties.ClassName, cimClass.ClassHandle, out tmpHandle);
if (result == MI_Result.MI_RESULT_INVALID_PARAMETER)
{
throw new ArgumentOutOfRangeException("cimClass");
}
CimException.ThrowIfMiResultFailure(result);
result = tmpHandle.SetNameSpace(cimClass.CimSystemProperties.Namespace);
CimException.ThrowIfMiResultFailure(result);
result = tmpHandle.SetServerName(cimClass.CimSystemProperties.ServerName);
CimException.ThrowIfMiResultFailure(result);
this.nativeInstance = tmpHandle;
}
public CimInstance(CimClass cimClass)
{
InstanceHandle instanceHandle = null;
this._CimSessionInstanceID = Guid.Empty;
if (cimClass != null)
{
MiResult miResult = ApplicationMethods.NewInstance(CimApplication.Handle, cimClass.CimSystemProperties.ClassName, cimClass.ClassHandle, out instanceHandle);
if (miResult != MiResult.INVALID_PARAMETER)
{
CimException.ThrowIfMiResultFailure(miResult);
this._myHandle = new SharedInstanceHandle(instanceHandle);
miResult = InstanceMethods.SetNamespace(this._myHandle.Handle, cimClass.CimSystemProperties.Namespace);
CimException.ThrowIfMiResultFailure(miResult);
miResult = InstanceMethods.SetServerName(this._myHandle.Handle, cimClass.CimSystemProperties.ServerName);
CimException.ThrowIfMiResultFailure(miResult);
return;
}
else
{
throw new ArgumentOutOfRangeException("cimClass");
}
}
else
{
throw new ArgumentNullException("cimClass");
}
}
internal ClassHandle DeserializeClassHandle (byte[] serializedData, ref int offset, CimClass parentClass, string computerName, string namespaceName)
{
return null;
}
private CimMethodParametersCollection CreateParametersCollection(IDictionary parameters, CimClass cimClass, CimInstance cimInstance, string methodName)
{
DebugHelper.WriteLogEx();
CimMethodParametersCollection cimMethodParametersCollection = null;
if (parameters != null)
{
if (parameters.Count != 0)
{
cimMethodParametersCollection = new CimMethodParametersCollection();
IDictionaryEnumerator enumerator = parameters.GetEnumerator();
while (enumerator.MoveNext())
{
string str = enumerator.Key.ToString();
CimFlags cimFlag = CimFlags.In;
object baseObject = base.GetBaseObject(enumerator.Value);
object[] objArray = new object[3];
objArray[0] = str;
objArray[1] = baseObject;
objArray[2] = cimFlag;
DebugHelper.WriteLog("Create parameter name= {0}, value= {1}, flags= {2}.", 4, objArray);
CimMethodParameter cimMethodParameter = null;
CimMethodDeclaration item = null;
string className = null;
if (cimClass == null)
{
if (cimInstance != null)
{
className = cimInstance.CimClass.CimSystemProperties.ClassName;
item = cimInstance.CimClass.CimClassMethods[methodName];
}
}
else
{
className = cimClass.CimSystemProperties.ClassName;
item = cimClass.CimClassMethods[methodName];
if (item == null)
{
object[] objArray1 = new object[2];
objArray1[0] = methodName;
objArray1[1] = className;
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, Strings.InvalidMethod, objArray1));
}
}
if (item == null)
{
if (baseObject != null)
{
CimType cimType = CimType.Unknown;
object referenceOrReferenceArrayObject = base.GetReferenceOrReferenceArrayObject(baseObject, ref cimType);
if (referenceOrReferenceArrayObject == null)
{
cimMethodParameter = CimMethodParameter.Create(str, baseObject, cimFlag);
}
else
{
cimMethodParameter = CimMethodParameter.Create(str, referenceOrReferenceArrayObject, cimType, cimFlag);
}
}
else
{
cimMethodParameter = CimMethodParameter.Create(str, baseObject, CimType.String, cimFlag);
}
}
else
{
CimMethodParameterDeclaration cimMethodParameterDeclaration = item.Parameters[str];
if (cimMethodParameterDeclaration != null)
{
cimMethodParameter = CimMethodParameter.Create(str, baseObject, cimMethodParameterDeclaration.CimType, cimFlag);
}
else
{
object[] objArray2 = new object[3];
objArray2[0] = str;
objArray2[1] = methodName;
objArray2[2] = className;
throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, Strings.InvalidMethodParameter, objArray2));
}
}
if (cimMethodParameter == null)
{
continue;
}
cimMethodParametersCollection.Add(cimMethodParameter);
}
return cimMethodParametersCollection;
}
else
{
return cimMethodParametersCollection;
}
}
else
{
return cimMethodParametersCollection;
}
}
public CimClass DeserializeClass(byte[] serializedData, ref int offset, CimClass parentClass)
{
return this.DeserializeClass(serializedData, ref offset, parentClass, null, null);
}
public CimClass DeserializeClass(byte[] serializedData, ref int offset, CimClass parentClass, string computerName, string namespaceName)
{
ClassHandle classHandle = this.DeserializeClassHandle(serializedData, ref offset, parentClass, computerName, namespaceName);
return new CimClass(classHandle);
}
private static bool IsSameNestedObject(CimClass oldClass, CimClass newClass)
{
// #1 both the classes should be nested class and not DSC resource
if ((oldClass.CimSuperClassName != null && string.Equals("OMI_BaseResource", oldClass.CimSuperClassName, StringComparison.OrdinalIgnoreCase)) ||
(newClass.CimSuperClassName != null && string.Equals("OMI_BaseResource", newClass.CimSuperClassName, StringComparison.OrdinalIgnoreCase)))
{
return false;
}
// #2 qualifier count, names, values and types should be same
if (!AreQualifiersSame(oldClass.CimClassQualifiers, newClass.CimClassQualifiers))
{
return false;
}
// #3 property count, names, values, qualifiers and types should be same
if (!ArePropertiesSame(oldClass.CimClassProperties, newClass.CimClassProperties))
{
return false;
}
return true;
}
private static string GetFriendlyName(CimClass cimClass)
{
try
{
var aliasQualifier = cimClass.CimClassQualifiers["FriendlyName"];
if (aliasQualifier != null)
{
return aliasQualifier.Value as string;
}
}
catch (Microsoft.Management.Infrastructure.CimException)
{
//exception means no DSCAlias
}
return null;
}
private static MiResult ValidateExportedCommandParameters(
CimClass resourceClass,
PSModuleInfo moduleInfo,
out UInt32 getActionStatusCode,
out ErrorRecord errorRecord)
{
// Get key and write parameter data from MOF schema.
List<CimPropertyDeclaration> keyProperties;
List<CimPropertyDeclaration> writeProperties;
List<CimPropertyDeclaration> requiredProperties;
Utility.GetKeyWriteRequiredProperties(resourceClass, out keyProperties, out writeProperties, out requiredProperties);
// Validate Get command against key parameters.
string moduleName = moduleInfo.Name;
CommandInfo cmdInfo = moduleInfo.ExportedCommands[PsDscCmdletGet];
MiResult result = ValidateCommandParameters(cmdInfo, keyProperties, moduleName, out getActionStatusCode, out errorRecord);
if (result != MiResult.OK) { return result; }
// Validate Set command against key and write parameters.
cmdInfo = moduleInfo.ExportedCommands[PsDscCmdletSet];
result = ValidateCommandParameters(cmdInfo, keyProperties, moduleName, out getActionStatusCode, out errorRecord);
if (result != MiResult.OK) { return result; }
result = ValidateCommandParameters(cmdInfo, writeProperties, moduleName, out getActionStatusCode, out errorRecord);
if (result != MiResult.OK) { return result; }
// Validate Test command against key and write parameters.
cmdInfo = moduleInfo.ExportedCommands[PsDscCmdletTest];
result = ValidateCommandParameters(cmdInfo, keyProperties, moduleName, out getActionStatusCode, out errorRecord);
if (result != MiResult.OK) { return result; }
return ValidateCommandParameters(cmdInfo, writeProperties, moduleName, out getActionStatusCode, out errorRecord);
}
public byte[] Serialize(CimClass cimClass, ClassSerializationOptions options)
{
unsafe
{
if (cimClass != null)
{
this.AssertNotDisposed();
int num = 0;
this.Serialize(cimClass, options, null, ref num);
byte[] numArray = new byte[num];
int num1 = 0;
this.Serialize(cimClass, options, numArray, ref num1);
return numArray;
}
else
{
throw new ArgumentNullException("cimClass");
}
}
}
public bool Serialize(CimClass cimClass, ClassSerializationOptions options, byte[] buffer, ref int offset)
{
int num = 0;
if (cimClass != null)
{
if (buffer != null)
{
if ((long)offset <= (long)((int)buffer.Length))
{
if ((long)offset == (long)((int)buffer.Length))
{
buffer = null;
}
}
else
{
throw new ArgumentOutOfRangeException("offset");
}
}
else
{
if (offset != 0)
{
throw new ArgumentNullException("buffer");
}
}
this.AssertNotDisposed();
bool flag = true;
MiResult miResult = MiResult.OK; //TODO: // SerializerMethods.SerializeClass(this._myHandle, options, cimClass.ClassHandle, buffer, offset, out num);
MiResult miResult1 = miResult;
switch (miResult1)
{
case MiResult.OK:
{
offset = offset + num;
flag = true;
return flag;
}
case MiResult.FAILED:
{
if (buffer == null || (long)(offset + num) > (long)((int)buffer.Length))
{
miResult = MiResult.OK;
offset = offset + num;
}
flag = false;
return flag;
}
}
CimException.ThrowIfMiResultFailure(miResult);
return flag;
}
else
{
throw new ArgumentNullException("cimClass");
}
}
