/// <summary>
/// 锁链表节点
/// </summary>
/// <param name="node"></param>
/// <param name="parser"></param>
internal LinkNode(Node node, ref OperationParameter.NodeParser parser)
{
OnReturn = parser.OnReturn;
this.node = node;
timeOutTicks = parser.ValueData.Int64.Long;
parser.OnReturn = null;
}
private void getUser(AutoCSer.Net.TcpOpenServer.ServerSocketSender socket, AutoCSer.Net.TcpServer.ServerCallback <ChatData.UserLogin> getUser)
{
User currentUser = getCurrentUser(socket);
if (currentUser != null)
{
currentUser.GetUser = getUser;
bool isLoaded = true;
removeUsers.ClearOnlyLength();
foreach (var user in users)
{
if (user.Value != currentUser && !getUser.Callback(new ChatData.UserLogin {
Name = user.Value.Name, Type = ChatData.UserLoginType.Load
}))
{
isLoaded = false;
removeUsers.Add(currentUser.Name);
break;
}
}
if (isLoaded)
{
getUser.Callback(new ChatData.UserLogin {
Type = ChatData.UserLoginType.Loaded
});
}
removeUser();
}
}
/// <summary>
/// 添加数据
/// </summary>
/// <param name="buffer"></param>
internal void Append(Buffer buffer)
{
if (buffer.Identity == writerAppendIdentity)
{
++writerAppendIdentity;
}
if (buffer.Identity == writeIdentity && writeIdentity < memoryEndIdentity && isDisposed == 0)
{
messages[writeMessageIndex].Set(buffer);
nextWriteIndex();
if (onGetMessage != null && (uint)(sendIdentity - Identity) != Config.SendClientCount)
{
if (onGetMessage.Callback(new ReturnParameter(messages[sendMessageIndex].Data, isGetMessageStream)))
{
nextSendIndex();
}
else
{
onGetMessage = null;
}
}
return;
}
buffer.FreeBuffer();
}
/// <summary>
/// 查询数据
/// </summary>
/// <param name="queryData">查询数据</param>
/// <param name="onQuery"></param>
/// <param name="isDeSerializeStream">是否反序列化网络流，否则需要 Copy 数据</param>
internal void Query(ref SubArray <byte> queryData, AutoCSer.Net.TcpServer.ServerCallback <IdentityReturnParameter> onQuery, bool isDeSerializeStream)
{
try
{
queryBuffer.Set(ref queryData);
fixed(byte *dataFixed = queryData.GetFixedBuffer())
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, queryBuffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
parser.SetOnReturn(onQuery, isDeSerializeStream);
onQuery = null;
try
{
dataStructure.Node.Query(ref parser);
}
finally
{
parser.CallOnReturnDistributionMessage();
}
}
}
}
finally
{
if (onQuery != null)
{
onQuery.Callback(new IdentityReturnParameter(ReturnType.DataStructureIdentityError));
}
}
}
/// <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>
internal DeployResultData Start()
{
if (IsCancel)
{
return(DeployState.Canceled);
}
ClientObject client = DeployInfo.Client;
Log log = new Log {
DeployIndex = DeployInfo.Index
};
bool isLog = true;
try
{
AutoCSer.Net.TcpServer.ServerCallback <Log> onLog = client.OnLog ?? AutoCSer.Net.TcpServer.ServerCallback <Log> .Null.Default;
byte[] data = null;
while (TaskIndex != DeployInfo.Tasks.Length && !IsCancel)
{
ClientTask.Task task = DeployInfo.Tasks.Array[TaskIndex];
log.Set(TaskIndex, task.Type);
isLog |= onLog.Callback(log);
DeployResultData state = task.Call(this);
log.Type = LogType.OnRun;
isLog |= onLog.Callback(log);
if (state.State != DeployState.Success)
{
return(state);
}
if (state.Data != null)
{
data = state.Data;
}
++TaskIndex;
}
return(new DeployResultData {
State = DeployState.Success, Data = data
});
}
catch (Exception error)
{
Console.WriteLine(error.ToString());
Error = error;
}
finally
{
//Server.Clear(ref Identity);
if (Error == null)
{
log.Type = LogType.Completed;
}
else
{
AutoCSer.LogHelper.Exception(Error, null, LogLevel.Exception | LogLevel.AutoCSer);
log.Type = LogType.Error;
}
//if (!(isLog |= onLog(log))) Server.ClearClient(ref clientId);
}
return(DeployState.Exception);
}
/// <summary>
/// 启动定时任务
/// </summary>
internal DeployState Start()
{
if (IsCancel)
{
return(DeployState.Canceled);
}
//IndexIdentity clientId = new IndexIdentity();
ClientObject client = DeployInfo.Client;
Log log = new Log {
Identity = Identity
};
bool isLog = true;
try
{
//Func<AutoCSer.Net.TcpServer.ReturnValue<Log>, bool> onLog = Server.GetLog(ref Identity, ref clientId) ?? Timer.onLog;
AutoCSer.Net.TcpServer.ServerCallback <Log> onLog = client.OnLog ?? AutoCSer.Net.TcpServer.ServerCallback <Log> .Null.Default;
log.Type = LogType.CreateBakDirectory;
isLog |= onLog.Callback(log);
(BakDirectory = new DirectoryInfo(Date.NowTime.Set().ToString("yyyyMMddHHmmss_" + Identity.Index.toString() + "_" + Identity.Identity.toString()))).Create();
log.Type = LogType.OnCreateBakDirectory;
isLog |= onLog.Callback(log);
while (TaskIndex != DeployInfo.Tasks.Length && !IsCancel)
{
Task task = DeployInfo.Tasks.Array[TaskIndex];
log.Set(TaskIndex, task.Type);
isLog |= onLog.Callback(log);
DeployState state = task.Run(this);
log.Type = LogType.OnRun;
isLog |= onLog.Callback(log);
if (state != DeployState.Success)
{
return(state);
}
++TaskIndex;
}
return(DeployState.Success);
}
catch (Exception error)
{
Console.WriteLine(error.ToString());
Error = error;
}
finally
{
Server.Clear(ref Identity);
if (Error == null)
{
log.Type = LogType.Completed;
}
else
{
AutoCSer.Log.Pub.Log.Add(AutoCSer.Log.LogType.Error, Error);
log.Type = LogType.Error;
}
//if (!(isLog |= onLog(log))) Server.ClearClient(ref clientId);
}
return(DeployState.Exception);
}
internal void OnLog(AutoCSer.Net.TcpServer.ServerCallback <Log> onLog)
{
foreach (Log log in Servers)
{
onLog.Callback(log);
}
onLog.Callback(Server);
}
internal void OnLog(Log log)
{
if (onLog != null && !onLog.Callback(log))
{
++Identity;
onLog = null;
}
}
/// <summary>
/// 添加获取数据任务
/// </summary>
/// <param name="reader"></param>
/// <param name="onReturn"></param>
/// <param name="parser"></param>
internal GetDistributionMessage(DistributionFileReader reader, AutoCSer.Net.TcpServer.ServerCallback <IdentityReturnParameter> onReturn, ref OperationParameter.NodeParser parser) : base(reader.Node)
{
OnReturn = onReturn;
sendCount = Math.Max(parser.ValueData.Int64.Int, 1);
isReturnStream = parser.ReturnParameter.IsReturnDeSerializeStream;
this.reader = reader;
parser.ReturnParameter.Value = null;
}
void Add(int left, int right, int count, AutoCSer.Net.TcpServer.ServerCallback <int> onAdd)
{
while (count != 0)
{
onAdd.Callback(left + right);
--count;
}
}
internal void CallOnReturn()
{
if (OnReturn != null)
{
OnReturn.Callback(new ReturnParameter(ref ReturnParameter));
OnReturn = 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;
}
internal void CallOnReturn(ulong identity)
{
ReturnParameter returnParameter = default(ReturnParameter);
returnParameter.Parameter.ReturnParameterSet(identity);
onReturn.Callback(returnParameter);
onReturn = null;
}
/// <summary>
/// 获取缓存数据
/// </summary>
/// <param name="cache">缓存管理</param>
/// <param name="onCache"></param>
internal CacheGetter(CacheManager cache, AutoCSer.Net.TcpServer.ServerCallback <CacheReturnParameter> onCache)
{
this.Cache = cache;
this.onCache = onCache;
timeoutTicks = cache.Config.GetCacheLoadTimeoutSeconds * TimeSpan.TicksPerSecond;
timeout = DateTime.MaxValue;
cache.AppendWait(this);
}
/// <summary>
/// 添加获取数据任务
/// </summary>
/// <param name="reader"></param>
/// <param name="parser"></param>
internal GetMessage(FileReader reader, ref OperationParameter.NodeParser parser) : base(reader.Node)
{
OnReturn = parser.OnReturn;
IsReturnStream = parser.ReturnParameter.IsReturnDeSerializeStream;
Identity = parser.ValueData.Int64.ULong;
this.reader = reader;
parser.OnReturn = null;
}
/// <summary>
/// 文件读取器
/// </summary>
/// <param name="file">文件流写入器</param>
/// <param name="index">当前读取位置</param>
/// <param name="onRead">读取文件回调委托</param>
internal FileReader(FileStreamWriter file, long index, AutoCSer.Net.TcpServer.ServerCallback <ReadFileParameter> onRead)
{
this.file = file;
this.index = index;
this.onRead = onRead;
buffer = new byte[(int)file.Config.ReaderBufferSize];
readHandle = read;
}
internal void CallOnReturn(uint sendCount)
{
ReturnParameter returnParameter = default(ReturnParameter);
returnParameter.Parameter.ReturnParameterSet(sendCount);
onReturn.Callback(returnParameter);
onReturn = null;
}
internal bool Set(int identity, AutoCSer.Net.TcpServer.ServerCallback <Log> onLog)
{
if (Identity == identity)
{
this.onLog = onLog;
return(true);
}
return(false);
}
internal void CallOnReturnDistributionMessage()
{
AutoCSer.Net.TcpServer.ServerCallback <IdentityReturnParameter> onReturn = ReturnParameter.Value as AutoCSer.Net.TcpServer.ServerCallback <IdentityReturnParameter>;
if (onReturn != null)
{
onReturn.Callback(new IdentityReturnParameter(ref ReturnParameter));
ReturnParameter.Value = null;
}
}
/// <summary>
/// 搜索树字典获取数据
/// </summary>
/// <param name="dictionary">搜索树字典</param>
/// <param name="skipCount">跳过记录数</param>
/// <param name="getCount">获取记录数</param>
/// <param name="parser">参数解析</param>
internal SearchTreeDictionaryGetter(Cache.Value.SearchTreeDictionary <keyType, valueType> dictionary, int skipCount, int getCount, ref OperationParameter.NodeParser parser)
{
OnReturn = parser.OnReturn;
cache = parser.Cache;
this.dictionary = dictionary;
this.skipCount = skipCount;
this.getCount = getCount;
parser.OnReturn = null;
}
/// <summary>
/// 错误回调
/// </summary>
/// <param name="returnType"></param>
internal void Error(ReturnType returnType)
{
FreeBuffer();
AutoCSer.Net.TcpServer.ServerCallback <ReturnParameter> onReturn = this.onReturn;
if (onReturn != null)
{
this.onReturn = null;
onReturn.Callback(new ReturnParameter(returnType));
}
}
private Buffer callback()
{
if (onReturn != null)
{
ReturnParameter returnParameter = new ReturnParameter();
returnParameter.Parameter.ReturnParameterSet(true);
onReturn.Callback(returnParameter);
onReturn = null;
}
return(LinkNext);
}
internal bool OnLog(AutoCSer.Net.TcpServer.ServerCallback <ServerLog> onLog)
{
foreach (ServerLog log in Servers)
{
if (!onLog.Callback(log))
{
return(false);
}
}
return(onLog.Callback(Server));
}
private void append(AppendBuffer buffer, AutoCSer.Net.TcpServer.ServerCallback <ulong> onWrite)
{
if (buffer.CheckBlockIndex(index))
{
block.Append(ref buffer, onWrite);
}
else
{
onWrite.Callback(0);
}
}
private void callback(ref Buffer next)
{
next = LinkNext;
LinkNext = null;
if (onReturn != null)
{
ReturnParameter returnParameter = new ReturnParameter();
returnParameter.Parameter.ReturnParameterSet(true);
onReturn.Callback(returnParameter);
onReturn = null;
}
}
/// <summary>
/// 获取数据
/// </summary>
/// <param name="getMessage"></param>
internal void Get(QueueTaskThread.GetMessage getMessage)
{
ReturnType returnType = ReturnType.MessageQueueNotFoundReader;
try
{
if (isDisposed == 0)
{
if (getMessage.Identity == Identity)
{
if (onGetMessage == null || !onGetMessage.Callback(new ReturnParameter(ReturnType.Success)))
{
onGetMessage = getMessage.OnReturn;
isGetMessageStream = getMessage.IsReturnStream;
ulong endIdentity = Math.Min(Identity + Config.SendClientCount, writeIdentity);
sendIdentity = Identity;
sendMessageIndex = messageIndex;
getMessage = null;
ReturnParameter returnParameter = default(ReturnParameter);
while (sendIdentity != endIdentity)
{
returnParameter.Set(messages[sendMessageIndex].Data, isGetMessageStream);
if (onGetMessage.Callback(returnParameter))
{
nextSendIndex();
}
else
{
onGetMessage = null;
return;
}
}
return;
}
else
{
returnType = ReturnType.MessageQueueGetMessageExists;
}
}
else
{
returnType = ReturnType.MessageQueueReaderIdentityError;
}
}
}
finally
{
if (getMessage != null)
{
getMessage.OnReturn.Callback(new ReturnParameter(returnType));
}
}
}
/// <summary>
/// 操作数据
/// </summary>
/// <param name="buffer">数据缓冲区</param>
/// <param name="onOperation"></param>
internal void Operation(Buffer buffer, AutoCSer.Net.TcpServer.ServerCallback <ReturnParameter> onOperation)
{
int isReturn = 0;
try
{
if (CanWrite)
{
fixed(byte *dataFixed = buffer.GetFixedBuffer())
{
OperationParameter.NodeParser parser = new OperationParameter.NodeParser(this, buffer, dataFixed);
ServerDataStructure dataStructure = parser.Get(Array);
if (dataStructure != null)
{
parser.OnReturn = onOperation;
try
{
dataStructure.Node.Operation(ref parser);
}
finally
{
if (parser.OnReturn == null)
{
isReturn = 1;
}
}
if (parser.IsOperation)
{
this.onOperation(buffer);
}
else
{
buffer.FreeReference();
}
return;
}
}
buffer.FreeReference();
isReturn = 1;
onOperation.Callback(new ReturnParameter(ReturnType.DataStructureIdentityError));
return;
}
buffer.FreeReference();
}
finally
{
if (isReturn == 0)
{
onOperation.Callback(new ReturnParameter(ReturnType.CanNotWrite));
}
}
}
/// <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;
}
private void read(ClientBuffer buffer, ulong index, AutoCSer.Net.TcpServer.ServerCallback <ClientBuffer> onRead)
{
if ((int)(index >> IndexShift) == this.index)
{
block.Read((long)(index & MaxIndex), buffer.Buffer.Start, onRead);
}
else
{
onRead.Callback(new ClientBuffer {
State = MemberState.BlockIndexError
});
}
}
