public void ReplySuccess()
{
RPCPacket response = new RPCPacket();
response.Status = (short)StatusCode.SUCCESS;
ReplyPacket(response);
}
public void Reply(params object[] data)
{
RPCPacket response = new RPCPacket();
response.Data = data;
ReplyPacket(response);
}
private void OnSubscribe(RPCPacket packet)
{
var path = packet.Url.SubRightWith('/', out string action);
var item = GetPublisher(action);
item.Add(packet.Session);
packet.ReplySuccess();
}
public void Reply(params object[] data)
{
RPCPacket response = new RPCPacket();
response.Status = (short)StatusCode.SUCCESS;
response.Data = data;
ReplyPacket(response);
}
public void ReplyError(short status, string message)
{
RPCPacket response = new RPCPacket();
response.Status = status;
response.Data = new string[] { message };
ReplyPacket(response);
}
public void ReplyError(string message)
{
RPCPacket response = new RPCPacket();
response.Status = (short)StatusCode.INNER_ERROR;
response.Data = new string[] { message };
ReplyPacket(response);
}
internal Task <RPCPacket> SendWait(RPCPacket request, ISession session, Type[] resultTypes)
{
var result = AwaiterFactory.Create(request, resultTypes, ClientTimeout);
request.ID = result.Item1;
session.Send(request);
System.Threading.Interlocked.Increment(ref mRequests);
return(result.Item2.Task);
}
protected override Task OnVoidExecute(params object[] data)
{
RPCPacket packet = new RPCPacket();
packet.NeedReply = false;
packet.Url = Clients.XRPCClient.DELEGATE_TAG + Name;
packet.Data = data;
Server.Send(packet, new ISession[] { Session });
return(Task.CompletedTask);
}
public void Send(RPCPacket response, ISession[] sessions)
{
if (sessions != null)
{
foreach (var item in sessions)
{
System.Threading.Interlocked.Add(ref mResponses, sessions.Length);
mServer.Send(response, sessions);
}
}
}
public void ReplyPacket(RPCPacket response)
{
response.ID = this.ID;
if (Sesion != null)
{
Sesion.Send(response);
}
if (Client != null)
{
Client.Send(response);
}
}
protected override void OnReceiveMessage(IServer server, ISession session, object message)
{
base.OnReceiveMessage(server, session, message);
RPCPacket request = (RPCPacket)message;
if (EnableLog(LogType.Debug))
{
Log(LogType.Debug, $"[{request.ID}]{session.RemoteEndPoint} receive message {request.Url}@{request.ID}");
}
System.Threading.Interlocked.Increment(ref mRequests);
Server.UpdateSession(session);
mRequestDispatchCenter.Enqueue(request);
}
public void Completed(EventNext.IEventOutput data)
{
RPCPacket response = new RPCPacket();
response.Status = (short)data.EventError;
response.Header = data.Properties;
response.Data = data.Data;
data.Token = null;
if (Server.EnableLog(LogType.Debug))
{
string info = Newtonsoft.Json.JsonConvert.SerializeObject(data);
Server.Log(LogType.Debug, $"[{data.ID}]{Request.Session.RemoteEndPoint} send event data:{info}");
}
Server.OnResponse(Request, response);
}
private async void InvokeDelegate(RPCPacket packet)
{
var path = packet.Url.SubRightWith('/', out string action);
if (mDelegateHandlers.TryGetValue(action, out DelegateHandler handler))
{
try
{
packet.LoadParameters(handler.Parameters);
object result = handler.Delegate.DynamicInvoke(packet.Data);
if (!handler.IsVoid)
{
await(Task) result;
if (handler.TargetReturnType != null)
{
var data = handler.GetValue(result);
packet.Reply(data);
}
else
{
packet.ReplySuccess();
}
}
}
catch (Exception e_)
{
if (!handler.IsVoid)
{
packet.ReplyError((short)StatusCode.INNER_ERROR, $"{action} delegate invoke error {e_.Message}!");
}
if (EnableLog(LogType.Error))
{
Log(LogType.Error, $"{action} delegate invoke error {e_.Message}@{e_.StackTrace}");
}
}
}
else
{
if (packet.NeedReply)
{
packet.ReplyError((short)StatusCode.ACTION_NOT_FOUND, $"{action} delegate not found!");
}
}
}
private void OnEventNext(RPCPacket e)
{
EventNext.EventInput input = new EventNext.EventInput();
input.ID = e.ID;
input.EventPath = e.Url;
input.Properties = e.Header;
input.Data = e.Data;
if (EnableLog(LogType.Debug))
{
string info = Newtonsoft.Json.JsonConvert.SerializeObject(input);
Log(LogType.Debug, $"[{input.ID}]{e.Session.RemoteEndPoint} receive event data:{info}");
}
input.Token = new XRPCEventToken {
Request = e, Server = this, Session = e.Session
};
EventCenter.Execute(input, new EventCompleted {
Server = this, Request = e
});
}
protected EventPacketProcessingArgs OnProcessing(RPCPacket packet)
{
if (Processing != null)
{
try
{
EventPacketProcessingArgs e = new EventPacketProcessingArgs(this, packet);
Processing(this, e);
return(e);
}
catch (Exception e_)
{
if (EnableLog(LogType.Error))
{
Log(LogType.Error, $"[{packet.ID}]{packet.Session.RemoteEndPoint} processing {packet.Url} event error {e_.Message}@{e_.StackTrace}!");
}
}
}
return(null);
}
protected override async Task <T> OnTaskExecute <T>(params object[] data)
{
bool istask = typeof(T) == typeof(RESULT_NULL);
RPCPacket packet = new RPCPacket();
packet.NeedReply = true;
packet.Url = Clients.XRPCClient.DELEGATE_TAG + Name;
packet.Data = data;
var returltype = GetReturnTypes();
var result = await Server.SendWait(packet, Session, returltype);
if (result.Status != (short)StatusCode.SUCCESS)
{
throw new XRPCException((string)result.Data[0]);
}
if (istask)
{
return((T)(object)new RESULT_NULL());
}
return((T)result.Data[0]);
}
protected virtual void OnVoidExecute(params object[] data)
{
RPCPacket packet = new RPCPacket();
packet.NeedReply = false;
packet.Url = Clients.XRPCClient.DELEGATE_TAG + Name;
packet.Data = data;
var sessions = Sessions;
foreach (var item in sessions)
{
if (item.IsDisposed)
{
Remove(item);
}
else
{
item.Send(packet);
}
}
}
private void OnRequestProcess(RPCPacket e)
{
RPCPacket response = e;
try
{
var evt = OnProcessing(e);
if (evt != null && evt.Cancel)
{
return;
}
if (this.Security)
{
if (e.Session.Authentication < AuthenticationType.User && e.Url != Clients.XRPCClient.LOGIN_TAG)
{
e.ReplyError((short)StatusCode.INNER_ERROR, "No permission operation in secure mode!");
return;
}
}
EventNext.EventActionHandler handler = EventCenter.GetActionHandler(e.Url);
if (handler != null)
{
BindRequestParameter(e, handler);
OnEventNext(e);
}
else
{
if (e.Url == "/__System/Ping")
{
response = new RPCPacket();
if (EnableLog(LogType.Debug))
{
Log(LogType.Debug, $"[{e.ID}]{e.Session.RemoteEndPoint} request {e.Url}");
}
response.Status = (short)StatusCode.SUCCESS;
OnResponse(e, response);
}
else if (e.Url == Clients.XRPCClient.LOGIN_TAG)
{
EventLoginArgs login = new EventLoginArgs(this, e.Session);
e.LoadParameters <string, string>();
login.UserName = (string)e.Data[0];
login.Password = (string)e.Data[1];
Login?.Invoke(this, login);
if (login.Success)
{
e.Session[NAME_PROPERTY_TAG] = login.UserName;
e.ReplySuccess();
}
else
{
string error = login.Message;
if (string.IsNullOrEmpty(error))
{
error = "Invalid username or password!";
}
e.ReplyError(error);
}
}
else
{
var awaitItem = AwaiterFactory.GetItem(response.ID);
if (awaitItem != null)
{
response.ResultType = awaitItem.ResultType;
try
{
if (response.ResultType != null)
{
response.LoadParameters(response.ResultType);
}
}
catch (Exception e_)
{
response.Status = (short)StatusCode.INNER_ERROR;
response.Data = new object[] { $"{e_.Message}@{e_.StackTrace}" };
}
AwaiterFactory.Completed(awaitItem, response);
}
else
{
if (response.Url.IndexOf(XRPCClient.DELEGATE_TAG, StringComparison.OrdinalIgnoreCase) == 0)
{
InvokeDelegate(response);
return;
}
if (response.Url.IndexOf(XRPCClient.SUBSCRIBE_TAG, StringComparison.OrdinalIgnoreCase) == 0)
{
OnSubscribe(response);
return;
}
if (NotFound == null)
{
if (EnableLog(LogType.Debug))
{
Log(LogType.Debug, $"[{e.ID}]{e.Session.RemoteEndPoint} request {e.Url} not found!");
}
response = new RPCPacket();
response.Status = (short)StatusCode.ACTION_NOT_FOUND;
response.Data = new object[] { $"request {e.Url} not found!" };
OnResponse(e, response);
}
else
{
NotFound.Invoke(this, new Events.EventPacketArgs(this, e));
}
}
}
}
}
catch (Exception e_)
{
if (EnableLog(LogType.Error))
{
Log(LogType.Error, $"[{e.ID}]{e.Session.RemoteEndPoint} process {e.Url} error {e_.Message}@{e_.StackTrace}!");
}
}
}
public void Reply(RPCPacket response, RPCPacket request)
{
OnResponse(request, response);
}
private void OnRequestProcess(RPCPacket e)
{
RPCPacket response = e;
try
{
EventNext.EventActionHandler handler = EventCenter.GetActionHandler(e.Url);
if (handler != null)
{
BindRequestParameter(e, handler);
OnEventNext(e);
}
else
{
if (e.Url == "/__System/Ping")
{
response = new RPCPacket();
if (EnableLog(LogType.Debug))
{
Log(LogType.Debug, $"[{e.ID}]{e.Sesion.RemoteEndPoint} request {e.Url}");
}
response.Status = (short)StatusCode.SUCCESS;
OnResponse(e, response);
}
else
{
var awaitItem = AwaiterFactory.GetItem(response.ID);
if (awaitItem != null)
{
response.ResultType = awaitItem.ResultType;
try
{
if (response.ResultType != null)
{
response.LoadParameters(response.ResultType);
}
}
catch (Exception e_)
{
response.Status = (short)StatusCode.INNER_ERROR;
response.Data = new object[] { $"{e_.Message}@{e_.StackTrace}" };
}
AwaiterFactory.Completed(awaitItem, response);
}
else
{
if (Receive == null)
{
if (EnableLog(LogType.Debug))
{
Log(LogType.Debug, $"[{e.ID}]{e.Sesion.RemoteEndPoint} request {e.Url} not found!");
}
response = new RPCPacket();
response.Status = (short)StatusCode.ACTION_NOT_FOUND;
response.Data = new object[] { $"request {e.Url} not found!" };
OnResponse(e, response);
}
else
{
Receive.Invoke(this, new Events.EventActionNotFoundArgs(this, e));
}
}
}
}
}
catch (Exception e_)
{
if (EnableLog(LogType.Error))
{
Log(LogType.Debug, $"[{e.ID}]{e.Sesion.RemoteEndPoint} request {e.Url} error {e_.Message}@{e_.StackTrace}!");
}
}
}
public Task <RPCPacket> SendWait(RPCPacket request, ISession session)
{
return(SendWait(request, session, null));
}
private void BindRequestParameter(RPCPacket request, EventNext.EventActionHandler handler)
{
request.LoadParameters(handler != null ? handler.ParametersType : null);
}
internal void OnResponse(RPCPacket request, RPCPacket response)
{
System.Threading.Interlocked.Increment(ref mResponses);
response.ID = request.ID;
request.Session.Send(response);
}
public Task <RPCPacket> SendWait(RPCPacket request, ISession session, int timeout = 10000)
{
return(SendWait(request, session, null, timeout));
}
