public void Encode(object data, IClient client, Stream stream)
{
PipeStream pstream = stream.ToPipeStream();
RPCPacket request = data as RPCPacket;
request.Write(Options, pstream);
}
public async void Ping()
{
if (System.Threading.Interlocked.CompareExchange(ref mPingStatus, 1, 0) == 0)
{
if (TcpClient.IsConnected)
{
try
{
RPCPacket request = new RPCPacket();
request.Url = "/__System/Ping";
var response = await XRPCClient.SendWait(request, TcpClient, null);
PingTime = TimeWatch.GetElapsedMilliseconds();
}
catch (Exception e_)
{
}
finally
{
if (TimeOut(XRPCClient.PingTimeout * 1000))
{
TcpClient.DisConnect();
bool isnew;
TcpClient.Connect(out isnew);
}
}
}
else
{
PingTime = TimeWatch.GetElapsedMilliseconds();
}
System.Threading.Interlocked.Exchange(ref mPingStatus, 0);
}
}
protected override object Invoke(MethodInfo targetMethod, object[] args)
{
if (!Handlers.TryGetValue(targetMethod.Name, out ClientActionHandler handler))
{
var error = new XRPCException($"{targetMethod.Name} action not found!");
error.ErrorCode = (short)StatusCode.ACTION_NOT_FOUND;
throw error;
}
else
{
if (!handler.IsTaskResult)
{
var error = new XRPCException("Definition is not supported, please define task with return value!");
error.ErrorCode = (short)StatusCode.NOT_SUPPORT;
throw error;
}
var request = new RPCPacket();
request.Url = handler.Url;
request.Data = args;
var task = Server.SendWait(request, Session, handler.ResponseType);
IAnyCompletionSource source = handler.GetCompletionSource();
source.WaitResponse(task);
return(source.GetTask());
}
}
private async void InvokeController(ControllerCenter.HandlerItem handler, RPCPacket packet)
{
RPCPacket response = new RPCPacket();
try
{
packet.LoadParameters(handler.Parameters);
var result = handler.Handler.Execute(handler.Controller, packet.Data);
if (result is Task task)
{
await task;
}
var data = handler.GetValue(result);
if (data != null)
{
response.Data = new object[] { data }
}
;
}
catch (Exception e_)
{
response.Status = (short)StatusCode.INNER_ERROR;
response.Data = new string[] { e_.Message };
}
packet.ReplyPacket(response);
}
private void OnEncode(ISession session, object data, System.IO.Stream stream)
{
PipeStream pstream = stream.ToPipeStream();
RPCPacket response = data as RPCPacket;
response.Write(Options, pstream);
}
public void Decode(IClient client, Stream stream)
{
PipeStream pstream = stream.ToPipeStream();
while (true)
{
if (mPacket == null)
{
mPacket = new RPCPacket();
mPacket.Client = (AsyncTcpClient)client;
}
if (mPacket.Read(Options, pstream))
{
try
{
Completed?.Invoke(client, mPacket);
}
finally
{
mPacket = null;
}
}
else
{
return;
}
}
}
public void Decode(ISession session, Stream stream)
{
PipeStream pstream = stream.ToPipeStream();
while (true)
{
if (mRequest == null)
{
mRequest = new RPCPacket();
mRequest.Sesion = session;
}
if (mRequest.Read(Options, pstream))
{
mCompletedArgs.SetInfo(session, mRequest);
try
{
Completed?.Invoke(this, mCompletedArgs);
}
finally
{
mRequest = null;
}
}
else
{
return;
}
}
}
private void OnPacketCompleted(IClient client, object message)
{
RPCPacket response = (RPCPacket)message;
System.Threading.Interlocked.Increment(ref mResponses);
mReceiveDispatchCenter.Enqueue(response);
}
protected virtual void OnProcess(RPCPacket response)
{
var awaitItem = mAwaiterFactory.GetItem(response.ID);
if (awaitItem != null)
{
response.ResultType = awaitItem.ResultType;
try
{
response.LoadParameters(response.ResultType);
}
catch (Exception e_)
{
response.Status = (short)StatusCode.INNER_ERROR;
response.Data = new object[] { $"{e_.Message}@{e_.StackTrace}" };
}
mAwaiterFactory.Completed(awaitItem, response);
}
else
{
try
{
if (response.Url.IndexOf(DELEGATE_TAG, StringComparison.OrdinalIgnoreCase) == 0)
{
InvokeDelegate(response);
return;
}
//notfound;
var item = Controllers.GetHandler(response.Url);
if (item != null)
{
InvokeController(item, response);
}
else
{
if (Receive != null)
{
Receive(this, response);
}
else
{
if (response.NeedReply)
{
var result = new RPCPacket();
result.Status = (short)StatusCode.NOT_SUPPORT;
result.Data = new object[] { $"{response.Url} not found!" };
response.ReplyPacket(result);
}
}
}
}
catch (Exception e_)
{
OnError(response.Client, new ClientErrorArgs {
Error = e_, Message = $"Packet process event error {e_.Message}"
});
}
}
}
private void OnTimeProcess(AwaiterItem item)
{
RPCPacket response = new RPCPacket();
response.Status = (short)StatusCode.REQUEST_TIMEOUT;
response.Data = new object[] { $"Request {item.Request.Url} time out!" };
Completed(item, response);
}
protected virtual Task OnVoidExecute(params object[] data)
{
RPCPacket packet = new RPCPacket();
packet.NeedReply = false;
packet.Url = Clients.XRPCClient.DELEGATE_TAG + Name;
packet.Data = data;
return(xRPCClient.Send(packet, null));
}
public bool Completed(RPCPacket data)
{
if (System.Threading.Interlocked.CompareExchange(ref mFree, 1, 0) == 0)
{
data.ResultType = ResultType;
completionSource.TrySetResult(data);
return(true);
}
return(false);
}
public bool Completed(AwaiterItem item, RPCPacket data)
{
if (item.Completed(data))
{
item.Response = null;
item.Request = null;
return(true);
}
return(false);
}
public void Send(RPCPacket request, AsyncTcpClient client = null)
{
client = client ?? GetClient();
bool isnew;
if (client.Connect(out isnew))
{
client.Send(request);
System.Threading.Interlocked.Increment(ref mRequests);
}
else
{
throw client.LastError;
}
}
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}!");
}
else
{
OnError(packet.Client, new ClientErrorArgs {
Error = e_, Message = $"{action} delegate invoke error {e_.Message}"
});
}
}
}
else
{
if (packet.NeedReply)
{
packet.ReplyError((short)StatusCode.ACTION_NOT_FOUND, $"{action} delegate not found!");
}
}
}
public Task <RPCPacket> SendWait(RPCPacket request, AsyncTcpClient client, Type[] resultType = null)
{
client = client ?? GetClient();
bool isnew;
if (client.Connect(out isnew))
{
var result = mAwaiterFactory.Create(request, resultType, TimeOut);
request.ID = result.Item1;
client.Send(request);
System.Threading.Interlocked.Increment(ref mRequests);
return(result.Item2.Task);
}
else
{
throw client.LastError;
}
}
protected virtual async Task OnLogin(AsyncTcpClient client)
{
if (!string.IsNullOrEmpty(UserName))
{
RPCPacket packet = new RPCPacket();
packet.Url = LOGIN_TAG;
packet.Data = new object[] { UserName, PassWord };
packet.NeedReply = true;
var response = await SendWait(packet, client);
if (response.Status != (short)StatusCode.SUCCESS)
{
client.DisConnect();
throw new XRPCException((string)response.Data[0]);
}
}
if (Connected != null)
{
await Connected(client);
}
}
protected virtual 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 xRPCClient.SendWait(packet, null, 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]);
}
public async void Ping()
{
if (System.Threading.Interlocked.CompareExchange(ref mPingStatus, 1, 0) == 0)
{
try
{
RPCPacket request = new RPCPacket();
request.Url = "/__System/Ping";
var response = await XRPCClient.SendWait(request, TcpClient, null);
}
catch (Exception e_)
{
mPingError++;
if (mPingError > 3)
{
mPingError = 0;
TcpClient.DisConnect();
}
}
System.Threading.Interlocked.Exchange(ref mPingStatus, 0);
}
}
public async Task Subscribe <T>(T handler, AsyncTcpClient client = null) where T : Delegate
{
DelegateHandler item = new DelegateHandler(typeof(T));
item.Delegate = handler;
item.Init();
if (!item.IsVoid)
{
throw new XRPCException($"The subscribe delegate return value must be void!");
}
if (item.Parameters == null || item.Parameters.Length == 0)
{
throw new XRPCException($"The subscribe delegate parameters can't be empty!");
}
RPCPacket packet = new RPCPacket();
packet.Url = SUBSCRIBE_TAG + item.Name;
packet.NeedReply = true;
await SendWait(packet, client);
mDelegateHandlers[item.Name] = item;
}
public (int, TaskCompletionSource <RPCPacket>) Create(RPCPacket request, Type[] resultType, int timeout = 1000 * 10)
{
request.NeedReply = true;
int id = 0;
long expiredTime;
lock (this)
{
mID++;
if (mID >= mEndID)
{
mID = mStartID;
}
id = mID;
}
expiredTime = TimeWatch.GetElapsedMilliseconds() + timeout;
var item = new AwaiterItem();
item.ID = id;
item.ResultType = resultType;
item.Request = request;
mAwaiterItemGroup.Set(item.ID, item);
return(id, item.Create(expiredTime));
}
public EventPacketProcessingArgs(XRPCServer server, RPCPacket packet) : base(server, packet)
{
}
public EventActionNotFoundArgs(XRPCServer server, RPCPacket packet) : base(server
)
{
Packet = packet;
}
protected override object Invoke(MethodInfo targetMethod, object[] args)
{
if (!mHandlers.TryGetValue(targetMethod.Name, out ClientActionHandler handler))
{
var error = new XRPCException($"{targetMethod.Name} action not found!");
error.ErrorCode = (short)StatusCode.ACTION_NOT_FOUND;
throw error;
}
else
{
if (!handler.IsTaskResult)
{
var error = new XRPCException("Definition is not supported, please define task with return value!");
error.ErrorCode = (short)StatusCode.NOT_SUPPORT;
throw error;
}
var request = new RPCPacket();
request.Url = handler.Url;
request.Data = args;
if (!string.IsNullOrEmpty(Actor))
{
request.Header = new Dictionary <string, string>();
request.Header[EventCenter.ACTOR_TAG] = this.Actor;
}
if (mHeader.Count > 0)
{
if (request.Header == null)
{
request.Header = new Dictionary <string, string>();
}
foreach (var item in mHeader)
{
request.Header.Add(item.Key, item.Value);
}
}
var task = Client.SendWait(request, TcpClient, handler.ResponseType);
if (!handler.IsTaskResult)
{
if (task.Wait(Client.TimeOut))
{
var response = task.Result;
if (response.Status == (short)StatusCode.SUCCESS)
{
if (response.Paramters > 0)
{
return(response.Data[0]);
}
return(null);
}
else
{
Client.AwaiterFactory.GetItem(request.ID);
var error = new XRPCException((string)response.Data[0]);
error.ErrorCode = response.Status;
throw error;
}
}
else
{
var error = new XRPCException($"{targetMethod.Name} action time out!");
error.ErrorCode = (short)StatusCode.REQUEST_TIMEOUT;
throw error;
}
}
else
{
IAnyCompletionSource source = handler.GetCompletionSource();
source.WaitResponse(task);
return(source.GetTask());
}
}
}
public EventPacketArgs(XRPCServer server, RPCPacket packet) : base(server
)
{
Packet = packet;
}
