private bool ShouldRunBackupAfterTimerCallback(NextBackup backupInfo, out PeriodicBackup periodicBackup)
{
if (_periodicBackups.TryGetValue(backupInfo.TaskId, out periodicBackup) == false)
{
// periodic backup doesn't exist anymore
return(false);
}
DatabaseTopology topology;
using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
using (var rawRecord = _serverStore.Cluster.ReadRawDatabaseRecord(context, _database.Name))
{
if (rawRecord == null)
{
return(false);
}
topology = rawRecord.GetTopology();
}
var taskStatus = GetTaskStatus(topology, periodicBackup.Configuration);
return(taskStatus == TaskStatus.ActiveByCurrentNode);
}
private void UpdateTimerInternal(NextBackup nextBackup, bool discardIfDisabled)
{
if (Disposed)
{
return;
}
if (discardIfDisabled && _backupTimer == null)
{
return;
}
_backupTimer?.Dispose();
if (_logger.IsOperationsEnabled)
{
_logger.Operations($"Next {(nextBackup.IsFull ? "full" : "incremental")} backup is in {nextBackup.TimeSpan.TotalMinutes} minutes.");
}
var timer = nextBackup.TimeSpan < _periodicBackupRunner.MaxTimerTimeout
? new Timer(_periodicBackupRunner.TimerCallback, nextBackup, nextBackup.TimeSpan, Timeout.InfiniteTimeSpan)
: new Timer(_periodicBackupRunner.LongPeriodTimerCallback, nextBackup, _periodicBackupRunner.MaxTimerTimeout, Timeout.InfiniteTimeSpan);
_backupTimer = new BackupTimer
{
Timer = timer,
CreatedAt = DateTime.UtcNow,
NextBackup = nextBackup
};
}
private void StartBackupTaskAndRescheduleIfNeeded(PeriodicBackup periodicBackup, NextBackup currentBackup)
{
try
{
CreateBackupTask(periodicBackup, currentBackup.IsFull, currentBackup.DateTime);
}
catch (BackupDelayException e)
{
if (_logger.IsInfoEnabled)
{
_logger.Info($"Backup task will be retried in {(int)e.DelayPeriod.TotalSeconds} seconds.", e);
}
// we'll retry in one minute
var backupTaskDetails = new NextBackup
{
IsFull = currentBackup.IsFull,
TaskId = periodicBackup.Configuration.TaskId,
DateTime = DateTime.UtcNow.Add(e.DelayPeriod),
TimeSpan = e.DelayPeriod
};
var timer = new Timer(TimerCallback, backupTaskDetails, backupTaskDetails.TimeSpan, Timeout.InfiniteTimeSpan);
periodicBackup.UpdateTimer(timer);
}
}
public void UpdateTimer(NextBackup nextBackup, bool lockTaken, bool discardIfDisabled = false)
{
if (nextBackup == null)
{
return;
}
if (lockTaken == false)
{
using (UpdateBackupTask())
{
UpdateTimerInternal(nextBackup, discardIfDisabled);
}
}
else
{
UpdateTimerInternal(nextBackup, discardIfDisabled);
}
}
private void UpdateTimerInternal(NextBackup nextRun)
{
if (Configuration.Disabled)
{
return;
}
_timer?.Dispose();
if (Logger.IsOperationsEnabled)
{
Logger.Operations($"OLAP ETL '{Name}' : Next run is in {nextRun.TimeSpan.TotalMinutes} minutes.");
}
var timer = new Timer(_ => _waitForChanges.Set(), state: nextRun, dueTime: nextRun.TimeSpan, period: Timeout.InfiniteTimeSpan);
_timer = new PeriodicBackup.PeriodicBackup.BackupTimer
{
Timer = timer,
CreatedAt = DateTime.UtcNow,
NextBackup = nextRun
};
}
