public void OnDropDatabase(String database)
{
IStateTransferTask task = null;
lock (dbStateTxferMgrMap)
{
if (dbStateTxferMgrMap.ContainsKey(database))
{
task = dbStateTxferMgrMap[database];
dbStateTxferMgrMap.Remove(database);
}
}
if (task != null)
{
lock (_schMutex)
{
//we don't know wether dropped database task is waiting or running so just remove it from both :)
waitingDBTasks.Remove(database);
runningDBTasks.Remove(database);
}
task.Stop();
}
}
public void Dispose()
{
lock (dbStateTxferMgrMap)
{
//lock (_stateTxfrMutex)
//{
if (_resourceManager != null)
{
_resourceManager.Dispose();
}
foreach (KeyValuePair <String, DatabaseStateTransferManager> dbTaskInfo in dbStateTxferMgrMap)
{
IStateTransferTask task = dbTaskInfo.Value as IStateTransferTask;
if (task != null)
{
task.Dispose();
}
}
dbStateTxferMgrMap.Clear();
dbStateTxferMgrMap = null;
//}
}
}
/// <summary>
/// Pause NST on this node
/// </summary>
public void Pause()
{
lock (dbStateTxferMgrMap)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("NodeStateTranferManager.Pause()", "State Transfer Paused on " + this.context.LocalAddress.ToString());
}
if (_resourceManager != null)
{
_resourceManager.Pause();
}
foreach (KeyValuePair <String, DatabaseStateTransferManager> dbTaskInfo in dbStateTxferMgrMap)
{
IStateTransferTask task = dbTaskInfo.Value as IStateTransferTask;
if (task != null)
{
task.Pause();
}
}
}
}
internal void OnDropCollection(String collection)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("DatabaseStateTransferManager.OnDropCollection()", "collection " + collection + " being dropped");
}
IStateTransferTask task = null;
lock (_schMutex)
{
lock (collectionTasksMap)
{
if (collectionTasksMap.ContainsKey(collection))
{
task = collectionTasksMap[collection];
collectionTasksMap.Remove(collection);
}
}
if (task != null)
{
waitingColTasks.Remove(collection);
runningColTasks.Remove(collection);
task.Stop();
}
}
lock (collectionCorresponderMap)
{
foreach (KeyValuePair <StateTransferIdentity, ICorresponder> pair in collectionCorresponderMap)
{
if (pair.Key.ColName.Equals(collection, StringComparison.OrdinalIgnoreCase))
{
ICorresponder crossponder = collectionCorresponderMap[pair.Key];
if (crossponder != null)
{
crossponder.Dispose();
if (resourceManager != null)
{
resourceManager.UnregisterResource(crossponder.ResourceID);
}
}
}
}
}
VerifyDST();
}
public void AllocateResource()
{
//Step1: Free Resources for next allocation
FreeResources();
//Step2: Check if any task remaining for allocation
lock (_schMutex)
{
if (waitingColTasks.Count == 0 && runningColTasks.Count == 0)
{
VerifyDST();
//IsCompleted();
//IsTaskAvailable = false;
return;
}
}
//Step3: Check if any slot avaialbe for waiting tasks
if (runningColTasks.Count >= MAX_RUNNING_COL_TASK)
{
return;
}
//Step4: Allocate resources to waiting tasks
while (runningColTasks.Count < MAX_RUNNING_COL_TASK && waitingColTasks.Count != 0)
{
var first = default(LinkedListNode <String>);
lock (_schMutex)
{
first = waitingColTasks.First;
if (first != null)
{
waitingColTasks.RemoveFirst();
}
}
if (first != null && first.Value != null && collectionTasksMap.ContainsKey(first.Value))
{
var colName = first.Value;
IStateTransferTask task = collectionTasksMap[colName];
task.Start();
task.Status = StateTxfrStatus.Running;
lock (_schMutex)
{
runningColTasks.AddLast(first);
}
}
}
}
public void Stop()
{
lock (_schMutex)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("DatabaseStateTransferManager.Stop()", "State Transfer Stopping for " + this.dbName);
}
foreach (var ColName in runningColTasks)
{
IStateTransferTask task = collectionTasksMap[ColName];
if (task != null)
{
task.Stop();
}
}
collectionTasksMap.Clear();
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("DatabaseStateTransferManager.Stop()", "State Transfer Stopped for " + this.dbName);
}
}
lock (collectionCorresponderMap)
{
foreach (KeyValuePair <StateTransferIdentity, ICorresponder> pair in collectionCorresponderMap)
{
ICorresponder crossponder = collectionCorresponderMap[pair.Key];
if (crossponder != null)
{
if (resourceManager != null)
{
resourceManager.UnregisterResource(crossponder.ResourceID);
}
crossponder.Dispose();
}
}
collectionCorresponderMap.Clear();
}
}
public void Stop()
{
lock (dbStateTxferMgrMap)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("NodeStateTranferManager.Stop()", "State Transfer Stoping on " + this.context.LocalAddress.ToString());
}
if (_resourceManager != null)
{
_resourceManager.Stop();
}
if (_taskAllocator != null)
{
_taskAllocator.Stop();
}
lock (_schMutex)
{
foreach (var dbName in runningDBTasks)
{
if (dbStateTxferMgrMap.ContainsKey(dbName))
{
IStateTransferTask task = dbStateTxferMgrMap[dbName];
if (task != null)
{
task.Stop();
}
}
}
}
runningDBTasks.Clear();
waitingDBTasks.Clear();
dbStateTxferMgrMap.Clear();
}
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("NodeStateTranferManager.Stop()", "State Transfer Stopped on " + this.context.LocalAddress.ToString());
}
}
public void Initialize(ICollection map, StateTransferType transferType, bool forLocal = false)
{
_isLocal = forLocal;
TransferType = transferType;
IDictionary <String, IDistribution> collectionMap = map as IDictionary <String, IDistribution>;
if (collectionMap != null && collectionMap.Count > 0)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsDebugEnabled)
{
LoggerManager.Instance.StateXferLogger.Debug("DatabaseStateTransferManager.Start()", "State Transfer Started for " + this.dbName);
}
//lock (_stateTxfrMutex)
//{
foreach (KeyValuePair <String, IDistribution> colInfo in collectionMap)
{
try
{
//NTD: [Normal] Kindly perform state transfer for attachment collection
//if (colInfo.Key.Equals(AttachmentAttributes.ATTACHMENT_COLLECTION, StringComparison.OrdinalIgnoreCase)) continue;
if (TransferType == StateTransferType.INTER_SHARD && colInfo.Value.Type == Alachisoft.NosDB.Common.Toplogies.Impl.Distribution.DistributionMethod.NonShardedDistribution)
{
NonShardedDistribution nonShardedDist = colInfo.Value as NonShardedDistribution;
if (!nonShardedDist.Bucket.FinalShard.Equals(context.LocalShardName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
IStateTransferTask task = null;
ICollection bucketList = GetBucketsForStateTransfer((IDistribution)colInfo.Value);
lock (collectionTasksMap)
{
if (!collectionTasksMap.ContainsKey((String)colInfo.Key))
{
if (TransferType == StateTransferType.INTER_SHARD)
{
collectionTasksMap[(String)colInfo.Key] = new StateTransferTask(context, dbName, (String)colInfo.Key, this, colInfo.Value.Type);
}
//else
// collectionTasksMap[(String)colInfo.Key] = new StateTrxfrOnReplicaTask(context, dbName, (String)colInfo.Key, this, colInfo.Value.Type);
}
task = collectionTasksMap[(String)colInfo.Key];
}
if (task != null)
{
task.Initialize(bucketList, transferType, IsLocal);
//KeyValuePair<String, IStateTransferTask> pair = new KeyValuePair<string, IStateTransferTask>(colInfo.Key, task);
lock (_schMutex)
{
waitingColTasks.AddLast(colInfo.Key);
}
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.StateXferLogger.IsErrorEnabled)
{
LoggerManager.Instance.StateXferLogger.Error("DatabaseStateTransferManager.Start()", ex.Message);
}
}
}
}
}
public void AllocateResource()
{
////Step1: Check if any task remaining for allocation
//if (IsCompleted())
//{
// if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
// LoggerManager.Instance.StateXferLogger.Info("NodeStateTxfrMgr.AllocateResource()", "State transfer of the node " + this.context.LocalAddress + " completed successfully.");
// return;
//}
//Step2: Allocate already task resoruces
AllocateRunningDBs();
//Step3: Free Resources for next allocation
FreeResources();
////Step1: Check if any task remaining for allocation
//lock(waitingDBTasks)
//{
// if(waitingDBTasks.Count==0)
// {
// IsTaskAvailable=false;
// return;
// }
//}
//Step4: Check if any slot avaialbe for waiting tasks
if (runningDBTasks.Count >= MAX_RUNNING_DB_TASK)
{
return;
}
//Step5: Allocate resources to waiting tasks
while (runningDBTasks.Count < MAX_RUNNING_DB_TASK && waitingDBTasks.Count > 0)
{
var firstNode = default(LinkedListNode <String>);
lock (_schMutex)
{
firstNode = waitingDBTasks.First;
if (firstNode != null)
{
waitingDBTasks.RemoveFirst();
}
}
if (firstNode != null && firstNode.Value != null && dbStateTxferMgrMap.ContainsKey(firstNode.Value))
{
var dbName = firstNode.Value;
IStateTransferTask task = null;
lock (dbStateTxferMgrMap)
{
task = dbStateTxferMgrMap[dbName];
}
task.Start();
task.Status = StateTxfrStatus.Running;
lock (_schMutex)
{
runningDBTasks.AddLast(firstNode);
}
}
}
}
