private int getPort(ClientId clientId, string host)
{
if (ticks == clientId.Tick && host != null)
{
IPAddress ip = HostPort.HostToIPAddress(host);
if (ip != null)
{
HashString ipHash = ip.ToString();
object arrayLock = clientPool.ArrayLock;
Ports ports;
Monitor.Enter(arrayLock);
if (clientPool.Array[clientId.Index].Identity == clientId.Identity)
{
try
{
if (!ipPorts.TryGetValue(ipHash, out ports))
{
ipPorts.Add(ipHash, ports = new Ports(config));
}
return(ports.Next);
}
finally { Monitor.Exit(arrayLock); }
}
Monitor.Exit(arrayLock);
}
}
return(0);
}
/// <summary>
/// TCP 服务客户端创建器
/// </summary>
/// <param name="commandClient">TCP 服务客户端</param>
internal ClientSocketCreator(ClientBase commandClient)
{
this.CommandClient = commandClient;
Host = Attribute.Host;
Port = Attribute.Port;
IpAddress = HostPort.HostToIPAddress(this.Host, CommandClient.Log);
}
/// <summary>
/// TCP 服务客户端
/// </summary>
/// <param name="host">监听主机名称</param>
/// <param name="port">监听端口</param>
/// <param name="serviceName">服务名称</param>
/// <param name="sendBufferMaxSize">发送数据缓存区最大字节大小</param>
/// <param name="minCompressSize">压缩启用最低字节数量</param>
/// <param name="log">日志接口</param>
/// <param name="maxInputSize">最大输入数据字节数</param>
internal Client(string host, int port, string serviceName, int sendBufferMaxSize, int minCompressSize, ILog log, int maxInputSize) : base(serviceName, sendBufferMaxSize, minCompressSize, log)
{
this.Host = host;
this.Port = port;
IpAddress = HostPort.HostToIPAddress(this.Host, Log);
this.maxInputSize = maxInputSize <= 0 ? int.MaxValue : maxInputSize;
outputStream = (outputSerializer = BinarySerialize.Serializer.YieldPool.Default.Pop() ?? new BinarySerialize.Serializer()).SetTcpServer();
}
/// <summary>
/// TCP 服务客户端
/// </summary>
/// <param name="attribute">TCP服务调用配置</param>
/// <param name="verify">获取客户端请求线程调用类型</param>
/// <param name="extendCommandBits">扩展服务命令二进制位数</param>
/// <param name="log">日志接口</param>
/// <param name="callQueueCount">独占的 TCP 服务器端同步调用队列数量</param>
/// <param name="isCallQueueLink">是否提供独占的 TCP 服务器端同步调用队列（低优先级）</param>
/// <param name="isSynchronousVerifyMethod">验证函数是否同步调用</param>
internal ServerBase(ServerBaseAttribute attribute, Func <System.Net.Sockets.Socket, bool> verify, byte extendCommandBits, ILog log, int callQueueCount, bool isCallQueueLink, bool isSynchronousVerifyMethod)
: base(attribute, attribute.GetReceiveBufferSize, attribute.GetSendBufferSize, attribute.GetServerSendBufferMaxSize, log)
{
#if !NOJIT
if (extendCommandBits == 0)
{
extendServerSet = ExtendServerSet.Null;
}
else if (extendCommandBits < 9 || extendCommandBits > 16)
{
throw new IndexOutOfRangeException("扩展服务命令二进制位数 " + extendCommandBits.toString() + " 超出范围 9-16");
}
else
{
extendServerSet = new ExtendServerSet(this, extendCommandBits);
}
#endif
this.verify = verify;
if (callQueueCount > 0)
{
if (callQueueCount == 1)
{
CallQueue = new ServerCallCanDisposableQueue(true, Log);
if (isCallQueueLink)
{
CallQueueLink = CallQueue.CreateLink();
}
}
else
{
CallQueueArray = new KeyValue <ServerCallCanDisposableQueue, Threading.TaskQueueThread <ServerCallBase> .LowPriorityLink> [Math.Min(callQueueCount, 256)];
if (isCallQueueLink)
{
for (int index = 0; index != CallQueueArray.Length; ++index)
{
ServerCallCanDisposableQueue callQueue = new ServerCallCanDisposableQueue(true, Log);
CallQueueArray[index].Set(callQueue, callQueue.CreateLink());
}
CallQueueLink = CallQueueArray[0].Value;
}
else
{
for (int index = 0; index != CallQueueArray.Length; ++index)
{
CallQueueArray[index].Key = new ServerCallCanDisposableQueue(true, Log);
}
}
CallQueue = CallQueueArray[0].Key;
}
}
ServerAttribute.Set(attribute);
Port = attribute.Port;
IpAddress = HostPort.HostToIPAddress(attribute.Host, Log);
int binaryDeSerializeMaxArraySize = attribute.GetBinaryDeSerializeMaxArraySize;
BinaryDeSerializeConfig = AutoCSer.Net.TcpOpenServer.ServerAttribute.GetBinaryDeSerializeConfig(binaryDeSerializeMaxArraySize <= 0 ? AutoCSer.BinaryDeSerializer.DefaultConfig.MaxArraySize : binaryDeSerializeMaxArraySize);
VerifyMethodCount = isSynchronousVerifyMethod ? Server.DefaultVerifyMethodCount : (byte)(Server.DefaultVerifyMethodCount + 1);
}
/// <summary>
/// TCP 服务客户端
/// </summary>
/// <param name="attribute">TCP服务调用配置</param>
/// <param name="verify">获取客户端请求线程调用类型</param>
/// <param name="log">日志接口</param>
/// <param name="isCallQueue">是否提供独占的 TCP 服务器端同步调用队列</param>
internal ServerBase(attributeType attribute, Func <System.Net.Sockets.Socket, bool> verify, ILog log, bool isCallQueue)
: base(attribute, attribute.GetReceiveBufferSize, attribute.GetSendBufferSize, attribute.GetServerSendBufferMaxSize, log)
{
this.verify = verify;
if (isCallQueue)
{
CallQueue = new ServerCallCanDisposableQueue();
}
Port = attribute.Port;
IpAddress = HostPort.HostToIPAddress(attribute.Host, Log);
}
/// <summary>
/// 主机名称转换成IP地址
/// </summary>
/// <returns>是否转换成功</returns>
public bool HostToIpAddress()
{
IPAddress ipAddress = HostPort.HostToIPAddress(Host);
if (ipAddress == null)
{
return(false);
}
Host = ipAddress.ToString();
return(true);
}
/// <summary>
/// TCP 服务客户端
/// </summary>
/// <param name="attribute">TCP服务调用配置</param>
/// <param name="verify">获取客户端请求线程调用类型</param>
/// <param name="log">日志接口</param>
/// <param name="isCallQueue">是否提供独占的 TCP 服务器端同步调用队列</param>
internal ServerBase(attributeType attribute, Func <System.Net.Sockets.Socket, bool> verify, ILog log, bool isCallQueue)
: base(attribute, attribute.GetReceiveBufferSize, attribute.GetSendBufferSize, attribute.GetServerSendBufferMaxSize, log)
{
this.verify = verify;
if (isCallQueue)
{
CallQueue = new ServerCallCanDisposableQueue();
}
Port = attribute.Port;
IpAddress = HostPort.HostToIPAddress(attribute.Host, Log);
int binaryDeSerializeMaxArraySize = attribute.GetBinaryDeSerializeMaxArraySize;
BinaryDeSerializeConfig = AutoCSer.Net.TcpOpenServer.ServerAttribute.GetBinaryDeSerializeConfig(binaryDeSerializeMaxArraySize <= 0 ? AutoCSer.BinarySerialize.DeSerializer.DefaultConfig.MaxArraySize : binaryDeSerializeMaxArraySize);
}
/// <summary>
/// 服务更新
/// </summary>
/// <param name="serverSet"></param>
internal void OnServerChange(TcpRegister.ServerSet serverSet)
{
TcpRegister.ServerLog server = serverSet.Server;
IPAddress ipAddress = HostPort.HostToIPAddress(server.Host, CommandClient.Log);
if (server.Port == Port && ipAddress.Equals(IpAddress))
{
TryCreateSocket();
}
else
{
Host = server.Host;
createSocket(IpAddress = ipAddress, Port = server.Port, Interlocked.Increment(ref CreateVersion));
}
}
/// <summary>
/// 服务更新
/// </summary>
/// <param name="serverSet"></param>
void TcpRegister.IClient.OnServerChange(TcpRegister.ServerSet serverSet)
{
if (serverSet != null)
{
TcpRegister.ServerLog server = serverSet.Server;
IPAddress ipAddress = HostPort.HostToIPAddress(server.Host, Log);
if (server.Port != Port || !ipAddress.Equals(IpAddress))
{
Host = server.Host;
IpAddress = ipAddress;
Port = server.Port;
}
createSocket();
}
}
/// <summary>
/// TCP 服务客户端
/// </summary>
/// <param name="attribute">TCP服务调用配置</param>
/// <param name="verify">获取客户端请求线程调用类型</param>
/// <param name="log">日志接口</param>
/// <param name="callQueueCount">独占的 TCP 服务器端同步调用队列数量</param>
/// <param name="isCallQueueLink">是否提供独占的 TCP 服务器端同步调用队列（低优先级）</param>
/// <param name="isSynchronousVerifyMethod">验证函数是否同步调用</param>
internal ServerBase(ServerBaseAttribute attribute, Func <System.Net.Sockets.Socket, bool> verify, ILog log, int callQueueCount, bool isCallQueueLink, bool isSynchronousVerifyMethod)
: base(attribute, attribute.GetReceiveBufferSize, attribute.GetSendBufferSize, attribute.GetServerSendBufferMaxSize, log)
{
this.verify = verify;
if (callQueueCount > 0)
{
if (callQueueCount == 1)
{
CallQueue = new ServerCallCanDisposableQueue(true, Log);
if (isCallQueueLink)
{
CallQueueLink = CallQueue.CreateLink();
}
}
else
{
CallQueueArray = new KeyValue <ServerCallCanDisposableQueue, Threading.QueueTaskLinkThread <ServerCallBase> .LowPriorityLink> [Math.Min(callQueueCount, 256)];
if (isCallQueueLink)
{
for (int index = 0; index != CallQueueArray.Length; ++index)
{
ServerCallCanDisposableQueue callQueue = new ServerCallCanDisposableQueue(true, Log);
CallQueueArray[index].Set(callQueue, callQueue.CreateLink());
}
CallQueueLink = CallQueueArray[0].Value;
}
else
{
for (int index = 0; index != CallQueueArray.Length; ++index)
{
CallQueueArray[index].Key = new ServerCallCanDisposableQueue(true, Log);
}
}
CallQueue = CallQueueArray[0].Key;
}
}
ServerAttribute.Set(attribute);
Port = attribute.Port;
IpAddress = HostPort.HostToIPAddress(attribute.Host, Log);
int binaryDeSerializeMaxArraySize = attribute.GetBinaryDeSerializeMaxArraySize;
BinaryDeSerializeConfig = AutoCSer.Net.TcpOpenServer.ServerAttribute.GetBinaryDeSerializeConfig(binaryDeSerializeMaxArraySize <= 0 ? AutoCSer.BinarySerialize.DeSerializer.DefaultConfig.MaxArraySize : binaryDeSerializeMaxArraySize);
VerifyMethodCount = isSynchronousVerifyMethod ? Server.DefaultVerifyMethodCount : (byte)(Server.DefaultVerifyMethodCount + 1);
}
/// <summary>
/// TCP 服务客户端
/// </summary>
/// <param name="attribute">TCP服务调用配置</param>
/// <param name="log">日志接口</param>
/// <param name="maxInputSize">最大输入数据字节数</param>
internal Client(TcpServer.ServerBaseAttribute attribute, ILog log, int maxInputSize)
: base(attribute, attribute.ClientSendBufferMaxSize, log)
{
this.Host = attribute.Host;
this.Port = attribute.Port;
IpAddress = HostPort.HostToIPAddress(this.Host, Log);
this.maxInputSize = maxInputSize <= 0 ? int.MaxValue : maxInputSize;
outputStream = (outputSerializer = BinarySerializer.YieldPool.Default.Pop() ?? new BinarySerializer()).SetTcpServer();
SubBuffer.Pool.GetPool(attribute.GetSendBufferSize).Get(ref Buffer);
if (attribute.IsRemoteExpression)
{
remoteExpressionServerNodeIdChecker = new RemoteExpressionServerNodeIdChecker {
Client = this
}
}
;
}
/// <summary>
/// 启动服务
/// </summary>
protected void start()
{
try
{
IPAddress ipAddress = HostPort.HostToIPAddress(host.Host, RegisterServer.TcpServer.Log);
socket = new System.Net.Sockets.Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(new IPEndPoint(ipAddress, host.Port));
socket.Listen(int.MaxValue);
socketHandle.Set(0);
AutoCSer.Threading.ThreadPool.TinyBackground.FastStart(GetSocket);
if (host.Port == 0)
{
RegisterServer.TcpServer.Log.Add(AutoCSer.Log.LogType.Warn, "HTTP 服务端口为 0");
}
}
catch (Exception error)
{
Dispose();
RegisterServer.TcpServer.Log.Add(AutoCSer.Log.LogType.Error, error, "HTTP 服务器端口 " + host.Host + ":" + host.Port.toString() + " TCP连接失败)");
}
}
/// <summary>
/// 服务更新
/// </summary>
/// <param name="serverSet"></param>
void TcpRegister.IClient.OnServerChange(TcpRegister.ServerSet serverSet)
{
if (serverSet != null)
{
TcpRegister.ServerInfo server = serverSet.Server.Server;
IPAddress ipAddress = HostPort.HostToIPAddress(server.Host, Log);
if (server.Port == Port && ipAddress.Equals(IpAddress))
{
if (!server.IsCheckRegister)
{
createSocket();
}
}
else
{
Host = server.Host;
IpAddress = ipAddress;
Port = server.Port;
createSocket();
}
}
}
/// <summary>
/// 服务更新
/// </summary>
/// <param name="serverSet"></param>
void TcpRegister.IClient.OnServerChange(TcpRegister.ServerSet serverSet)
{
if (serverSet == null)
{
SocketWait.PulseReset();
}
else
{
TcpRegister.ServerInfo server = serverSet.Server.Server;
IPAddress ipAddress = HostPort.HostToIPAddress(server.Host, Log);
if (server.Port == Port && ipAddress.Equals(IpAddress))
{
if (!server.IsCheckRegister)
{
TryCreateSocket();
}
}
else
{
Host = server.Host;
createSocket(IpAddress = ipAddress, Port = server.Port, Interlocked.Increment(ref CreateVersion));
}
}
}
