public RemoteResult SendToWriter(ServerId server, NetCommand command)
{
Logger.Logger.Instance.TraceFormat("SendSync command {0} to {1}", command.GetType(), server);
var connection = FindServer(server) as SingleConnectionToWriter;
if (connection == null)
{
ConnectToWriter(server);
connection = FindServer(server) as SingleConnectionToWriter;
}
if (connection == null)
{
Logger.Logger.Instance.DebugFormat("WriterNetModule: process server not found server = {0}", server);
return(new ServerNotFoundResult());
}
var ret = connection.SendSync(command);
if (ret is FailNetResult)
{
Logger.Logger.Instance.DebugFormat("WriterNetModule: process fail result server = {0}", server);
RemoveConnection(server);
}
return(ret);
}
public RemoteResult SendToWriter(ServerId server, NetCommand command)
{
Logger.Logger.Instance.TraceFormat("SendSync command {0} to {1}", command.GetType(), server);
var connection = FindServer(server) as SingleConnectionToWriter;
if (connection == null)
{
ConnectToWriter(server);
connection = FindServer(server) as SingleConnectionToWriter;
}
if (connection == null)
{
_distributor.ServerNotAvailable(server);
return(new ServerNotFoundResult());
}
var ret = connection.SendSync(command);
if (ret is FailNetResult)
{
RemoveConnection(server);
_distributor.ServerNotAvailable(server);
}
return(ret);
}
//编码
protected override byte[] EncodeCmd(NetCommand cmd)
{
if (cmd.GetType() == typeof(ByteNetCommand))
{
return((cmd as ByteNetCommand).buf);
}
else
{
var pyaloadStream = new MemoryStream();
ProtoBuf.Serializer.Serialize(pyaloadStream, cmd);
return(pyaloadStream.ToArray());
}
}
internal void HandleNetCommand(NetCommand netCommand)
{
var commandHandler = CommandFactory.GetReflectedInstance(netCommand.GetType());
if (commandHandler != null)
{
commandHandler.HandleCommand(netCommand);
}
else
{
FFB.Instance.AddReport(RawString.Create($"Missing handler for NetCommand {netCommand.GetType().Name}"));
}
}
//TODO посмотреть будет ли работать
public RemoteResult SendToDistributor(NetCommand command)
{
Logger.Logger.Instance.TraceFormat("SendSync command {0}", command.GetType());
var connection = FindServer <SingleConnectionToDistributor>() as SingleConnectionToDistributor;
if (connection == null)
{
return(new ServerNotFoundResult());
}
var ret = connection.SendSync(command);
return(ret);
}
public string GetValue(string meta, NetCommand args)
{
switch (meta)
{
case "route":
{
string tpName = args.GetType() == typeof(ByteNetCommand) ? (args as ByteNetCommand).msgname : args.GetType().Name;
string path = makeRouteName(tpName);
string tp = types[tpName];
return(path + $"{GetValue(tp, args)}");
}
default:
return(metas[meta]);
}
}
private void ProcessInner(NetCommand command)
{
if (command is RestoreCommand)
{
var comm = command as RestoreCommand;
Logger.Logger.Instance.Debug(
string.Format("First restore server = {0}", _model.Servers.Count(x => !x.Equals(_model.Local))),
"restore");
if (comm.FailedServers != null)
{
var list = _model.Servers.Where(x => comm.FailedServers.Contains(x)).ToList();
_asyncDbWork.Restore(_model.LocalMap, list, comm.IsModelUpdated, comm.TableName);
}
else
{
var servers = comm.IsModelUpdated
? _model.Servers
: _model.Servers.Where(x => !x.Equals(_model.Local));
_asyncDbWork.Restore(_model.LocalMap, servers.ToList(), comm.IsModelUpdated, comm.TableName);
}
}
else if (command is RestoreInProcessCommand)
{
_asyncDbWork.PeriodMessageIncome(((RestoreInProcessCommand)command).ServerId);
}
else if (command is RestoreCompleteCommand)
{
_asyncDbWork.LastMessageIncome(((RestoreCompleteCommand)command).ServerId);
}
else if (command is RestoreCommandWithData)
{
var comm = command as RestoreCommandWithData;
_asyncDbWork.RestoreIncome(comm.ServerId, comm.IsModelUpdated, comm.Hash, comm.TableName);
}
else
{
Logger.Logger.Instance.ErrorFormat("Not supported command {0}", command.GetType());
}
}
protected override uint Getpid(NetCommand cmd)
{
return(cmd.GetType() == typeof(ByteNetCommand) ? (cmd as ByteNetCommand).pid : Registry.MustFind(cmd.GetType()));
}
private void Process(NetCommand message)
{
if (message is ServerNotAvailableCommand)
{
ServerNotAvailableInner((message as ServerNotAvailableCommand).Server);
}
else if (message is AddDistributorFromDistributorCommand)
{
AddDistributor(message as AddDistributorFromDistributorCommand);
}
else if (message is RestoreCommand)
{
RestoreServerCommand(message as RestoreCommand);
}
else
{
Logger.Logger.Instance.ErrorFormat("Not supported command type = {0}", message.GetType());
}
}
public static string GetLog(ServerId server, NetCommand command)
{
return(string.Format("Server = {0}, command = {1}", server, command.GetType()));
}
public static string GetLog(NetCommand command)
{
return(string.Format("command = {0}", command.GetType()));
}
public RemoteResult ASendToProxy(ServerId server, NetCommand command)
{
Logger.Logger.Instance.TraceFormat("ASendSync to proxy command {0} to {1}", command.GetType(), server);
var connection = FindServer(server) as SingleConnectionToProxy;
if (connection == null)
{
ConnectToProxy(server);
connection = FindServer(server) as SingleConnectionToProxy;
}
if (connection == null)
{
return(new ServerNotFoundResult());
}
var ret = connection.SendASyncWithResult(command);
if (ret is FailNetResult)
{
Logger.Logger.Instance.DebugFormat("DistributorNetModule: process fail result server = {0}", server);
RemoveConnection(server);
}
return(ret);
}