//[MessageMethod(NetOpcode.Q2P_New_Node)]
async void Q2P_New_Node_Handle(Session session, int opcode, object msg)
{
Q2P_New_Node new_Node = msg as Q2P_New_Node;
try
{
if (new_Node.version != BlockMgr.networkID)
{
R2P_New_Node response = new R2P_New_Node()
{
Nodes = "", nodeTime = TimeHelper.Now()
};
response.Message = $"Network Version Not Compatible your:{new_Node.version} cur:{BlockMgr.networkID}";
session.Reply(new_Node, response);
return;
}
//Log.Debug($"Q2P_New_Node_Handle {new_Node.address} ipEndPoint: {new_Node.ipEndPoint} 1");
Session sessionNew = await networkInner.Get(NetworkHelper.ToIPEndPoint(new_Node.ipEndPoint), 2);
Q2P_IP_INFO qIPNode = new Q2P_IP_INFO();
R2P_IP_INFO rIPNode = (R2P_IP_INFO)await sessionNew.Query(qIPNode, 0.3f);
if (rIPNode != null)
{
NodeData data = new NodeData();
data.nodeId = new_Node.ActorId;
data.address = new_Node.address;
data.ipEndPoint = new_Node.ipEndPoint;
data.state = new_Node.state;
data.version = new_Node.version;
data.kIndex = GetkIndex();
AddNode(data);
R2P_New_Node response = new R2P_New_Node()
{
Nodes = "", nodeTime = TimeHelper.Now()
};
string nodesjson = JsonHelper.ToJson(nodes);
if (StringHelper.HashCode(nodesjson) != new_Node.HashCode)
{
response.Nodes = nodesjson;
//session.Send(response);
}
session.Reply(new_Node, response);
return;
}
}
catch (Exception)
{
}
{
R2P_New_Node response = new R2P_New_Node()
{
Nodes = "", nodeTime = TimeHelper.Now()
};
response.Message = "LAN not supported or Your network has a firewall";
session.Reply(new_Node, response);
}
}
public static void Q2P_McBlockHash_Handle(Session session, int opcode, object msg)
{
Q2P_McBlockHash q2q_McBlockHash = msg as Q2P_McBlockHash;
Block mcbkl = BlockChainHelper.GetMcBlock(q2q_McBlockHash.height);
var cons = Entity.Root.GetComponent <Consensus>();
if (mcbkl == null && cons.transferHeight + 3 >= q2q_McBlockHash.height)
{
// 取最新高度
var chain1 = BlockChainHelper.GetBlockChain(cons.transferHeight);
while (chain1 != null)
{
if (q2q_McBlockHash.height == chain1.height)
{
mcbkl = chain1.GetMcBlock();
break;
}
chain1 = chain1.GetMcBlockNext();
}
}
R2P_McBlockHash r2p_McBlockHash = new R2P_McBlockHash()
{
hash = mcbkl != null ? mcbkl.hash : ""
};
if (r2p_McBlockHash.hash == "")
{
r2p_McBlockHash.hash = "";
}
session.Reply(q2q_McBlockHash, r2p_McBlockHash);
}
public async Task Handle(Session session, Entity entity, IActorMessage actorRequest)
{
Message msg = actorRequest as Message;
if (msg == null)
{
Log.Error($"消息类型转换错误: {actorRequest.GetType().FullName} to {typeof (Message).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
await this.Run(e, msg);
// 等回调回来,session可以已经断开了,所以需要判断session id是否为0
if (session.IsDisposed)
{
return;
}
ActorResponse response = new ActorResponse
{
RpcId = actorRequest.RpcId
};
session.Reply(response);
}
public async Task Handle(Session session, Entity entity, IActorMessage actorRequest)
{
try
{
Request request = actorRequest as Request;
if (request == null)
{
Log.Error($"消息类型转换错误: {actorRequest.GetType().FullName} to {typeof (Request).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
int rpcId = request.RpcId;
await this.Run(e, request, response =>
{
// 等回调回来,session可以已经断开了,所以需要判断session id是否为0
if (session.IsDisposed)
{
return;
}
response.RpcId = rpcId;
session.Reply(response);
});
}
catch (Exception e)
{
throw new Exception($"解释消息失败: {actorRequest.GetType().FullName}", e);
}
}
public async Task Handle(Session session, Entity entity, IActorMessage actorRequest)
{
Message msg = actorRequest as Message;
if (msg == null)
{
Log.Error($"消息类型转换错误: {actorRequest.GetType().FullName} to {typeof (Message).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
int rpcId = actorRequest.RpcId;
ActorResponse response = new ActorResponse
{
RpcId = rpcId
};
session.Reply(response);
await this.Run(e, msg);
}
public async ETTask Handle(Session session, Entity entity, object actorMessage)
{
Message msg = actorMessage as Message;
if (msg == null)
{
Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Message).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
ActorResponse actorResponse = new ActorResponse();
actorResponse.RpcId = msg.RpcId;
session.Reply(actorResponse);
this.Run(e, msg);
await ETTask.CompletedTask;
}
void Q2P_New_Node_Handle(Session session, int opcode, object msg)
{
Q2P_New_Node new_Node = msg as Q2P_New_Node;
//Log.Debug($"Q2P_New_Nod {new_Node.ActorId} \r\nHash: {new_Node.HashCode}");
if (nodeManager != null)
{
//Internet
var nodes = nodeManager.GetNodeList();
nodes = nodes.FindAll((n) => { return((n.state & NodeManager.EnumState.RelayNetwork) == NodeManager.EnumState.RelayNetwork); });
//// LAN
//var node = new NodeManager.NodeData();
//node.address = Wallet.GetWallet().GetCurWallet().ToAddress();
//node.nodeId = nodeManager.GetMyNodeId();
//node.ipEndPoint = $"{relayNetworkInner.ipEndPoint.Address}:{Entity.Root.GetComponent<ComponentNetworkInner>().ipEndPoint.Port}";
//node.state = 7;
//var nodes = new List<NodeManager.NodeData>();
//nodes.Add(node);
//
R2P_New_Node response = new R2P_New_Node()
{
Nodes = JsonHelper.ToJson(nodes), nodeTime = TimeHelper.Now()
};
session.Reply(new_Node, response);
}
}
public void Handle(Session session, object message)
{
try
{
Request request = message as Request;
if (request == null)
{
Log.Error($"消息类型转换错误: {message.GetType().Name} to {typeof (Request).Name}");
}
this.Run(session, request, response =>
{
// 等回调回来,session可以已经断开了,所以需要判断session id是否为0
if (session.IsDisposed)
{
return;
}
int rpcId = request.RpcId;
response.RpcId = rpcId;
session.Reply(response);
});
}
catch (Exception e)
{
throw new Exception($"解释消息失败: {message.GetType().FullName}", e);
}
}
//[MessageMethod(NetOpcode.O2G_New_Node)]
void Q2P_New_Node_Handle(Session session, int opcode, object msg)
{
Q2P_New_Node new_Node = msg as Q2P_New_Node;
//Log.Debug($"Q2P_New_Nod {new_Node.ActorId} \r\nHash: {new_Node.HashCode}");
NodeData data = new NodeData();
data.nodeId = new_Node.ActorId;
data.address = new_Node.address;
data.ipEndPoint = new_Node.ipEndPoint;
data.kIndex = GetkIndex();
AddNode(data);
R2P_New_Node response = new R2P_New_Node()
{
Nodes = "", sendTime = new_Node.sendTime, nodeTime = TimeHelper.Now()
};
if (StringHelper.HashCode(JsonHelper.ToJson(nodes)) != new_Node.HashCode)
{
response.Nodes = JsonHelper.ToJson(nodes);
session.Send(response);
}
session.Reply(new_Node, response);
}
static public void Q2P_IP_INFO_Handle(Session session, int opcode, object msg)
{
Q2P_IP_INFO qNode = msg as Q2P_IP_INFO;
R2P_IP_INFO response = new R2P_IP_INFO()
{
address = session.RemoteAddress.Address.ToString()
};
session.Reply(qNode, response);
}
public async ETTask Handle(Session session, Entity entity, object actorMessage)
{
try
{
Request request = actorMessage as Request;
if (request == null)
{
Log.Error($"消息类型转换错误: {actorMessage.GetType().FullName} to {typeof (Request).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof (E).Name}");
return;
}
int rpcId = request.RpcId;
long instanceId = session.InstanceId;
Response response = Activator.CreateInstance <Response>();
void Reply()
{
// 等回调回来,session可以已经断开了,所以需要判断session InstanceId是否一样
if (session.InstanceId != instanceId)
{
return;
}
response.RpcId = rpcId;
session.Reply(response);
}
try
{
await this.Run(e, request, response, Reply);
}
catch (Exception exception)
{
Log.Error(exception);
response.Error = ErrorCode.ERR_RpcFail;
response.Message = e.ToString();
Reply();
}
}
catch (Exception e)
{
Log.Error($"解释消息失败: {actorMessage.GetType().FullName}\n{e}");
}
}
public static void Q2P_Prehashmkl_Handle(Session session, int opcode, object msg)
{
Q2P_Prehashmkl q2p_Prehashmkl = msg as Q2P_Prehashmkl;
Block mcbkl = BlockChainHelper.GetMcBlock(q2p_Prehashmkl.height);
R2P_Prehashmkl r2p_Prehashmkl = new R2P_Prehashmkl()
{
prehashmkl = mcbkl != null ? mcbkl.prehashmkl : ""
};
session.Reply(q2p_Prehashmkl, r2p_Prehashmkl);
}
public static void Q2P_Block_Handle(Session session, int opcode, object msg)
{
Q2P_Block q2p_Block = msg as Q2P_Block;
Block blk = Entity.Root.GetComponent <BlockMgr>().GetBlock(q2p_Block.hash);
R2P_Block r2p_Block = new R2P_Block()
{
block = blk != null?JsonHelper.ToJson(blk) : ""
};
session.Reply(q2p_Block, r2p_Block);
}
public static void Q2P_McBlock_Handle(Session session, int opcode, object msg)
{
Q2P_McBlock q2p_McBlock = msg as Q2P_McBlock;
Block mcbkl = BlockChainHelper.GetMcBlock(q2p_McBlock.height);
R2P_McBlock r2p_McBlock = null;
r2p_McBlock = new R2P_McBlock()
{
block = mcbkl != null?JsonHelper.ToJson(mcbkl) : ""
};
session.Reply(q2p_McBlock, r2p_McBlock);
}
public static void Q2P_Transfer_Handle(Session session, int opcode, object msg)
{
Q2P_Transfer q2p_Transfer = msg as Q2P_Transfer;
BlockSub transfer = JsonHelper.FromJson <BlockSub>(q2p_Transfer.transfer);
R2P_Transfer r2p_Transfer = new R2P_Transfer()
{
rel = "-10000"
};
if (transfer.CheckSign())
{
r2p_Transfer.rel = Entity.Root.GetComponent <Rule>().AddTransfer(transfer).ToString();
}
session.Reply(q2p_Transfer, r2p_Transfer);
}
public async Task Handle(Session session, Entity entity, ActorRequest actorRequest, object message)
{
try
{
Request request = message as Request;
if (request == null)
{
Log.Error($"消息类型转换错误: {message.GetType().FullName} to {typeof (Request).Name}");
return;
}
E e = entity as E;
if (e == null)
{
Log.Error($"Actor类型转换错误: {entity.GetType().Name} to {typeof(E).Name}");
return;
}
int rpcId = request.RpcId;
await this.Run(e, request, response =>
{
// 等回调回来,session可以已经断开了,所以需要判断session id是否为0
if (session.IsDisposed)
{
return;
}
response.RpcId = rpcId;
OpcodeTypeComponent opcodeTypeComponent = session.Network.Entity.GetComponent <OpcodeTypeComponent>();
ushort opcode = opcodeTypeComponent.GetOpcode(response.GetType());
byte[] repsponseBytes = session.Network.MessagePacker.SerializeToByteArray(response);
ActorResponse actorResponse = new ActorResponse
{
Flag = 0x01,
Op = opcode,
AMessage = repsponseBytes
};
actorResponse.RpcId = actorRequest.RpcId;
session.Reply(actorResponse);
});
}
catch (Exception e)
{
throw new Exception($"解释消息失败: {message.GetType().FullName}", e);
}
}
public async ETVoid Handle(Session session, object message)
{
try
{
Request request = message as Request;
if (request == null)
{
Log.Error($"消息类型转换错误: {message.GetType().Name} to {typeof (Request).Name}");
}
int rpcId = request.RpcId;
long instanceId = session.InstanceId;
//创建响应的对象
Response response = Activator.CreateInstance <Response>();
//定义Reply方法
void Reply()
{
// 等回调回来,session可以已经断开了,所以需要判断session InstanceId是否一样
if (session.InstanceId != instanceId)
{
return;
}
response.RpcId = rpcId;
//响应消息给客户端
session.Reply(response);
}
try
{
//将session, request, response, Reply放在参数传递给Run方法
await this.Run(session, request, response, Reply);
}
catch (Exception e)
{
Log.Error(e);
response.Error = ErrorCode.ERR_RpcFail;
response.Message = e.ToString();
Reply();
}
}
catch (Exception e)
{
Log.Error($"解释消息失败: {message.GetType().FullName}\n{e}");
}
}
public static void Q2P_BeLinkHash_Handle(Session session, int opcode, object msg)
{
Q2P_BeLinkHash q2q_McBlockHash = msg as Q2P_BeLinkHash;
R2P_BeLinkHash r2p_McBlockHash = new R2P_BeLinkHash();
var consensus = Entity.Root.GetComponent <Consensus>();
var blockMgr = Entity.Root.GetComponent <BlockMgr>();
Block mcbkl = blockMgr.GetBlock(q2q_McBlockHash.hash);
double t_1max = consensus.GetRuleCount(mcbkl.height + 1);
List <Block> blks = blockMgr.GetBlock(mcbkl.height + 1);
blks = BlockChainHelper.GetRuleBlk(consensus, blks, mcbkl.hash);
string[] hashs = blks.Select(a => a.hash).ToArray();
r2p_McBlockHash.hashs = JsonHelper.ToJson(hashs);
session.Reply(q2q_McBlockHash, r2p_McBlockHash);
}
