protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
AsyncHelpers.RunSync(() => Task.WhenAll(_activeWriteTasks));
_isDisposed.Raise();
}
public void Dispose()
{
if (!_disposed.Raise())
{
return;
}
GC.SuppressFinalize(this);
_options.IoMetrics.FileClosed(FileName.FullPath);
List <Exception> exceptions = null;
TryExecute(() =>
{
_readHandle.Dispose();
if (_readHandle.FailCode != PalFlags.FailCodes.Success)
{
PalHelper.ThrowLastError(_readHandle.FailCode, _readHandle.ErrorNo,
$"Attempted to close 'read journal handle' - Path: {FileName.FullPath}");
}
});
TryExecute(() =>
{
_writeHandle.Dispose();
if (_writeHandle.FailCode != PalFlags.FailCodes.Success)
{
PalHelper.ThrowLastError(_writeHandle.FailCode, _writeHandle.ErrorNo,
$"Attempted to close 'write journal handle' - Path: {FileName.FullPath}");
}
});
if (exceptions != null)
{
throw new AggregateException("Failed to dispose journal writer", exceptions);
}
if (DeleteOnClose)
{
_options.TryStoreJournalForReuse(FileName);
}
void TryExecute(Action a)
{
try
{
a();
}
catch (Exception e)
{
if (exceptions == null)
{
exceptions = new List <Exception>();
}
exceptions.Add(e);
}
}
}
public void Dispose()
{
if (_disposed.Raise() == false)
{
return;
}
_writer.Dispose();
GlobalCache.Free(_cacheItem);
}
public override void Dispose()
{
if (_disposed.Raise() == false)
{
return;
}
_writer.Dispose();
base.Dispose();
}
public void Dispose()
{
_isDisposed.Raise();
_cts.Cancel();
_sendQueue.Enqueue(new ChangeValue
{
AllowSkip = false,
ValueToSend = null
});
_cts.Dispose();
}
public void Initialize(DatabaseRecord record)
{
if (_isInitialized) //precaution -> probably not necessary, but still...
{
return;
}
ConflictSolverConfig = record.ConflictSolverConfig;
ConflictResolver = new ResolveConflictOnReplicationConfigurationChange(this, _log);
ConflictResolver.RunConflictResolversOnce();
_isInitialized.Raise();
}
/// <summary>
/// Mark the passage of time and decay the current rate accordingly.
/// </summary>
public void Tick()
{
var count = _uncounted.GetAndSet(0);
var instantRate = count / _interval;
if (_initialized.Raise())
{
_rate.Set(instantRate);
}
else
{
_rate += _alpha * (instantRate - _rate);
}
}
public void Tick()
{
var count = Interlocked.Exchange(ref _uncounted, 0);
var instantRate = count / _interval;
if (_initialized.Raise())
{
Volatile.Write(ref _rate, instantRate);
}
else
{
double doubleRate = Volatile.Read(ref _rate);
Volatile.Write(ref _rate, doubleRate + _alpha * (instantRate - doubleRate));
}
}
public void Dispose()
{
// There are multiple invocations of dispose, this happens sometimes during tests, causing failures.
if (!_disposed.Raise())
{
return;
}
var timeout = _parent._server.Engine.TcpConnectionTimeout;
if (_log.IsInfoEnabled)
{
_log.Info($"Disposing OutgoingReplicationHandler ({FromToString}) [Timeout:{timeout}]");
}
_database.Changes.OnDocumentChange -= OnDocumentChange;
_database.Changes.OnCounterChange -= OnCounterChange;
_cts.Cancel();
DisposeTcpClient();
_connectionDisposed.Set();
if (_longRunningSendingWork != null && _longRunningSendingWork != PoolOfThreads.LongRunningWork.Current)
{
while (_longRunningSendingWork.Join((int)timeout.TotalMilliseconds) == false)
{
if (_log.IsInfoEnabled)
{
_log.Info($"Waited {timeout} for timeout to occur, but still this thread is keep on running. Will wait another {timeout} ");
}
DisposeTcpClient();
}
}
try
{
_cts.Dispose();
}
catch (ObjectDisposedException)
{
//was already disposed? we don't care, we are disposing
}
}
public void Dispose()
{
// There are multiple invocations of dispose, this happens sometimes during tests, causing failures.
if (!_disposed.Raise())
{
return;
}
if (_log.IsInfoEnabled)
{
_log.Info($"Disposing OutgoingReplicationHandler ({FromToString})");
}
_database.Changes.OnDocumentChange -= OnDocumentChange;
_cts.Cancel();
try
{
_tcpClient?.Dispose();
}
catch (Exception)
{
// nothing we can do here
}
_connectionDisposed.Set();
if (_sendingThread != Thread.CurrentThread)
{
_sendingThread?.Join();
}
try
{
_cts.Dispose();
}
catch (ObjectDisposedException)
{
//was already disposed? we don't care, we are disposing
}
}
public void Dispose()
{
if (!_disposed.Raise())
{
return;
}
GC.SuppressFinalize(this);
_options.IoMetrics.FileClosed(_filename.FullPath);
_readHandle?.Dispose();
_readHandle = null;
_handle?.Dispose();
_handle = null;
if (_nativeOverlapped != null)
{
NativeMemory.Free((byte *)_nativeOverlapped, sizeof(NativeOverlapped));
_nativeOverlapped = null;
}
if (DeleteOnClose)
{
_options.TryStoreJournalForReuse(_filename);
}
}
public void RingBuffer_WhenEmptyAndSimultaneouslyTryPushAndTryAcquired_ShouldAcquiredLegal()
{
var rb = new SingleConsumerRingBuffer <TestItem>(4);
var acquiredEnd = new SingleUseFlag();
var finished = new Barrier(2);
var cancellation = new CancellationTokenSource();
var timeout = TimeSpan.FromSeconds(1);
var exceptions = new List <Exception>();
var pushTask = Task.Run(() =>
{
try
{
while (acquiredEnd.IsRaised() == false)
{
if (finished.SignalAndWait(timeout, cancellation.Token) == false)
{
break;
}
var testItem = new TestItem
{
TestProperty = finished.CurrentPhaseNumber
};
rb.TryPush(ref testItem);
}
}
catch (OperationCanceledException)
{
}
catch (Exception e)
{
exceptions.Add(e);
}
}, cancellation.Token);
try
{
for (var i = 0; i < 1000; i++)
{
if (finished.SignalAndWait(timeout) == false)
{
break;
}
for (int j = 0; j < 100; j++)
{
if (rb.TryAcquireSingle(out var ringItem))
{
Assert.NotNull(ringItem.Item);
Assert.True(ringItem.IsReady == 1, $"Acquired {ringItem.GetType()} should be set to ready");
break;
}
}
}
}
catch (Exception e)
{
exceptions.Add(e);
}
finally
{
cancellation.Cancel();
acquiredEnd.Raise();
try
{
pushTask.Wait(timeout);
}
catch (Exception e)
{
exceptions.Add(e);
}
cancellation.Dispose();
if (exceptions.Any())
{
throw new AggregateException(exceptions);
}
}
}
public void Dispose()
{
_disposed.Raise();
GC.SuppressFinalize(this);
}
public void MarkForDisposal()
{
ShouldDispose.Raise();
}
