public string Format(IRpcContext context, AuditLogType logType, AmpMessage req, AmpMessage rsp, long elapsedMS)
{
string log = string.Empty;
if (req == null || rsp == null)
{
return(log);
}
var reqParser = GetMessageParser(req.ServiceId, req.MessageId, 1);
var resParser = GetMessageParser(rsp.ServiceId, rsp.MessageId, 2);
if (reqParser == null || resParser == null)
{
Console.WriteLine("{0},{1} ,错误的服务ID和消息ID", req.ServiceId, req.MessageId);
return(null);
}
if (logType == AuditLogType.CACAduit)
{
log = FormatCACLog(req, rsp, elapsedMS, reqParser, resParser);
}
else if (logType == AuditLogType.RequestAudit)
{
log = FormatRequestLog(context, req, rsp, elapsedMS, reqParser, resParser);
}
return(log);
}
public static void RpcWithMultipleDependencyParameters(
IRpcContext context,
[Dependency] FooDependency x,
[Dependency] BarDependency y
)
{
}
public virtual async Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage message)
{
using (var audit = new RequestAuditLogger())
{
AmpMessage rsp;
try
{
audit.PushRequest(message);
Logger.LogDebug("recieve message,Id={0}", message.Id);
rsp = await ProcessAsync(message);
rsp.Sequence = message.Sequence; //通讯请求序列
audit.PushResponse(rsp);
audit.PushContext(context);
await context.SendAsync(rsp);
//Logger.LogError("send message,Id={0}", message.Id);
}
catch (ClosedChannelException closedEx)
{
Logger.LogError(closedEx, "recieve message occ error,channel closed,{messageId}", message.Id);
}
catch (Exception ex)
{
Logger.LogError(ex, "recieve message occ error");
rsp = await SendErrorResponseAsync(context, message);
audit.PushResponse(rsp);
}
}
}
internal void HandleMessage(IRpcContext context, string Message, IPythonServerContext serverContext)
{
if (OnMessage != null)
{
OnMessage(this, context, Message, serverContext);
}
}
void _q_OnMessage(object sender, IRpcContext context, string message)
{
if (OnMessage != null)
{
OnMessage(sender, context, message);
}
}
private string FormatRequestLog(IRpcContext context, AmpMessage req, AmpMessage rsp, long elapsedMS, Google.Protobuf.MessageParser reqParser, Google.Protobuf.MessageParser resParser)
{
string remoteIP = "UNKNOWN";
if (context != null && context.RemoteAddress != null)
{
remoteIP = DotBPE.Rpc.Utils.ParseUtils.ParseEndPointToIPString(context.RemoteAddress);
}
string mothedName = req.FriendlyServiceName ?? req.MethodIdentifier;
IMessage reqMsg = reqParser.ParseFrom(req.Data);
IMessage resMsg = resParser.ParseFrom(rsp.Data);
var jsonReq = JsonFormatter.Format(reqMsg);
var jsonRsp = JsonFormatter.Format(resMsg);
var clientIP = FindFieldValue(reqMsg, "client_ip");
var requestId = FindFieldValue(reqMsg, "x_request_id");
if (string.IsNullOrEmpty(clientIP))
{
clientIP = "UNKNOWN";
}
else
{
clientIP = remoteIP;
}
if (string.IsNullOrEmpty(requestId))
{
requestId = "UNKNOWN";
}
//remoteIP,clientIp,requestId,serviceName,request_data,response_data , elapsedMS ,status_code
return(string.Format("{0}, {1}, {2}, {3}, req={4}, res={5}, {6}, {7}", remoteIP, clientIP, requestId, mothedName, jsonReq, jsonRsp, elapsedMS, rsp.Code));
}
public string Format(IRpcContext context, AuditLogType logType, string methodName, object req, RpcResult <object> res, long elapsedMs)
{
if (req == null || res == null)
{
return(string.Format("req or res is null ------------,reqType={0},resType = {1}", req?.GetType().Name, res?.Data?.GetType().Name));
}
return(string.Format("logType={0},methodName={1}, elapsedMs={2}", logType, methodName, elapsedMs));
}
public static void GeneralRpc(
IRpcContext context,
[Dependency] FooDependency x,
[Dependency] BarDependency y,
int a,
string b
)
{
}
protected Task ReceiveNotFoundAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
var response = AmpMessage.CreateResponseMessage(req.ServiceId, req.MessageId);
response.Sequence = req.Sequence;
response.InvokeMessageType = DotBPE.Rpc.Codes.InvokeMessageType.NotFound;
Logger.Error("recieve message serviceId={0},messageId={1},Length ={2},Actor NotFound", req.ServiceId, req.MessageId, req.Length);
return(context.SendAsync(response));
}
public static void GeneralRpcWithWeirdParameterAttribute(
IRpcContext context,
[Dependency] FooDependency x,
[Dependency] BarDependency y,
int a,
[UndefinedAttribute] string b
)
{
}
public Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
//方法Greeter.Hello
if (req.MessageId == 1)
{
return(this.ReceiveHelloAsync(context, req));
}
return(Task.CompletedTask);
}
public object[] SendFileData(IRpcContext context, string FileName, byte[] Data)
{
var fs = GetFileStream(FileName, false);
Data = _fileHandlers.RaiseReceiveFileDataEvent(FileName, fs, Data);
fs.Write(Data, 0, Data.Length);
return(new object[] { "success" });
}
public object[] EndSendFile(IRpcContext context, string FileName)
{
var fs = GetFileStream(FileName, false);
_fileHandlers.RaiseReceiveFileCompleteEvent(FileName, fs);
fs.Close();
Files.Remove(FileName);
return(new object[] { "success" });
}
//调用委托
private async Task ReceiveHelloAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
var request = HelloRequest.Parser.ParseFrom(req.Data);
var data = await HelloAsync(request);
var response = AmpMessage.CreateResponseMessage(req.ServiceId, req.MessageId);
response.Sequence = req.Sequence;
response.Data = data.ToByteArray();
await context.SendAsync(response);
}
public object[] Eval(IRpcContext context, List <string> Args)
{
GetParams(Args);
_controller = BeginProcess(_processName);
var ctx = _controller.CreateScriptContextFromString(_code);
ctx.Execute();
//code.Run(_controller.Scope);
return(new object[0]);
}
public async Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage message)
{
AmpMessage response = new AmpMessage
{
InvokeMessageType = InvokeMessageType.NotFound,
ServiceId = message.ServiceId,
MessageId = message.MessageId
};
response.Sequence = message.Sequence;
await context.SendAsync(response);
}
public virtual async Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage message)
{
try
{
var response = await ProcessAsync(message);
}
catch (Exception ex)
{
Logger.Error(ex, "recieve message occ error:" + ex.Message);
await SendErrorResponseTask(context, message);
}
}
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 async Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage message)
{
AmpMessage response = new AmpMessage
{
InvokeMessageType = InvokeMessageType.Response,
Code = ErrorCodes.CODE_SERVICE_NOT_FOUND,
ServiceId = message.ServiceId,
MessageId = message.MessageId
};
response.Sequence = message.Sequence;
await context.SendAsync(response);
}
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 Task ReceiveAsync(IRpcContext <AmpMessage> context, AmpMessage req)
{
//方法BenchmarkTest.Echo
if (req.MessageId == 1)
{
return(this.ReceiveEchoAsync(context, req));
}
//方法BenchmarkTest.Quit
if (req.MessageId == 10000)
{
return(this.ReceiveQuitAsync(context, req));
}
return(Task.CompletedTask);
}
/// <summary>
/// 发送服务端意外错误的消息
/// </summary>
/// <param name="context"></param>
/// <param name="reqMessage"></param>
/// <returns></returns>
private Task SendErrorResponseTask(IRpcContext <AmpMessage> context, AmpMessage reqMessage)
{
try
{
var rsp = AmpMessage.CreateResponseMessage(reqMessage.ServiceId, reqMessage.MessageId);
rsp.InvokeMessageType = InvokeMessageType.ERROR;
rsp.Sequence = reqMessage.Sequence;
return(context.SendAsync(rsp));
}
catch (Exception ex)
{
Logger.Error(ex, "send error response fail:" + ex.Message);
return(Rpc.Utils.TaskUtils.CompletedTask);
}
}
public Task ReceiveAsync(IRpcContext <TMessage> context, TMessage message)
{
if (Recieved != null)
{
return(Task.Factory.StartNew(() =>
{
Recieved.Invoke(this, new MessageRecievedEventArgs <TMessage>(context, message));
}
));
}
else
{
return(Utils.TaskUtils.CompletedTask);
}
}
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 IReadOnlyList <MethodInfo> Get()
{
IRpcContext context = this.contextAccessor.Value !;
StaticRpcMethodData?data = this.dataAccessor.Value;
if (data == null)
{
throw new InvalidOperationException("No rpc method data is avaliable. It must be added to the request pipeline.");
}
if (context.Path == null)
{
return(data.BaseMethods);
}
bool result = data.Methods.TryGetValue(context.Path, out List <MethodInfo>?m);
return(result ? m ! : (IReadOnlyList <MethodInfo>)Array.Empty <MethodInfo>());
}
/// <summary>
/// 发送服务端意外错误的消息
/// </summary>
/// <param name="context"></param>
/// <param name="reqMessage"></param>
/// <returns></returns>
private async Task <AmpMessage> SendErrorResponseAsync(IRpcContext <AmpMessage> context, AmpMessage reqMessage)
{
var rsp = AmpMessage.CreateResponseMessage(reqMessage.ServiceId, reqMessage.MessageId);
rsp.InvokeMessageType = InvokeMessageType.Response;
rsp.Sequence = reqMessage.Sequence;
rsp.Code = ErrorCodes.CODE_INTERNAL_ERROR; //内部错误
try
{
await context.SendAsync(rsp);
}
catch (Exception ex)
{
Logger.LogError(ex, "send error response fail:" + ex.Message);
}
return(rsp);
}
public object[] RunScript(IRpcContext context, string FileName, List <string> Args)
{
GetParams(Args);
var args = _cmd.ParamsAfterSwitch("args");
_context = context;
_fileName = FileName;
_args = args;
_controller = BeginProcess(_processName);
//c.SearchPaths.Add(@"E:\Dev\Source\AndresIPyResource\Scripts");
var ctx = _controller.CreateScriptContextFromFile(FileName);
_controller.SetSysArgV(args);
ctx.Execute();
return(new object[0]);
}
public virtual Task ReceiveAsync(IRpcContext <TMessage> context, TMessage message)
{
if (message.InvokeMessageType != InvokeMessageType.Request)
{
return(Utils.TaskUtils.CompletedTask);
}
var actor = this._actorLocator.LocateServiceActor(message);
if (actor == null) // 找不到对应的执行程序
{
Logger.LogError("IServiceActor NOT FOUND,MethodId={methodIdentifier}", message.MethodIdentifier);
return(Utils.TaskUtils.CompletedTask);
}
else
{
return(actor.ReceiveAsync(context, message));
}
}
public virtual async Task ReceiveAsync(IRpcContext <TMessage> context, TMessage message)
{
RaiseReceivedEvent(context, message);
//本地服务互调也会进入到这里，但是这里不能再重复处理了，不然就是死循环
if (message.InvokeMessageType != InvokeMessageType.Request)
{
return;
}
var actor = this._actorLocator.LocateServiceActor(message);
if (actor == null) // 找不到对应的执行程序
{
Logger.Error("IServiceActor NOT FOUND");
}
else
{
await actor.ReceiveAsync(context, message);
}
}
private static void AddAuditLog(IRpcContext context, ILogger writer, IAuditLoggerFormat format, AuditLogType logType, string methodName, object req, object rsp, long elapsedMS)
{
if (writer == null || format == null)
{
return;
}
var entity = new AuditLogEntity {
MethodFullName = methodName,
Request = req,
Response = rsp,
ElapsedMS = elapsedMS,
Writer = writer,
Context = context,
Formatter = format,
LogType = logType
};
logDict.Enqueue(entity);
StartWrite();
}
public object[] SendFileData(IRpcContext context, string FileName, byte[] Data)
{
var fs = GetFileStream(FileName, false);
Data = _fileHandlers.RaiseReceiveFileDataEvent(FileName, fs, Data);
fs.Write(Data, 0, Data.Length);
return new object[] { "success" };
}
public object[] EndSendFile(IRpcContext context, string FileName)
{
var fs = GetFileStream(FileName, false);
_fileHandlers.RaiseReceiveFileCompleteEvent(FileName, fs);
fs.Close();
Files.Remove(FileName);
return new object[] { "success" };
}
public object[] BeginSendFile(IRpcContext context, string FileName)
{
GetFileStream(FileName, true);
return new object[] { "success" };
}
public object[] RunScript(IRpcContext context, string FileName, List<string> Args)
{
GetParams(Args);
var args = _cmd.ParamsAfterSwitch("args");
_context = context;
_fileName = FileName;
_args = args;
_controller = BeginProcess(_processName);
//c.SearchPaths.Add(@"E:\Dev\Source\AndresIPyResource\Scripts");
var ctx = _controller.CreateScriptContextFromFile(FileName);
_controller.SetSysArgV(args);
ctx.Execute();
return new object[0];
}
public object[] Eval(IRpcContext context, List<string> Args)
{
GetParams(Args);
_controller = BeginProcess(_processName);
var ctx = _controller.CreateScriptContextFromString(_code);
ctx.Execute();
//code.Run(_controller.Scope);
return new object[0];
}
internal void HandleMessage(IRpcContext context, string Message, IPythonServerContext serverContext)
{
if (OnMessage != null)
{
OnMessage(this, context, Message, serverContext);
}
}
