static DbRetVal AppRecoverWrapFast(DB_ENV* evp, ref DBT logrec, DB_LSN* lsnp, DB_RECOPS op) {
Env env = null;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
CallbackStatus cs = env.appRecoverFast(env, ref logrec, lsnp, (RecoveryOps)op);
return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.APP_RECOVER_FAILED;
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "TxnRecover");
return DbRetVal.APP_RECOVER_FAILED;
}
}
static void PanicCallWrapCLS(DB_ENV* evp, int errval) {
Env env = null;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
env.panicCallCLS(env, errval);
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "Panic Call");
if (env != null)
env.Error((int)DbRetVal.PANICCALL_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.PANICCALL_FAILED, null);
}
}
void SetAppDispatch(DB_ENV.AppRecoverFcn value) {
IntPtr txRec = IntPtr.Zero;
if (value != null)
txRec = Marshal.GetFunctionPointerForDelegate(value);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
ret = evp->SetAppDispatch(evp, txRec);
}
Util.CheckRetVal(ret);
}
void SetThreadIdString(DB_ENV.ThreadIdStringFcn value) {
IntPtr ti = IntPtr.Zero;
if (value != null)
ti = Marshal.GetFunctionPointerForDelegate(value);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
ret = evp->SetThreadIdString(evp, ti);
}
Util.CheckRetVal(ret);
}
static DbRetVal PageOutWrapCLS(DB_ENV* evp, UInt32 pgno, void* pgaddr, ref DBT pgcookie) {
Env env = null;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
CallbackStatus cs = PageInOutWrapCLS(env, pgno, pgaddr, ref pgcookie, env.pageOutCLS);
return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.PAGE_OUT_FAILED;
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "PageOut");
return DbRetVal.PAGE_OUT_FAILED;
}
}
static void EventNotifyWrapCLS(DB_ENV* evp, UInt32 evnt, void* event_info) {
Env env = null;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
object eventInfo = null;
if (evnt == DbConst.DB_EVENT_REP_NEWMASTER)
eventInfo = *((int*)event_info);
env.eventNotifyCLS(env, (EventType)evnt, eventInfo);
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "Event Notification");
if (env != null)
env.Error((int)DbRetVal.EVENT_NOTIFY_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.EVENT_NOTIFY_FAILED, null);
}
}
static int IsAliveWrapCLS(DB_ENV* evp, int pid, UInt32 tid, UInt32 flags) {
Env env = null;
bool result;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
result = env.isAliveCLS(env, pid, unchecked((int)tid), unchecked((IsAliveFlags)flags));
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "IsAlive");
if (env != null)
env.Error((int)DbRetVal.ISALIVE_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.ISALIVE_FAILED, null);
result = false;
}
return result ? 1 : 0;
}
static void MsgCallWrapFast(DB_ENV* evp, byte* msg) {
try {
Env env = (Env)((GCHandle)evp->api_internal).Target;
((MsgCallFastFcn)env.msgCallProcessor)(env, msg);
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "Message Call");
}
}
static void MsgCallWrapCLS(DB_ENV* evp, byte* msg) {
try {
Env env = (Env)((GCHandle)evp->api_internal).Target;
UTF8Encoding utf8 = new UTF8Encoding();
string message;
lock (env.callBackLock) {
// build msg string
int size = Util.PtrToBuffer(msg, ref env.callBackBuffer1);
message = utf8.GetString(env.callBackBuffer1, 0, size);
// call CLS compliant delegate - we assume it is not null
((MsgCallFcn)env.msgCallProcessor)(env, message);
}
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "Message Call");
}
}
static void ErrCallWrapStream(DB_ENV* evp, byte* errpfx, byte* msg) {
try {
Env env = (Env)((GCHandle)evp->api_internal).Target;
int pfxSize = Util.ByteStrLen(errpfx);
int msgSize = Util.ByteStrLen(msg);
// add necessary space for ": " and line break
int size;
if (pfxSize > 0)
size = pfxSize + 2 + msgSize + utf8nl.Length;
else
size = msgSize + utf8nl.Length;
lock (env.callBackLock) {
// copy into byte buffer
if (size > env.callBackBuffer1.Length)
env.callBackBuffer1 = new byte[size];
if (errpfx != null) {
Marshal.Copy((IntPtr)errpfx, env.callBackBuffer1, 0, pfxSize);
env.callBackBuffer1[pfxSize++] = (byte)':';
env.callBackBuffer1[pfxSize++] = (byte)' ';
}
if (msg != null) {
Marshal.Copy((IntPtr)msg, env.callBackBuffer1, pfxSize, msgSize);
pfxSize += msgSize;
}
// add line break
for (int indx = 0; indx < utf8nl.Length; indx++)
env.callBackBuffer1[pfxSize++] = utf8nl[indx];
// write to error stream
((Stream)env.errCallProcessor).Write(env.callBackBuffer1, 0, size);
}
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "Error Call");
}
}
void SetMsgCall(DB_ENV.MsgCallFcn value) {
IntPtr msgCall = IntPtr.Zero;
if (value != null)
msgCall = Marshal.GetFunctionPointerForDelegate(value);
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
evp->SetMsgCall(evp, msgCall);
}
}
static DbRetVal RepSendWrapCLS(
DB_ENV* evp,
ref DBT control,
ref DBT rec,
DB_LSN* lsnp,
int envid,
uint flags)
{
Env env = null;
try {
env = Util.GetEnv(evp);
lock (env.callBackLock) {
// construct DbEntry for control
int size = unchecked((int)control.size);
if (size > env.callBackBuffer1.Length)
env.callBackBuffer1 = new byte[size];
Marshal.Copy((IntPtr)control.data, env.callBackBuffer1, 0, size);
DbEntry ctrlEntry = DbEntry.InOut(env.callBackBuffer1, 0, size);
// construct DbEntry for rec
size = unchecked((int)rec.size);
if (size > env.callBackBuffer2.Length)
env.callBackBuffer2 = new byte[size];
Marshal.Copy((IntPtr)rec.data, env.callBackBuffer2, 0, size);
DbEntry recEntry = DbEntry.InOut(env.callBackBuffer2, 0, size);
// construct Lsn
Lsn? lsn;
if (lsnp == null) lsn = null; else lsn = new Lsn(*lsnp);
// call CLS compliant delegate - we assume it is not null
CallbackStatus cs = env.repSendCLS(
env, ref ctrlEntry, ref recEntry, lsn, envid, unchecked((RepSendFlags)flags));
return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.REPSEND_FAILED;
}
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "RepSend");
if (env != null)
env.Error((int)DbRetVal.REPSEND_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.REPSEND_FAILED, null);
return DbRetVal.REPSEND_FAILED;
}
}
static DbRetVal RepSendWrapFast(
DB_ENV* evp,
ref DBT control,
ref DBT rec,
DB_LSN* lsnp,
int envid,
uint flags)
{
Env env = null;
try {
env = Util.GetEnv(evp);
CallbackStatus cs = env.repSendFast(
env, ref control, ref rec, lsnp, envid, unchecked((RepSendFlags)flags));
return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.REPSEND_FAILED;
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "RepSend");
if (env != null)
env.Error((int)DbRetVal.REPSEND_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.REPSEND_FAILED, null);
return DbRetVal.REPSEND_FAILED;
}
}
void RepSetTransport(int envId, DB_ENV.RepSendFcn value) {
IntPtr repSnd = IntPtr.Zero;
if (value != null)
repSnd = Marshal.GetFunctionPointerForDelegate(value);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
#if BDB_4_3_29
ret = evp->SetRepTransport(evp, envId, repSnd);
#endif
#if BDB_4_5_20
ret = evp->RepSetTransport(evp, envId, repSnd);
#endif
}
Util.CheckRetVal(ret);
}
static DbRetVal AppRecoverWrapCLS(DB_ENV* evp, ref DBT logrec, DB_LSN* lsnp, DB_RECOPS op) {
Env env = null;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
// construct DbEntry for log_rec
int size = unchecked((int)logrec.size);
// we are not using a shared buffer - the call-back might take
// a long time and we do not want to lock the buffer that long
byte[] buffer = new byte[size];
Marshal.Copy((IntPtr)logrec.data, buffer, 0, size);
DbEntry logEntry = DbEntry.InOut(buffer, 0, size);
logEntry.dbt.flags = logrec.flags;
logEntry.dbt.dlen = logrec.dlen;
logEntry.dbt.doff = logrec.doff;
// construct Lsn
Lsn? lsn;
if (lsnp == null) lsn = null; else lsn = new Lsn(*lsnp);
// call CLS compliant delegate - we assume it is not null
CallbackStatus cs = env.appRecoverCLS(env, ref logEntry, lsn, (RecoveryOps)op);
return cs == CallbackStatus.Success ? DbRetVal.SUCCESS : DbRetVal.APP_RECOVER_FAILED;
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "TxnRecover");
return DbRetVal.APP_RECOVER_FAILED;
}
}
static void MsgCallWrapStream(DB_ENV* evp, byte* msg) {
try {
Env env = (Env)((GCHandle)evp->api_internal).Target;
int msgSize = Util.ByteStrLen(msg);
// add necessary space for line break
int size = msgSize + utf8nl.Length;
lock (env.callBackLock) {
// copy into byte buffer
if (size > env.callBackBuffer1.Length)
env.callBackBuffer1 = new byte[size];
if (msg != null)
Marshal.Copy((IntPtr)msg, env.callBackBuffer1, 0, msgSize);
// add line break
for (int indx = 0; indx < utf8nl.Length; indx++)
env.callBackBuffer1[msgSize++] = utf8nl[indx];
// write to message stream
((Stream)env.msgCallProcessor).Write(env.callBackBuffer1, 0, size);
}
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "Message Call");
}
}
void SetEventNotify(DB_ENV.EventNotifyFcn value) {
IntPtr en = IntPtr.Zero;
if (value != null)
en = Marshal.GetFunctionPointerForDelegate(value);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
ret = evp->SetEventNotify(evp, en);
}
Util.CheckRetVal(ret);
}
void SetFeedback(DB_ENV.FeedbackFcn value) {
IntPtr fb = IntPtr.Zero;
if (value != null)
fb = Marshal.GetFunctionPointerForDelegate(value);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
ret = evp->SetFeedback(evp, fb);
}
Util.CheckRetVal(ret);
}
void SetIsAlive(DB_ENV.IsAliveFcn value) {
IntPtr ial = IntPtr.Zero;
if (value != null)
ial = Marshal.GetFunctionPointerForDelegate(value);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
ret = evp->SetIsAlive(evp, ial);
}
Util.CheckRetVal(ret);
}
static void FeedbackWrapCLS(DB_ENV* evp, int opcode, int percent) {
Env env = null;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
env.feedbackCLS(env, opcode, percent);
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "Feedback");
if (env != null)
env.Error((int)DbRetVal.FEEDBACK_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.FEEDBACK_FAILED, null);
}
}
static void ThreadIdWrapCLS(DB_ENV* evp, out int pid, out UInt32 tid) {
Env env = null;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
int tidCLS;
env.threadIdCLS(env, out pid, out tidCLS);
tid = unchecked((UInt32)tidCLS);
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "ThreadId");
if (env != null)
env.Error((int)DbRetVal.THREADID_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.THREADID_FAILED, null);
pid = 0;
tid = 0;
}
}
void SetPanicCall(DB_ENV.PanicCallFcn value) {
IntPtr pc = IntPtr.Zero;
if (value != null)
pc = Marshal.GetFunctionPointerForDelegate(value);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
ret = evp->SetPanicCall(evp, pc);
}
Util.CheckRetVal(ret);
}
static byte* ThreadIdStringWrapCLS(DB_ENV* evp, int pid, UInt32 tid, byte* buf) {
Env env = null;
int count = 0;
try {
env = (Env)((GCHandle)evp->api_internal).Target;
string tidStr = env.threadIdStringCLS(env, pid, unchecked((int)tid));
fixed (char* tidChars = tidStr) {
count = new UTF8Encoding().GetBytes(tidChars, tidStr.Length, buf, DbConst.DB_THREADID_STRLEN - 1);
}
}
catch (Exception ex) {
Trace.WriteLine(ex.Message, "ThreadIdString");
if (env != null)
env.Error((int)DbRetVal.THREADID_STRING_FAILED, ex.Message);
else
evp->Err(evp, (int)DbRetVal.THREADID_STRING_FAILED, null);
}
buf[count] = 0;
return buf;
}
void CacheRegister(int fType, DB_ENV.PageInOutFcn pageIn, DB_ENV.PageInOutFcn pageOut) {
IntPtr pgIn = IntPtr.Zero;
if (pageIn != null)
pgIn = Marshal.GetFunctionPointerForDelegate(pageIn);
IntPtr pgOut = IntPtr.Zero;
if (pageOut != null)
pgOut = Marshal.GetFunctionPointerForDelegate(pageOut);
DbRetVal ret;
lock (rscLock) {
DB_ENV* evp = CheckDisposed();
ret = evp->MemPoolRegister(evp, fType, pgIn, pgOut);
}
Util.CheckRetVal(ret);
}
