public ShardRecoveryJobState(string identifier, string shard, string node, string cluster, RecoveryJobType jobType)
{
if (!string.IsNullOrEmpty(identifier))
{
_identifier = identifier;
}
if (!string.IsNullOrEmpty(shard))
{
_shard = shard;
}
if (!string.IsNullOrEmpty(node))
{
_node = node;
}
if (!string.IsNullOrEmpty(cluster))
{
_cluster = cluster;
}
_jobType = jobType;
_entityList = new List <RecoveryJobStateBase>();
_status = RecoveryStatus.uninitiated;
_message = string.Empty;
_percentage = 0;
}
internal ConfigurationRecoveryJobBase(string jobIdentifier, RecoveryJobType jobType, RecoveryPersistenceManager persistenceManager, string cluster)
{
_jobIdentifier = jobIdentifier;
_jobType = jobType;
_persistenceManager = persistenceManager;
_cluster = cluster;
_executionState = new ShardRecoveryJobState(jobIdentifier, string.Empty, string.Empty, _cluster, _jobType);
}
public RecoveryConfiguration()
{
_jobType = RecoveryJobType.DataBackup;
_operation = RecoveryOpCodes.SubmitTask;
_recoveryPath = string.Empty;
_renameMapping = new Dictionary <string, string>();
_executionPreference = ExecutionPreference.Primary;
_creationTime = DateTime.Now;
_username = String.Empty;
_password = String.Empty;
}
public void Deserialize(Serialization.IO.CompactReader reader)
{
_jobType = (RecoveryJobType)reader.ReadInt32();
_operation = (RecoveryOpCodes)reader.ReadInt32();
_identifier = reader.ReadString();
_cluster = reader.ReadString();
_executionPreference = (ExecutionPreference)reader.ReadInt32();
_configCluster = reader.ReadString();
_recoveryPath = reader.ReadString();
_renameMapping = Util.SerializationUtility.DeserializeDictionary <string, string>(reader);
_creationTime = reader.ReadDateTime();
_username = reader.ReadString();
_password = reader.ReadString();
}
public void Deserialize(Common.Serialization.IO.CompactReader reader)
{
_id = reader.ReadInt64();
NumberOfSlices = reader.ReadInt64();
Database = reader.ReadString();
DatabaseCluster = reader.ReadString();
_crc = reader.ReadInt64();
Version = reader.ReadString();
_creationDate = reader.ReadDateTime();
SegmentMap = Common.Util.SerializationUtility.DeserializeDictionary <long, long>(reader);
_recoveryType = (RecoveryJobType)reader.ReadInt32();
_fullBackupDate = reader.ReadDateTime();
_state = (RecoveryFileState)reader.ReadInt32();
}
public bool SetJobConfiguration(RecoveryJobType jobType, RecoveryPersistenceConfiguration config, string db, int jobCount = 0)
{
bool status = false;
if (_activeContext == null)
{
try
{
PersistenceContext _context = new PersistenceContext();
_context.JobType = jobType;
_context.SharedQueue = this._persistenceQueue;
_context.PersistenceConfiguration = config;
_context.ActiveDB = db;
foreach (string fileName in config.FileName)
{
switch (jobType)
{
case RecoveryJobType.ConfigBackup:
case RecoveryJobType.DataBackup:
case RecoveryJobType.FullBackup:
BackupFile file = new BackupFile(fileName, config.FilePath, config.UserName, config.Password);
file.FileHeader.Database = config.DatabaseName;
file.FileHeader.DatabaseCluster = config.Cluster;
_context.AddNewFile(file);
break;
case RecoveryJobType.ConfigRestore:
case RecoveryJobType.DataRestore:
_context.AddNewFile(new BackupFile(fileName, config.FilePath, config.UserName, config.Password));
break;
}
}
_activeContext = _context;
CreatePersistenceRoles(_context, jobCount == 0 ? DEFAULT_JOB_COUNT : jobCount);
status = true;
}
catch (Exception exp)
{
if (LoggerManager.Instance.RecoveryLogger != null && LoggerManager.Instance.RecoveryLogger.IsErrorEnabled)
{
LoggerManager.Instance.RecoveryLogger.Error("RecoveryPersistenceManager.SetConfig()", exp.ToString());
}
}
}
return(status);
}
protected override void BeginProcessing()
{
SessionState s1 = SessionState;
if (s1.Drive.Current is NosDBPSDriveInfo)
{
if (ConfigurationConnection.ConfigCluster == null)
{
throw new Exception("You must be connected to database cluster for submit-recovery job.");
}
switch (Type.ToLower())
{
case "configrestore":
_jobType = RecoveryJobType.ConfigRestore;
SourceDatabaseName = string.Empty;
break;
case "configbackup":
_jobType = RecoveryJobType.ConfigBackup;
SourceDatabaseName = string.Empty;
break;
case "databackup":
_jobType = RecoveryJobType.DataBackup;
VerifyDatabaseName();
break;
case "datarestore":
_jobType = RecoveryJobType.DataRestore;
VerifyDatabaseName();
break;
case "fullbackup":
_jobType = RecoveryJobType.FullBackup;
VerifyDatabaseName();
break;
case "restore":
_jobType = RecoveryJobType.Restore;
VerifyDatabaseName();
break;
}
}
else
{
throw new Exception("You must be in NosDB: PSDrive for Submit-RecoveryJob.");
}
}
public override void Deserialize(Serialization.IO.CompactReader reader)
{
Identifier = reader.ReadString();
Message = reader.ReadString();
Status = (RecoveryStatus)reader.ReadInt32();
PercentageExecution = reader.ReadSingle();
MessageTime = reader.ReadDateTime();
StopTime = reader.ReadDateTime();
_cluster = reader.ReadString();
_shard = reader.ReadString();
_node = reader.ReadString();
_jobType = (RecoveryJobType)reader.ReadInt32();
Detail = Common.Util.SerializationUtility.DeserializeList <RecoveryJobStateBase>(reader);
_lastOperationID = (OperationId)reader.ReadObject();
_lastFullBackupDate = reader.ReadDateTime();
}
internal RecoveryJobBase(string identifier, string database, List <string> collectionList, RecoveryJobType jobType,
RecoveryPersistenceManager _manager, string cluster)
{
_jobIdentifier = identifier;
_database = database;
_collections = collectionList;
_jobType = jobType;
string entityName = database;
switch (jobType)
{
case RecoveryJobType.ConfigBackup:
case RecoveryJobType.ConfigRestore:
entityName = "ConfigServer";
break;
}
_executionStatus = new RecoveryJobStateBase(identifier, entityName);
_persistenceManager = _manager;
_cluster = cluster;
}
public static RecoveryOperationStatus ValidateFolderStructure(string path, RecoveryJobType jobType, bool configCheck, List <string> shardNameList)
{
RecoveryOperationStatus state = new RecoveryOperationStatus(RecoveryStatus.Success);
try
{
// based on folder type shared or local
// 1. check if folder accessible
// 2. check if provided folders comply with the requirements
bool networkPath = PathIsNetworkPath(path);
if (networkPath)
{
if (configCheck)
{
if (!Directory.Exists(path))
{
state.Status = RecoveryStatus.Failure;
state.Message = "Provided path'" + path + "' is invalid or access is denied";
return(state);
}
}
switch (jobType)
{
case RecoveryJobType.ConfigRestore:
state = ValidateConfigFolder(path, false);
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
break;
case RecoveryJobType.Restore:
state = ValidateConfigFolder(path, false);
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
state = RemoteValidateShardFolder(path, false, shardNameList);
break;
case RecoveryJobType.DataRestore:
state = RemoteValidateShardFolder(path, false, shardNameList);
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
//check for file paths of all shards
break;
case RecoveryJobType.Export:
if (!Directory.Exists(path))
{
state.Message = "Path provided is invalid or access is denied";
}
break;
case RecoveryJobType.Import:
if (!File.Exists(path))
{
state.Message = "Path provided is invalid or access is denied";
}
break;
}
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
}
else
{
if (configCheck)
{
if (Directory.Exists(path))
{
switch (jobType)
{
case RecoveryJobType.ConfigRestore:
case RecoveryJobType.Restore:
state = ValidateConfigFolder(path, false);
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
break;
}
}
else
{
state.Message = "Path provided is invalid or access is denied";
}
}
else
{
switch (jobType)
{
case RecoveryJobType.DataRestore:
state = ValidateShardFolder(path, false);
if (state.Status == RecoveryStatus.Failure)
{
return(state);
}
break;
case RecoveryJobType.Export:
if (!Directory.Exists(path))
{
state.Message = "Path provided is invalid or access is denied";
return(state);
}
break;
case RecoveryJobType.Import:
if (!File.Exists(path))
{
state.Message = "Path provided is invalid or access is denied";
return(state);
}
break;
}
}
}
}
catch (Exception exp)
{
state.Message = exp.ToString();
}
return(state);
}
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);
}
internal JobInfoObject(string id, string shardName, string nodeAddress, string clusterName, RecoveryJobType jobType, string path)
{
_jobList = new List <RecoveryJobBase>();
_jobIdentifier = id;
_rootPath = path;
_recoveryPersistenceManager = new Recovery.RecoveryPersistenceManager();
_recoveryPersistenceManager.LocalShardName = shardName;
_executionState = new ShardRecoveryJobState(id, shardName, nodeAddress, clusterName, jobType);
_mutex = new object();
}
internal ConfigurationRestoreJob(string identifier, RecoveryPersistenceManager persistenceManager, IConfigOperationExecutor opHandler, string cluster, Dictionary <string, string> database, RecoveryJobType jobType)
: base(identifier, jobType, persistenceManager, cluster)
{
operationHandler = opHandler;
_database = database;
}
public RecoveryOperationStatus ValidatePath(string path, RecoveryJobType jobType)
{
return(RecoveryFolderStructure.ValidateFolderStructure(path, jobType, false, null));
}
