//调用委托
private async Task ReceiveFindByAccountAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
var request = FindAccountReq.Parser.ParseFrom(req.Data);
var data = await FindByAccountAsync(request);
var response = AmpMessage.CreateResponseMessage(req.ServiceId, req.MessageId);
response.Sequence = req.Sequence;
response.Data = data.ToByteArray();
await context.SendAsync(response);
}
/// <summary>
/// 处理消息请求
/// </summary>
/// <param name="req">请求的消息</param>
/// <returns>返回消息</returns>
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
Logger.Debug("receive message:ServiceId={0},MessageId = {1},Sequence={2}", req.ServiceId, req.MessageId, req.Sequence);
switch (req.MessageId)
{
case 1: // 1 = Add
return(AddAsync(req));
default:
return(base.ProcessNotFoundAsync(req));
}
}
/// <summary>
///
/// </summary>
/// <param name="tc"></param>
private void RunTestCase(ICallInvoker <AmpMessage> caller, TestCase tc, IMessageParser <AmpMessage> parser)
{
try
{
Console.WriteLine("--------start run testcase {0}-----------", tc.Id);
Console.WriteLine("ServiceId: {0},MessageId:{1},Req:{2}", tc.ServiceId, tc.MessageId, tc.Json);
RequestData rd = new RequestData();
rd.ServiceId = tc.ServiceId;
rd.MessageId = tc.MessageId;
rd.Data = new Dictionary <string, string>();
rd.RawBody = tc.Json;
AmpMessage req = parser.ToMessage(rd);
if (req == null)
{
TOTAL_ERROR++;
Console.WriteLine("协议转换出错，请检查serviceId={0}和messageId={1}", tc.ServiceId, tc.MessageId);
System.Environment.Exit(1);
return;
}
AmpMessage rsp = caller.BlockingCall(req);
if (rsp == null)
{
TOTAL_ERROR++;
Console.WriteLine(">>----end run testcase {0} fail,no repsonse--------", tc.Id);
}
else
{
Console.WriteLine(">>----end run testcase {0} success,response code = {1}-------", tc.Id, rsp.Code);
var jsonRsp = parser.ToJson(rsp);
if (string.IsNullOrEmpty(jsonRsp))
{
TOTAL_ERROR++;
Console.WriteLine(">>----end run testcase {0} fail,没有配置对应服务响应消息---------", tc.Id);
}
else
{
Console.WriteLine(">>response:{0}", jsonRsp);
}
}
}
catch (Exception ex)
{
Console.WriteLine("执行测试出错:" + ex.Message);
System.Environment.Exit(1);
}
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法AuthService.Create
case 1: return(this.ProcessCreateAsync(req));
//方法AuthService.Auth
case 2: return(this.ProcessAuthAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
public override Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
switch (req.MessageId)
{
//方法AuthService.Create
case 1: return(this.ReceiveCreateAsync(context, req));
//方法AuthService.Auth
case 2: return(this.ReceiveAuthAsync(context, req));
default: return(base.ReceiveNotFoundAsync(context, req));
}
}
//同步方法
public HelloResponse Hello(HelloRequest request)
{
AmpMessage message = AmpMessage.CreateRequestMessage(100, 1);
message.Data = request.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response != null && response.Data != null)
{
return(HelloResponse.Parser.ParseFrom(response.Data));
}
throw new RpcException("请求出错，请检查!");
}
public override Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
switch (req.MessageId)
{
//方法StatisticService.UpdateStatistics
case 1: return(this.ReceiveUpdateStatisticsAsync(context, req));
//方法StatisticService.FindByAccount
case 2: return(this.ReceiveFindByAccountAsync(context, req));
default: return(base.ReceiveNotFoundAsync(context, req));
}
}
public static void ServiceActorException(this DiagnosticListener listener, ISocketContext <AmpMessage> context
, AmpMessage request, Exception exception)
{
if (listener.IsEnabled(DotBPEDiagnosticServiceActorException))
{
listener.Write(DotBPEDiagnosticServiceActorException, new
{
Context = context,
Request = request,
Exception = exception
});
}
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法 Greeter.SayHello
case 1: return(this.ProcessSayHelloAsync(req));
//方法 Greeter.SayHelloAgain
case 2: return(this.ProcessSayHelloAgainAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法StatisticService.UpdateStatistics
case 1: return(this.ProcessUpdateStatisticsAsync(req));
//方法StatisticService.FindByAccount
case 2: return(this.ProcessFindByAccountAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
public async Task <HelloResponse> HelloAsync(HelloRequest request, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(100, 1);
message.Data = request.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response != null && response.Data != null)
{
return(HelloResponse.Parser.ParseFrom(response.Data));
}
throw new RpcException("请求出错，请检查!");
}
private void TimeOutCallBack(string id)
{
if (this._resultDictionary.TryRemove(id, out var task))
{
var message = AmpMessage.CreateResponseMessage(id);
message.Code = RpcErrorCodes.CODE_TIMEOUT;
if (!task.TrySetResult(message))
{
this._logger.LogWarning("set timeout result fail,maybe task is completed,message {0}", id);
}
this._logger.LogWarning("message {0}, timeout", id);
}
}
private async Task Excute(int serviceId, int messageId, string data, PerformContext context)
{
try
{
CommonTaskReq req = new CommonTaskReq();
req.JobId = context.BackgroundJob.Id;
req.ServiceId = serviceId;
req.MessageId = messageId;
req.Data = data;
var reqMsg = AmpMessage.CreateRequestMessage(HangfireConstant.CONSUMER_SERVER_ID, HangfireConstant.CONSUMER_DEFAULT_MESSAGE_ID);
reqMsg.Data = req.ToByteArray();
context.WriteLine("Start Excute Task With serviceId={0},messageId={1},data ={2}", serviceId, messageId, data);
var resMsg = await _invoker.AsyncCall(reqMsg, 30000); //30秒超时
if (resMsg != null)
{
if (resMsg.Code == 0)
{
context.WriteLine("Excute Success!");
}
else
{
context.SetTextColor(ConsoleTextColor.Red);
string errorMsg = "";
if (resMsg.Data != null)
{
var resData = TaskVoidRes.Parser.ParseFrom(resMsg.Data);
errorMsg = resData.ReturnMessage;
}
context.WriteLine("Excute failed, Code = {0},ErrorMessage={1}", resMsg.Code, errorMsg);
context.ResetTextColor();
}
}
else
{
context.SetTextColor(ConsoleTextColor.Red);
context.WriteLine("Excute Error, Response is null");
context.ResetTextColor();
}
}
catch (Exception ex)
{
_logger.LogError(ex, "调用任务消费服务出错:{0}", ex.Message);
}
}
public override Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
switch (req.MessageId)
{
//方法AccountService.FindByName
case 1: return(this.ReceiveFindByNameAsync(context, req));
//方法AccountService.Create
case 2: return(this.ReceiveCreateAsync(context, req));
//方法AccountService.Save
case 3: return(this.ReceiveSaveAsync(context, req));
default: return(base.ReceiveNotFoundAsync(context, req));
}
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法 TaskProducerService.Enqueue
case 1: return(this.ProcessEnqueueAsync(req));
//方法 TaskProducerService.Schedule
case 2: return(this.ProcessScheduleAsync(req));
//方法 TaskProducerService.ScheduleSecond
case 3: return(this.ProcessScheduleSecondAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法AccountService.FindByName
case 1: return(this.ProcessFindByNameAsync(req));
//方法AccountService.Create
case 2: return(this.ProcessCreateAsync(req));
//方法AccountService.Save
case 3: return(this.ProcessSaveAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
//同步方法
public AccountRsp Create(UserReq request)
{
AmpMessage message = AmpMessage.CreateRequestMessage(1001, 2);
message.Data = request.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new AccountRsp());
}
return(AccountRsp.Parser.ParseFrom(response.Data));
}
public async Task <VoidRsp> SaveAsync(AccountReq request, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(1001, 3);
message.Data = request.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new VoidRsp());
}
return(VoidRsp.Parser.ParseFrom(response.Data));
}
//同步方法
public CommonRsp Test(VoidReq request)
{
AmpMessage message = AmpMessage.CreateRequestMessage(50001, 1);
message.Data = request.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new CommonRsp());
}
return(CommonRsp.Parser.ParseFrom(response.Data));
}
//同步方法
public BenchmarkMessage Echo(BenchmarkMessage request)
{
AmpMessage message = AmpMessage.CreateRequestMessage(50000, 1);
message.Data = request.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new BenchmarkMessage());
}
return(BenchmarkMessage.Parser.ParseFrom(response.Data));
}
//同步方法
public VoidRsp UpdateStatistics(AccountReq request)
{
AmpMessage message = AmpMessage.CreateRequestMessage(1003, 1);
message.Data = request.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new VoidRsp());
}
return(VoidRsp.Parser.ParseFrom(response.Data));
}
public async Task <BenchmarkMessage> EchoAsync(BenchmarkMessage request, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(50000, 1);
message.Data = request.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new BenchmarkMessage());
}
return(BenchmarkMessage.Parser.ParseFrom(response.Data));
}
public async Task <HelloRes> SayHelloAgainAsync(HelloReq request, int timeOut = 3000)
{
AmpMessage message = AmpMessage.CreateRequestMessage(10006, 2);
message.Data = request.ToByteArray();
var response = await base.CallInvoker.AsyncCall(message, timeOut);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new HelloRes());
}
return(HelloRes.Parser.ParseFrom(response.Data));
}
//同步方法
public HelloRes SayHelloAgain(HelloReq request)
{
AmpMessage message = AmpMessage.CreateRequestMessage(10006, 2);
message.Data = request.ToByteArray();
var response = base.CallInvoker.BlockingCall(message);
if (response == null)
{
throw new RpcException("error,response is null !");
}
if (response.Data == null)
{
return(new HelloRes());
}
return(HelloRes.Parser.ParseFrom(response.Data));
}
private void ErrorCallBack(string id)
{
if (!this._resultDictionary.ContainsKey(id))
{
return;
}
if (this._resultDictionary.TryRemove(id, out var task))
{
var message = AmpMessage.CreateResponseMessage(id);
message.Code = RpcErrorCodes.CODE_INTERNAL_ERROR;
if (!task.TrySetResult(message))
{
this._logger.LogWarning("set error result fail,maybe task is completed");
}
this._logger.LogWarning("message {0}, error", id);
}
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法 APaperInnerService.SaveAPaper
case 1: return(this.ProcessSaveAPaperAsync(req));
//方法 APaperInnerService.QueryAPaperList
case 2: return(this.ProcessQueryAPaperListAsync(req));
//方法 APaperInnerService.GetAPaper
case 3: return(this.ProcessGetAPaperAsync(req));
//方法 APaperInnerService.GetAPaperSta
case 4: return(this.ProcessGetAPaperStaAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
//调用委托
private async Task <AmpMessage> ProcessAddAsync(AmpMessage req)
{
AddReq request = null;
if (req.Data == null)
{
request = new AddReq();
}
else
{
request = AddReq.Parser.ParseFrom(req.Data);
}
var data = await AddAsync(request);
var response = AmpMessage.CreateResponseMessage(req.ServiceId, req.MessageId);
response.Data = data.ToByteArray();
return(response);
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法 UserGateService.Register
case 31: return(this.ProcessRegisterAsync(req));
//方法 UserGateService.Login
case 32: return(this.ProcessLoginAsync(req));
//方法 UserGateService.EditUser
case 33: return(this.ProcessEditUserAsync(req));
//方法 UserGateService.CheckLogin
case 34: return(this.ProcessCheckLoginAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
public override Task <AmpMessage> ProcessAsync(AmpMessage req)
{
switch (req.MessageId)
{
//方法 UserInnerService.Register
case 1: return(this.ProcessRegisterAsync(req));
//方法 UserInnerService.Login
case 2: return(this.ProcessLoginAsync(req));
//方法 UserInnerService.Edit
case 3: return(this.ProcessEditAsync(req));
//方法 UserInnerService.GetUserInfo
case 4: return(this.ProcessGetUserInfoAsync(req));
default: return(base.ProcessNotFoundAsync(req));
}
}
static void Main(string[] args)
{
new ClientProxyBuilder().UseServer("127.0.0.1:6201").BuildDefault();
using (var caller = DotBPE.Rpc.Environment.ServiceProvider.GetService <ICallInvoker <AmpMessage> >())
{
Console.WriteLine("ready to send message");
ushort serviceId = 10001; // 10001 = MathService ,1 = ADd
AmpMessage reqMsg = AmpMessage.CreateRequestMessage(serviceId, 1);
var random = new Random();
AddReq req = new AddReq();
req.A = random.Next(1, 10000);
req.B = random.Next(1, 10000);
var reqJson = Jil.JSON.Serialize(req);
reqMsg.Data = Encoding.UTF8.GetBytes(reqJson);
Console.WriteLine("call sever MathService.Add --> {0}+{1} ", req.A, req.B);
try
{
var res = caller.BlockingCall(reqMsg);
if (res.Code == 0)
{
string jsonRes = Encoding.UTF8.GetString(res.Data);
var addRes = Jil.JSON.Deserialize <AddRes>(jsonRes);
Console.WriteLine("server repsonse:<-----{0}+{1}={2}", req.A, req.B, addRes.C);
}
else
{
Console.WriteLine("server error,code={0}", res.Code);
}
}
catch (Exception ex)
{
Console.WriteLine("error occ {0}", ex.Message);
}
}
Console.WriteLine("channel is closed!");
}
