/// <summary>
/// 添加定时任务节点
/// </summary>
/// <param name="node"></param>
internal void Append(SecondTimerTaskNode node)
{
long timeoutSeconds = node.TimeoutSeconds;
TimerLinkLock.Enter();
long index = timeoutSeconds - linkArrayBaseSeconds;
if (index < linkArrayCapacity)
{
if (index >= linkArrayIndex)
{
linkArray[(int)index].Append(node);
TimerLinkLock.Exit();
return;
}
}
else
{
index = ((index - linkArrayCapacity) >> linkArrayBitSize) + nextLinkArrayIndex;
if (index < linkArrayCapacity)
{
nextLinkArray[(int)index].Append(node);
}
else
{
timerLink.Append(node);
}
TimerLinkLock.Exit();
return;
}
TimerLinkLock.Exit();
node.AppendCall();
}
/// <summary>
/// 删除文件缓存
/// </summary>
/// <param name="path"></param>
private void remove(ref FileCacheKey path)
{
FileCache file;
fileLock.Enter();
if (files.Remove(ref path, out file))
{
freeCacheSize += file.Size;
}
fileLock.Exit();
}
/// <summary>
/// 获取用户长连接轮询验证
/// </summary>
/// <param name="userId">用户标识</param>
/// <param name="sessionId">长连接轮询验证,0表示失败</param>
internal void Get(int userId, out AutoCSer.Net.HttpDomainServer.SessionId sessionId)
{
int index = userId >> 8;
if ((uint)index < (uint)sessions.Length)
{
sessionLock.Enter();
sessionId = sessions[index].Get(timeoutTicks);
sessionLock.Exit();
}
else
{
sessionId = default(AutoCSer.Net.HttpDomainServer.SessionId);
}
}
/// <summary>
/// 根据类型获取成员索引分组
/// </summary>
/// <param name="type">对象类型</param>
/// <returns>成员索引分组</returns>
public static MemberIndexGroup Get(Type type)
{
MemberIndexGroup value;
cacheLock.Enter();
try
{
if (!cache.TryGetValue(type, out value))
{
cacheLock.SleepFlag = 1;
cache.Add(type, value = new MemberIndexGroup(type, false));
}
}
finally { cacheLock.ExitSleepFlag(); }
return(value);
}
public void Dispose()
{
searcher.State = null;
Unmanaged.Free(ref data);
lastLock.Enter();
Unmanaged.Free(ref lastDomain);
lastLock.Exit();
}
/// <summary>
/// 检测短路径的有效性
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
private ReturnType check(MasterServer.TcpInternalClient client)
{
createLock.Enter();
switch (Identity.Type)
{
case ReturnType.NotFoundShortPathNode: createLock.Exit(); return(ReturnType.NotFoundShortPathNode);
case ReturnType.NotFoundShortPath: reCreate(client); return(Identity.Type);
}
if (socketIdentity == Client.SocketIdentity)
{
createLock.Exit();
}
else
{
reCreate(client);
}
return(Identity.Type);
}
/// <summary>
/// 获取服务端节点标识
/// </summary>
/// <param name="remoteTypes"></param>
/// <returns></returns>
internal unsafe static int[] Get(AutoCSer.Reflection.RemoteType[] remoteTypes)
{
int[] ids = new int[remoteTypes.Length];
fixed(int *idFixed = ids)
{
int *idStart = idFixed;
foreach (AutoCSer.Reflection.RemoteType remoteType in remoteTypes)
{
Type type;
if (remoteType.TryGet(out type))
{
if (types.TryGetValue(type, out *idStart))
{
++idStart;
}
else
{
typeLock.Enter();
if (types.TryGetValue(type, out *idStart))
{
typeLock.Exit();
++idStart;
}
else
{
typeLock.SleepFlag = 1;
try
{
Func <Node> createNode = (Func <Node>)Delegate.CreateDelegate(typeof(Func <Node>), createNodeMethod.MakeGenericMethod(type));
int id = createNodes.Length;
createNodes.Add(createNode);
types.Add(type, id);
*idStart++ = id;
}
finally { typeLock.ExitSleepFlag(); }
}
}
}
else
{
*idStart++ = 0;
}
}
}
return(ids);
}
internal static int RegisterClient(Func <ReturnValue> createReturnValue)
{
createReturnValueLock.Enter();
int id = createReturnValues.Length;
try
{
if (createReturnValues.FreeCount == 0)
{
createReturnValueLock.SleepFlag = 1;
}
createReturnValues.Add(createReturnValue);
}
finally { createReturnValueLock.ExitSleepFlag(); }
return(id);
}
/// <summary>
/// 新建客户端命令池
/// </summary>
/// <param name="currentIndex">当前空闲命令位置</param>
/// <returns></returns>
private int create(int currentIndex)
{
if (bitSize == maxArrayBitSize)
{
if (arrayCount == arrays.Length)
{
if (arrayCount == 1 << (Server.CommandIndexBits - maxArrayBitSize))
{
freeIndex = currentIndex;
if (isErrorLog == 0)
{
isErrorLog = 1;
client.Log.Error("TCP 客户端活动会话数量过多", LogLevel.Error | LogLevel.AutoCSer);
}
return(0);
}
arrays = arrays.copyNew(arrayCount << 1);
}
int index = 1 << maxArrayBitSize;
CommandLink[] array = new CommandLink[index];
do
{
array[index - 1].Next = commandCount + index;
}while (--index != 0);
arrays[arrayCount++] = array;
freeEndIndexLock.Enter();
arrays[freeEndIndex >> bitSize][freeEndIndex & arraySizeAnd].Next = commandCount;
freeEndIndex = (commandCount += 1 << maxArrayBitSize) - 1;
freeEndIndexLock.Exit();
}
else
{
CommandLink[] array = new CommandLink[1 << ++bitSize];
for (int index = commandCount, endIndex = commandCount << 1; index != endIndex; ++index)
{
array[index].Next = index + 1;
}
freeEndIndexLock.Enter();
Array.CopyTo(array, 0);
arrays[0] = Array = array;
array[freeEndIndex].Next = commandCount;
freeEndIndex = arraySizeAnd = (commandCount <<= 1) - 1;
freeEndIndexLock.Exit();
}
freeIndex = (currentIndex < (1 << maxArrayBitSize) ? Array : pushArray)[currentIndex & arraySizeAnd].Next;
return(currentIndex);
}
/// <summary>
/// 接收数据回调处理
/// </summary>
/// <param name="data">输出数据</param>
internal override void OnReceive(ref SubArray <byte> data)
{
Action <ReturnValue> callback = Callback;
if (callback != null)
{
ReturnType value = GetReturnType(ref data);
if ((byte)value < (byte)ReturnType.Success)
{
KeepCallback.Cancel();
}
if (CommandInfo.TaskType == ClientTaskType.Synchronous)
{
try
{
callback(new ReturnValue {
Type = value
});
}
catch (Exception error) { Socket.Log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer); }
}
else
{
int isOutput = 1;
Exception exception = null;
OutputLock.Enter();
try
{
if (outputParameters.FreeCount == 0)
{
OutputLock.SleepFlag = 1;
}
outputParameters.Add(value);
isOutput = this.isOutput;
this.isOutput = 1;
}
catch (Exception error) { exception = error; }
finally
{
OutputLock.ExitSleepFlag();
if (exception != null)
{
Socket.Log.Exception(exception, null, LogLevel.Exception | LogLevel.AutoCSer);
}
}
if (isOutput == 0)
{
switch (CommandInfo.TaskType)
{
case ClientTaskType.ThreadPool: if (!System.Threading.ThreadPool.QueueUserWorkItem(threadPoolOnReceive))
{
AutoCSer.Threading.TaskSwitchThreadArray.Default.CurrentThread.Add(this);
}
return;
case ClientTaskType.Timeout: AutoCSer.Threading.TaskSwitchThreadArray.Default.CurrentThread.Add(this); return;
case ClientTaskType.TcpTask: ClientCallThreadArray.Default.CurrentThread.Add(this); return;
case ClientTaskType.TcpQueue: ClientCallQueue.Default.Add(this); return;
}
}
}
}
}