/// <summary>
/// Thread function, keeps running.
/// </summary>
protected void Run()
{
while (this._worker != null && !this._isDisposing)
{
WriteOperation operation = null;
try
{
lock (this)
{
if (this._updateQueue.Count < 1)
{
if (_shutdownStatusLatch.IsAnyBitsSet(ShutDownStatus.SHUTDOWN_INPROGRESS))
{
_shutdownStatusLatch.SetStatusBit(ShutDownStatus.SHUTDOWN_COMPLETED, ShutDownStatus.SHUTDOWN_INPROGRESS);
return;
}
Monitor.Wait(this);
}
if (this._updateQueue.Count > 0)
{
operation = this._updateQueue.Dequeue();
}
else if (_updateQueue.Count == 0 && _shutdownStatusLatch.IsAnyBitsSet(ShutDownStatus.SHUTDOWN_INPROGRESS))
{
break;
}
}
if (operation == null)
{
continue;
}
lock (_processMutex)
{
if (!_isDisposing)
{
if (_dsMgr != null)
{
_dsMgr.DSAsyncUpdateInCache(operation);
}
}
}
}
catch (ThreadAbortException e)
{
break;
}
catch (ThreadInterruptedException e)
{
break;
}
catch (Exception e)
{
}
}
}
internal void AssureSend(byte[] buffer, Socket client, bool checkConnected)
{
int dataSent = 0, dataLeft = buffer.Length;
lock (_connectionMutex)
{
if (checkConnected &&
_connectionStatusLatch.IsAnyBitsSet(ConnectionStatus.Disconnected | ConnectionStatus.Connecting))
{
throw new ConnectionException(this._serverAddress.IpAddress, this._serverAddress.Port);
}
while (dataSent < buffer.Length)
{
try
{
dataLeft = buffer.Length - dataSent;
dataSent += client.Send(buffer, dataSent, dataLeft, SocketFlags.None);
}
catch (SocketException se)
{
if (se.SocketErrorCode == SocketError.NoBufferSpaceAvailable)
{
}
else
{
if (_logger.IsErrorLogsEnabled)
{
_logger.NCacheLog.Error("Connection.AssureSend().SocketException ", se.ToString());
}
_connectionStatusLatch.SetStatusBit(ConnectionStatus.Disconnected,
ConnectionStatus.Connected);
throw new ConnectionException(this._serverAddress.IpAddress, this._serverAddress.Port);
}
}
catch (ObjectDisposedException)
{
if (_logger.IsErrorLogsEnabled)
{
_logger.NCacheLog.Error("Connection.AssureSend", "socket is already closed");
}
if (_connectionStatusLatch.IsAnyBitsSet(ConnectionStatus.Connected))
{
_connectionStatusLatch.SetStatusBit(ConnectionStatus.Disconnected,
ConnectionStatus.Connected);
}
throw new ConnectionException(this._serverAddress.IpAddress, this._serverAddress.Port);
}
}
}
}
public void WaitForStatus(string tmpOwner, byte status)
{
if (tmpOwner != null)
{
while (tmpOwner == _finalShard)
{
if (_stateTxfrLatch.IsAnyBitsSet(status))
{
return;
}
lock (_status_wait_mutex)
{
if ((tmpOwner == _finalShard) || _stateTxfrLatch.IsAnyBitsSet(status))
{
return;
}
Monitor.Wait(_status_wait_mutex);
}
}
}
}
public void WaitForStatus(Address tmpOwner, byte status)
{
if (tmpOwner != null)
{
while (tmpOwner == _tempAddress)
{
if (_stateTxfrLatch.IsAnyBitsSet(status))
{
return;
}
lock (_status_wait_mutex)
{
if ((tmpOwner == _tempAddress) || _stateTxfrLatch.IsAnyBitsSet(status))
{
return;
}
Monitor.Wait(_status_wait_mutex);
}
}
}
}
public bool Send(byte[] buffer, int offset, int count)
{
bool sent = false;
//If we want to wait for re-connect
_statusLatch.WaitForAny((byte)Status.Disconnected | (byte)Status.Connected);
if (!_statusLatch.IsAnyBitsSet((byte)Status.Connected))
{
throw new ConnectionException();
}
lock (_sync_lock)
{
if (_connected)
{
int dataSent = 0;
while (count > 0)
{
try
{
dataSent = _socket.Send(buffer, offset, count, SocketFlags.None);
offset += dataSent;
count = count - dataSent;
}
catch (SocketException se)
{
_statusLatch.SetStatusBit((byte)Status.Disconnected, (byte)Status.Connected | (byte)Status.Reconnecting);
_connected = false;
throw new ConnectionException(se.Message, se);
}
}
sent = true;
}
else
{
throw new ConnectionException();
}
}
AddToClientsBytesSent(buffer.Length);
return(sent);
}
/// <summary>
/// replication thread function.
/// note: While replicating operations, a dummy '0' sequence id is passed.
/// this sequence id is totally ignored by asynchronous POR, but we are keeping it
/// to maintain the symmetry in API.
/// </summary>
public void Run()
{ //reload threshold value from service config, consider the probability that values would have been changed by user
_bulkKeysToReplicate = ServiceConfiguration.BulkItemsToReplicate;
IList opCodesToBeReplicated = new ClusteredArrayList(_bulkKeysToReplicate);
IList infoToBeReplicated = new ClusteredArrayList(_bulkKeysToReplicate);
IList compilationInfo = new ClusteredArrayList(_bulkKeysToReplicate);
IList userPayLoad = new ClusteredArrayList();
try
{
while (!stopped || _queue.Count > 0)
{
DateTime startedAt = DateTime.Now;
DateTime finishedAt = DateTime.Now;
try
{
for (int i = 0; _queue.Count > 0 && i < _bulkKeysToReplicate; i++)
{
IOptimizedQueueOperation operation = null;
operation = _queue.Dequeue();
DictionaryEntry entry = (DictionaryEntry)operation.Data;
opCodesToBeReplicated.Add(entry.Key);
infoToBeReplicated.Add(entry.Value);
if (operation.UserPayLoad != null)
{
if (userPayLoad == null)
{
userPayLoad = new ArrayList();
}
for (int j = 0; j < operation.UserPayLoad.Length; j++)
{
userPayLoad.Add(operation.UserPayLoad.GetValue(j));
}
}
compilationInfo.Add(operation.PayLoadSize);
}
object[] updateIndexKeys = GetIndexOperations();
if (!stopped)
{
if (opCodesToBeReplicated.Count > 0 || updateIndexKeys != null)
{
if (updateIndexKeys != null)
{
opCodesToBeReplicated.Add((int)ClusterCacheBase.OpCodes.UpdateIndice);
infoToBeReplicated.Add(updateIndexKeys);
}
_context.CacheImpl.ReplicateOperations(opCodesToBeReplicated, infoToBeReplicated, userPayLoad, compilationInfo, _context.CacheImpl.OperationSequenceId, _context.CacheImpl.CurrentViewId);
}
}
if (!stopped && _context.PerfStatsColl != null)
{
_context.PerfStatsColl.IncrementMirrorQueueSizeStats(_queue.Count);
}
}
catch (Exception e)
{
if (e.Message.IndexOf("operation timeout", StringComparison.OrdinalIgnoreCase) >= 0 && !_shutdownStatusLatch.IsAnyBitsSet(ShutDownStatus.SHUTDOWN_INPROGRESS))
{
_context.NCacheLog.CriticalInfo("AsyncReplicator.Run", "Bulk operation timeout. Retrying the operation.");
try
{
if (!stopped)
{
_context.CacheImpl.ReplicateOperations(opCodesToBeReplicated, infoToBeReplicated, userPayLoad, compilationInfo, 0, 0);
_context.NCacheLog.CriticalInfo("AsyncReplicator.Run", "RETRY is successfully.");
}
}
catch (Exception ex)
{
if (_context.NCacheLog.IsErrorEnabled)
{
_context.NCacheLog.Error("AsyncReplicator.RUN", "Error occurred while retrying operation. " + ex.ToString());
}
}
}
else
if (_context.NCacheLog.IsErrorEnabled)
{
_context.NCacheLog.Error("AsyncReplicator.RUN", e.ToString());
}
}
finally
{
opCodesToBeReplicated.Clear();
infoToBeReplicated.Clear();
compilationInfo.Clear();
if (userPayLoad != null)
{
userPayLoad.Clear();
}
finishedAt = DateTime.Now;
}
if (_queue.Count > 0)
{
continue;
}
else if (_queue.Count == 0 && _shutdownStatusLatch.IsAnyBitsSet(ShutDownStatus.SHUTDOWN_INPROGRESS))
{
_shutdownStatusLatch.SetStatusBit(ShutDownStatus.SHUTDOWN_COMPLETED, ShutDownStatus.SHUTDOWN_INPROGRESS);
return;
}
if ((finishedAt.Ticks - startedAt.Ticks) < _interval.Ticks)
{
Thread.Sleep(_interval.Subtract(finishedAt.Subtract(startedAt)));
}
else
{
Thread.Sleep(_interval);
}
}
}
catch (ThreadAbortException ta)
{
//_context.CacheTrace.error("AsyncReplicator.RUN", "Async replicator stopped. " + ta.ToString());
}
catch (ThreadInterruptedException ti)
{
//_context.CacheTrace.error("AsyncReplicator.RUN", "Async replicator stopped. " + ti.ToString());
}
catch (NullReferenceException)
{
}
catch (Exception e)
{
if (!stopped)
{
_context.NCacheLog.Error("AsyncReplicator.RUN", "Async replicator stopped. " + e.ToString());
}
}
}
