/// <summary>
/// 重建短路径
/// </summary>
/// <param name="client"></param>
/// <param name="returnType"></param>
/// <returns></returns>
internal bool ReCreate(MasterServer.TcpInternalClient client, ref ReturnType returnType)
{
switch (returnType)
{
case ReturnType.NotFoundShortPathNode: Identity.Type = ReturnType.NotFoundShortPathNode; return(false);
case ReturnType.NotFoundShortPath:
Monitor.Enter(createLock);
if (Identity.Type != ReturnType.NotFoundShortPathNode)
{
Identity.Type = ReturnType.NotFoundShortPath;
if (reCreate(client))
{
return(true);
}
}
else
{
Monitor.Exit(createLock);
}
break;
}
returnType = Identity.Type;
return(false);
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (client != null)
{
client.Dispose();
client = null;
}
}
/// <summary>
/// 文件备份
/// </summary>
/// <param name="fileName">文件名称</param>
/// <param name="trySeconds">失败重试间隔秒数</param>
/// <param name="masterClient">缓存主服务客户端</param>
/// <param name="log">日志处理</param>
public FileBackup(string fileName, int trySeconds = 4, MasterServer.TcpInternalClient masterClient = null, AutoCSer.Log.ILog log = null)
{
this.fileName = fileName;
tryTicks = Math.Max(trySeconds, 1) * TimeSpan.TicksPerSecond;
this.masterClient = masterClient ?? new MasterServer.TcpInternalClient();
this.log = log ?? AutoCSer.Log.Pub.Log;
onReadHandle = onRead;
AutoCSer.Threading.ThreadPool.TinyBackground.Start(getVersion);
}
/// <summary>
/// 缓存主服务
/// </summary>
/// <param name="config">缓存主服务配置</param>
public SlaveServer(SlaveServerConfig config) : base()
{
Config = config ?? defaultConfig;
if (Config.IsMasterCacheServer)
{
masterClient = new MasterServer.TcpInternalClient(Config.CacheServerAttribute);
}
else
{
slaveClient = new SlaveServer.TcpInternalClient(Config.CacheServerAttribute);
}
}
internal ReturnType Check(MasterServer.TcpInternalClient client)
{
switch (Identity.Type)
{
case ReturnType.NotFoundShortPathNode: return(ReturnType.NotFoundShortPathNode);
case ReturnType.NotFoundShortPath: return(check(client));
}
if (socketIdentity != Client.SocketIdentity)
{
return(check(client));
}
return(Identity.Type);
}
/// <summary>
/// 检测短路径的有效性
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
private ReturnType check(MasterServer.TcpInternalClient client)
{
Monitor.Enter(createLock);
switch (Identity.Type)
{
case ReturnType.NotFoundShortPathNode: Monitor.Exit(createLock); return(ReturnType.NotFoundShortPathNode);
case ReturnType.NotFoundShortPath: reCreate(client); return(Identity.Type);
}
if (socketIdentity == Client.SocketIdentity)
{
Monitor.Exit(createLock);
}
else
{
reCreate(client);
}
return(Identity.Type);
}
/// <summary>
/// 消息分发 客户端消费者
/// </summary>
/// <param name="node">消费分发节点</param>
/// <param name="config">消息分发 读取配置</param>
/// <param name="log">日志处理</param>
protected DistributionConsumer(DataStructure.Abstract.Node node, DistributionConsumerConfig config, AutoCSer.ILog log)
{
client = node.ClientDataStructure.Client.MasterClient;
if (client == null)
{
throw new InvalidOperationException();
}
this.node = node;
if (config == null)
{
Config = defaultConfig;
}
else
{
config.Format();
Config = config;
}
Log = log ?? client._TcpClient_.Log;
getSendCountNode = new DataStructure.Parameter.Value(node, OperationParameter.OperationType.MessageQueueGetDequeueIdentity);
getSendCountNode.Parameter.SetJson((Cache.MessageQueue.DistributionConfig)Config);
getMessageNode = new DataStructure.Parameter.Value(node, OperationParameter.OperationType.MessageQueueDequeue, config.LoopSendCount);
}
/// <summary>
/// 消息队列 客户端消费者
/// </summary>
/// <param name="client">TCP 客户端</param>
/// <param name="config">队列数据 读取配置</param>
/// <param name="log">日志处理</param>
/// <param name="readerIndexNode"></param>
protected Consumer(MasterServer.TcpInternalClient client, ConsumerConfig config, AutoCSer.ILog log, DataStructure.Abstract.Node readerIndexNode)
{
if (client == null)
{
throw new InvalidOperationException();
}
this.client = client;
if (config == null)
{
Config = defaultConfig;
}
else
{
config.Format();
Config = config;
}
Log = log ?? client._TcpClient_.Log;
getDequeueIdentityNode = new DataStructure.Parameter.Value(readerIndexNode, OperationParameter.OperationType.MessageQueueGetDequeueIdentity);
getDequeueIdentityNode.Parameter.SetJson((Cache.MessageQueue.ReaderConfig)Config);
getMessageNode = new DataStructure.Parameter.Value(readerIndexNode, OperationParameter.OperationType.MessageQueueDequeue);
setDequeueIdentityNode = new DataStructure.Parameter.Value(readerIndexNode, OperationParameter.OperationType.MessageQueueSetDequeueIdentity);
}
/// <summary>
/// 重建短路径
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
private bool reCreate(MasterServer.TcpInternalClient client)
{
try
{
do
{
socketIdentity = Client.SocketIdentity;
AutoCSer.Net.TcpServer.ReturnValue <ReturnParameter> value = client.Query(new OperationParameter.QueryNode {
Node = Parameter
});
if (socketIdentity == Client.SocketIdentity)
{
return(isCreate(ref value));
}
}while (true);
}
catch (Exception error)
{
client._TcpClient_.AddLog(error);
}
finally { Monitor.Exit(createLock); }
return(false);
}
/// <summary>
/// 缓存服务客户端
/// </summary>
/// <param name="serverAttribute">缓存服务端配置</param>
public MasterClient(AutoCSer.Net.TcpInternalServer.ServerAttribute serverAttribute)
{
client = new MasterServer.TcpInternalClient(serverAttribute);
}
/// <summary>
/// 缓存服务客户端
/// </summary>
/// <param name="client">缓存服务客户端</param>
public MasterClient(MasterServer.TcpInternalClient client = null)
{
this.client = client ?? new MasterServer.TcpInternalClient();
}
