public static IDBResponse GetResponse(DatabaseOperationType operationTypeArg)
{
IDBResponse response = null;
switch (operationTypeArg)
{
case DatabaseOperationType.Insert:
response = new InsertDocumentsResponse();
break;
case DatabaseOperationType.Delete:
response = new DeleteDocumentsResponse();
break;
case DatabaseOperationType.Get:
response = new GetDocumentsResponse();
break;
case DatabaseOperationType.Update:
response = new UpdateResponse();
break;
case DatabaseOperationType.ReadQuery:
response = new ReadQueryResponse();
break;
case DatabaseOperationType.WriteQuery:
response = new WriteQueryResponse();
break;
case DatabaseOperationType.GetChunk:
response = new GetChunkResponse();
break;
case DatabaseOperationType.DisposeReader:
response = new DatabaseResponse();
break;
case DatabaseOperationType.Replace:
response = new ReplaceDocumentsResponse();
break;
case DatabaseOperationType.Authenticate:
response = new AuthenticationResponse();
break;
case DatabaseOperationType.Init:
response = new InitDatabaseResponse();
break;
default:
throw new NotSupportedException("Operation " + operationTypeArg + " not supported");
}
return(response);
}
private void DropCollection(String database, String collection)
{
var operation = new LocalDropCollectionOperation();
operation.Database = database;
operation.Collection = collection;
if (_databasesManager != null)
{
IDBResponse dbResponse = _databasesManager.DropCollection(operation);
if (dbResponse.IsSuccessfull)
{
((PartitionOfReplica)Context.TopologyImpl).PulseGetClusterConfAndStore();
}
}
}
public byte[] Serialize(object graph)
{
try
{
IDBResponse dbResponse = graph as IDBResponse;
return(dbResponse != null?dbResponse.Serialize() : null);
}
catch (Exception e)
{
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("Error: ClientMgr.OnRequest() Serialize Response",
e.Message + " StackTrace:" + e.StackTrace);
}
throw;
}
}
internal Response(string msg, IDBResponse response)
: base(msg)
{
ActualResponse = response;
}
public object Deserialize(byte[] buffer)
{
//deseralize
IDBResponse dbResponse = null;
try
{
Response response = Response.ParseFrom(buffer);
if (response != null)
{
switch (response.Type)
{
case Response.Types.Type.INSERT_DOCUMENTS:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.InsertDocumentsResponse(response);
break;
case Response.Types.Type.GET_DOCUMENTS:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.GetDocumentsResponse(response);
break;
case Response.Types.Type.DELETE_DOCUMENTS:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.DeleteDocumentsResponse(response);
break;
case Response.Types.Type.UPDATE:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.UpdateResponse(response);
break;
case Response.Types.Type.WRITE_QUERY:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.WriteQueryResponse(response);
break;
case Response.Types.Type.READ_QUERY:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.ReadQueryResponse(response);
break;
case Response.Types.Type.CREATE_SESSION:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.CreateSessionResponse(response);
break;
case Response.Types.Type.GET_CHUNK:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.GetChunkResponse(response);
break;
case Response.Types.Type.DISPOSE_READER:
dbResponse = new DatabaseResponse(response.ToBuilder());
break;
case Response.Types.Type.REPLACE_DOCUMENTS:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.ReplaceDocumentsResponse(response);
break;
case Response.Types.Type.AUTHENTICATION:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.AuthenticationResponse(response);
break;
case Response.Types.Type.INIT_DATABASE:
dbResponse = new Alachisoft.NosDB.Common.Server.Engine.Impl.InitDatabaseResponse(response);
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error: Deserialize Response on client Side : " + ex);
throw;
}
return(dbResponse);
}
//BucketRemovalInfo info;
//IDatabasesManager _databasesManager;
//public BucketRemoval(BucketRemovalInfo info, NodeContext context)
//{
// this.info = info;
// if (context != null)
// _databasesManager = context.DatabasesManager;
//}
public static void Execute(BucketRemovalInfo info, IDatabasesManager _databasesManager, bool forLocal)
{
if (info.KeysEnumrator == null)
{
if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsDebugEnabled)
{
LoggerManager.Instance.StateXferLogger.Debug("AysncBucketRemoval.Execute", "Keys for Bucket " + info.BucketID + " is null");
}
return;
}
var operation = new LocalDeleteOperation();
operation.OperationType = DatabaseOperationType.StateTransferDelete;
operation.Collection = info.Collection;
operation.Database = info.Database;
operation.Documents = new List <IJSONDocument>();
operation.Context = new OperationContext();
operation.Context.Add(Common.Enum.ContextItem.AllowCappedDelete, true);
if (forLocal)
{
operation.Context.Add(ContextItem.DoNotLog, true);
}
while (info.KeysEnumrator.MoveNext())
{
var docKey = info.KeysEnumrator.Current;
if (docKey == null)
{
continue;
}
var jdoc = new JSONDocument {
Key = docKey.Value as string
};
operation.Documents.Add(jdoc);
}
try
{
IDBResponse resposne = null;
if (_databasesManager != null)
{
resposne = _databasesManager.DeleteDocuments(operation);
}
if (resposne != null && !resposne.IsSuccessfull)
{
throw new DatabaseException(ErrorMessages.GetErrorMessage(resposne.ErrorCode, resposne.ErrorParams));
}
}
catch (Exception ex)
{
//Log AsyncBucketRemovalTask.Excetue fail to delete key on state txfer completed
LoggerManager.Instance.StateXferLogger.Error("AsyncBucketRemovalTask", ex);
}
//try
//{
// OperationParam param = new OperationParam();
// param.SetParamValue(ParamName.BucketID, info.BucketID);
// if (_databasesManager != null)
// _databasesManager.OnOperationRecieved(new StateTransferOperation(info.TaskIdentity, StateTransferOpCode.RemoveLocalBucket, param));
//}
//catch (Exception ex)
//{
// if (LoggerManager.Instance.StateXferLogger != null && LoggerManager.Instance.StateXferLogger.IsErrorEnabled)
// LoggerManager.Instance.StateXferLogger.Error("AysncBucketRemoval.Execute", ex.Message);
//}
}
public IDBResponse CreateDbResponse()
{
_dbResponse = _dbOperation.CreateResponse();
return(_dbResponse);
}
public object OnRequest(IRequest request)
{
IDBOperation dbOperation = null;
IDBResponse response = null;
RequestParser requestParser = null;
try
{
requestParser = request as RequestParser;
try
{
dbOperation = requestParser.ParseRequest();
}
catch (Exception ex)
{
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("Error: ClientMgr.OnRequest() On Parse Request", ex.ToString());
}
throw;
}
if (dbOperation == null)
{
throw new NullReferenceException("Database Operation");
}
if (_shardName != null && _statsCollector == null)
{
_statsCollector = StatsManager.Instance.GetStatsCollector(new StatsIdentity(_shardName, dbOperation.Database));
}
//Dispose Reader check is a temporary fix for Single Get Operation.
if (dbOperation.OperationType != DatabaseOperationType.DisposeReader && _statsCollector != null)
{
_statsCollector.IncrementStatsValue(StatisticsType.RequestsPerSec);
}
//TODO: when SessionId will be embedded into command from router, this code needs to be removed
//if (dbOperation.SessionId == null)
// dbOperation.SessionId = new RouterSessionId();
//dbOperation.SessionId = SessionId;
//if (_dbEngine == null)
// throw new NullReferenceException("DBEngine (Client Manager)");
//LoggerManager.Instance.SetThreadContext(new LoggerContext { ShardName = ((DataBaseEngine)DbEngine).NodeContext.LocalShardName, DatabaseName = dbOperation.Database });
switch (dbOperation.OperationType)
{
case DatabaseOperationType.Init:
response = _dbEngine.InitializeDatabase((InitDatabaseOperation)dbOperation);
if (response.IsSuccessfull)
{
_database = dbOperation.Database;
}
break;
case DatabaseOperationType.Insert:
response = _dbEngine.InsertDocuments((InsertDocumentsOperation)dbOperation);
break;
case DatabaseOperationType.Delete:
response = _dbEngine.DeleteDocuments((DeleteDocumentsOperation)dbOperation);
break;
case DatabaseOperationType.Get:
response = _dbEngine.GetDocuments((GetDocumentsOperation)dbOperation);
if (response != null && response.IsSuccessfull)
{
var getResponse = (GetDocumentsResponse)response;
if (!getResponse.DataChunk.IsLastChunk)
{
var readerInfo = new ReaderInfo
{
DatabaseName = dbOperation.Database,
CollectionName = dbOperation.Collection,
ReaderId = getResponse.DataChunk.ReaderUID
};
lock (_readersList)
{
_readersList.Add(readerInfo);
}
}
}
break;
case DatabaseOperationType.Update:
response = _dbEngine.UpdateDocuments((UpdateOperation)dbOperation);
break;
case DatabaseOperationType.Replace:
response = _dbEngine.ReplaceDocuments((IDocumentsWriteOperation)dbOperation);
break;
case DatabaseOperationType.ReadQuery:
response = _dbEngine.ExecuteReader((ReadQueryOperation)dbOperation);
if (response != null && response.IsSuccessfull)
{
var readQueryResponse = (ReadQueryResponse)response;
if (!readQueryResponse.DataChunk.IsLastChunk)
{
var readerInfo = new ReaderInfo
{
DatabaseName = dbOperation.Database,
CollectionName = dbOperation.Collection,
ReaderId = readQueryResponse.DataChunk.ReaderUID
};
lock (_readersList)
{
_readersList.Add(readerInfo);
}
}
}
break;
case DatabaseOperationType.WriteQuery:
response = _dbEngine.ExecuteNonQuery((WriteQueryOperation)dbOperation);
break;
case DatabaseOperationType.CreateSession:
break;
case DatabaseOperationType.GetChunk:
response = _dbEngine.GetDataChunk((GetChunkOperation)dbOperation);
break;
case DatabaseOperationType.DisposeReader:
var disposeReaderOperation = (DisposeReaderOperation)dbOperation;
response = _dbEngine.DiposeReader(disposeReaderOperation);
if (response != null && response.IsSuccessfull)
{
lock (_readersList)
{
_readersList.RemoveAll(
x =>
x.CollectionName == disposeReaderOperation.Collection &&
x.DatabaseName == disposeReaderOperation.Database &&
x.ReaderId == disposeReaderOperation.ReaderUID);
}
}
break;
case DatabaseOperationType.Authenticate:
var authenticationOperation = (AuthenticationOperation)dbOperation;
_noSConnectionString = new ConnectionStringBuilder(authenticationOperation.ConnectionString);
_dbEngine = _databaseEngineFactory.GetDatabaseEngine(_noSConnectionString);
authenticationOperation.Address = ServerChannel.PeerAddress;
response = _dbEngine.Authenticate(authenticationOperation);
AuthenticationResponse authResponse = response as AuthenticationResponse;
if (
!(authResponse.ServerToken.Status == Common.Security.SSPI.SecurityStatus.SecurityDisabled ||
authResponse.ServerToken.Status == Common.Security.SSPI.SecurityStatus.ContinueNeeded ||
authResponse.ServerToken.Status == Common.Security.SSPI.SecurityStatus.OK))
{
this.ChannelDisconnected(_serverChannel, "unauthenticated");
}
else
{
CsSessionId = dbOperation.SessionId;
_clientProcessID = authenticationOperation.ClientProcessID;
}
break;
default:
throw new Exception("Invalid Operation");
}
}
catch (SerializationException se)
{
try
{
if (requestParser == null)
{
requestParser = request.Message as RequestParser;
}
response = OperationMapper.GetResponse(requestParser.OperationType);
response.IsSuccessfull = false;
response.RequestId = requestParser.RequestId;
response.ErrorCode = se.ErrorCode != 0 ? se.ErrorCode : ErrorCodes.Cluster.UNKNOWN_ISSUE;
response.ErrorParams = se.Parameters;
}
catch (Exception)
{
//Create response if exception occurs.
if (dbOperation != null)
{
response = dbOperation.CreateResponse();
}
response.ErrorCode = ErrorCodes.Cluster.UNKNOWN_ISSUE;
}
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("Error: ClientMgr.OnRequest()", se.ToString());
}
}
catch (DatabaseException de)
{
if (dbOperation != null)
{
response = dbOperation.CreateResponse();
}
if (response != null)
{
response.IsSuccessfull = false;
response.ErrorCode = de.ErrorCode != 0 ? de.ErrorCode : ErrorCodes.Cluster.UNKNOWN_ISSUE;
response.ErrorParams = de.Parameters;
}
}
catch (ManagementException me)
{
if (dbOperation != null)
{
response = dbOperation.CreateResponse();
}
if (response != null)
{
response.IsSuccessfull = false;
if (me.IsErrorCodeSpecified)
{
response.ErrorCode = me.ErrorCode;
response.ErrorParams = me.Parameters;
}
}
}
catch (Exception e)
{
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("Error: ClientMgr.OnRequest()",
e.Message + " StackTrace:" + e.StackTrace);
}
if (dbOperation != null)
{
response = dbOperation.CreateResponse();
}
if (response != null)
{
response.IsSuccessfull = false;
response.ErrorCode = ErrorCodes.Cluster.UNKNOWN_ISSUE;
}
}
finally
{
try
{
if (request.Channel.Connected)
{
request.Channel.SendMessage(response);
}
}
catch (ChannelException e)
{
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("Error: ClientMgr.OnRequest()", e.ToString());
}
}
catch (Exception ex)
{
if (LoggerManager.Instance.ShardLogger != null && LoggerManager.Instance.ShardLogger.IsErrorEnabled)
{
LoggerManager.Instance.ShardLogger.Error("Error: Exception on ClientMgr.OnRequest()", ex.ToString());
}
}
}
return(null);
}
