public static async Task <IActorResponse> Call(this ActorMessageSender self, IActorRequest message)
{
Session session = Game.Scene.GetComponent <NetInnerComponent>().Get(self.Address);
message.ActorId = self.ActorId;
return((IActorResponse)await session.Call(message));
}
private async Task <IActorResponse> RunInner(IActorRequest iActorRequest)
{
try
{
if (ActorId == 0)
{
Log.Info($"actor send message fail, actorid: {Id}");
Dispose();
return(new ActorResponse()
{
Error = ErrorCode.ERR_ActorNotOnline
});
}
LastSendOrRecvTime = TimeHelper.CurrentLocalMilliseconds();
IActorResponse response = await ActorMessageSenderComponent.Instance.CallWithoutException(ActorId, iActorRequest);
switch (response.Error)
{
case ErrorCode.ERR_NotFoundActor:
{
// 如果没找到Actor,重试
++FailTimes;
if (FailTimes > ActorLocationSender.MaxFailTimes)
{
Log.Info($"actor send message fail, actorid: {Id}");
Dispose();
return(response);
}
// 等待0.5s再发送
long instanceId = InstanceId;
await TimerComponent.Instance.WaitAsync(500);
if (InstanceId != instanceId)
{
throw new RpcException(ErrorCode.ERR_ActorRemove, $"{DCETRuntime.MongoHelper.ToJson(iActorRequest)}");
}
ActorId = await LocationProxyComponent.Instance.Get(Id);
return(await RunInner(iActorRequest));
}
}
LastSendOrRecvTime = TimeHelper.CurrentLocalMilliseconds();
FailTimes = 0;
return(response);
}
catch (RpcException)
{
Dispose();
throw;
}
catch (Exception e)
{
Dispose();
throw new Exception($"{DCETRuntime.MongoHelper.ToJson(iActorRequest)}\n{e}");
}
}
private async ETVoid HandleIActorRequest(Session session, IActorRequest message)
{
using (await CoroutineLockComponent.Instance.Wait(message.ActorId))
{
Entity entity = (Entity)Game.EventSystem.Get(message.ActorId);
if (entity == null)
{
Log.Warning($"not found actor: {message}");
ActorResponse response = new ActorResponse
{
Error = ErrorCode.ERR_NotFoundActor,
RpcId = message.RpcId
};
session.Reply(response);
return;
}
MailBoxComponent mailBoxComponent = entity.GetComponent <MailBoxComponent>();
if (mailBoxComponent == null)
{
ActorResponse response = new ActorResponse
{
Error = ErrorCode.ERR_ActorNoMailBoxComponent,
RpcId = message.RpcId
};
session.Reply(response);
Log.Error($"actor not add MailBoxComponent: {entity.GetType().Name} {message}");
return;
}
await mailBoxComponent.Add(session, message);
}
}
public Task <IActorResponse> Call(long actorId, IActorRequest message)
{
if (actorId == 0)
{
throw new Exception($"actor id is 0: {DCETRuntime.MongoHelper.ToJson(message)}");
}
string address = StartConfigComponent.Instance.GetProcessInnerAddress(IdGenerater.GetProcessId(actorId));
Session session = NetInnerComponent.Instance.Get(address);
message.ActorId = actorId & IdGenerater.HeadMask | IdGenerater.Head;
message.RpcId = ++RpcId;
var tcs = new TaskCompletionSource <IActorResponse>();
requestCallback.Add(message.RpcId, new ActorMessageSender((response) =>
{
if (ErrorCode.IsRpcNeedThrowException(response.Error))
{
tcs.SetException(new Exception($"Rpc error: {DCETRuntime.MongoHelper.ToJson(response)}"));
return;
}
tcs.SetResult(response);
}));
session.Send(message);
return(tcs.Task);
}
public static Task <IResponse> Call(this ActorMessageSender self, IActorRequest request)
{
TaskCompletionSource <IResponse> tcs = new TaskCompletionSource <IResponse>();
ActorTask task = new ActorTask(request, tcs);
self.Add(task);
return(task.Tcs.Task);
}
public static IActorResponse CreateResponse(IActorRequest iActorRequest, int error)
{
Type responseType = OpcodeTypeComponent.Instance.GetResponseType(iActorRequest.GetType());
IActorResponse response = (IActorResponse)Activator.CreateInstance(responseType);
response.Error = error;
response.RpcId = iActorRequest.RpcId;
return(response);
}
public static Task <IResponse> Call(this ActorProxy self, IActorRequest request)
{
ActorTask task = new ActorTask {
message = request, proxy = self, Tcs = new TaskCompletionSource <IResponse>()
};
self.Add(task);
return(task.Tcs.Task);
}
public static void Send(this ActorLocationSender self, IActorRequest request)
{
if (request == null)
{
throw new Exception($"actor send message is null");
}
ActorTask task = new ActorTask(request);
self.Add(task);
}
public static Task <IResponse> Call(this ActorMessageSender self, IActorRequest request)
{
if (request == null)
{
throw new Exception($"actor call message is null");
}
TaskCompletionSource <IResponse> tcs = new TaskCompletionSource <IResponse>();
ActorTask task = new ActorTask(request, tcs);
self.Add(task);
return(task.Tcs.Task);
}
public Task <IResponse> Call(IActorRequest request)
{
ActorTask task = new ActorTask
{
message = request,
proxy = this,
Tcs = new TaskCompletionSource <IResponse>()
};
this.Add(task);
return(task.Tcs.Task);
}
public CreateFilmVIewModel(IFilmsRequest filmDataHttpProxy, IActorRequest actorDataHttpProxy, ICountryRequest countryDataHttpProxy, IGenreRequest genreDataProxy)
{
#region Proxy Initialize
_actorDataHttpProxy = actorDataHttpProxy;
_countryDataHttpProxy = countryDataHttpProxy;
_genreDataProxy = genreDataProxy;
_filmDataHttpProxy = filmDataHttpProxy;
#endregion
#region Initilize List
ListInitialisation();
#endregion
#region GetDataFromServeur
#endregion
#region ObservableCollectionInitalize
AddCountryUserControlCollection = new ObservableCollection <CountryDto>();
AddActorUserControlCollection = new ObservableCollection <ActorDto>();
AddPremiereUserControlsCollection = new ObservableCollection <PremiereDto>();
AddGenresUserControlsCollection = new ObservableCollection <GenreDto>();
#endregion
#region Commande Intialize
AddCountryUserControlCommand = new RelayCommand(CreateCountryUserControls);
AddActorUserControlCommand = new RelayCommand(CreateActorUserControls);
AddPremiereUserControlCommand = new RelayCommand(CreatePremierUserControls);
AddGenreUserControlCommand = new RelayCommand(CreateGenreUserContrlos);
BrowseImageCommand = new RelayCommand(OpenFileDialog);
SubmitFilm = new RelayCommand <IClosable>(PullServeur);
#endregion
#region Initialize Film
Films = new FilmsDto()
{
Actor = new Collection <ActorDto>(),
Country = new Collection <CountryDto>(),
Genre = new Collection <GenreDto>(),
Premiere = new Collection <PremiereDto>()
};
#endregion
}
private async Task <IActorResponse> Run(IActorRequest iActorRequest)
{
long instanceId = InstanceId;
using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.ActorLocationSender, Id))
{
if (InstanceId != instanceId)
{
throw new RpcException(ErrorCode.ERR_ActorRemove, $"{DCETRuntime.MongoHelper.ToJson(iActorRequest)}");
}
return(await RunInner(iActorRequest));
}
}
public static void HandleIActorRequest(ushort opcode, long actorId, IActorRequest iActorRequest, Action <IActorResponse> reply)
{
Entity entity = Game.EventSystem.Get(actorId);
if (entity == null)
{
FailResponse(iActorRequest, ErrorCore.ERR_NotFoundActor, reply);
return;
}
MailBoxComponent mailBoxComponent = entity.GetComponent <MailBoxComponent>();
if (mailBoxComponent == null)
{
Log.Warning($"actor not found mailbox: {entity.GetType().Name} {actorId} {iActorRequest}");
FailResponse(iActorRequest, ErrorCore.ERR_NotFoundActor, reply);
return;
}
switch (mailBoxComponent.MailboxType)
{
case MailboxType.MessageDispatcher:
{
async ETTask MessageDispatcherHandler()
{
long instanceId = entity.InstanceId;
using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Mailbox, actorId))
{
if (entity.InstanceId != instanceId)
{
FailResponse(iActorRequest, ErrorCore.ERR_NotFoundActor, reply);
return;
}
await ActorMessageDispatcherComponent.Instance.Handle(entity, iActorRequest, reply);
}
}
MessageDispatcherHandler().Coroutine();
break;
}
case MailboxType.UnOrderMessageDispatcher:
{
ActorMessageDispatcherComponent.Instance.Handle(entity, iActorRequest, reply).Coroutine();
break;
}
}
}
public static async ETTask <IActorResponse> Call(
this ActorMessageSenderComponent self,
long actorId,
IActorRequest request,
bool needException = true
)
{
request.RpcId = self.GetRpcId();
if (actorId == 0)
{
throw new Exception($"actor id is 0: {request}");
}
(ushort _, MemoryStream stream) = MessageSerializeHelper.MessageToStream(request);
return(await self.Call(actorId, request.RpcId, stream, needException));
}
public static async ETVoid HandleIActorRequest(Session session, IActorRequest iActorRequest)
{
InstanceIdStruct instanceIdStruct = new InstanceIdStruct(iActorRequest.ActorId);
int replyId = instanceIdStruct.Process;
instanceIdStruct.Process = IdGenerater.Process;
iActorRequest.ActorId = instanceIdStruct.ToLong();
string address = StartProcessConfigCategory.Instance.Get(replyId).InnerAddress;
Session ss = NetInnerComponent.Instance.Get(address);
Entity entity = Game.EventSystem.Get(iActorRequest.ActorId);
if (entity == null)
{
Log.Warning($"not found actor: {MongoHelper.ToJson(iActorRequest)}");
ActorResponse response = new ActorResponse
{
Error = ErrorCode.ERR_NotFoundActor,
RpcId = iActorRequest.RpcId,
};
ss.Reply(response);
return;
}
MailBoxComponent mailBoxComponent = entity.GetComponent <MailBoxComponent>();
if (mailBoxComponent == null)
{
ActorResponse response = new ActorResponse
{
Error = ErrorCode.ERR_ActorNoMailBoxComponent,
RpcId = iActorRequest.RpcId,
};
ss.Reply(response);
Log.Error($"actor not add MailBoxComponent: {entity.GetType().Name} {iActorRequest}");
return;
}
await mailBoxComponent.Handle(ss, iActorRequest);
}
public static async void HandleIActorRequest(Session session, IActorRequest iActorRequest)
{
long replyId = IdGenerater.GetProcessId(iActorRequest.ActorId);
iActorRequest.ActorId = iActorRequest.ActorId & IdGenerater.HeadMask | IdGenerater.Head;
string address = StartConfigComponent.Instance.GetProcessInnerAddress(replyId);
Session ss = NetInnerComponent.Instance.Get(address);
Entity entity = Game.EventSystem.Get(iActorRequest.ActorId);
if (entity == null)
{
Log.Warning($"not found actor: {DCETRuntime.MongoHelper.ToJson(iActorRequest)}");
ActorResponse response = new ActorResponse
{
Error = ErrorCode.ERR_NotFoundActor,
RpcId = iActorRequest.RpcId,
};
ss.Reply(response);
return;
}
MailBoxComponent mailBoxComponent = entity.GetComponent <MailBoxComponent>();
if (mailBoxComponent == null)
{
ActorResponse response = new ActorResponse
{
Error = ErrorCode.ERR_ActorNoMailBoxComponent,
RpcId = iActorRequest.RpcId,
};
ss.Reply(response);
Log.Error($"actor not add MailBoxComponent: {entity.GetType().Name} {iActorRequest}");
return;
}
await mailBoxComponent.Handle(ss, iActorRequest);
}
private static void FailResponse(IActorRequest iActorRequest, int error, Action <IActorResponse> reply)
{
IActorResponse response = ActorHelper.CreateResponse(iActorRequest, error);
reply.Invoke(response);
}
public ActorTask(IActorLocationMessage actorRequest)
{
this.ActorRequest = actorRequest;
this.Tcs = null;
}
/// <summary>
/// 发送RPC协议给Actor
/// </summary>
/// <param name="actorId">注册Actor的InstanceId</param>
/// <param name="message"></param>
/// <returns></returns>
public static async ETTask <IActorResponse> CallActor(long actorId, IActorRequest message)
{
return(await ActorMessageSenderComponent.Instance.Call(actorId, message));
}
public static ETTask <IActorResponse> Call(this ActorMessageSenderComponent self, long actorId, IActorRequest message, bool exception = true)
{
if (actorId == 0)
{
throw new Exception($"actor id is 0: {MongoHelper.ToJson(message)}");
}
var tcs = new ETTaskCompletionSource <IActorResponse>();
int process = IdGenerater.GetProcess(actorId);
string address = StartProcessConfigCategory.Instance.Get(process).InnerAddress;
Session session = NetInnerComponent.Instance.Get(address);
InstanceIdStruct instanceIdStruct = new InstanceIdStruct(actorId);
instanceIdStruct.Process = IdGenerater.Process;
message.ActorId = instanceIdStruct.ToLong();
message.RpcId = ++self.RpcId;
self.requestCallback.Add(message.RpcId, new ActorMessageSender((response) =>
{
if (exception && ErrorCode.IsRpcNeedThrowException(response.Error))
{
tcs.SetException(new Exception($"Rpc error: {MongoHelper.ToJson(response)}"));
return;
}
tcs.SetResult(response);
}));
session.Send(message);
return(tcs.Task);
}
public static async ETTask <IActorResponse> CallWithoutException(this ActorMessageSenderComponent self, long actorId, IActorRequest message)
{
return(await self.Call(actorId, message, false));
}
private static async ETTask <IActorResponse> Run(this ActorLocationSender self, IActorRequest iActorRequest)
{
long instanceId = self.InstanceId;
using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.ActorLocationSender, self.Id))
{
if (self.InstanceId != instanceId)
{
throw new RpcException(ErrorCode.ERR_ActorRemove, $"{MongoHelper.ToJson(iActorRequest)}");
}
return(await self.RunInner(iActorRequest));
}
}
private static async ETTask <IActorResponse> RunInner(this ActorLocationSender self, IActorRequest iActorRequest)
{
try
{
if (self.ActorId == 0)
{
Log.Info($"actor send message fail, actorid: {self.Id}");
self.Dispose();
return(new ActorResponse()
{
Error = ErrorCode.ERR_ActorNotOnline
});
}
self.LastSendOrRecvTime = TimeHelper.Now();
IActorResponse response = await ActorMessageSenderComponent.Instance.CallWithoutException(self.ActorId, iActorRequest);
switch (response.Error)
{
case ErrorCode.ERR_NotFoundActor:
{
// 如果没找到Actor,重试
++self.FailTimes;
if (self.FailTimes > ActorLocationSender.MaxFailTimes)
{
Log.Info($"actor send message fail, actorid: {self.Id}");
self.Dispose();
return(response);
}
// 等待0.5s再发送
long instanceId = self.InstanceId;
await TimerComponent.Instance.WaitAsync(500);
if (self.InstanceId != instanceId)
{
throw new RpcException(ErrorCode.ERR_ActorRemove, $"{MongoHelper.ToJson(iActorRequest)}");
}
self.ActorId = await LocationProxyComponent.Instance.Get(self.Id);
return(await self.RunInner(iActorRequest));
}
}
self.LastSendOrRecvTime = TimeHelper.Now();
self.FailTimes = 0;
return(response);
}
catch (RpcException)
{
self.Dispose();
throw;
}
catch (Exception e)
{
self.Dispose();
throw new Exception($"{MongoHelper.ToJson(iActorRequest)}\n{e}");
}
}
public static async ETTask <IActorResponse> Call(this ActorLocationSenderComponent self, long entityId, IActorRequest iActorRequest)
{
ActorLocationSender actorLocationSender = self.GetOrCreate(entityId);
// 先序列化好
int rpcId = ActorMessageSenderComponent.Instance.GetRpcId();
iActorRequest.RpcId = rpcId;
(ushort _, MemoryStream stream) = MessageSerializeHelper.MessageToStream(0, iActorRequest);
long actorLocationSenderInstanceId = actorLocationSender.InstanceId;
using (await CoroutineLockComponent.Instance.Wait(CoroutineLockType.ActorLocationSender, entityId))
{
if (actorLocationSender.InstanceId != actorLocationSenderInstanceId)
{
throw new RpcException(ErrorCore.ERR_ActorTimeout, $"{stream.ToActorMessage()}");
}
// 队列中没处理的消息返回跟上个消息一样的报错
if (actorLocationSender.Error == ErrorCore.ERR_NotFoundActor)
{
return(ActorHelper.CreateResponse(iActorRequest, actorLocationSender.Error));
}
try
{
return(await self.CallInner(actorLocationSender, rpcId, stream));
}
catch (RpcException)
{
self.Remove(actorLocationSender.Id);
throw;
}
catch (Exception e)
{
self.Remove(actorLocationSender.Id);
throw new Exception($"{stream.ToActorMessage()}", e);
}
}
}
public static void Send(this ActorLocationSenderComponent self, long entityId, IActorRequest message)
{
self.Call(entityId, message).Coroutine();
}
private static async ETTask <IActorResponse> CallInner(this ActorLocationSenderComponent self, ActorLocationSender actorLocationSender, int rpcId, MemoryStream memoryStream)
{
int failTimes = 0;
long instanceId = actorLocationSender.InstanceId;
actorLocationSender.LastSendOrRecvTime = TimeHelper.ServerNow();
while (true)
{
if (actorLocationSender.ActorId == 0)
{
actorLocationSender.ActorId = await LocationProxyComponent.Instance.Get(actorLocationSender.Id);
if (actorLocationSender.InstanceId != instanceId)
{
throw new RpcException(ErrorCore.ERR_ActorLocationSenderTimeout2, $"{memoryStream.ToActorMessage()}");
}
}
if (actorLocationSender.ActorId == 0)
{
IActorRequest iActorRequest = (IActorRequest)memoryStream.ToActorMessage();
return(ActorHelper.CreateResponse(iActorRequest, ErrorCore.ERR_NotFoundActor));
}
IActorResponse response = await ActorMessageSenderComponent.Instance.Call(actorLocationSender.ActorId, rpcId, memoryStream, false);
if (actorLocationSender.InstanceId != instanceId)
{
throw new RpcException(ErrorCore.ERR_ActorLocationSenderTimeout3, $"{memoryStream.ToActorMessage()}");
}
switch (response.Error)
{
case ErrorCore.ERR_NotFoundActor:
{
// 如果没找到Actor,重试
++failTimes;
if (failTimes > 20)
{
Log.Debug($"actor send message fail, actorid: {actorLocationSender.Id}");
actorLocationSender.Error = ErrorCore.ERR_NotFoundActor;
// 这里不能删除actor，要让后面等待发送的消息也返回ERR_NotFoundActor，直到超时删除
return(response);
}
// 等待0.5s再发送
await TimerComponent.Instance.WaitAsync(500);
if (actorLocationSender.InstanceId != instanceId)
{
throw new RpcException(ErrorCore.ERR_ActorLocationSenderTimeout4, $"{memoryStream.ToActorMessage()}");
}
actorLocationSender.ActorId = 0;
continue;
}
case ErrorCore.ERR_ActorTimeout:
{
throw new RpcException(response.Error, $"{memoryStream.ToActorMessage()}");
}
}
if (ErrorCore.IsRpcNeedThrowException(response.Error))
{
throw new RpcException(response.Error, $"Message: {response.Message} Request: {memoryStream.ToActorMessage()}");
}
return(response);
}
}
public ActorTask(IActorRequest actorRequest)
{
this.ActorRequest = actorRequest;
this.Tcs = null;
}
public static async ETTask <IActorResponse> CallWithoutException(this ActorMessageSender self, IActorRequest message)
{
//内网组件获取到会话实体Session
Session session = Game.Scene.GetComponent <NetInnerComponent>().Get(self.Address);
//设置消息的ActorId
message.ActorId = self.ActorId;
//通过内网组件的Session会话实体进行发送消息
return((IActorResponse)await session.CallWithoutException(message));
}
public ActorTask(IActorRequest actorRequest, TaskCompletionSource <IActorResponse> tcs)
{
this.ActorRequest = actorRequest;
this.Tcs = tcs;
}
public static ETTask <IActorResponse> CallWithoutException(this ActorMessageSenderComponent self, long actorId, IActorRequest message)
{
if (actorId == 0)
{
throw new Exception($"actor id is 0: {MongoHelper.ToJson(message)}");
}
string address = StartConfigComponent.Instance.GetProcessInnerAddress(IdGenerater.GetProcessId(actorId));
Session session = NetInnerComponent.Instance.Get(address);
message.ActorId = actorId & IdGenerater.HeadMask | IdGenerater.Head;
message.RpcId = ++self.RpcId;
var tcs = new ETTaskCompletionSource <IActorResponse>();
self.requestCallback.Add(message.RpcId, new ActorMessageSender((response) =>
{
tcs.SetResult(response);
}));
session.Send(message);
return(tcs.Task);
}
