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); }