private bool onGetMessage(ulong identity, ref ValueData.Data message)
{
if (message.Type == dataType)
{
if (consumer.IsProcessor(this))
{
valueType value = getValue(ref message);
do
{
try
{
onMessage(value);
consumer.SetDequeueIdentity(identity);
return(true);
}
catch (Exception error)
{
consumer.Log.Add(Log.LogType.Error, error);
System.Threading.Thread.Sleep(1);
}
}while (true);
}
}
else if (message.Type == ValueData.DataType.Null)
{
return(true);
}
return(false);
}
private bool onGetMessage(ref ValueData.Data message)
{
if (message.Type == dataType)
{
if (consumer.IsProcessor(this))
{
valueType value = getValue(ref message);
ONMESSAGE:
try
{
onMessage(value);
}
catch (Exception error)
{
consumer.Log.Add(Log.LogType.Error, error);
System.Threading.Thread.Sleep(1);
goto ONMESSAGE;
}
++identity;
if (messageTime != Date.NowTime.Now || --sendClientCount == 0)
{
consumer.SetDequeueIdentity(identity);
messageTime = Date.NowTime.Now;
sendClientCount = (consumer.Config.SendClientCount >> 1) | 1U;
}
return(true);
}
}
else if (message.Type == ValueData.DataType.Null)
{
return(true);
}
return(false);
}
/// <summary>
/// 数据缓冲区
/// </summary>
/// <param name="node"></param>
/// <param name="onReturn"></param>
/// <param name="message"></param>
internal Buffer(Node node, AutoCSer.Net.TcpServer.ServerCallback <ReturnParameter> onReturn, ref DistributionMessageItem message)
{
Node = node;
this.onReturn = onReturn;
Data = message.Data;
BufferCount = message.OnAppendFile();
}
/// <summary>
/// 数据缓冲区
/// </summary>
/// <param name="node"></param>
/// <param name="onReturn"></param>
/// <param name="message"></param>
internal Buffer(Node node, Func <AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter>, bool> onReturn, ref DistributionMessageItem message)
{
Node = node;
this.onReturn = onReturn;
Data = message.Data;
BufferCount = message.OnAppendFile();
}
internal void Set(Buffer buffer)
{
Data = buffer.Data;
BufferCount = buffer.BufferCount;
Data.ReturnType = ReturnType.Success;
buffer.BufferCount = null;
}
/// <summary>
/// 数据缓冲区
/// </summary>
/// <param name="node"></param>
/// <param name="parser"></param>
internal Buffer(Node node, ref OperationParameter.NodeParser parser)
{
Data = parser.ValueData;
onReturn = parser.OnReturn;
Node = node;
BufferCount = Data.CopyToMessageQueueBufferCount();
parser.OnReturn = null;
}
/// <summary>
/// 消息队列数据缓冲区计数
/// </summary>
/// <param name="buffer">消息队列数据缓冲区</param>
internal BufferCount(Buffer buffer)
{
data = buffer.Data;
count = buffer.BufferCount;
Identity = buffer.Identity;
data.ReturnType = ReturnType.Success;
isBufferCount = 0;
buffer.BufferCount = null;
}
internal AutoCSer.CacheServer.BufferCount Get(out ValueData.Data data)
{
data = this.data;
if (count != null)
{
if (isBufferCount == 0) isBufferCount = 1;
else Interlocked.Increment(ref count.Count);
return count;
}
return null;
}
/// <summary>
/// 节点解析
/// </summary>
/// <param name="cache">缓存管理</param>
/// <param name="loadData">加载数据</param>
internal NodeParser(CacheManager cache, ref LoadData loadData)
{
Cache = cache;
Buffer = loadData.Buffer;
dataFixed = loadData.DataFixed;
end = Read = null;
OnReturn = null;
OperationType = default(OperationType);
ValueData = default(ValueData.Data);
ReturnParameter = default(ValueData.Data);
IsOperation = false;
}
internal bool Send(ulong identity, ref ValueData.Data data, ref bool isNext)
{
data.IsReturnDeSerializeStream = isGetMessageStream;
if (OnGetMessage.Callback(new IdentityReturnParameter(identity, ref data)))
{
if (--sendCount == 0)
{
isNext = true;
sendCount = maxSendCount;
}
return(true);
}
return(false);
}
/// <summary>
/// 参数解析
/// </summary>
/// <param name="cache">缓存管理</param>
/// <param name="buffer">数据缓冲区</param>
/// <param name="dataFixed">数据起始位置</param>
internal NodeParser(CacheManager cache, Buffer buffer, byte *dataFixed)
{
Read = dataFixed + buffer.Array.Start;
Buffer = buffer;
Cache = cache;
OnReturn = null;
this.dataFixed = dataFixed;
end = Read + buffer.Array.Count;
OperationType = (OperationType)(*(ushort *)(Read + Serializer.OperationTypeOffset));
ValueData = default(ValueData.Data);
ReturnParameter = default(ValueData.Data);
IsOperation = false;
Read += Serializer.HeaderSize;
}
/// <summary>
/// Json 数据节点
/// </summary>
/// <param name="data">数据</param>
internal Binary(ref ValueData.Data data)
{
Parameter = data;
}
/// <summary>
/// 获取参数数据委托
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
internal static valueType GetData(ref ValueData.Data parameter)
{
valueType value = default(valueType);
return(parameter.GetBinary(ref value) ? value : default(valueType));
}
internal ReturnParameter OperationStream(OperationParameter.ShortPathOperationNode parameter)
{
ValueData.Data returnValue = Cache.Operation(ref parameter);
returnValue.IsReturnDeSerializeStream = true;
return(new ReturnParameter(ref returnValue));
}
/// <summary>
/// Json 数据节点
/// </summary>
/// <param name="data">数据</param>
internal Json(ref ValueData.Data data)
{
Parameter = data;
}
internal ReturnParameter QueryStream(OperationParameter.QueryNode parameter)
{
ValueData.Data returnValue = Cache.Query(ref parameter.QueryData);
returnValue.IsReturnDeSerializeStream = true;
return(new ReturnParameter(ref returnValue));
}
/// <summary>
/// 返回值类型
/// </summary>
/// <param name="parameter">返回值参数</param>
internal ReturnParameter(ref ValueData.Data parameter)
{
Parameter = parameter;
}
/// <summary>
/// 返回值类型
/// </summary>
/// <param name="returnType">返回值类型</param>
internal ReturnParameter(ReturnType returnType)
{
//Parameter = new ValueData.Data(returnType);
Parameter = default(ValueData.Data);
Parameter.ReturnType = returnType;
}
internal void Set(ValueData.Data parameter, bool isDeSerializeStream)
{
parameter.IsReturnDeSerializeStream = isDeSerializeStream;
Parameter = parameter;
}
/// <summary>
/// 查询参数节点
/// </summary>
/// <param name="parent">父节点</param>
/// <param name="parameter">查询参数</param>
/// <param name="operationType">操作类型</param>
internal QueryReturnValue(Abstract.Node parent, ref ValueData.Data parameter, OperationParameter.OperationType operationType) : base(parent)
{
Parameter = parameter;
Parameter.OperationType = operationType;
}
/// <summary>
/// 附带标识的返回值参数
/// </summary>
/// <param name="identity"></param>
/// <param name="parameter"></param>
internal IdentityReturnParameter(ulong identity, ref ValueData.Data parameter)
{
Identity = identity;
Parameter = parameter;
}
/// <summary>
/// 返回值类型
/// </summary>
/// <param name="returnType">返回值类型</param>
internal IdentityReturnParameter(ReturnType returnType)
{
Parameter = default(ValueData.Data);
Identity = 0;
Parameter.ReturnType = returnType;
}
/// <summary>
/// 返回值类型
/// </summary>
/// <param name="parameter">返回值参数</param>
internal IdentityReturnParameter(ref ValueData.Data parameter)
{
Identity = 0;
Parameter = parameter;
}
