/// <summary>
/// Logs the operation
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="entry"></param>
/// <param name="type"></param>
/// <param name="logMode"></param>
/// <returns>True, in case operation is logged otherwise false</returns>
public bool LogOperation(int bucket, object key, Object entry, OperationType type)
{
OperationLogger logger = null;
lock (this)
{
if (_loggers.Contains(bucket))
{
logger = _loggers[bucket] as OperationLogger;
}
}
if (logger != null)
{
if (_logEnteries)
{
logger.LogOperation(key, entry, type);
}
else
{
logger.LogOperation(key, null, type);
}
return(true);
}
return(false);
}
public bool IsLoggingEnbaled(int bucket, LogMode logMode)
{
if (_loggers.Contains(bucket))
{
OperationLogger logger = _loggers[bucket] as OperationLogger;
return(logger.LoggingMode == logMode);
}
return(false);
}
public void StopLogging(int bucket)
{
if (_loggers.Contains(bucket))
{
OperationLogger logger = _loggers[bucket] as OperationLogger;
logger.BucketTransfered = _allowOPAfterBuckeTxfrd;;
logger.Clear();
}
}
/// <summary>
/// if bucket has been transfered to an another node than operation are not allowed.
/// </summary>
/// <param name="bucket"></param>
/// <returns></returns>
public bool IsOperationAllowed(int bucket)
{
if (_loggers.Contains(bucket))
{
OperationLogger logger = _loggers[bucket] as OperationLogger;
return(!logger.BucketTransfered);
}
return(true);
}
public bool IsLoggingEnbaled(int bucket, LogMode logMode)
{
OperationLogger logger = _loggers[bucket];
if (logger != null)
{
return(logger.LoggingMode == logMode);
}
return(false);
}
public Hashtable GetLoggedEnteries(int bucket)
{
Hashtable result = null;
if (_loggers.Contains(bucket))
{
OperationLogger opLogger = (OperationLogger)_loggers[bucket];
result = opLogger.LoggedEnteries.Clone() as Hashtable;
opLogger.Clear();
}
return(result);
}
public void StopLogging(int bucket)
{
OperationLogger logger = _loggers[bucket];
if (logger != null)
{
lock (logger)
{
logger.BucketTransfered = _allowOPAfterBuckeTxfrd;
logger.Clear();
}
}
}
public void StartLogging(int bucket, LogMode loggingMode)
{
if (!_loggers.Contains(bucket))
{
_loggers.Add(bucket, new OperationLogger(bucket, loggingMode));
}
else
{
OperationLogger logger = _loggers[bucket] as OperationLogger;
logger.LoggingMode = loggingMode;
logger.BucketTransfered = false;
logger.Clear();
}
}
/// <summary>
/// if bucket has been transfered to an another node than operation are not allowed.
/// </summary>
/// <param name="bucket"></param>
/// <returns></returns>
public bool IsOperationAllowed(int bucket)
{
OperationLogger logger = _loggers[bucket];
if (logger != null && logger.BucketTransfered)
{
if (OperationContext.IsReplicationOperation) //replication operations are not filtered
{
return(true);
}
return(false);
}
return(true);
}
public Hashtable GetLoggedEnteries(int bucket)
{
Hashtable result = null;
OperationLogger logger = _loggers[bucket];
if (logger != null)
{
lock (logger)
{
result = logger.LoggedEnteries.Clone() as Hashtable;
logger.Clear();
}
}
return(result);
}
internal override CacheInsResult InsertInternal(object key, CacheEntry cacheEntry, bool isUserOperation, CacheEntry oldEntry, OperationContext operationContext)
{
int bucketId = GetBucketId(key as string);
OperationLogger opLogger = null;
//muds:
//fetch the operation logger...
if (_logMgr.IsOperationAllowed(bucketId) && LocalBuckets.Contains(bucketId))
{
long oldEntrysize = oldEntry == null ? 0 : oldEntry.DataSize;
if (_logMgr.IsLoggingEnbaled(bucketId, LogMode.LogBeforeActualOperation) && isUserOperation)
{
_logMgr.LogOperation(bucketId, key, cacheEntry, OperationType.Insert);
return(oldEntry != null ? CacheInsResult.SuccessOverwrite : CacheInsResult.Success);
}
CacheEntry clone = (CacheEntry)cacheEntry.Clone();
CacheInsResult result = base.InsertInternal(key, cacheEntry, isUserOperation, oldEntry, operationContext);
switch (result)
{
case CacheInsResult.SuccessNearEvicition:
case CacheInsResult.Success:
if (isUserOperation)
{
_logMgr.LogOperation(bucketId, key, clone, OperationType.Insert);
}
IncrementBucketStats(key as string, bucketId, cacheEntry.DataSize);
break;
case CacheInsResult.SuccessOverwriteNearEviction:
case CacheInsResult.SuccessOverwrite:
if (isUserOperation)
{
_logMgr.LogOperation(bucketId, key, clone, OperationType.Insert);
}
DecrementBucketStats(key as string, bucketId, oldEntrysize);
IncrementBucketStats(key as string, bucketId, cacheEntry.DataSize);
break;
}
return(result);
}
throw new StateTransferException("I am no more the owner of this bucket");
}
/// <summary>
/// Logs the operation
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="entry"></param>
/// <param name="type"></param>
/// <param name="logMode"></param>
/// <returns>True, in case operation is logged otherwise false</returns>
public bool LogOperation(int bucket, object key, CacheEntry entry, OperationType type)
{
if (_loggers.Contains(bucket))
{
OperationLogger logger = _loggers[bucket] as OperationLogger;
if (_logEnteries)
{
logger.LogOperation(key, entry, type);
}
else
{
logger.LogOperation(key, null, type);
}
return(true);
}
return(false);
}
public void StartLogging(int bucket, LogMode loggingMode)
{
OperationLogger logger = _loggers[bucket];
if (logger == null)
{
logger = new OperationLogger(bucket, loggingMode);
_loggers[bucket] = logger;
}
lock (logger)
{
logger.LoggingMode = loggingMode;
logger.BucketTransfered = false;
logger.Clear();
}
//}
}
/// <summary>
/// Logs the operation
/// </summary>
/// <param name="bucket"></param>
/// <param name="key"></param>
/// <param name="entry"></param>
/// <param name="type"></param>
/// <param name="logMode"></param>
/// <returns>True, in case operation is logged otherwise false</returns>
public bool LogOperation(int bucket, object key, Object entry, OperationType type)
{
OperationLogger logger = _loggers[bucket];
if (logger != null)
{
if (_logEnteries)
{
logger.LogOperation(key, entry, type);
}
else
{
logger.LogOperation(key, null, type);
}
return(true);
}
return(false);
}
public Hashtable GetLoggedEnteries(int bucket)
{
Hashtable result = null;
OperationLogger logger = null;
lock (this)
{
if (_loggers.Contains(bucket))
{
logger = _loggers[bucket] as OperationLogger;
}
}
if (logger != null)
{
result = logger.LoggedEnteries.Clone() as Hashtable;
logger.Clear();
}
return(result);
}
/// <summary>
/// if bucket has been transfered to an another node than operation are not allowed.
/// </summary>
/// <param name="bucket"></param>
/// <returns></returns>
public bool IsOperationAllowed(int bucket)
{
OperationLogger logger = null;
lock (this)
{
if (_loggers.Contains(bucket))
{
logger = _loggers[bucket] as OperationLogger;
}
}
if (logger != null && logger.BucketTransfered)
{
if (OperationContext.IsReplicationOperation) //replication operations are not filtered
{
return(true);
}
return(false);
}
return(true);
}
