private JET_err RestoreStatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { output(string.Format("Esent Restore: {0} {1} {2}", snp, snt, data)); Console.WriteLine("Esent Restore: {0} {1} {2}", snp, snt, data); return(JET_err.Success); }
/// <summary> /// Callback function for native code. We don't want to throw an exception through /// unmanaged ESENT because that will corrupt ESENT's internal state. Instead we /// catch all exceptions and return an error instead. We use a CER to make catching /// the exceptions as reliable as possible. /// </summary> /// <param name="nativeSesid"> /// The session with which the long running operation was called. /// </param> /// <param name="nativeSnp">The type of operation.</param> /// <param name="nativeSnt">The status of the operation.</param> /// <param name="nativeData">Optional <see cref="NATIVE_SNPROG"/>.</param> /// <returns>An error code.</returns> private JET_err CallbackImpl(IntPtr nativeSesid, uint nativeSnp, uint nativeSnt, IntPtr nativeData) { RuntimeHelpers.PrepareConstrainedRegions(); try { var sesid = new JET_SESID { Value = nativeSesid }; JET_SNP snp = (JET_SNP)nativeSnp; JET_SNT snt = (JET_SNT)nativeSnt; object data = CallbackDataConverter.GetManagedData(nativeData, snp, snt); return(this.wrappedCallback(sesid, snp, snt, data)); } catch (ThreadAbortException) { Trace.WriteLineIf(TraceSwitch.TraceWarning, "Caught ThreadAbortException"); // Stop the thread abort and let the unmanaged ESENT code finish. // ThrowSavedException will call Thread.Abort() again. this.ThreadWasAborted = true; Thread.ResetAbort(); return(JET_err.CallbackFailed); } catch (Exception ex) { Trace.WriteLineIf( TraceSwitch.TraceWarning, String.Format(CultureInfo.InvariantCulture, "Caught Exception {0}", ex)); this.SavedException = ex; return(JET_err.CallbackFailed); } // What happens if the thread is aborted here, outside of the CER? // We probably throw the exception through ESENT, which isn't good. }
/// <summary> /// Progress reporting callback. /// </summary> /// <param name="sesid">The session performing the operation.</param> /// <param name="snp">The operation type.</param> /// <param name="snt">The type of the progress report.</param> /// <param name="data">Progress info.</param> /// <returns>An error code.</returns> private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { this.statusCallbackWasCalled = true; if (JET_SNT.Progress == snt) { if (data as JET_SNPROG == null) { Assert.Inconclusive( "Not all cases in CallbackDataConverter.GetManagedData() have been implemented. snp={0},snt={1}", snp, snt); } var snprog = data as JET_SNPROG; Assert.IsNotNull(snprog, "Expected an snprog in a progress callback"); Assert.IsTrue(snprog.cunitDone <= snprog.cunitTotal, "done > total in the snprog"); } // On Windows Store Apps, the functions that reference this variable are compiled out, so this // prevents a warning-as-error. Assert.IsTrue(this.statusCallbackWasCalled, "This will always be true."); return(JET_err.Success); }
/// <summary> /// Get the managed data object from the unmanaged data. /// </summary> /// <param name="nativeData">The native data.</param> /// <param name="snp">The SNP (used to determine the type of object).</param> /// <param name="snt">The SNT (used to determine the type of object).</param> /// <returns>The managed data object.</returns> public static object GetManagedData(IntPtr nativeData, JET_SNP snp, JET_SNT snt) { if (IntPtr.Zero != nativeData && JET_SNT.Progress == snt) { NATIVE_SNPROG native = (NATIVE_SNPROG)Marshal.PtrToStructure(nativeData, typeof(NATIVE_SNPROG)); JET_SNPROG managed = new JET_SNPROG(); managed.SetFromNative(native); return managed; } return null; }
/// <summary> /// Get the managed data object from the unmanaged data. /// </summary> /// <param name="nativeData">The native data.</param> /// <param name="snp">The SNP (used to determine the type of object).</param> /// <param name="snt">The SNT (used to determine the type of object).</param> /// <returns>The managed data object.</returns> public static object GetManagedData(IntPtr nativeData, JET_SNP snp, JET_SNT snt) { if (IntPtr.Zero != nativeData && JET_SNT.Progress == snt) { NATIVE_SNPROG native = (NATIVE_SNPROG)Marshal.PtrToStructure(nativeData, typeof(NATIVE_SNPROG)); JET_SNPROG managed = new JET_SNPROG(); managed.SetFromNative(native); return(managed); } return(null); }
/// <summary> /// Progress reporting callback. /// </summary> /// <param name="sesid">The session performing the operation.</param> /// <param name="snp">The operation type.</param> /// <param name="snt">The type of the progress report.</param> /// <param name="data">Progress info.</param> /// <returns>An error code.</returns> private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { this.statusCallbackWasCalled = true; Assert.IsTrue( JET_SNP.Backup == snp || JET_SNP.Restore == snp || JET_SNP.Compact == snp, "Unexpected snp (progress type)"); if (JET_SNT.Progress == snt) { var snprog = data as JET_SNPROG; Assert.IsNotNull(snprog, "Expected an snprog in a progress callback"); Assert.IsTrue(snprog.cunitDone <= snprog.cunitTotal, "done > total in the snprog"); } return(JET_err.Success); }
private JET_err CompactStatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Console.WriteLine("Esent Compact: {0} {1} {2}", snp, snt, data); if (snt == JET_SNT.Progress) { if (SystemTime.UtcNow - lastCompactionProgressStatusUpdate < TimeSpan.FromMilliseconds(100)) { return(JET_err.Success); } lastCompactionProgressStatusUpdate = SystemTime.UtcNow; } output(string.Format("Esent Compact: {0} {1} {2}", snp, snt, data)); return(JET_err.Success); }
/// <summary> /// Callback function for native code. /// </summary> /// <param name="nativeSesid"> /// The session with which the long running operation was called. /// </param> /// <param name="nativeSnp">The type of operation.</param> /// <param name="nativeSnt">The status of the operation.</param> /// <param name="nativeSnprog">Optional <see cref="NATIVE_SNPROG"/>.</param> /// <returns>An error code.</returns> private JET_err CallbackImpl(IntPtr nativeSesid, uint nativeSnp, uint nativeSnt, IntPtr nativeSnprog) { RuntimeHelpers.PrepareConstrainedRegions(); try { var sesid = new JET_SESID { Value = nativeSesid }; JET_SNP snp = (JET_SNP)nativeSnp; JET_SNT snt = (JET_SNT)nativeSnt; JET_SNPROG snprog = null; // Other callback types can have pointers to different structures. if (IntPtr.Zero != nativeSnprog && JET_SNT.Progress == snt) { NATIVE_SNPROG native = (NATIVE_SNPROG)Marshal.PtrToStructure(nativeSnprog, typeof(NATIVE_SNPROG)); snprog = new JET_SNPROG(); snprog.SetFromNative(native); } return(this.wrappedCallback(sesid, snp, snt, snprog)); } catch (ThreadAbortException) { Trace.WriteLineIf(this.traceSwitch.TraceWarning, "Caught ThreadAbortException"); // Stop the thread abort and let the unmanaged ESENT code finish. // ThrowSavedException will call Thread.Abort() again. this.ThreadWasAborted = true; Thread.ResetAbort(); return(JET_err.CallbackFailed); } catch (Exception ex) { Trace.WriteLineIf(this.traceSwitch.TraceWarning, "Caught Exception"); this.SavedException = ex; return(JET_err.CallbackFailed); } // What happens if the thread is aborted here, outside of the CER? // We probably throw the exception through ESENT, which isn't good. }
/// <summary> /// Progress reporting callback. /// </summary> /// <param name="sesid">The session performing the operation.</param> /// <param name="snp">The operation type.</param> /// <param name="snt">The type of the progress report.</param> /// <param name="data">Progress info.</param> /// <returns>An error code.</returns> private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { this.statusCallbackWasCalled = true; if (JET_SNT.Progress == snt) { if (data as JET_SNPROG == null) { Assert.Inconclusive( "Not all cases in CallbackDataConverter.GetManagedData() have been implemented. snp={0},snt={1}", snp, snt); } var snprog = data as JET_SNPROG; Assert.IsNotNull(snprog, "Expected an snprog in a progress callback"); Assert.IsTrue(snprog.cunitDone <= snprog.cunitTotal, "done > total in the snprog"); } return(JET_err.Success); }
private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Console.WriteLine("Esent Restore: {0} {1} {2}", snp, snt, data); return(JET_err.Success); }
private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Console.WriteLine("Esent Restore: {0} {1} {2}", snp, snt, data); return JET_err.Success; }
private JET_err RestoreStatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { output(string.Format("Esent Restore: {0} {1} {2}", snp, snt, data)); Console.WriteLine("Esent Restore: {0} {1} {2}", snp, snt, data); return JET_err.Success; }
static JET_err progress(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { return(JET_err.Success); }
private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Notify(string.Format("Esent {0} {1} {2}", snp, snt, data).Trim(), BackupStatus.BackupMessageSeverity.Informational); return JET_err.Success; }
private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Notify(string.Format("Esent {0} {1} {2}", snp, snt, data).Trim()); return JET_err.Success; }
private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Notify(string.Format("Esent {0} {1} {2}", snp, snt, data).Trim(), BackupStatus.BackupMessageSeverity.Informational); return(JET_err.Success); }
/// <summary> /// Progress reporting callback. /// </summary> /// <param name="sesid">The session performing the operation.</param> /// <param name="snp">The operation type.</param> /// <param name="snt">The type of the progress report.</param> /// <param name="data">Progress info.</param> /// <returns>An error code.</returns> private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { this.statusCallbackWasCalled = true; if (JET_SNT.Progress == snt) { if (data as JET_SNPROG == null) { Assert.Inconclusive( "Not all cases in CallbackDataConverter.GetManagedData() have been implemented. snp={0},snt={1}", snp, snt); } var snprog = data as JET_SNPROG; Assert.IsNotNull(snprog, "Expected an snprog in a progress callback"); Assert.IsTrue(snprog.cunitDone <= snprog.cunitTotal, "done > total in the snprog"); } return JET_err.Success; }
private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Notify(string.Format("Esent {0} {1} {2}", snp, snt, data).Trim()); return(JET_err.Success); }
private JET_err CompactStatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { Console.WriteLine("Esent Compact: {0} {1} {2}", snp, snt, data); if (snt == JET_SNT.Progress) { if(SystemTime.UtcNow - lastCompactionProgressStatusUpdate < TimeSpan.FromMilliseconds(100)) return JET_err.Success; lastCompactionProgressStatusUpdate = SystemTime.UtcNow; } output(string.Format("Esent Compact: {0} {1} {2}", snp, snt, data)); return JET_err.Success; }
/// <summary> /// Progress reporting callback. /// </summary> /// <param name="sesid">The session performing the operation.</param> /// <param name="snp">The operation type.</param> /// <param name="snt">The type of the progress report.</param> /// <param name="data">Progress info.</param> /// <returns>An error code.</returns> private JET_err StatusCallback(JET_SESID sesid, JET_SNP snp, JET_SNT snt, object data) { this.statusCallbackWasCalled = true; Assert.IsTrue( JET_SNP.Backup == snp || JET_SNP.Restore == snp || JET_SNP.Compact == snp, "Unexpected snp (progress type)"); if (JET_SNT.Progress == snt) { var snprog = data as JET_SNPROG; Assert.IsNotNull(snprog, "Expected an snprog in a progress callback"); Assert.IsTrue(snprog.cunitDone <= snprog.cunitTotal, "done > total in the snprog"); } return JET_err.Success; }