private void RecreateCluster(DataSlice slice)
{
if (slice.Data != null)
{
_entity = (CsBackupableEntities)CompactBinaryFormatter.FromByteBuffer(slice.Data, string.Empty);
if (slice.SliceHeader.ContentType == DataSliceType.Config)
{
if (operationHandler != null)
{
operationHandler.Restore(_entity, _database, Cluster);
}
}
}
}
private RecoveryOperationStatus DatabaseExists(Dictionary <string, string> dbMap, CsBackupableEntities entity, RecoveryJobType jobType)
{
RecoveryOperationStatus state = new RecoveryOperationStatus(RecoveryStatus.Success);
if (dbMap.Count > 0)
{
switch (jobType)
{
case RecoveryJobType.ConfigRestore:
case RecoveryJobType.Restore:
foreach (string db in dbMap.Keys)
{
string destination = dbMap[db];
if (!string.IsNullOrEmpty(destination) && !string.IsNullOrWhiteSpace(destination))
{
if (entity.Database.Keys.Contains(destination))
{
state.Status = RecoveryStatus.Failure;
state.Message = "Destination Database {" + destination + "} already exists";
return(state);
}
}
else if (!string.IsNullOrEmpty(db))
{
if (entity.Database.Keys.Contains(db))
{
state.Status = RecoveryStatus.Failure;
state.Message = "Database {" + db + "} already exists with the Name provided";
return(state);
}
}
else
{
state.Status = RecoveryStatus.Failure;
state.Message = "In-valid name provided for Backup";
return(state);
}
}
break;
case RecoveryJobType.ConfigBackup:
case RecoveryJobType.DataBackup:
case RecoveryJobType.FullBackup:
foreach (string db in dbMap.Keys)
{
if (!string.IsNullOrEmpty(db))
{
if (!entity.Database.Keys.Contains(db))
{
state.Status = RecoveryStatus.Failure;
state.Message = "Database {" + db + "} does not exists";
return(state);
}
}
else
{
state.Status = RecoveryStatus.Failure;
state.Message = "In-valid name provided for Restore";
return(state);
}
}
break;
}
}
return(state);
}
public void Restore(CsBackupableEntities entity, Dictionary <string, string> database, string cluster)
{
_operationHandler.Restore(entity, database, cluster);
}
private RecoveryOperationStatus EnsurePreRequisites(RecoveryConfiguration config, object additionalParams)
{
RecoveryOperationStatus state = new RecoveryOperationStatus(RecoveryStatus.Failure);
state.JobIdentifier = config.Identifier;
Impersonation impersonation = null;
if (RecoveryFolderStructure.PathIsNetworkPath(config.RecoveryPath))
{
impersonation = new Impersonation(config.UserName, config.Password);
}
List <string> shardNameList = new List <string>();
ClusterInfo clusterInfo = GetConfiguredClusters(config.Cluster);
shardNameList.AddRange(clusterInfo.ShardInfo.Keys);
state = RecoveryFolderStructure.ValidateFolderStructure(config.RecoveryPath, config.JobType, true,
shardNameList);
if (state.Status == RecoveryStatus.Failure)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("RecoveryManager.EnsurePreRequisites()", config.RecoveryPath + " : " + state.Message);
}
}
if (state.Status == RecoveryStatus.Success)
{
CsBackupableEntities entity = (CsBackupableEntities)additionalParams;
#region validate db Name
switch (config.JobType)
{
case RecoveryJobType.ConfigRestore:
case RecoveryJobType.Restore:
state = DatabaseExists(config.DatabaseMap, entity, config.JobType);
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
break;
case RecoveryJobType.ConfigBackup:
case RecoveryJobType.DataBackup:
case RecoveryJobType.FullBackup:
state = DatabaseExists(config.DatabaseMap, entity, config.JobType);
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
break;
}
state.Status = RecoveryStatus.Success;
#endregion
#region validate files
if (config.JobType == RecoveryJobType.Restore)
{
string configPath = Path.Combine(config.RecoveryPath, RecoveryFolderStructure.CONFIG_SERVER);
string filePath = Path.Combine(configPath, RecoveryFolderStructure.CONFIG_SERVER);
if (File.Exists(filePath))
{
BackupFile file = new BackupFile(RecoveryFolderStructure.CONFIG_SERVER, configPath, config.UserName, config.Password);
Alachisoft.NosDB.Core.Recovery.Persistence.BackupFile.Header header = file.ReadFileHeader();
if (!header.Database.ToLower().Equals(config.DatabaseMap.First().Key))
{
state.Status = RecoveryStatus.Failure;
state.Message = "Provided file does not contain the source database " +
config.DatabaseMap.First().Key;
}
file.Close();
}
else
{
state.Status = RecoveryStatus.Failure;
state.Message = "No file exists in the given folder";
}
}
#endregion
if (impersonation != null)
{
impersonation.Dispose();
}
}
if (state.Status == RecoveryStatus.Failure)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("RecoveryManager.EnsurePreRequisites()", state.Message);
}
}
return(state);
}
public void SubmitConfigChanged(object changeConfig)
{
try
{
bool failed = true;;
// get all clustered jobs working on given config
foreach (ClusterRecoveryJob job in _runningClusteredJobMap.Values)
{
if (job.ActiveConfig.JobType == RecoveryJobType.Restore || job.ActiveConfig.JobType == RecoveryJobType.ConfigRestore)
{
string db = string.Empty;
// check if exception or actual data
if (changeConfig is RecoveryOperationStatus)
{
RecoveryOperationStatus status = (RecoveryOperationStatus)changeConfig;
string[] splitString = status.JobIdentifier.Split('_');
if (!string.IsNullOrEmpty(splitString[1]))
{
db = splitString[1];
}
else
{
db = splitString[0];
}
}
if (changeConfig is CsBackupableEntities)
{
CsBackupableEntities entity = (CsBackupableEntities)changeConfig;
db = entity.Database.First().Key.ToLower();
failed = false;
}
KeyValuePair <string, string> dbMap = job.ActiveConfig.DatabaseMap.First();
bool valid = false;
if (!string.IsNullOrEmpty(dbMap.Value))
{
if (dbMap.Value.ToLower().Equals(db))
{
valid = true;
}
}
else
{
if (dbMap.Key.ToLower().Equals(db))
{
valid = true;
}
}
if (valid && !failed)
{
RecoveryConfiguration config = new RecoveryConfiguration();
config.Identifier = job.JobIdentifier;
RecoveryStatus state = (job.CurrentState(config) as ClusteredRecoveryJobState).Status;
if (state != RecoveryStatus.Failure || state != RecoveryStatus.Cancelled || state != RecoveryStatus.Completed)
{
if (changeConfig != null)
{
job.SubmitConfigChanged(changeConfig);
}
else
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("RecoveryManager.SubmitConfigChanged()", "failing");
}
job.Cancel(config);// job has failed
// remove job from active config
RemoveRunningJob(config.Identifier);
break;
}
}
}
else if (failed)
{
RecoveryConfiguration config = new RecoveryConfiguration();
config.Identifier = job.JobIdentifier;
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("RecoveryManager.SubmitConfigChanged()", "overall failure");
}
job.Cancel(config);
// remove job from active config
RemoveRunningJob(config.Identifier);
break;
}
//job.
}
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("RecoveryManager.SubmitConfigChanged()", ex.ToString());
}
}
}
internal ConfigurationBackupJob(string identifier, RecoveryPersistenceManager persistenceManager, CsBackupableEntities entities, string cluster, bool isDifJob)
: base(identifier, RecoveryJobType.ConfigBackup, persistenceManager, cluster)
{
_entities = entities;
_isDIFBackup = isDifJob;
}
