internal void InitializeResponse(Common.Net.Address address, CommandBase command)
{
if (command is SurrogateCommand)
{
//in case of surrogate command, we initialize response against the actual targetnode
address = ((SurrogateCommand)command).ActualTargetNode;
}
lock (_responseMutex)
{
if (_responses == null)
{
_responses = new Dictionary <Common.Net.Address, Dictionary <int, ResponseList> >();
}
//RemoveResponse(address, command.CommandID);
if (!_responses.ContainsKey(address))
{
_responses.Add(address, new Dictionary <int, ResponseList>());
}
Dictionary <int, ResponseList> allResponses = _responses[address];
allResponses[command.CommandID] = new ResponseList(command);
}
command.FinalDestinationAddress = address;
}
/// <summary>
/// Creates a new instance of CacheResultItem
/// <param name="brokerReset">True if broker is reset due to lost connection, false otherwise</param>
/// </summary>
public CommandResponse(bool brokerReset, Common.Net.Address resetConnectionIP)
{
_key = null;
_value = null;
_brokerReset = brokerReset;
_resetConnectionIP = resetConnectionIP;
}
internal bool ExpectingResponseFrom(Common.Net.Address address)
{
lock (_responseMutex)
{
bool result = _responses.ContainsKey(address);
return(result);
}
}
internal void AddCommand(Common.Net.Address address, CommandBase command)
{
_name = command.CommandName;
command.Parent = this;
if (!_commands.ContainsKey(address))
{
_commands.Add(address, command);
}
}
internal void InitializeResponse(Common.Net.Address address)
{
lock (_responseMutex)
{
if (!_responses.ContainsKey(address))
{
_responses.Add(address, new ResponseList());
}
}
}
public void RemoveServer(Common.Net.Address server)
{
lock (this)
{
if (_serverMap.ContainsKey(server))
{
_serverMap.Remove(server);
}
}
}
public TaskNextRecordCommand(string clientId, string taskId, short callbackId,
Common.Net.Address _clientAddress, Common.Net.Address _clusterAddress)
{
this.clientId = clientId;
this.taskId = taskId;
this.callbackId = callbackId;
this.clientIp = _clientAddress.IpAddress.ToString();
this.clientPort = _clientAddress.Port;
this.clusterIp = _clusterAddress.IpAddress.ToString();
this.clusterPort = _clusterAddress.Port;
}
internal bool RemoveResponse(Common.Net.Address address)
{
lock (_responseMutex)
{
_responses.Remove(address);
bool removeRequestFromTable = _responses.Count == 0;
return(removeRequestFromTable);
}
}
internal void ResetFailedResponse(Common.Net.Address ip)
{
lock (_responseMutex)
{
if (_responses.ContainsKey(ip))
{
ResponseList responseList = _responses[ip];
responseList.Clear();
responseList.AddResponse(new CommandResponse(true, ip));
}
}
}
internal void ResetResponseNodeForShutDown(Common.Net.Address ip)
{
lock (_responseMutex)
{
if (_responses.ContainsKey(ip))
{
ResponseList responseList = _responses[ip];
responseList.Clear();
responseList.AddResponse(new CommandResponse(false, ip));
_resend = true;
}
}
}
internal void RemoveResponse(Common.Net.Address address, int commandId)
{
lock (_responseMutex)
{
if (address != null && _responses.ContainsKey(address))
{
_responses[address].Remove(commandId);
if (_responses[address].Count == 0)
{
_responses.Remove(address);
}
}
}
}
public Response AddResponseFragment(Common.Net.Address server, FragmentedResponse responseFragment)
{
List <FragmentedResponse> responseList = null;
Dictionary <long, List <FragmentedResponse> > resposeTable = null;
lock (this)
{
if (!_serverMap.ContainsKey(server))
{
_serverMap.Add(server, new Dictionary <long, List <FragmentedResponse> >());
}
resposeTable = _serverMap[server];
if (!resposeTable.ContainsKey(responseFragment.messageId))
{
resposeTable.Add(responseFragment.messageId, new List <FragmentedResponse>());
}
}
responseList = resposeTable[responseFragment.messageId];
responseList.Add(responseFragment);
if (responseList.Count == responseFragment.totalFragments)
{
lock (this)
{
resposeTable.Remove(responseFragment.messageId);
}
responseList.Sort(this);
Response finalResponse = null;
using (MemoryStream stream = new MemoryStream())
{
foreach (FragmentedResponse fragment in responseList)
{
stream.Write(fragment.message, 0, fragment.message.Length);
}
stream.Position = 0;
finalResponse = ProtoBuf.Serializer.Deserialize <Alachisoft.NCache.Common.Protobuf.Response>(stream);
stream.Close();
}
return(finalResponse);
}
return(null);
}
internal void InitializeResponse(Common.Net.Address address, CommandBase command)
{
lock (_responseMutex)
{
if (!_responses.ContainsKey(address))
{
_responses.Add(address, new Dictionary <int, ResponseList>());
}
Dictionary <int, ResponseList> allResponses = _responses[address];
allResponses[command.CommandID] = new ResponseList(command);
}
command.FinalDestinationAddress = address;
}
internal void AddResponse(Common.Net.Address address, CommandResponse response)
{
_type = response.Type;
lock (_responseMutex)
{
if (_responses.ContainsKey(address))
{
if (!response.IsInternalResponse && response.NeedsDeserialization)
{
if (_rawResponses == null)
{
_rawResponses = new List <CommandResponse>();
}
_rawResponses.Add(response);
}
else
{
ResponseList responseList;
if (response.CommandID <= 0)
{
var responses = _responses[address];
foreach (var rsp in responses.Values)
{
if (!rsp.IsComplete())
{
rsp.AddResponse(response);
break;
}
}
return;
}
if (_responses[address].TryGetValue(response.CommandID, out responseList))
{
if (Connection.WriteRequestIdInResponse || !responseList.IsComplete())
{
responseList.AddResponse(response);
}
}
}
}
}
}
internal void AddCommand(Common.Net.Address address, CommandBase command)
{
_name = command.CommandName;
command.Parent = this;
command.CommandID = this.GetNextCommandID();
if (_commands == null)
{
_commands = new Dictionary <Common.Net.Address, CommandBase>();
}
if (!_commands.ContainsKey(address))
{
_commands.Add(address, command);
}
}
internal void Reset(Common.Net.Address ip)
{
lock (_responseMutex)
{
if (_responses.ContainsKey(ip))
{
Dictionary <int, ResponseList> allResponses = _responses[ip];
foreach (ResponseList responseList in allResponses.Values)
{
if (!responseList.IsComplete)
{
responseList.Clear();
responseList.AddResponse(new CommandResponse(true, ip));
_failedCommands.Add(responseList.Command);
}
}
}
}
}
internal void AddResponse(Common.Net.Address address, CommandResponse response)
{
_type = response.Type;
lock (_responseMutex)
{
if (_responses.ContainsKey(address))
{
ResponseList responseList;
if (_responses[address].TryGetValue(response.CommandID, out responseList))
{
if (!responseList.IsComplete)
{
responseList.AddResponse(response);
}
}
}
}
}
internal bool ExpectingResponseFrom(Common.Net.Address address)
{
lock (_responseMutex)
{
DeserializeRawResponsesIfPresent();
if (_responses.ContainsKey(address))
{
//True if response from specified ip address is not completed, else false
foreach (ResponseList responseList in _responses[address].Values)
{
if (!responseList.IsComplete())
{
return(true);
}
}
}
}
return(false);
}
internal void AddResponse(Common.Net.Address address, CommandResponse response)
{
_type = response.Type;
lock (_responseMutex)
{
if (_responses.ContainsKey(address))
{
ResponseList responseList = _responses[address];
if (!responseList.IsComplete)
{
responseList.AddResponse(response);
}
else
{
if (_reRoutedAddress != null && !_reRoutedAddress.Equals(address))
{
if (!_responses.ContainsKey(_reRoutedAddress))
{
ResponseList rspList = new ResponseList();
if (!rspList.IsComplete)
{
rspList.AddResponse(response);
}
_responses.Add(_reRoutedAddress, rspList);
}
else
{
responseList = _responses[_reRoutedAddress];
if (!responseList.IsComplete)
{
responseList.AddResponse(response);
}
}
}
}
}
}
}
internal void MergeResponse(Common.Net.Address address, CommandResponse response)
{
if (_finalResponse == null && response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.GET_NEXT_CHUNK &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.GET_READER_CHUNK &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.EXECUTE_READER)
{
_finalResponse = response;
if (response.IsBrokerReset)
{
MergeFailedResponse(response);
}
}
else
{
if (response.IsBrokerReset)
{
MergeFailedResponse(response);
}
else
{
IDictionaryEnumerator ide = null;
switch (response.Type)
{
case Alachisoft.NCache.Common.Protobuf.Response.Type.ADD_BULK:
case Alachisoft.NCache.Common.Protobuf.Response.Type.INSERT_BULK:
case Alachisoft.NCache.Common.Protobuf.Response.Type.GET_BULK:
case Alachisoft.NCache.Common.Protobuf.Response.Type.REMOVE_BULK:
ide = response.KeyValueDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyValueDic[ide.Key] = ide.Value;
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.SEARCH:
if ((_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND) ||
(_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType.ATTRIBUTE_INDEX_NOT_FOUND))
{
_finalResponse = response;
break;
}
switch (response.ResultSet.AggregateFunctionType)
{
case Alachisoft.NCache.Common.Enum.AggregateFunctionType.NOTAPPLICABLE:
_finalResponse.KeyList.AddRange(response.KeyList);
break;
default:
if (!_finalResponse.ResultSet.IsInitialized)
{
SetAggregateFunctionResult();
_finalResponse.ResultSet.Initialize(_finalResponse.ResultSet);
}
_finalResponse.ResultSet.Compile(response.ResultSet);
break;
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.SEARCH_ENTRIES:
if ((_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND) ||
(_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType.ATTRIBUTE_INDEX_NOT_FOUND))
{
_finalResponse = response;
break;
}
switch (response.ResultSet.AggregateFunctionType)
{
case Alachisoft.NCache.Common.Enum.AggregateFunctionType.NOTAPPLICABLE:
ide = response.KeyValueDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyValueDic[ide.Key] = ide.Value;
}
break;
default:
if (!_finalResponse.ResultSet.IsInitialized)
{
SetAggregateFunctionResult();
_finalResponse.ResultSet.Initialize(_finalResponse.ResultSet);
}
_finalResponse.ResultSet.Compile(response.ResultSet);
break;
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.GET_NEXT_CHUNK:
if (_finalResponse == null)
{
_finalResponse = response;
}
EnumerationDataChunk chunk = null;
if (_chunks.ContainsKey(address))
{
chunk = _chunks[address];
}
else
{
chunk = new EnumerationDataChunk();
chunk.Data = new List <string>();
_chunks.Add(address, chunk);
}
for (int i = 0; i < response.NextChunk.Count; i++)
{
chunk.Data.AddRange(response.NextChunk[i].Data);
chunk.Pointer = response.NextChunk[i].Pointer;
if (chunk.Pointer.NodeIpAddress == null)
{
chunk.Pointer.NodeIpAddress = address;
}
}
_finalResponse.NextChunk = new List <EnumerationDataChunk>(_chunks.Values);
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.EXECUTE_READER:
if (_finalResponse == null)
{
_finalResponse = response;
}
if ((_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND) ||
(_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType.ATTRIBUTE_INDEX_NOT_FOUND))
{
_finalResponse = response;
break;
}
List <ReaderResultSet> protoReaders = response.ProtobufResponse.executeReaderResponse.readerResultSets;
if (protoReaders != null && protoReaders.Count > 0)
{
foreach (ReaderResultSet protoReaderResultSet in protoReaders)
{
Common.DataReader.ReaderResultSet readerResultSet = null;
foreach (Common.DataReader.ReaderResultSet set in _finalResponse.ReaderResultSets)
{
if (protoReaderResultSet.readerId == set.ReaderID && protoReaderResultSet.nodeAddress == set.NodeAddress)
{
readerResultSet = set;
break;
}
}
if (readerResultSet != null)
{
PopulateRows((Common.DataReader.RecordSet)readerResultSet.RecordSet, protoReaderResultSet.recordSet.rows);
}
else
{
readerResultSet = ConvertToReaderResult(protoReaderResultSet);
_finalResponse.ReaderResultSets.Add(readerResultSet);
}
}
}
break;
case Common.Protobuf.Response.Type.GET_READER_CHUNK:
if (_finalResponse == null)
{
_finalResponse = response;
}
ReaderResultSet protoReaderChunkResultSet = response.ProtobufResponse.getReaderChunkResponse.readerResultSets;
Common.DataReader.ReaderResultSet readerChunkResultSet = _finalResponse.ReaderNextChunk;
if (readerChunkResultSet != null)
{
PopulateRows((Common.DataReader.RecordSet)readerChunkResultSet.RecordSet, protoReaderChunkResultSet.recordSet.rows);
}
else
{
readerChunkResultSet = ConvertToReaderResult(protoReaderChunkResultSet);
_finalResponse.ReaderNextChunk = readerChunkResultSet;
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.EXCEPTION:
if (response.ExceptionType == Common.Enum.ExceptionType.STATE_TRANSFER_EXCEPTION)
{
_finalResponse = response;
}
break;
default:
break;
}
}
}
}
internal void Reset(Common.Net.Address ip)
{
ResetInternal(ip);
}
/// <summary>
/// Creates a new instance of CacheResultItem
/// <param name="brokerReset">True if broker is reset due to lost connection, false otherwise</param>
/// </summary>
public CommandResponse(bool brokerReset, Common.Net.Address resetConnectionIP)
{
_key = null;
_value = null;
_brokerReset = brokerReset;
_resetConnectionIP = resetConnectionIP;
}
internal void MergeResponse(Common.Net.Address address, CommandResponse response)
{
if (_finalResponse == null && (response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.GET_NEXT_CHUNK &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.GET_READER_CHUNK &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.EXECUTE_READER &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.EXECUTE_READER_CQ))
{
_finalResponse = response;
if (response.IsBrokerReset)
{
MergeFailedResponse(response);
}
}
else
{
if (response.IsBrokerReset)
{
MergeFailedResponse(response);
}
else
{
IDictionaryEnumerator ide = null;
switch (response.Type)
{
case Common.Protobuf.Response.Type.POLL:
_finalResponse.PollingResult.RemovedKeys.AddRange(response.PollingResult.RemovedKeys);
_finalResponse.PollingResult.UpdatedKeys.AddRange(response.PollingResult.UpdatedKeys);
break;
case Common.Protobuf.Response.Type.ADD_BULK:
case Common.Protobuf.Response.Type.INSERT_BULK:
case Common.Protobuf.Response.Type.GET_BULK:
case Common.Protobuf.Response.Type.BULK_GET_CACHEITEM:
case Common.Protobuf.Response.Type.REMOVE_BULK:
case Common.Protobuf.Response.Type.MESSAGE_ACKNOWLEDGEMENT:
ide = response.KeyValueDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyValueDic[ide.Key] = ide.Value;
}
ide = response.KeyVersionDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyVersionDic[ide.Key] = ide.Value;
}
break;
case Common.Protobuf.Response.Type.CONTAINS_BULK:
ide = response.KeyValueDic.GetEnumerator();
while (ide.MoveNext())
{
if (_finalResponse.KeyValueDic.ContainsKey(ide.Key))
{
((ArrayList)_finalResponse.KeyValueDic[ide.Key]).AddRange((ArrayList)ide.Value);
}
else
{
_finalResponse.KeyValueDic[ide.Key] = ide.Value;
}
}
break;
case Common.Protobuf.Response.Type.GET_MESSAGE:
foreach (var item in response.MessageDic)
{
if (!_finalResponse.MessageDic.ContainsKey(item.Key))
{
_finalResponse.MessageDic.Add(item.Key, item.Value);
}
else
{
foreach (var message in item.Value)
{
_finalResponse.MessageDic[item.Key].Add(message);
}
}
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.GET_SERVER_MAPPING:
_finalResponse.ServerMappingList = response.ServerMappingList;
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.GET_NEXT_CHUNK:
if (_finalResponse == null)
{
_finalResponse = response;
}
if (_chunks == null)
{
_chunks = new Dictionary <Common.Net.Address, EnumerationDataChunk>();
}
EnumerationDataChunk chunk = null;
if (_chunks.ContainsKey(address))
{
chunk = _chunks[address];
}
else
{
chunk = new EnumerationDataChunk();
chunk.Data = new List <string>();
_chunks.Add(address, chunk);
}
for (int i = 0; i < response.NextChunk.Count; i++)
{
chunk.Data.AddRange(response.NextChunk[i].Data);
chunk.Pointer = response.NextChunk[i].Pointer;
if (chunk.Pointer.NodeIpAddress == null)
{
chunk.Pointer.NodeIpAddress = address;
}
}
_finalResponse.NextChunk = new List <EnumerationDataChunk>(_chunks.Values);
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.EXCEPTION:
if (response.ExceptionType == Common.Enum.ExceptionType.STATE_TRANSFER_EXCEPTION)
{
_finalResponse = response;
}
break;
default:
break;
}
}
}
}
internal void MergeResponse(Common.Net.Address address, CommandResponse response)
{
if (_finalResponse == null &&
(response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.GET_NEXT_CHUNK &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.GET_READER_CHUNK &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.EXECUTE_READER &&
response.Type != Alachisoft.NCache.Common.Protobuf.Response.Type.EXECUTE_READER_CQ))
{
_finalResponse = response;
if (response.IsBrokerReset)
{
MergeFailedResponse(response);
}
}
else
{
if (response.IsBrokerReset)
{
MergeFailedResponse(response);
}
else
{
IDictionaryEnumerator ide = null;
switch (response.Type)
{
case Common.Protobuf.Response.Type.POLL:
_finalResponse.PollingResult.RemovedKeys.AddRange(response.PollingResult.RemovedKeys);
_finalResponse.PollingResult.UpdatedKeys.AddRange(response.PollingResult.UpdatedKeys);
break;
case Common.Protobuf.Response.Type.ADD_BULK:
case Common.Protobuf.Response.Type.INSERT_BULK:
case Common.Protobuf.Response.Type.GET_BULK:
case Common.Protobuf.Response.Type.REMOVE_BULK:
case Common.Protobuf.Response.Type.GET_GROUP_DATA:
case Common.Protobuf.Response.Type.GET_TAG:
case Common.Protobuf.Response.Type.HYBRID_BULK:
case Common.Protobuf.Response.Type.INVOKE_ENTRY_PROCESSOR:
case Common.Protobuf.Response.Type.MESSAGE_ACKNOWLEDGEMENT:
ide = response.KeyValueDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyValueDic[ide.Key] = ide.Value;
}
ide = response.KeyVersionDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyVersionDic[ide.Key] = ide.Value;
}
break;
case Common.Protobuf.Response.Type.GET_MESSAGE:
foreach (var item in response.MessageDic)
{
if (!_finalResponse.MessageDic.ContainsKey(item.Key))
{
_finalResponse.MessageDic.Add(item.Key, item.Value);
}
else
{
foreach (var message in item.Value)
{
_finalResponse.MessageDic[item.Key].Add(message);
}
}
}
break;
case Common.Protobuf.Response.Type.GET_GROUP_KEYS:
case Common.Protobuf.Response.Type.GET_KEYS_TAG:
_finalResponse.KeyList.AddRange(response.KeyList);
break;
case Common.Protobuf.Response.Type.EXECUTE_READER:
case Common.Protobuf.Response.Type.EXECUTE_READER_CQ:
if (_finalResponse == null)
{
_finalResponse = response;
}
if ((_finalResponse.ExceptionType == Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND) ||
(_finalResponse.ExceptionType ==
Common.Enum.ExceptionType.ATTRIBUTE_INDEX_NOT_FOUND))
{
_finalResponse = response;
break;
}
List <ReaderResultSet> protoReaders =
response.Type == Common.Protobuf.Response.Type.EXECUTE_READER
? response.ProtobufResponse.executeReaderResponse.readerResultSets
: response.ProtobufResponse.executeReaderCQResponse.readerResultSets;
if (protoReaders != null && protoReaders.Count > 0)
{
foreach (ReaderResultSet protoReaderResultSet in protoReaders)
{
Common.DataReader.ReaderResultSet readerResultSet = null;
foreach (Common.DataReader.ReaderResultSet set in _finalResponse.ReaderResultSets)
{
if (protoReaderResultSet.readerId == set.ReaderID &&
protoReaderResultSet.nodeAddress == set.NodeAddress)
{
readerResultSet = set;
break;
}
}
if (readerResultSet != null)
{
PopulateRows((Common.DataReader.RecordSet)readerResultSet.RecordSet,
protoReaderResultSet.recordSet.rows);
}
else
{
readerResultSet = ConvertToReaderResult(protoReaderResultSet);
_finalResponse.ReaderResultSets.Add(readerResultSet);
}
}
}
break;
case Common.Protobuf.Response.Type.GET_READER_CHUNK:
if (_finalResponse == null)
{
_finalResponse = response;
}
ReaderResultSet protoReaderChunkResultSet =
response.ProtobufResponse.getReaderChunkResponse.readerResultSets;
Common.DataReader.ReaderResultSet readerChunkResultSet = _finalResponse.ReaderNextChunk;
if (readerChunkResultSet != null)
{
PopulateRows((Common.DataReader.RecordSet)readerChunkResultSet.RecordSet,
protoReaderChunkResultSet.recordSet.rows);
}
else
{
readerChunkResultSet = ConvertToReaderResult(protoReaderChunkResultSet);
_finalResponse.ReaderNextChunk = readerChunkResultSet;
}
break;
case Common.Protobuf.Response.Type.DELETE_QUERY:
case Common.Protobuf.Response.Type.REMOVE_QUERY:
if ((_finalResponse.ExceptionType == Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND) ||
(_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType
.ATTRIBUTE_INDEX_NOT_FOUND))
{
if ((response.ExceptionType != Common.Enum.ExceptionType.ATTRIBUTE_INDEX_NOT_FOUND) ||
(response.ExceptionType != Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND))
{
_finalResponse = response;
}
}
else if (_finalResponse != null &&
(response.ExceptionType != Common.Enum.ExceptionType.ATTRIBUTE_INDEX_NOT_FOUND) ||
(response.ExceptionType != Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND))
{
_finalResponse.RemovedKeyCount += response.RemovedKeyCount;
}
break;
case Common.Protobuf.Response.Type.SEARCH_CQ:
_finalResponse.KeyList.AddRange(response.KeyList);
if (response.ResultSet != null && !string.IsNullOrEmpty(response.ResultSet.CQUniqueId))
{
string uniqueID = response.ResultSet.CQUniqueId;
if (!string.IsNullOrEmpty(uniqueID) && uniqueID != "-1")
{
if (_finalResponse.ResultSet != null &&
string.IsNullOrEmpty(_finalResponse.ResultSet.CQUniqueId))
{
_finalResponse.ResultSet.CQUniqueId = uniqueID;
}
}
}
break;
case Common.Protobuf.Response.Type.SEARCH_ENTRIES:
if ((_finalResponse.ExceptionType == Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND) ||
(_finalResponse.ExceptionType ==
Common.Enum.ExceptionType.ATTRIBUTE_INDEX_NOT_FOUND))
{
_finalResponse = response;
break;
}
switch (response.ResultSet.Type)
{
case NCache.Caching.Queries.QueryType.GroupByAggregateFunction:
break;
default:
switch (response.ResultSet.AggregateFunctionType)
{
case Alachisoft.NCache.Common.Enum.AggregateFunctionType.NOTAPPLICABLE:
ide = response.KeyValueDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyValueDic[ide.Key] = ide.Value;
}
break;
default:
if (!_finalResponse.ResultSet.IsInitialized)
{
SetAggregateFunctionResult();
_finalResponse.ResultSet.Initialize(_finalResponse.ResultSet);
}
_finalResponse.ResultSet.Compile(response.ResultSet);
break;
}
break;
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.SEARCH:
if ((_finalResponse.ExceptionType ==
Alachisoft.NCache.Common.Enum.ExceptionType.TYPE_INDEX_NOT_FOUND) ||
(_finalResponse.ExceptionType == Alachisoft.NCache.Common.Enum.ExceptionType
.ATTRIBUTE_INDEX_NOT_FOUND))
{
_finalResponse = response;
break;
}
switch (response.ResultSet.AggregateFunctionType)
{
case Alachisoft.NCache.Common.Enum.AggregateFunctionType.NOTAPPLICABLE:
_finalResponse.KeyList.AddRange(response.KeyList);
break;
default:
if (!_finalResponse.ResultSet.IsInitialized)
{
SetAggregateFunctionResult();
_finalResponse.ResultSet.Initialize(_finalResponse.ResultSet);
}
_finalResponse.ResultSet.Compile(response.ResultSet);
break;
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.GET_SERVER_MAPPING:
_finalResponse.ServerMappingList = response.ServerMappingList;
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.SEARCH_ENTRIES_CQ:
ide = response.KeyValueDic.GetEnumerator();
while (ide.MoveNext())
{
_finalResponse.KeyValueDic[ide.Key] = ide.Value;
}
if (response.ResultSet != null && response.ResultSet.CQUniqueId != null)
{
string uniqueID = response.ResultSet.CQUniqueId;
if (!string.IsNullOrEmpty(uniqueID) && uniqueID != null)
{
if (_finalResponse.ResultSet != null &&
string.IsNullOrEmpty(_finalResponse.ResultSet.CQUniqueId))
{
_finalResponse.ResultSet.CQUniqueId = response.ResultSet.CQUniqueId;
}
}
}
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.GET_NEXT_CHUNK:
if (_finalResponse == null)
{
_finalResponse = response;
}
EnumerationDataChunk chunk = null;
if (_chunks.ContainsKey(address))
{
chunk = _chunks[address];
}
else
{
chunk = new EnumerationDataChunk();
chunk.Data = new List <string>();
_chunks.Add(address, chunk);
}
for (int i = 0; i < response.NextChunk.Count; i++)
{
chunk.Data.AddRange(response.NextChunk[i].Data);
chunk.Pointer = response.NextChunk[i].Pointer;
if (chunk.Pointer.NodeIpAddress == null)
{
chunk.Pointer.NodeIpAddress = address;
}
}
_finalResponse.NextChunk = new List <EnumerationDataChunk>(_chunks.Values);
break;
case Common.Protobuf.Response.Type.TASK_ENUMERATOR:
_finalResponse.TaskEnumerator.AddRange(response.TaskEnumerator);
break;
case Alachisoft.NCache.Common.Protobuf.Response.Type.EXCEPTION:
if (response.ExceptionType == Common.Enum.ExceptionType.STATE_TRANSFER_EXCEPTION)
{
_finalResponse = response;
}
break;
default:
break;
}
}
}
}
