public void RecoverScannedImages(Action<IScannedImage> imageCallback)
{
var op = new RecoveryOperation(formFactory, scannedImageFactory, userConfigManager, threadFactory);
var progressForm = formFactory.Create<FProgress>();
progressForm.Operation = op;
if (op.Start(imageCallback))
{
progressForm.ShowDialog();
}
}
public void RecoverScannedImages(Action<ScannedImage> imageCallback)
{
var op = new RecoveryOperation(formFactory, threadFactory, thumbnailRenderer);
var progressForm = formFactory.Create<FProgress>();
progressForm.Operation = op;
if (op.Start(imageCallback))
{
progressForm.ShowDialog();
}
}
public RecoveryOperationViewModel(RecoveryOperation recoveryOperationInfo, NotificationApplicationCompletionProgress progress)
{
NotificationId = recoveryOperationInfo.NotificationId;
NotificationType = recoveryOperationInfo.NotificationType;
IsPreconsentStatusChosen = progress.HasPreconsentedInformation;
AreOperationCodesChosen = progress.HasOperationCodes;
IsTechnologyEmployedCompleted = progress.HasTechnologyEmployed;
IsReasonForExportCompleted = progress.HasReasonForExport;
PreconstedAnswer = recoveryOperationInfo.PreconstedAnswer;
OperationCodes = recoveryOperationInfo.OperationCodes.OrderBy(c => c).Select(EnumHelper.GetDisplayName).ToList();
TechnologyEmployed = recoveryOperationInfo.TechnologyEmployed;
ReasonForExport = recoveryOperationInfo.ReasonForExport;
}
public void correct_recovery_operation_is_invoked()
{
RecoveryResult result;
LiveProducer.SetLastTimestampBeforeDisconnect(DateTime.MinValue);
var operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LiveMessagesOnly }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out result));
LiveProducer.SetLastTimestampBeforeDisconnect(TimeProviderAccessor.Current.Now - TimeSpan.FromMinutes(10));
operation.Start();
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), It.IsAny <DateTime>(), 0), Times.Once);
_recoveryRequestIssuerMock.Verify(x => x.RequestFullOddsRecoveryAsync(It.IsAny <IProducer>(), 0), Times.Once);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out result));
}
public void starting_recovery_with_after_to_far_in_past_throws()
{
var producer = LiveProducer;
producer.SetLastTimestampBeforeDisconnect(_timeProvider.Now - (producer.MaxAfterAge() + TimeSpan.FromSeconds(30)));
var operation = new RecoveryOperation(producer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, true);
try
{
operation.Start();
}
catch (Exception)
{
_recoveryRequestIssuerMock.Verify(x => x.RequestFullOddsRecoveryAsync(It.IsAny <IProducer>(), 0), Times.Never);
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), It.IsAny <DateTime>(), 0), Times.Never);
producer.SetLastTimestampBeforeDisconnect(DateTime.MinValue);
throw;
}
}
public void RecoveryIsCalledWithCorrectAdjustedAfter()
{
var operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LiveMessagesOnly }, 0, true);
_liveProducer.SetLastTimestampBeforeDisconnect(TimeProviderAccessor.Current.Now - TimeSpan.FromMinutes(321));
operation.Start();
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), _liveProducer.LastTimestampBeforeDisconnect, 0), Times.Once);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
_liveProducer.SetLastTimestampBeforeDisconnect(TimeProviderAccessor.Current.Now - TimeSpan.FromMinutes(90));
operation.Start();
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), _liveProducer.LastTimestampBeforeDisconnect, 0), Times.Once);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
_liveProducer.SetLastTimestampBeforeDisconnect(TimeProviderAccessor.Current.Now - TimeSpan.FromMinutes(10));
operation.Start();
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), _liveProducer.LastTimestampBeforeDisconnect, 0), Times.Once);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
}
public void FirstInterruptTimeIsRecorded()
{
var operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Start();
_timeProvider.AddSeconds(60);
var interruptTime = _timeProvider.Now;
operation.Interrupt(interruptTime);
_timeProvider.AddSeconds(60);
operation.Interrupt(_timeProvider.Now);
operation.TryComplete(MessageInterest.AllMessages, out var result);
Assert.IsNotNull(result);
Assert.AreEqual(result.InterruptedAt, interruptTime);
}
public void recovery_is_called_with_correct_after()
{
RecoveryResult result;
var operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LiveMessagesOnly }, 0, false);
LiveProducer.SetLastTimestampBeforeDisconnect(TimeProviderAccessor.Current.Now - TimeSpan.FromMinutes(10));
operation.Start();
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), LiveProducer.LastTimestampBeforeDisconnect, 0), Times.Once);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out result));
LiveProducer.SetLastTimestampBeforeDisconnect(TimeProviderAccessor.Current.Now - TimeSpan.FromMinutes(90));
operation.Start();
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), LiveProducer.LastTimestampBeforeDisconnect, 0), Times.Once);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out result));
LiveProducer.SetLastTimestampBeforeDisconnect(TimeProviderAccessor.Current.Now - TimeSpan.FromMinutes(321));
operation.Start();
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(It.IsAny <IProducer>(), LiveProducer.LastTimestampBeforeDisconnect, 0), Times.Once);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out result));
}
public void values_after_time_out_are_correct()
{
var operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Start();
var startTime = _timeProvider.Now;
_timeProvider.AddSeconds(LiveProducer.MaxRecoveryTime + 1);
Assert.IsTrue(operation.HasTimedOut());
var result = operation.CompleteTimedOut();
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.AreEqual(result.RequestId, 1);
Assert.AreEqual(result.InterruptedAt, null);
Assert.AreEqual(result.StartTime, startTime);
Assert.IsTrue(result.TimedOut);
Assert.IsFalse(operation.IsRunning);
Assert.IsNull(operation.RequestId);
}
private RecoveryOperationStatus ResumeRecoveryJob(RecoveryOperation opContext)
{
RecoveryOperationStatus status = new RecoveryOperationStatus(RecoveryStatus.Failure);
status.JobIdentifier = opContext.JobIdentifer;
if (opContext != null)
{
if (_databaseJobMap.ContainsKey(opContext.JobIdentifer))
{
List <RecoveryJobBase> _jobList = _databaseJobMap[opContext.JobIdentifer].JobList;
if (_jobList.Count == 1)
{
_jobList[0].Resume();
}
else
{
// M_TODO: complete sharded backup
}
}
}
return(status);
}
public void OperationCanBeReused()
{
var operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LiveMessagesOnly }, 0, false);
operation.Start();
_timeProvider.AddSeconds(60);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
_timeProvider.AddSeconds(1800);
operation.Start();
_timeProvider.AddSeconds(120);
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
operation.Start();
_timeProvider.AddSeconds(_liveProducer.MaxRecoveryTime + 1);
Assert.IsTrue(operation.HasTimedOut());
Assert.IsNotNull(operation.CompleteTimedOut());
_timeProvider.AddSeconds(10);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
}
public void works_correct_with_only_one_session()
{
RecoveryResult result;
RecoveryOperation operation;
operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.AllMessages, out result));
operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LiveMessagesOnly }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out result));
operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.PrematchMessagesOnly }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.PrematchMessagesOnly, out result));
operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.VirtualSportMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.VirtualSportMessages, out result));
operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.HighPriorityMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.HighPriorityMessages, out result));
operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LowPriorityMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.LowPriorityMessages, out result));
operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Start();
Assert.IsFalse(operation.TryComplete(MessageInterest.LiveMessagesOnly, out result));
Assert.IsFalse(operation.TryComplete(MessageInterest.PrematchMessagesOnly, out result));
Assert.IsFalse(operation.TryComplete(MessageInterest.VirtualSportMessages, out result));
Assert.IsFalse(operation.TryComplete(MessageInterest.HighPriorityMessages, out result));
Assert.IsFalse(operation.TryComplete(MessageInterest.LowPriorityMessages, out result));
Assert.IsTrue(operation.TryComplete(MessageInterest.AllMessages, out result));
}
public void ValuesAfterCompletionAreCorrect()
{
var operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Start();
var startTime = _timeProvider.Now;
_timeProvider.AddSeconds(60);
var completed = operation.TryComplete(MessageInterest.AllMessages, out var result);
Assert.IsTrue(completed);
Assert.IsNotNull(result);
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.RequestId);
Assert.AreEqual(startTime, result.StartTime);
Assert.IsNull(result.InterruptedAt);
Assert.IsFalse(result.TimedOut);
Assert.IsFalse(operation.IsRunning);
Assert.IsNull(operation.RequestId);
}
private RecoveryOperationStatus GetJobStatistics(RecoveryOperation opContext)
{
RecoveryOperationStatus status = new RecoveryOperationStatus(RecoveryStatus.Success);
status.JobIdentifier = opContext.JobIdentifer;
if (opContext != null)
{
try
{
if (_databaseJobMap.ContainsKey(opContext.JobIdentifer))
{
foreach (RecoveryJobBase job in _databaseJobMap[opContext.JobIdentifer].JobList)
{
// query latest job status
_databaseJobMap[opContext.JobIdentifer].ExecutionState.UpdateEntityState((RecoveryJobStateBase)job.JobStatistics());// job statistics returning mechanism
}
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("ShardRecoveryManager.GetStatistics()", opContext.JobIdentifer + "_" + _databaseJobMap[opContext.JobIdentifer].ExecutionState.JobType + " : " + ex.ToString());
}
if (_databaseJobMap.ContainsKey(opContext.JobIdentifer))
{
_databaseJobMap[opContext.JobIdentifer].ExecutionState.Status = RecoveryStatus.Failure;
_databaseJobMap[opContext.JobIdentifer].ExecutionState.Message = "Failure during get statistics call";
}
}
finally
{
CheckJobState(opContext.JobIdentifer, true);
}
}
return(status);
}
public void WorksCorrectWithOnlyOneSession()
{
var operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.AllMessages, out _));
operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LiveMessagesOnly }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.PrematchMessagesOnly }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.PrematchMessagesOnly, out _));
operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.VirtualSportMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.VirtualSportMessages, out _));
operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.HighPriorityMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.HighPriorityMessages, out _));
operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.LowPriorityMessages }, 0, false);
operation.Start();
Assert.IsTrue(operation.TryComplete(MessageInterest.LowPriorityMessages, out _));
operation = new RecoveryOperation(_liveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Start();
Assert.IsFalse(operation.TryComplete(MessageInterest.LiveMessagesOnly, out _));
Assert.IsFalse(operation.TryComplete(MessageInterest.PrematchMessagesOnly, out _));
Assert.IsFalse(operation.TryComplete(MessageInterest.VirtualSportMessages, out _));
Assert.IsFalse(operation.TryComplete(MessageInterest.HighPriorityMessages, out _));
Assert.IsFalse(operation.TryComplete(MessageInterest.LowPriorityMessages, out _));
Assert.IsTrue(operation.TryComplete(MessageInterest.AllMessages, out _));
}
public void recovery_is_started_after_connection_is_shutdown()
{
_timeProvider.Now = new DateTime(2000, 1, 1, 12, 0, 0);
var disconnectedTime = _timeProvider.Now - TimeSpan.FromHours(2);
_producer.SetLastTimestampBeforeDisconnect(disconnectedTime);
var recoveryOperation = new RecoveryOperation(_producer, _recoveryRequestIssuerMock.Object, new[] { DefaultInterest }, 0, false);
var recoveryManager = new ProducerRecoveryManager(_producer, recoveryOperation, _timestampTracker);
recoveryManager.ProcessSystemMessage(_messageBuilder.BuildAlive());
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(_producer, disconnectedTime, 0), Times.Once);
Assert.AreEqual(ProducerRecoveryStatus.Started, recoveryManager.Status);
Debug.Assert(recoveryOperation.RequestId != null, "recoveryOperation.RequestId != null");
recoveryManager.ProcessUserMessage(_messageBuilder.BuildSnapshotComplete(recoveryOperation.RequestId.Value), DefaultInterest);
Assert.AreEqual(ProducerRecoveryStatus.Completed, recoveryManager.Status);
recoveryManager.ProcessUserMessage(_messageBuilder.BuildAlive(_producer.Id, _timeProvider.Now), DefaultInterest);
recoveryManager.ConnectionShutdown();
Assert.AreEqual(ProducerRecoveryStatus.Error, recoveryManager.Status);
recoveryManager.ProcessSystemMessage(_messageBuilder.BuildAlive());
Assert.AreEqual(ProducerRecoveryStatus.Started, recoveryManager.Status);
_recoveryRequestIssuerMock.Verify(x => x.RequestRecoveryAfterTimestampAsync(_producer, _timeProvider.Now, 0));
}
//M_TODO: must Specify DB name in case of shard job, so a separate job is created, for now this will run multiple times and override job if more
//than one db is specified.
private JobInfoObject CreateRestoreJob(RecoveryOperation opContext)
{
JobInfoObject infoObject = null;
RecoveryJobBase dataJob = null;
#region RestoreJob
SubmitRestoreOpParams resParam = (SubmitRestoreOpParams)opContext.Parameter;
foreach (string db in resParam.PersistenceConfiguration.DbCollectionMap.Keys)
{
// create handler object
// Note: this is kept inside the loop with the assumption that a seperate info object is to be kept for each database in complete cluster job
infoObject = new JobInfoObject(opContext.JobIdentifer, _context.LocalShardName, _context.LocalAddress.ip, _context.ClusterName,
RecoveryJobType.DataRestore, resParam.PersistenceConfiguration.FilePath);
string destination = resParam.PersistenceConfiguration.DbCollectionMap[db].Keys.First();
// create DataJob
dataJob = new DatabaseRestoreJob(opContext.JobIdentifer, _context, destination, resParam.PersistenceConfiguration.DbCollectionMap[db][destination].ToList <string>(), infoObject.RecoveryPersistenceManager, _context.ClusterName);
dataJob.RegisterProgressHandler(this);
infoObject.AddJob(dataJob);
// set persistence configuration
if (resParam.PersistenceConfiguration.FileName == null)
{
resParam.PersistenceConfiguration.FileName = new List <string>();
resParam.PersistenceConfiguration.FileName.Add(db);//add name of all databases for shard level job
}
infoObject.RecoveryPersistenceManager.SetJobConfiguration(RecoveryJobType.DataRestore, resParam.PersistenceConfiguration, db, 1);
}
#endregion
return(infoObject);
}
public RecoveryOperationStatus SubmitDataRecoveryJob(string cluster, string shard, RecoveryOperation opContext)
{
try
{
return(dbMgtServer.OnRecoveryOperationReceived(cluster, shard, opContext));
}
catch (System.Exception ex)
{
throw ex;
}
}
internal override bool Initialize(RecoveryOperation operation)
{
return(base.Initialize(operation));
}
internal RecoveryOperationStatus RecoveryOperationReceived(RecoveryOperation opContext)
{
RecoveryOperationStatus status = new RecoveryOperationStatus(RecoveryStatus.Failure);
status.JobIdentifier = opContext.JobIdentifer;
try
{
switch (opContext.OpCode)
{
case RecoveryOpCodes.SubmitBackupJob:
case RecoveryOpCodes.SubmitRestoreJob:
if (ValidatePrequisites(opContext).Status == RecoveryStatus.Success)
{
status.Status = RecoveryStatus.Submitted;
status.Message = "Submitted successfuly";
SubmitRecoveryJob(opContext);
}
else
{
status.Message = "Failed to submit task on node";
}
break;
case RecoveryOpCodes.StartJob:
status = StartRecoveryJob(opContext);
break;
case RecoveryOpCodes.EndJob:
case RecoveryOpCodes.CancelJob:
status = CancelRecoveryJob(opContext);
break;
case RecoveryOpCodes.PauseJob:
status = PauseRecoveryJob(opContext);
break;
case RecoveryOpCodes.ResumeJob:
status = ResumeRecoveryJob(opContext);
break;
case RecoveryOpCodes.CancelAllJobs:
status = CancelAllJobs();
break;
case RecoveryOpCodes.SubmitShardBackupJob:
case RecoveryOpCodes.SubmitShardRecoveryJob:
if (ValidatePrequisites(opContext).Status == RecoveryStatus.Success)
{
status.Status = RecoveryStatus.Submitted;
status.Message = "Submitted successfuly";
SubmitShardRecoveryJob(opContext);
}
else
{
status.Message = "Failed to submit task on node";
}
break;
case RecoveryOpCodes.GetJobStatistics:
status = GetJobStatistics(opContext);
break;
}
}
catch (Exception exp)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("ShardRecoveryManager.Receive()", exp.ToString());
}
}
return(status);
}
private RecoveryOperationStatus ValidatePrequisites(RecoveryOperation opContext)
{
RecoveryOperationStatus state = new RecoveryOperationStatus(RecoveryStatus.Success);
state.JobIdentifier = opContext.JobIdentifer;
try
{
// must check state transfer
//if (_context.StatusLatch.IsAnyBitsSet(BucketStatus.UnderStateTxfr))
//{
// state.Status = RecoveryStatus.Success;//M_TODO: change this to false, once this state transfer code is complete
// if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsInfoEnabled)
// LoggerManager.Instance.RecoveryLogger.Info("ShardRecoveryManager.Validate()", opContext.JobIdentifer + " failed because node is in state transfer");
//}
if (state.Status == RecoveryStatus.Success)
{
string path = string.Empty;
string username = "";
string password = "";
Dictionary <string, Dictionary <string, string[]> > dbMap = new Dictionary <string, Dictionary <string, string[]> >();
switch (opContext.OpCode)
{
case RecoveryOpCodes.SubmitBackupJob:
SubmitBackupOpParams _bckpParam = (SubmitBackupOpParams)opContext.Parameter;
path = _bckpParam.PersistenceConfiguration.FilePath;
dbMap = _bckpParam.PersistenceConfiguration.DbCollectionMap;
username = _bckpParam.PersistenceConfiguration.UserName;
password = _bckpParam.PersistenceConfiguration.Password;
break;
case RecoveryOpCodes.SubmitRestoreJob:
SubmitRestoreOpParams _resParam = (SubmitRestoreOpParams)opContext.Parameter;
path = Path.Combine(_resParam.PersistenceConfiguration.FilePath);
username = _resParam.PersistenceConfiguration.UserName;
password = _resParam.PersistenceConfiguration.Password;
dbMap = _resParam.PersistenceConfiguration.DbCollectionMap;
List <string> shardNameList = new List <string>();
shardNameList.Add(_context.LocalShardName);
Impersonation impersonation = null;
bool isSharedPath = RecoveryFolderStructure.PathIsNetworkPath(path);
if (isSharedPath)
{
impersonation = new Impersonation(username, password);
}
state = RecoveryFolderStructure.ValidateFolderStructure(path, RecoveryJobType.DataRestore, false, shardNameList);
if (isSharedPath)
{
impersonation.Dispose();
}
if (state.Status == RecoveryStatus.Failure)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("ShardRecoveryManager.Validate()", state.Message);
}
return(state);
}
else
{
#region validate files
string folderName = string.Empty;
string fileName = dbMap.First().Key;
string folderPath = Path.Combine(path, folderName);
string filePath = Path.Combine(folderPath, fileName);
isSharedPath = RecoveryFolderStructure.PathIsNetworkPath(folderPath);
bool fileExists = false;
if (isSharedPath)
{
BackupFile file = new BackupFile(fileName, folderPath, null, null);
impersonation = new Impersonation(username, password);
fileExists = File.Exists(filePath);
impersonation.Dispose();
}
else
{
fileExists = File.Exists(filePath);
}
if (fileExists)
{
BackupFile file = new BackupFile(fileName, folderPath, username, password);
Alachisoft.NosDB.Core.Recovery.Persistence.BackupFile.Header header = file.ReadFileHeader();
if (!header.Database.ToLower().Equals(dbMap.First().Key))
{
state.Status = RecoveryStatus.Failure;
state.Message = "Provided file does not contain the source database " + fileName;
file.Close();
return(state);
}
file.Close();
}
else
{
state.Status = RecoveryStatus.Failure;
state.Message = "No file exists in the given folder";
return(state);
}
#endregion
}
break;
}
// this will only be false for backup
if (!Directory.Exists(path))
{
try
{
Impersonation impersonation = null;
if (RecoveryFolderStructure.PathIsNetworkPath(path))
{
impersonation = new Impersonation(username, password);
}
Directory.CreateDirectory(path);
if (dbMap.Count > 0)
{
// check space for backup job
long size = 0;
foreach (string db in dbMap.Keys)
{
DatabaseStore database = _context.DatabasesManager.GetDatabase(db) as DatabaseStore;
size = database.Size;
}
ulong availableFreeSpace = Util.DirectoryUtil.GetDiskFreeSpace(path);
ulong requiredSize = (ulong)size;
if (availableFreeSpace > requiredSize)
{
state.Status = RecoveryStatus.Success;
}
else
{
state.Status = RecoveryStatus.Failure;
state.Message = "Available memory is less than the required memory for backup";
return(state);
}
}
if (impersonation != null)
{
impersonation.Dispose();
}
}
catch (Exception ex)
{
state.Status = RecoveryStatus.Failure;
state.Message = ex.Message;
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("ShardRecoveryManager.Validate()", ex.ToString());
}
}
}
}
}
catch (Exception exp)
{
state.Status = RecoveryStatus.Failure;
state.Message = exp.ToString();
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("ShardRecoveryManager.Validate()", opContext.JobIdentifer + " : " + exp.ToString());
}
}
return(state);
}
public void setting_interrupt_on_not_running_instance_throws()
{
var operation = new RecoveryOperation(LiveProducer, _recoveryRequestIssuerMock.Object, new[] { MessageInterest.AllMessages }, 0, false);
operation.Interrupt(_timeProvider.Now);
}
public RecoveryOperationStatus SubmitRecoveryJob(string cluster, string shard, RecoveryOperation opContext)
{
return(_communicationHandler.SubmitRecoveryJob(cluster, shard, opContext));
}
private RecoveryOperationStatus CancelRecoveryJob(RecoveryOperation opContext)
{
RecoveryOperationStatus status = new RecoveryOperationStatus(RecoveryStatus.Success);
status.JobIdentifier = opContext.JobIdentifer;
if (opContext != null)
{
try
{
#region End/Cancel job
if (_databaseJobMap.ContainsKey(opContext.JobIdentifer))
{
List <RecoveryJobBase> jobList = _databaseJobMap[opContext.JobIdentifer].JobList;
foreach (RecoveryJobBase job in jobList)
{
if (opContext.OpCode == RecoveryOpCodes.CancelJob)
{
switch (job.JobType)
{
case RecoveryJobType.DataBackup:
_databaseJobMap[opContext.JobIdentifer].RecoveryPersistenceManager.CloseBackupFile(job.Database, RecoveryFileState.Cancelled);
break;
//NOTE: diffbackup job is ignored under the assumption oplog file will close the file for it
}
}
//if (job.JobType != RecoveryJobType.DifferentialRestore)
{
try
{
if (job.State != ThreadState.Unstarted && job.State != ThreadState.Stopped && job.State != ThreadState.WaitSleepJoin)
{
job.Stop();
}
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
catch (Exception exp)
{ }
try
{
job.Dispose();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
catch (Exception exp)
{ }
}
//else
//{
// _databaseJobMap[opContext.JobIdentifer].RecoveryPersistenceManager.IsJobActive = false;
// _databaseJobMap[opContext.JobIdentifer].RecoveryPersistenceManager.Dispose();
//}
}
#region rename folder
JobInfoObject infoObj = _databaseJobMap[opContext.JobIdentifer];
if (infoObj.JobType == RecoveryJobType.DataBackup)
{
switch (opContext.OpCode)
{
case RecoveryOpCodes.CancelJob:
infoObj.RenameRootFolder(RecoveryFileState.Cancelled);
break;
}
}
#endregion
// removing job from databaseJobMap
_databaseJobMap[opContext.JobIdentifer].RecoveryPersistenceManager.IsJobActive = false;
_databaseJobMap[opContext.JobIdentifer].Dispose();
_databaseJobMap.Remove(opContext.JobIdentifer);
}
#endregion
}
catch (Exception exp)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("ShardRecoveryManager.CancelRecoveryJob()", opContext.JobIdentifer + "_" + _databaseJobMap[opContext.JobIdentifer].ExecutionState.JobType + " : " + exp.ToString());
}
if (_databaseJobMap.ContainsKey(opContext.JobIdentifer))
{
_databaseJobMap[opContext.JobIdentifer].ExecutionState.Status = RecoveryStatus.Failure;
_databaseJobMap[opContext.JobIdentifer].ExecutionState.Message = "Failure during Cancel phase";
// commented because the config server will not have any job handler to recieve this message
//CheckJobState(opContext.JobIdentifer, true);
}
status.Status = RecoveryStatus.Failure;
status.Message = exp.ToString();
}
}
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsInfoEnabled)
{
LoggerManager.Instance.RecoveryLogger.Info("ShardRecoveryManager.CancelRecoveryJob()", status.ToString());
}
return(status);
}
internal virtual bool Initialize(RecoveryOperation operation)
{
_jobIdentifier = operation.JobIdentifer;
return(true);
}
public Common.Recovery.RecoveryOperationStatus SubmitDataRecoveryJob(string cluster, string shard, RecoveryOperation opContext)
{
try
{
ManagementCommand command = GetManagementCommand(ConfigurationCommandUtil.MethodName.SubmitRecoveryJob);
command.Parameters.AddParameter(cluster);
command.Parameters.AddParameter(shard);
command.Parameters.AddParameter(opContext);
return((Common.Recovery.RecoveryOperationStatus)ExecuteCommandOnMgtServer(command, true));
}
catch (System.Exception e)
{
throw e;
}
}
