/// <summary>
/// AckState Transfer Compelete for buckets, remove buckets being transfered from local bucket list on this node
/// </summary>
/// <param name="operation"></param>
/// <returns></returns>
private object HandleAckBucketTxfer(IStateTransferOperation operation)
{
try
{
lock (collectionCorresponderMap)
{
if (!collectionCorresponderMap.ContainsKey(operation.TaskIdentity))
{
throw new Alachisoft.NosDB.Core.Toplogies.Exceptions.StateTransferException("no corrosponder found for " + operation.TaskIdentity.ToString());
}
}
ICorresponder corrosponder = collectionCorresponderMap[operation.TaskIdentity];
corrosponder.BucketTransferCompeleted(operation.Params);
}
catch (Exception anyException)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsErrorEnabled)
{
LoggerManager.Instance.StateXferLogger.Error("DatabaseStateTransferManager.handleAckStateTxfr()", anyException.ToString());
}
return(anyException);
}
return(null);
}
/// <summary>
/// Handle Signal End Of State Transfer, remove corrosponder associated with state transfer
/// </summary>
/// <param name="operation"></param>
private void HandleDestroyCorresponder(IStateTransferOperation operation)
{
if (this.collectionCorresponderMap != null)
{
lock (collectionCorresponderMap)
{
if (collectionCorresponderMap.ContainsKey(operation.TaskIdentity))
{
ICorresponder cor = collectionCorresponderMap[operation.TaskIdentity] as StateTxfrCorresponder;
if (cor != null)
{
//mark transfer compelete and remove from corresponderMap
cor.TransferCompleted();
collectionCorresponderMap.Remove(operation.TaskIdentity);
}
}
//else
//{
// if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsErrorEnabled)
// {
// LoggerManager.Instance.StateXferLogger.Error("DatabaseStateTransferManager.HandleSignalEndOfStateTransfer", "Coresponder not found for " + operation.TaskIdentity.ToString());
//}
//}
OnCorresponderDestroyed();
}
}
}
/// <summary>
/// Bucket Keys Filter Enumerator is special Enumerator which iterate collection to filter out keys which belong to specified bucket
/// And enable logging for that bucket on oplog if provided
/// </summary>
/// <param name="_currentBucket"></param>
/// <param name="enableLogs"></param>
/// <returns></returns>
private IEnumerator <DocumentKey> GetBucketKeysFilterEnumerator(int _currentBucket, bool enableLogs)
{
IStateTransferOperation operation = this.CreateStateTransferOperation(StateTransferOpCode.GetBucketKeysFilterEnumerator);
operation.Params.SetParamValue(ParamName.BucketID, _currentBucket);
return(_dispatcher.DispatchOperation <IEnumerator <DocumentKey> >(operation));
}
/// <summary>
/// Handle Transfer Bucket, Actually transfer bucket data to requesting node/shard
/// </summary>
/// <param name="operation"></param>
/// <returns></returns>
private object HandleCreateCorresponder(IStateTransferOperation operation)
{
lock (collectionCorresponderMap)
{
if (collectionCorresponderMap.ContainsKey(operation.TaskIdentity))
{
if (LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("DatabaseStateTransferManager.HandleCreateCorresponder", "StateTxferCorrosponder for :" + operation.TaskIdentity.ToString() + "already exist");
}
//Temporary Fix because this condition should not be true
collectionCorresponderMap.Remove(operation.TaskIdentity);
//return true;
}
if (LoggerManager.Instance.StateXferLogger.IsDebugEnabled)
{
LoggerManager.Instance.StateXferLogger.Debug("DatabaseStateTransferManager.HandleCreateCorresponder", "Creating New StateTxferCorrosponder for :" + operation.TaskIdentity.ToString());
}
ICorresponder corresponder = new StateTxfrCorresponder(context, this, operation.TaskIdentity, IsLocal);
collectionCorresponderMap[operation.TaskIdentity] = corresponder;
resourceManager.RegisterResource(corresponder);
OnCorresponderCreated();
}
return(true);
}
/// <summary>
/// Dispacth operations to the Configuration Server if configuration operations,and pass to upper layer otherwise
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="operation"></param>
/// <returns></returns>
public T DispatchOperation <T>(IStateTransferOperation operation) where T : class
{
switch (operation.OpCode)
{
// Send lock buckets request to configuration server
case StateTransferOpCode.LockBucketsOnCS:
// Send release lock buckets request to configuration server
case StateTransferOpCode.ReleaseBucketsOnCS:
// Announce State Transfer on configuration server
case StateTransferOpCode.AnnounceBucketTxfer:
// check if specified bucket is spared
case StateTransferOpCode.IsSparsedBucket:
// Verify Bucket Ownership
case StateTransferOpCode.VerifyFinalOwnerShip:
// Finalize State Transfer
case StateTransferOpCode.FinalizeStateTransfer:
return(context.ConfigurationSession.StateTransferOperation(context.ClusterName, operation) as T);
case StateTransferOpCode.StateTxferCompeleted:
OnStateTxfrCompleted(operation);
break;
case StateTransferOpCode.StateTxferFailed:
OnStateTxfrFailed(operation);
break;
case StateTransferOpCode.GetShardPrimary:
return(GetShardPrimary(operation) as T);
}
// For Shard/Cluster Level Operations
return(dispatcher.DispatchOperation <T>(operation));
}
public bool OnStateTxfrFailed(IStateTransferOperation operation)
{
if (operation != null && operation.TaskIdentity != null)
{
if (collectionTasksMap != null && collectionTasksMap.Count > 0)
{
if (collectionTasksMap.ContainsKey(operation.TaskIdentity.ColName))
{
collectionTasksMap[operation.TaskIdentity.ColName].Status = StateTxfrStatus.Failed;
}
bool isComplete = true;
foreach (KeyValuePair <String, IStateTransferTask> pair in collectionTasksMap)
{
if (pair.Value.Status.Equals(StateTxfrStatus.Waiting) || pair.Value.Status.Equals(StateTxfrStatus.Running))
{
isComplete = false;
break;
}
}
if (isComplete)
{
this.Status = StateTxfrStatus.Failed;
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("DBStateTxfrMgr.OnStateTxfrFailed()", "State transfer of the database " + this.dbName + " stopped.");
}
}
return(isComplete);
}
}
return(false);
}
/// <summary>
/// /// Get Primary node of given shard name
/// /// </summary>
private Address GetShardPrimary(IStateTransferOperation operation)
{
//if (Cluster == null) return null;
//if (Context.LocalShardName.Equals(shardName, StringComparison.OrdinalIgnoreCase) && Cluster.ThisShard != null && Cluster.ThisShard.Primary != null)
//{
// return Cluster.ThisShard.Primary.Address;
//}
//if (Cluster.Shards != null && Cluster.Shards.ContainsKey(shardName))
//{
// if(Cluster.Shards[shardName]!=null)
// return this.Cluster.Shards[shardName].Primary.Address;
// try
// {
// Membership membership = Context.ConfigurationSession.GetMembershipInfo(Context.ClusterName, shardName);
// if (membership != null && membership.Primary != null)
// {
// return new Address(membership.Primary.Name, Cluster.Shards[shardName].Port);
// }
// }
// catch (Alachisoft.NosDB.Common.Exceptions.TimeoutException ex)
// {
// return null;
// }
//}
return(null);
}
/// <summary>
/// Handle Transfer Bucket, Actually transfer bucket data to requesting node/shard
/// </summary>
/// <param name="operation"></param>
/// <returns></returns>
private object HandleTransferBucketKeys(IStateTransferOperation operation)
{
ICorresponder corrosponder = null;
lock (collectionCorresponderMap)
{
//if (!collectionCorresponderMap.ContainsKey(operation.TaskIdentity))
//{
// if (LoggerManager.Instance.StateXferLogger.IsDebugEnabled)
// LoggerManager.Instance.StateXferLogger.Debug("DatabaseStateTransferManager.HandleTransferBucketKeys","Creating StateTxferCorrosponder for :"+operation.TaskIdentity.ToString());
// collectionCorresponderMap[operation.TaskIdentity] = new StateTxfrCorresponder(context, this, operation.TaskIdentity);//.DBName, operation.TaskIdentity.ColName, operation.TaskIdentity.NodeInfo, operation.TaskIdentity.Type);
//}
corrosponder = collectionCorresponderMap[operation.TaskIdentity];
}
if (corrosponder == null)
{
Exception ex = new StateTransferException("No corrosponder found for :" + operation.TaskIdentity.ToString());
if (LoggerManager.Instance.StateXferLogger.IsErrorEnabled)
{
LoggerManager.Instance.StateXferLogger.Error("DatabaseStateTransferManager.HandleTransferBucketKeys", ex);
}
return(ex);
}
return(corrosponder.GetBucketKeys(operation.Params));
}
/// <summary>
/// Verify DatabaseStateTransferManager if no task is running/waiting/failed then state transfer is compelted for this database.
/// </summary>
/// <returns></returns>
///
private void VerifyDST()
{
//bool isComplete = true;
//StateTxfrStatus dbTaskStatus = StateTxfrStatus.CompletedSuccessfully;
//foreach (KeyValuePair<String, IStateTransferTask> pair in collectionTasksMap)
//{
// if (pair.Value.Status.Equals(StateTxfrStatus.Failed)) dbTaskStatus = StateTxfrStatus.Failed;
// if (pair.Value.Status.Equals(StateTxfrStatus.Waiting) || pair.Value.Status.Equals(StateTxfrStatus.Running))
// {
// isComplete = false;
// break;
// }
//}
//if (isComplete)
//{
// this.Status = dbTaskStatus;
if (IsCompleted())
{
//this.Status = operation.OpCode == StateTransferOpCode.StateTxferCompeleted ? StateTxfrStatus.CompletedSuccessfully : StateTxfrStatus.Failed;
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("DBStateTxfrMgr.VerifyDST()", "State transfer of the database " + this.dbName + " completed with status " + this.Status.ToString());
}
if (this.dispatcher != null)
{
// in case database tasks been entertained, notify NodeStateTransferManager about status
StateTransferOpCode opCode = this.Status == StateTxfrStatus.CompletedSuccessfully ? StateTransferOpCode.StateTxferCompeleted : StateTransferOpCode.StateTxferFailed;
IStateTransferOperation dbOperation = CreateStateTransferOperation(opCode);
this.dispatcher.DispatchOperation <Object>(dbOperation);
}
}
}
private void ApplyLogOperation(ClusteredArrayList logOperations)
{
if (this.operationDispatcher != null && logOperations != null && logOperations.Count > 0)
{
IStateTransferOperation operation = this.CreateStateTransferOperation(StateTransferOpCode.ApplyLogOperations);
operation.Params.SetParamValue(ParamName.LogOperations, logOperations);
operationDispatcher.DispatchOperation <Object>(operation);
}
}
public void OnStateTxfrCompleted(IStateTransferOperation operation)
{
if (operation != null && operation.TaskIdentity != null && operation.TaskIdentity.DBName != null)
{
if (this.dbStateTxferMgrMap != null && dbStateTxferMgrMap.Count > 0)
{
if (dbStateTxferMgrMap.ContainsKey(operation.TaskIdentity.DBName))
{
dbStateTxferMgrMap[operation.TaskIdentity.DBName].Status = StateTxfrStatus.CompletedSuccessfully;
if (dbStateTxferMgrMap[operation.TaskIdentity.DBName].IsLocal && dbStateTxferMgrMap[operation.TaskIdentity.DBName].TransferType == StateTransferType.INTRA_SHARD)
{
try
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("NodeStateTxfrMgr.OStateTxfrCompletion()", "Inter Shard State transfer of the migrated database " + operation.TaskIdentity.DBName + " completed successfully.");
}
context.ConfigurationSession.SetDatabaseMode(context.ClusterName, operation.TaskIdentity.DBName,
DatabaseMode.Online);
}
catch (Exception exception)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsErrorEnabled)
{
LoggerManager.Instance.StateXferLogger.Error("NodeStateTxfrMgr.OStateTxfrCompletion()", "Error changing databasemode to Promoted of database " + operation.TaskIdentity.DBName + "." + exception.Message);
}
}
}
}
VerifyNST();
//bool isComplete = true;
//foreach (var pair in dbStateTxferMgrMap)
//{
// StateTxfrStatus status = pair.Value.Status;
// if (status == StateTxfrStatus.Running || status == StateTxfrStatus.Failed || status == StateTxfrStatus.Waiting)
// {
// isComplete = false;
// break;
// }
//}
//if (isComplete)
//{
// lock (_inStTxfrMutex)
// {
// _replication.NodeIsInStateTxfr = false;
// }
// if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
// LoggerManager.Instance.StateXferLogger.Info("NodeStateTxfrMgr.OStateTxfrCompletion()", "State transfer of the node " + this.context.LocalAddress + " completed successfully.");
//}
}
}
}
private ClusteredList <DocumentKey> GetBucketKeys(int _currentBucket)
{
if (_dispatcher != null)
{
IStateTransferOperation operation = CreateStateTransferOperation(StateTransferOpCode.GetBucketKeys);
operation.Params.SetParamValue(ParamName.BucketID, _currentBucket);
return(_dispatcher.DispatchOperation <ClusteredList <DocumentKey> >(operation));
}
return(new ClusteredList <DocumentKey>());
}
public void OnCollectionTaskEnd(IStateTransferOperation operation)
{
if (operation != null && operation.TaskIdentity != null)
{
if (collectionTasksMap != null && collectionTasksMap.Count > 0)
{
if (collectionTasksMap.ContainsKey(operation.TaskIdentity.ColName))
{
collectionTasksMap[operation.TaskIdentity.ColName].Status = operation.OpCode == StateTransferOpCode.StateTxferCompeleted ? StateTxfrStatus.CompletedSuccessfully : StateTxfrStatus.Failed;
VerifyDST();
}
else
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
{
LoggerManager.Instance.StateXferLogger.Info("DBStateTxfrMgr.OStateTxfrCompletion()", "Task not found for collection " + operation.TaskIdentity.ColName);
}
return;
}
//bool isComplete = true;
//StateTxfrStatus dbTaskStatus = StateTxfrStatus.CompletedSuccessfully;
//foreach (KeyValuePair<String, IStateTransferTask> pair in collectionTasksMap)
//{
// if (pair.Value.Status.Equals(StateTxfrStatus.Failed)) dbTaskStatus = StateTxfrStatus.Failed;
// if (pair.Value.Status.Equals(StateTxfrStatus.Waiting) || pair.Value.Status.Equals(StateTxfrStatus.Running))
// {
// isComplete = false;
// break;
// }
//}
//if (isComplete)
//{
// this.Status = dbTaskStatus;
// //this.Status = operation.OpCode == StateTransferOpCode.StateTxferCompeleted ? StateTxfrStatus.CompletedSuccessfully : StateTxfrStatus.Failed;
// if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsInfoEnabled)
// LoggerManager.Instance.StateXferLogger.Info("DBStateTxfrMgr.OStateTxfrCompletion()", "State transfer of the database " + this.dbName + " completed with status "+this.Status.ToString());
// if (this.dispatcher != null)
// {
// // in case database tasks been entertained, notify NodeStateTransferManager about status
// StateTransferOpCode opCode = this.Status == StateTxfrStatus.CompletedSuccessfully ? StateTransferOpCode.StateTxferCompeleted : StateTransferOpCode.StateTxferFailed;
// IStateTransferOperation dbOperation = CreateStateTransferOperation(opCode);
// this.dispatcher.DispatchOperation<Object>(dbOperation);
// }
//}
}
}
}
/// <summary>
/// Set Status of transfered bucket locally
/// </summary>
/// <param name="owner"></param>
/// <param name="buckets"></param>
/// <param name="sparsed"></param>
private void SetBucketStatus(NodeIdentity owner, ArrayList buckets)
{
if (this._dispatcher != null)
{
IStateTransferOperation operation = CreateStateTransferOperation(StateTransferOpCode.SetBucketStatus);
operation.Params.SetParamValue(ParamName.BucketList, buckets);
operation.Params.SetParamValue(ParamName.BucketStatus, BucketStatus.Functional);
operation.Params.SetParamValue(ParamName.BucketFinalShard, owner);
operation.Params.SetParamValue(ParamName.IsSource, true);
_dispatcher.DispatchOperation <Object>(operation);
}
}
public void OnStateTxfrFailed(IStateTransferOperation operation)
{
if (operation != null && operation.TaskIdentity != null && operation.TaskIdentity.DBName != null)
{
if (this.dbStateTxferMgrMap != null && dbStateTxferMgrMap.Count > 0)
{
if (dbStateTxferMgrMap.ContainsKey(operation.TaskIdentity.DBName))
{
dbStateTxferMgrMap[operation.TaskIdentity.DBName].Status = StateTxfrStatus.Failed;
}
}
}
}
/// <summary>
/// Will recieve local operations from local DatabaseStateTransferManager class
/// </summary>
/// <param name="operation"></param>
/// <returns></returns>
public object OnOperationRecieved(IStateTransferOperation operation)
{
String dbName = operation.TaskIdentity.DBName;
if (!String.IsNullOrEmpty(dbName) && _databases.ContainsKey(dbName))
{
IStateTxfrOperationListener dbStore = _databases[dbName] as IStateTxfrOperationListener;
if (dbStore != null)
{
return(dbStore.OnOperationRecieved(operation));
}
}
return(null);
}
public object OnOperationRecieved(IStateTransferOperation operation)
{
lock (dbStateTxferMgrMap)
{
if (!dbStateTxferMgrMap.ContainsKey(operation.TaskIdentity.DBName))
{
dbStateTxferMgrMap[operation.TaskIdentity.DBName] = new DatabaseStateTransferManager(context, operation.TaskIdentity.DBName, this, _resourceManager);
}
}
IStateTxfrOperationListener task = dbStateTxferMgrMap[operation.TaskIdentity.DBName];
if (task != null)
{
return(task.OnOperationRecieved(operation));
}
return(null);
}
/// <summary>
/// Dispacth operations to the underlying Database Manager if local operations,and pass to upper layer otherwise
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="operation"></param>
/// <returns></returns>
public T DispatchOperation <T>(IStateTransferOperation operation) where T : class
{
switch (operation.OpCode)
{
// Param should contain at least db plus collection name and bucket id
case StateTransferOpCode.GetBucketKeysFilterEnumerator:
//case StateTransferOpCode.GetLogTable:
//case StateTransferOpCode.RemoveLoggedOperations:
case StateTransferOpCode.EmptyBucket:
//case StateTransferOpCode.StartBeforeOperationLogging:
//case StateTransferOpCode.StopBeforeOperationLogging:
case StateTransferOpCode.ApplyLogOperations:
case StateTransferOpCode.SetBucketStatus:
case StateTransferOpCode.GetBucketStats:
case StateTransferOpCode.GetBucketKeys:
{
if (context != null && context.DatabasesManager != null)
{
return(context.DatabasesManager.OnOperationRecieved(operation) as T);
}
return(default(T));
}
//If State Transfer for this Database has been compeleted then call node level manager for compeletion
case StateTransferOpCode.StateTxferCompeleted:
//If State Transfer for this Database has been stopped then call node level manager for compeletion
case StateTransferOpCode.StateTxferFailed:
{
OnCollectionTaskEnd(operation);
return(default(T));
}
////If State Transfer for this Database has been stopped then call node level manager for compeletion
//case StateTransferOpCode.StateTxferFailed:
// {
// if (OnStateTxfrFailed(operation)) break;
// return default(T);
// }
}
return((T)dispatcher.DispatchOperation <T>(operation));
}
/// <summary>
/// Will recieve handle cluster operations from remote nodes/shards
/// </summary>
/// <param name="operation"></param>
/// <returns></returns>
public object OnOperationRecieved(IStateTransferOperation operation)
{
//Look for crossponder and handover the operation
switch (operation.OpCode)
{
case StateTransferOpCode.CreateCorresponder:
return(HandleCreateCorresponder(operation));
case StateTransferOpCode.TransferBucketKeys:
return(HandleTransferBucketKeys(operation));
case StateTransferOpCode.TransferBucketData:
return(HandleTransferBucketData(operation));
case StateTransferOpCode.AckBucketTxfer:
return(HandleAckBucketTxfer(operation));
case StateTransferOpCode.DestroyCorresponder:
HandleDestroyCorresponder(operation);
break;
}
return(null);
}
/// <summary>
/// Handle Transfer Bucket, Actually transfer bucket data to requesting node/shard
/// </summary>
/// <param name="operation"></param>
/// <returns></returns>
private object HandleTransferBucketData(IStateTransferOperation operation)
{
ICorresponder corrosponder = null;
lock (collectionCorresponderMap)
{
if (collectionCorresponderMap.ContainsKey(operation.TaskIdentity))
{
corrosponder = collectionCorresponderMap[operation.TaskIdentity];
}
}
if (corrosponder == null)
{
Exception ex = new StateTransferException("No corrosponder found for :" + operation.TaskIdentity.ToString());
if (LoggerManager.Instance.StateXferLogger.IsErrorEnabled)
{
LoggerManager.Instance.StateXferLogger.Error("DatabaseStateTransferManager.HandleTransferBucketData", ex);
}
return(ex);
}
return(corrosponder.GetBucketData(operation.Params));
}
