public RabbitBus(
IEasyNetQLogger logger,
IConventions conventions,
IAdvancedBus advancedBus,
IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy,
IRpc rpc,
ISendReceive sendReceive,
IConnectionConfiguration connectionConfiguration)
{
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(advancedBus, "advancedBus");
Preconditions.CheckNotNull(publishExchangeDeclareStrategy, "publishExchangeDeclareStrategy");
Preconditions.CheckNotNull(rpc, "rpc");
Preconditions.CheckNotNull(sendReceive, "sendReceive");
Preconditions.CheckNotNull(connectionConfiguration, "connectionConfiguration");
this.logger = logger;
this.conventions = conventions;
this.advancedBus = advancedBus;
this.publishExchangeDeclareStrategy = publishExchangeDeclareStrategy;
this.rpc = rpc;
this.sendReceive = sendReceive;
this.connectionConfiguration = connectionConfiguration;
advancedBus.Connected += OnConnected;
advancedBus.Disconnected += OnDisconnected;
}
public RpcTask(int id, IRpc rpc, DateTime expire)
{
CompleteWaiter = new ManualResetEventSlim(false);
Id = id;
Rpc = rpc;
ExpireDate = expire;
}
public AzureBus(
IAzureNetQLogger logger,
IConventions conventions,
IRpc rpc,
ISendReceive sendReceive,
IAzureAdvancedBus advancedBus,
IConnectionConfiguration connectionConfiguration,
ISerializer serializer)
{
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(rpc, "rpc");
Preconditions.CheckNotNull(sendReceive, "sendReceive");
Preconditions.CheckNotNull(advancedBus, "advancedBus");
Preconditions.CheckNotNull(connectionConfiguration, "connectionConfiguration");
Preconditions.CheckNotNull(serializer, "serializer");
this.logger = logger;
this.conventions = conventions;
this.rpc = rpc;
this.sendReceive = sendReceive;
this.advancedBus = advancedBus;
this.connectionConfiguration = connectionConfiguration;
this.serializer = serializer;
this.exceptionHandler = new ExceptionHandler(logger);
}
/// <summary>
/// Retorna o RPC registrado para o número de mensagem informado, ou null caso
/// não haja um RPC registrado para o número de mensagem.
/// </summary>
/// <param name="msgId">Número da mensagem</param>
/// <returns>RPC registrado para o número da mensagem, ou null caso nenhum registrado.</returns>
protected IRpc GetRpc(int msgId)
{
IRpc rpc = null;
m_rpcs.TryGetValue(msgId, out rpc);
return(rpc);
}
public Proto5Handler(TezosNode node, TzktContext db, CacheService cache, QuotesService quotes, IServiceProvider services, IConfiguration config, ILogger <Proto5Handler> logger)
: base(node, db, cache, quotes, services, config, logger)
{
Rpc = new Rpc(node);
Diagnostics = new Diagnostics(this);
Validator = new Validator(this);
}
private RpcManager()
{
this.asyncRpcIndex = 0;
QueuedRpcs = new Dictionary <Player, Queue <QueuedRpc> >();
registeredRPCs = new Dictionary <string, List <RegisteredRpc> >();
registeredAsyncRPCs = new Dictionary <string, List <RegisteredRpc> >();
RootElement.OnMiscelaniousEvent += (eventName, source, p1, p2, p3, p4, p5, p6, p7, p8) =>
{
if (registeredRPCs.ContainsKey(eventName))
{
Player player = ElementManager.Instance.GetElement <Player>(source);
var registeredRpcs = registeredRPCs[eventName];
foreach (var registeredRpc in registeredRpcs)
{
var method = registeredRpc.callback;
IRpc rpc = (IRpc)Activator.CreateInstance(registeredRpc.type);
rpc.Parse(p1);
method.Invoke(player, rpc);
}
}
else if (registeredAsyncRPCs.ContainsKey(eventName))
{
Player player = ElementManager.Instance.GetElement <Player>(source);
var registeredRpcs = registeredAsyncRPCs[eventName];
foreach (var registeredRpc in registeredRpcs)
{
var method = registeredRpc.callback;
AsyncRpc asyncRpc = Activator.CreateInstance <AsyncRpc>();
asyncRpc.Parse(p1);
method.Invoke(player, asyncRpc);
}
}
};
RegisterRPC <EmptyRpc>("slipe-client-ready-rpc", (player, rpc) =>
{
if (QueuedRpcs.TryGetValue(player, out Queue <QueuedRpc> rpcQueue))
{
player.IsReadyForIncomingRequests = true;
QueuedRpcs.Remove(player);
while (rpcQueue.TryDequeue(out QueuedRpc queuedRpc))
{
if (queuedRpc.bandwidth != -1)
{
TriggerLatentRPC(player, queuedRpc.key, queuedRpc.bandwidth, queuedRpc.rpc, queuedRpc.persists);
}
else
{
TriggerRPC(player, queuedRpc.key, queuedRpc.rpc);
}
}
}
public QueuedRpc(string key, IRpc rpc, int bandwidth, bool persists)
{
this.key = key;
this.rpc = rpc;
this.bandwidth = bandwidth;
this.persists = persists;
}
private void QueueRpc(Player target, string key, IRpc argument, int bandwidth = -1, bool persists = false)
{
if (!QueuedRpcs.ContainsKey(target))
{
QueuedRpcs[target] = new List <QueuedRpc>();
}
QueuedRpcs[target].Add(new QueuedRpc(key, argument, bandwidth, persists));
}
public RpcTask Send(uint packetId, IRpc rpc, int timeout = 60000)
{
var expire = DateTime.Now.AddMilliseconds(timeout);
if (timeout == -1)
{
expire = DateTime.MaxValue;
}
return(Send(packetId, rpc, expire));
}
/// <summary>
/// Retorna o RPC para o número de mensagem, ou null em caso de nenhum RPC registrado
/// para o número informado (p.ex. nova requisição).
/// </summary>
/// <param name="msgId">Número de mensagem</param>
/// <returns>RPC ativo, ou null caso nenhum ativo para o número de mensagem.</returns>
private IRpc GetRpc(int msgId)
{
IRpc ret = null;
if (m_Rpcs.TryGetValue(msgId, out ret))
{
return(ret);
}
return(null);
}
public void Call(IRpc f, int id, string method, ListTreeNode <T> args)
{
Callback callback;
if (!m_map.TryGetValue(method, out callback))
{
throw new KeyNotFoundException();
}
callback(id, args, f);
}
/// <summary>
/// Set up a responder for an RPC service.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="rpc">The rpc instance</param>
/// <param name="responder">A function that performs the response</param>
/// <param name="cancellationToken">The cancellation token</param>
public static AwaitableDisposable <IDisposable> RespondAsync <TRequest, TResponse>(
this IRpc rpc,
Func <TRequest, Task <TResponse> > responder,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
return(rpc.RespondAsync <TRequest, TResponse>((r, c) => responder(r), c => { }, cancellationToken));
}
public static RpcServer UseRpc(this IRpc host, RpcServer server)
{
var tupple = host.ReflectRpcFunctions();
tupple.ForEach(t =>
{
server.Register(t.Item1, t.Item2);
});
return(server);
}
/// <summary>
/// Set up a responder for an RPC service.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="rpc">The rpc instance</param>
/// <param name="responder">A function that performs the response</param>
/// <param name="cancellationToken">The cancellation token</param>
public static IDisposable Respond <TRequest, TResponse>(
this IRpc rpc,
Func <TRequest, Task <TResponse> > responder,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
return(rpc.Respond(responder, c => { }, cancellationToken));
}
/// <summary>
/// Makes an RPC style request
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="rpc">The rpc instance.</param>
/// <param name="request">The request message.</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public static Task <TResponse> RequestAsync <TRequest, TResponse>(
this IRpc rpc,
TRequest request,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
return(rpc.RequestAsync <TRequest, TResponse>(request, c => { }, cancellationToken));
}
public static TMLobby RecallRpc(this IRpc host, TMLobby lobby)
{
var tupple = host.ReflectRpcFunctions();
tupple.ForEach(t =>
{
lobby.Unregister(t.Item1);
});
return(lobby);
}
/// <summary>
/// Trigger an RPC on a player
/// </summary>
public void TriggerRPC(Player target, string key, IRpc argument)
{
if (!target.IsReadyForIncomingRequests && argument.OnClientRpcFailed == ClientRpcFailedAction.Queue)
{
QueueRpc(target, key, argument);
}
else
{
MtaServer.TriggerClientEvent(target.MTAElement, key, Element.Root.MTAElement, argument);
}
}
/// <summary>
/// Makes an RPC style request
/// </summary>
/// <param name="rpc">The rpc instance.</param>
/// <param name="request">The request message.</param>
/// <param name="requestType">The request type</param>
/// <param name="responseType">The response type</param>
/// <param name="configure">
/// Fluent configuration e.g. x => x.WithQueueName("uk.london")
/// </param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public static Task <object> RequestAsync(
this IRpc rpc,
object request,
Type requestType,
Type responseType,
Action <IRequestConfiguration> configure,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
var requestDelegate = RequestDelegates.GetOrAdd(Tuple.Create(requestType, responseType), t =>
{
var requestMethodInfo = typeof(IRpc).GetMethod("RequestAsync");
if (requestMethodInfo == null)
{
throw new MissingMethodException(nameof(IRpc), "RequestAsync");
}
var toTaskOfObjectMethodInfo = typeof(NonGenericRpcExtensions).GetMethod(nameof(ToTaskOfObject), BindingFlags.NonPublic | BindingFlags.Static);
if (toTaskOfObjectMethodInfo == null)
{
throw new MissingMethodException(nameof(NonGenericRpcExtensions), nameof(ToTaskOfObject));
}
var genericRequestPublishMethodInfo = requestMethodInfo.MakeGenericMethod(t.Item1, t.Item2);
var genericToTaskOfObjectMethodInfo = toTaskOfObjectMethodInfo.MakeGenericMethod(t.Item2);
var rpcParameter = Expression.Parameter(typeof(IRpc), "rpc");
var requestParameter = Expression.Parameter(typeof(object), "request");
var requestTypeParameter = Expression.Parameter(typeof(Type), "requestType");
var responseTypeParameter = Expression.Parameter(typeof(Type), "responseType");
var configureParameter = Expression.Parameter(typeof(Action <IRequestConfiguration>), "configure");
var cancellationTokenParameter = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
var genericRequestMethodCallExpression = Expression.Call(
rpcParameter,
genericRequestPublishMethodInfo,
Expression.Convert(requestParameter, t.Item1),
configureParameter,
cancellationTokenParameter
);
var lambda = Expression.Lambda <NonGenericRequestDelegate>(
Expression.Call(null, genericToTaskOfObjectMethodInfo, genericRequestMethodCallExpression),
rpcParameter,
requestParameter,
requestTypeParameter,
responseTypeParameter,
configureParameter,
cancellationTokenParameter
);
return(lambda.Compile());
});
return(requestDelegate(rpc, request, requestType, responseType, configure, cancellationToken));
}
/// <summary>
/// Set up a responder for an RPC service.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="rpc">The rpc instance</param>
/// <param name="responder">A function that performs the response</param>
/// <param name="configure">A function that performs the configuration</param>
/// <param name="cancellationToken">The cancellation token</param>
public static IDisposable Respond <TRequest, TResponse>(
this IRpc rpc,
Func <TRequest, Task <TResponse> > responder,
Action <IResponderConfiguration> configure,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
return(rpc.Respond <TRequest, TResponse>((r, c) => responder(r), configure, cancellationToken));
}
/// <summary>
/// Trigger an RPC with limited bandwidth
/// </summary>
public void TriggerLatentRPC(Player target, string key, int bandwidth, IRpc argument, bool persists = false)
{
if (!target.IsReadyForIncomingRequests && argument.OnClientRpcFailed == ClientRpcFailedAction.Queue)
{
QueueRpc(target, key, argument, bandwidth, persists);
}
else
{
MtaServer.TriggerLatentClientEvent(target.MTAElement, key, bandwidth, persists, Element.Root.MTAElement, argument);
}
}
/// <summary>
/// Set up a responder for an RPC service.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="rpc">The rpc instance</param>
/// <param name="responder">A function that performs the response</param>
/// <param name="cancellationToken">The cancellation token</param>
public static AwaitableDisposable <IDisposable> RespondAsync <TRequest, TResponse>(
this IRpc rpc,
Func <TRequest, TResponse> responder,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
var asyncResponder = TaskHelpers.FromFunc <TRequest, TResponse>((m, c) => responder(m));
return(rpc.RespondAsync <TRequest, TResponse>(asyncResponder, c => { }, cancellationToken));
}
/// <summary>
/// Makes an RPC style request
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="rpc">The rpc instance.</param>
/// <param name="request">The request message.</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public static TResponse Request <TRequest, TResponse>(
this IRpc rpc,
TRequest request,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
return(rpc.RequestAsync <TRequest, TResponse>(request, cancellationToken)
.GetAwaiter()
.GetResult());
}
/// <summary>
/// Makes an RPC style request
/// </summary>
/// <param name="rpc">The rpc instance.</param>
/// <param name="request">The request message.</param>
/// <param name="requestType">The request type</param>
/// <param name="responseType">The response type</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public static Task <object> RequestAsync(
this IRpc rpc,
object request,
Type requestType,
Type responseType,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
return(rpc.RequestAsync(request, requestType, responseType, c => { }, cancellationToken));
}
public static Task RpcAsync(this IRpc @this, IEnumerable <TMClient> clients, string methodName, bool isStatic, params object[] args)
{
var type = @this.GetType();
var hostAttribute = type.GetCustomAttribute <RpcHostAttribute>();
var hostName = string.IsNullOrEmpty(hostAttribute.Name) ? type.Name : hostAttribute.Name;
var rpcMethodName = string.Format("{0}_{1}", hostName, methodName);
if (!isStatic)
{
var hostId = @this.ReflectRpcHostIdPropertyValue();
rpcMethodName = $"{hostName}_{hostId}_{methodName}";
}
return(clients.RpcAsync(rpcMethodName, args));
}
/// <summary>
/// Callback de notificação de pacote recebido.
/// Localiza o RPC a partir do número da mensagem e transmite o pacote
/// para o RPC.
/// </summary>
/// <param name="sender"></param>
/// <param name="packet"></param>
protected void OnPacketReceived(object sender, InternalPacket packet)
{
int msgId = packet.MsgId;
IRpc rpc = GetRpc(msgId);
if (rpc != null)
{
rpc.OnPacketReceived(GetSession(), packet);
return;
}
MyDebug.LogDebug("Channel.OnPacketReceived: msgid {0} desconhecido ou inesperado", packet.MsgId);
}
/// <summary>
/// Makes an RPC style request
/// </summary>
/// <param name="rpc">The rpc instance.</param>
/// <param name="request">The request message.</param>
/// <param name="requestType">The request type</param>
/// <param name="responseType">The response type</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>The response</returns>
public static object Request(
this IRpc rpc,
object request,
Type requestType,
Type responseType,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(rpc, "rpc");
return(rpc.RequestAsync(request, requestType, responseType, cancellationToken)
.GetAwaiter()
.GetResult());
}
public RabbitBus(
IAdvancedBus advanced,
IPubSub pubSub,
IRpc rpc,
ISendReceive sendReceive,
IScheduler scheduler,
IRabbitMQPersistentConnection connection)
{
_advanced = advanced;
_pubsub = pubSub;
_rpc = rpc;
_sendreceive = sendReceive;
_scheduler = scheduler;
_connection = connection;
}
protected async Task <Tout> CallAsync <Tout>(IRpc rpc)
{
var requestPath = config.GetServerEndpoint() + "/" + rpc.Controller;
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Add("debug-uid-override", sessionData.UID);
HttpResponseMessage response = await client.GetAsync(requestPath);
if (response.IsSuccessStatusCode)
{
var responseString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <Tout>(responseString));
}
return(default);
private static bool RpcHandler(YangStatement statement, IRpc partial)
{
switch (statement.Keyword)
{
case "input":
partial.Input = ParseStatement(statement, RpcParameterHandlers, new RpcParameter(statement.Keyword));
return(false);
case "output":
partial.Output = ParseStatement(statement, RpcParameterHandlers, new RpcParameter(statement.Keyword));
return(false);
default:
return(false);
}
}
public static string ReflectRpcHostIdPropertyValue(this IRpc rpcHost)
{
PropertyInfo[] props = rpcHost.GetType().GetProperties();
foreach (PropertyInfo prop in props)
{
object[] attrs = prop.GetCustomAttributes(true);
foreach (object attr in attrs)
{
if (attr is RpcHostIdPropertyAttribute idAttr)
{
return(prop.GetValue(rpcHost).ToString());
}
}
}
return("");
}
