internal override MI_Result NativeMoveNext(MI_Operation operationHandle, out CimClass currentItem,
out bool moreResults, out MI_Result operationResult,
out string errorMessage, out MI_Instance errorDetailsHandle)
{
Debug.Assert(operationHandle != null, "Caller should verify operationHandle != null");
currentItem = null;
MI_Class classHandle;
MI_Result functionResult = operationHandle.GetClass(
out classHandle,
out moreResults,
out operationResult,
out errorMessage,
out errorDetailsHandle);
if ((classHandle != null) && !classHandle.IsNull)
{
if (!this.ShortenLifetimeOfResults)
{
classHandle = classHandle.Clone();
}
currentItem = new CimClass(classHandle);
}
return(functionResult);
}
internal static MI_Class GetSerializableTestClass()
{
MI_Operation queryOperation;
StaticFixtures.Session.GetClass(MI_OperationFlags.Default, null, SerializableClassNamespace, SerializableClassClassname, null, out queryOperation);
MI_Class classResult;
MI_Result operationResult;
bool moreResults;
string errorMessage;
MI_Instance completionDetails;
MI_Result res = queryOperation.GetClass(out classResult, out moreResults, out operationResult, out errorMessage, out completionDetails);
MIAssert.Succeeded(res);
MIAssert.Succeeded(operationResult);
Assert.False(moreResults);
MI_Class clonedClass;
res = classResult.Clone(out clonedClass);
MIAssert.Succeeded(res);
queryOperation.Close();
return(clonedClass);
}
internal MI_Result GetElementAt(
UInt32 index,
out string name,
out MI_Value value,
out bool valueExists,
out MI_Type type,
out string referenceClass,
out MI_QualifierSet qualifierSet,
out MI_Flags flags
)
{
MI_String nameLocal = MI_String.NewIndirectPtr();
MI_String referenceClassLocal = MI_String.NewIndirectPtr();
MI_Value valueLocal = new MI_Value();
MI_QualifierSet qualifierSetLocal = MI_QualifierSet.NewDirectPtr();
MI_Result resultLocal = this.ft.GetElementAt(this,
index,
nameLocal,
valueLocal,
out valueExists,
out type,
referenceClassLocal,
qualifierSetLocal,
out flags);
name = nameLocal.Value;
referenceClass = referenceClassLocal.Value;
value = valueLocal;
qualifierSet = qualifierSetLocal;
return(resultLocal);
}
internal MI_Result DeserializeClass(
MI_SerializerFlags flags,
IntPtr serializedBuffer,
UInt32 serializedBufferLength,
MI_Class parentClass,
string serverName,
string namespaceName,
IntPtr classObjectNeeded,
IntPtr classObjectNeededContext,
out UInt32 serializedBufferRead,
out MI_Class classObject,
out MI_Instance cimErrorDetails
)
{
MI_Class classObjectLocal = MI_Class.NewIndirectPtr();
MI_Instance cimErrorDetailsLocal = MI_Instance.NewIndirectPtr();
MI_Result resultLocal = this.commonFT.DeserializeClass(this,
flags,
serializedBuffer,
serializedBufferLength,
parentClass,
serverName,
namespaceName,
classObjectNeeded,
classObjectNeededContext,
out serializedBufferRead,
classObjectLocal,
cimErrorDetailsLocal);
classObject = classObjectLocal;
cimErrorDetails = cimErrorDetailsLocal;
return(resultLocal);
}
internal MI_Result NewSession(
string protocol,
string destination,
MI_DestinationOptions options,
MI_SessionCreationCallbacks callbacks,
out MI_Instance extendedError,
out MI_Session session
)
{
if (callbacks != null)
{
throw new NotImplementedException();
}
MI_Instance extendedErrorLocal = MI_Instance.NewIndirectPtr();
MI_Session sessionLocal = MI_Session.NewDirectPtr();
MI_Result resultLocal = this.ft.NewSession(this,
protocol,
destination,
options,
null,
extendedErrorLocal,
sessionLocal);
extendedError = extendedErrorLocal;
session = sessionLocal;
return(resultLocal);
}
public void BadHost()
{
MI_Session badSession;
MI_Instance extendedError = null;
MI_Result res = StaticFixtures.Application.NewSession(null,
"badhost",
MI_DestinationOptions.Null,
MI_SessionCreationCallbacks.Null,
out extendedError,
out badSession);
MIAssert.Succeeded(res, "Expect simple NewSession to succeed");
MI_Operation operation = null;
badSession.TestConnection(0, null, out operation);
bool moreResults;
MI_Result result;
string errorMessage = null;
MI_Instance instance = null;
MI_Instance errorDetails = null;
res = operation.GetInstance(out instance, out moreResults, out result, out errorMessage, out errorDetails);
MIAssert.Succeeded(res, "Expect the GetInstance operation to succeed");
MIAssert.Failed(result, "Expect the actual retrieval to fail");
Assert.True(!String.IsNullOrEmpty(errorMessage), "Expect error message to be available");
res = operation.Close();
MIAssert.Succeeded(res, "Expect to be able to close operation now");
res = badSession.Close(IntPtr.Zero, null);
MIAssert.Succeeded(res, "Expect to be able to close the bad session");
}
internal MI_Result GetIndication(
out MI_Instance instance,
out string bookmark,
out string machineID,
out bool moreResults,
out MI_Result result,
out string errorMessage,
out MI_Instance completionDetails
)
{
MI_Instance instanceLocal = MI_Instance.NewIndirectPtr();
MI_String bookmarkLocal = MI_String.NewIndirectPtr();
MI_String machineIDLocal = MI_String.NewIndirectPtr();
MI_String errorMessageLocal = MI_String.NewIndirectPtr();
MI_Instance completionDetailsLocal = MI_Instance.NewIndirectPtr();
MI_Result resultLocal = this.ft.GetIndication(this,
instanceLocal,
bookmarkLocal,
machineIDLocal,
out moreResults,
out result,
errorMessageLocal,
completionDetailsLocal);
instance = instanceLocal;
bookmark = bookmarkLocal.Value;
machineID = machineIDLocal.Value;
errorMessage = errorMessageLocal.Value;
completionDetails = completionDetailsLocal;
return(resultLocal);
}
internal MI_Result SerializeClass(
MI_SerializerFlags flags,
MI_Class classObject,
out byte[] clientBuffer
)
{
clientBuffer = null;
UInt32 spaceNeeded = 0;
MI_Result resultLocal = this.ft.SerializeClass(this,
flags,
classObject,
IntPtr.Zero,
0,
out spaceNeeded);
if (resultLocal == MI_Result.MI_RESULT_OK || (resultLocal == MI_Result.MI_RESULT_FAILED && spaceNeeded != 0))
{
UInt32 spaceUsed;
IntPtr clientBufferLocal = Marshal.AllocHGlobal((IntPtr)spaceNeeded);
resultLocal = this.ft.SerializeClass(this,
flags,
classObject,
clientBufferLocal,
spaceNeeded,
out spaceUsed);
if (clientBufferLocal != IntPtr.Zero)
{
clientBuffer = new byte[spaceNeeded];
Marshal.Copy(clientBufferLocal, clientBuffer, 0, (int)spaceNeeded);
Marshal.FreeHGlobal(clientBufferLocal);
}
}
return(resultLocal);
}
internal void ClassCallback(
CimOperationCallbackProcessingContext callbackProcessingContext,
MI_Operation operationHandle,
MI_Class ClassHandle,
bool moreResults,
MI_Result operationResult,
String errorMessage,
MI_Instance errorDetailsHandle)
{
CimClass currentItem = null;
if ((ClassHandle != null) && (!ClassHandle.IsNull))
{
if (!_shortenLifetimeOfResults)
{
ClassHandle = ClassHandle.Clone();
}
currentItem = new CimClass(ClassHandle);
}
try
{
this.ProcessNativeCallback(callbackProcessingContext, currentItem, moreResults, operationResult, errorMessage, errorDetailsHandle);
}
finally
{
if (_shortenLifetimeOfResults)
{
if (currentItem != null)
{
currentItem.Dispose();
}
}
}
}
internal override MI_Result NativeMoveNext(MI_Operation operationHandle, out CimSubscriptionResult currentItem,
out bool moreResults, out MI_Result operationResult,
out string errorMessage, out MI_Instance errorDetailsHandle)
{
Debug.Assert(operationHandle != null, "Caller should verify operationHandle != null");
currentItem = null;
MI_Instance instanceHandle;
string bookmark;
string machineID;
MI_Result functionResult = operationHandle.GetIndication(
out instanceHandle,
out bookmark,
out machineID,
out moreResults,
out operationResult,
out errorMessage,
out errorDetailsHandle);
if ((instanceHandle != null) && !instanceHandle.IsNull)
{
if (!this.ShortenLifetimeOfResults)
{
instanceHandle = instanceHandle.Clone();
}
currentItem = new CimSubscriptionResult(instanceHandle, bookmark, machineID);
}
return(functionResult);
}
internal abstract MI_Result NativeMoveNext(
MI_Operation operationHandle,
out T currentItem,
out bool moreResults,
out MI_Result operationResult,
out string errorMessage,
out MI_Instance errorDetailsHandle);
internal override MI_Result NativeMoveNext(MI_Operation operationHandle, out CimInstance currentItem, out bool moreResults, out MI_Result operationResult, out string errorMessage, out MI_Instance errorDetailsHandle)
{
Debug.Assert(operationHandle != null, "Caller should verify operationHandle != null");
currentItem = null;
MI_Instance instanceHandle;
MI_Result functionResult = operationHandle.GetInstance(
out instanceHandle,
out moreResults,
out operationResult,
out errorMessage,
out errorDetailsHandle);
if ((instanceHandle != null) && !instanceHandle.IsNull)
{
if (!this.ShortenLifetimeOfResults)
{
instanceHandle = instanceHandle.Clone();
}
currentItem = new CimInstance(instanceHandle);
currentItem.SetCimSessionComputerName(this._CimSessionComputerName);
currentItem.SetCimSessionInstanceId(this._CimSessionInstanceID);
}
return(functionResult);
}
static private string GetExceptionMessage(MI_Result errorCode, string errorMessage, MI_Instance errorDetailsHandle)
{
string result;
// first check if CIM_Error provided an error message
result = GetExceptionMessage(errorDetailsHandle);
if (!string.IsNullOrEmpty(result))
{
return(result);
}
// if the above failed, then use MI_Utilities_CimErrorFromErrorCode to get a good CIM_Error
// TODO: Add GetCimErrorFromMiResult to MI API
//Native.ApplicationMethods.GetCimErrorFromMiResult(errorCode, errorMessage, out errorDetailsHandle);
try
{
result = GetExceptionMessage(errorDetailsHandle);
if (!string.IsNullOrEmpty(result))
{
return(result);
}
}
finally
{
if (errorDetailsHandle != null)
{
errorDetailsHandle.Delete();
}
}
// if everything fails, then return a non-localized errorCode
return(errorCode.ToString());
}
public override CimProperty this[string propertyName]
{
get
{
if (string.IsNullOrWhiteSpace(propertyName))
{
throw new ArgumentNullException("propertyName");
}
MI_Value value;
MI_Type type;
MI_Flags flags;
UInt32 index;
MI_Result result = this._instance.InstanceHandle.GetElement(propertyName,
out value,
out type,
out flags,
out index);
switch (result)
{
case MI_Result.MI_RESULT_NO_SUCH_PROPERTY:
return(null);
default:
CimException.ThrowIfMiResultFailure(result);
return(new CimPropertyOfInstance(this._instance, (int)index));
}
}
}
/// <summary>
/// Instantiates an empty <see cref="CimInstance"/>.
/// </summary>
/// <remarks>
/// This constructor provides a way to create CIM instances, without communicating with a CIM server.
/// This constructor is typically used when the client knows all the key properties (<see cref="CimFlags.Key"/>)
/// of the instance and wants to pass the instance as an argument of a CimSession method
/// (for example as a "sourceInstance" parameter of <see cref="CimSession.EnumerateAssociatedInstances(string, CimInstance, string, string, string, string)"/>).
/// <see cref="CimSession.EnumerateInstances(string,string)"/> or <see cref="CimSession.GetInstance(string, CimInstance)"/>.
/// </remarks>
/// <param name="className"></param>
/// <exception cref="ArgumentException">Thrown when <paramref name="className"/> is null or when it doesn't follow the format specified by DSP0004</exception>
public CimInstance(string className, string namespaceName)
{
if (className == null)
{
throw new ArgumentNullException("className");
}
MI_Instance tmpHandle;
MI_Result result = CimApplication.Handle.NewInstance(className, null, out tmpHandle);
if (result == MI_Result.MI_RESULT_INVALID_PARAMETER)
{
throw new ArgumentOutOfRangeException("className");
}
CimException.ThrowIfMiResultFailure(result);
if (namespaceName != null)
{
result = tmpHandle.SetNameSpace(namespaceName);
CimException.ThrowIfMiResultFailure(result);
}
this.nativeInstance = tmpHandle;
}
internal CimSessionOptions(CimSessionOptions optionsToClone)
{
if (optionsToClone == null)
{
throw new ArgumentNullException("optionsToClone");
}
this.Protocol = optionsToClone.Protocol;
if (optionsToClone.DestinationOptionsHandle == null)
{
// underline DestinationOptions is not created yet, then create a new one
this._destinationOptionsHandle = new Lazy <MI_DestinationOptions>(
delegate
{
MI_DestinationOptions tmp;
MI_Result result = CimApplication.Handle.NewDestinationOptions(out tmp);
CimException.ThrowIfMiResultFailure(result);
return(tmp);
});
}
else
{
MI_DestinationOptions tmp;
MI_Result result = optionsToClone.DestinationOptionsHandle.Clone(out tmp);
CimException.ThrowIfMiResultFailure(result);
this._destinationOptionsHandle = new Lazy <MI_DestinationOptions>(() => tmp);
}
// Ensure the destinationOptions is created
if (this.DestinationOptionsHandleOnDemand == null)
{
CimException.ThrowIfMiResultFailure(MI_Result.MI_RESULT_FAILED);
}
}
public override CimMethodDeclaration this[string methodName]
{
get
{
if (string.IsNullOrWhiteSpace(methodName))
{
throw new ArgumentNullException("methodName");
}
MI_QualifierSet qualifierSet;
MI_ParameterSet parameterSet;
UInt32 index;
MI_Result result = this.classHandle.GetMethod(methodName,
out qualifierSet,
out parameterSet,
out index);
switch (result)
{
case MI_Result.MI_RESULT_METHOD_NOT_FOUND:
return(null);
default:
CimException.ThrowIfMiResultFailure(result);
return(new CimMethodDeclarationOfClass(this.classHandle, (int)index));
}
}
}
private void Initialize(CimSubscriptionDeliveryType types)
{
MI_SubscriptionDeliveryOptions tmp;
MI_Result result = CimApplication.Handle.NewSubscriptionDeliveryOptions((MI_SubscriptionDeliveryType)types, out tmp);
CimException.ThrowIfMiResultFailure(result);
this._subscriptionDeliveryOptionsHandle = tmp;
}
internal MI_Result SetServerName(
string name
)
{
MI_Result resultLocal = this.ft.SetServerName(this,
name);
return(resultLocal);
}
internal MI_Result GetCredentialsCount(
out UInt32 count
)
{
MI_Result resultLocal = this.ft.GetCredentialsCount(this,
out count);
return(resultLocal);
}
internal static void ThrowIfMiResultFailure(MI_Result result, string errorMessage, MI_Instance errorData)
{
CimException exception = GetExceptionIfMiResultFailure(result, errorMessage, errorData);
if (exception != null)
{
throw exception;
}
}
internal MI_Result GetQualifierCount(
out UInt32 count
)
{
MI_Result resultLocal = this.ft.GetQualifierCount(this,
out count);
return(resultLocal);
}
internal MI_Result GetSession(
MI_Session session
)
{
MI_Result resultLocal = this.ft.GetSession(this,
session);
return(resultLocal);
}
internal MI_Result Cancel(
MI_CancellationReason reason
)
{
MI_Result resultLocal = this.ft.Cancel(this,
reason);
return(resultLocal);
}
internal MI_Result ClearElement(
string name
)
{
MI_Result resultLocal = this.ft.ClearElement(this,
name);
return(resultLocal);
}
private CimMofDeserializer()
{
MI_Deserializer tmpHandle;
MI_Result result = CimApplication.Handle.NewDeserializer(MI_SerializerFlags.None, MI_SerializationFormat.MOF, out tmpHandle);
CimException.ThrowIfMiResultFailure(result);
this._myHandle = tmpHandle;
this.SchemaValidationOption = MofDeserializerSchemaValidationOption.Default;
}
internal MI_Result GetElementCount(
out UInt32 count
)
{
MI_Result resultLocal = this.ft.GetElementCount(this,
out count);
return(resultLocal);
}
internal MI_Result ClearElementAt(
UInt32 index
)
{
MI_Result resultLocal = this.ft.ClearElementAt(this,
index);
return(resultLocal);
}
public ApplicationFixture()
{
MI_Instance extendedError = null;
MI_Application newApplication;
MI_Result res = MI_Application.Initialize(ApplicationName, out extendedError, out newApplication);
MIAssert.Succeeded(res, "Expect basic application initialization to succeed");
this.Application = newApplication;
}
internal MI_Result GetApplication(
MI_Application application
)
{
MI_Result resultLocal = this.ft.GetApplication(this,
application);
return(resultLocal);
}
