public ApiClient(IMessageHandlerProvider messageHandlerProvider)
{
HttpClient = new HttpClient(messageHandlerProvider.NativeHandler)
{
BaseAddress = new Uri(BaseAddress)
};
}
protected MessagePipelineBase(IMessageHandlerProvider messageHandlerProvider, ILifetimeScope lifetimeScope, IMessage message, Logger logger)
: base(logger)
{
_messageHandlerProvider = messageHandlerProvider;
LifetimeScope = lifetimeScope;
Message = message;
}
protected Subscriber(IMessageHandlerProvider messageHandlerProvider, IRabbitConnection connection, IMessageFormatter messageFormatter, Logger logger)
: base(logger)
{
MessageHandlerProvider = messageHandlerProvider;
Connection = connection;
Connection.ConnectionMade += ConnectionConnectionMade;
Connection.ConnectionLost += ConnectionConnectionLost;
MessageFormatter = messageFormatter;
}
public LocalMessagePublisher(
IServiceScopeFactory serviceScopeFactory,
ILogger <LocalMessagePublisher> logger,
IMessageHandlerProvider messageHandlerProvider)
: base(serviceScopeFactory)
{
_logger = logger;
_messageHandlerProvider = messageHandlerProvider;
}
protected override void AddBrokerHandlers(IMessageHandlerProvider provider)
{
provider.RegisterConsumer <NotifyUserEvent, NotifyUserEventHandler>();
provider.RegisterCommandConsumer <SetMessageType, SetTypeEventHandler>();
provider.RegisterCommand <CreateRepostGroup>();
provider.RegisterCommand <RepostCreated>();
provider.RegisterCommand <SetMessageType>();
}
protected override void AddBrokerHandlers(IMessageHandlerProvider provider)
{
provider.RegisterConsumer <LoginEvent, LoginEventHandler>();
provider.RegisterConsumer <UserTokenRemoved, UserTokenRemovedHandler>();
provider.RegisterConsumer <UserTokenChanged, UserTokenChangedHandler>();
provider.RegisterCommandConsumer <CreateRepostGroup, RepostEventGroupCreatedHandler>();
provider.RegisterCommandConsumer <RepostCreated, RepostedEventHandler>();
provider.RegisterCommandConsumer <ExecuteNextRepost, RepostUserEventHandler>();
provider.RegisterCommand <ExecuteNextRepost>();
provider.RegisterCommand <RepostCreated>();
}
public DefaultMessageDispatcher(
ITypeCodeProvider typeCodeProvider,
IMessageHandlerProvider handlerProvider,
IMessageHandleRecordStore messageHandleRecordStore,
IOHelper ioHelper,
ILoggerFactory loggerFactory)
{
_typeCodeProvider = typeCodeProvider;
_handlerProvider = handlerProvider;
_messageHandleRecordStore = messageHandleRecordStore;
_ioHelper = ioHelper;
_logger = loggerFactory.Create(GetType().FullName);
}
public DefaultMessageDispatcher(
ITypeCodeProvider typeCodeProvider,
IMessageHandlerProvider handlerProvider,
IMessageHandleRecordStore messageHandleRecordStore,
IOHelper ioHelper,
ILoggerFactory loggerFactory)
{
_typeCodeProvider = typeCodeProvider;
_handlerProvider = handlerProvider;
_messageHandleRecordStore = messageHandleRecordStore;
_ioHelper = ioHelper;
_logger = loggerFactory.Create(GetType().FullName);
}
public RabbitMqMessageSubscribe(
IMessageHandlerManager messageHandlerManager,
IMessageHandlerProvider messageHandlerProvider,
IRabbitMqMessageConsumerFactory rabbitMqMessageConsumerFactory,
IOptions <EventBusRabbitMqOptions> options,
ILogger <RabbitMqMessageSubscribe> logger)
{
_messageHandlerManager = messageHandlerManager;
_messageHandlerProvider = messageHandlerProvider;
_rabbitMqMessageConsumerFactory = rabbitMqMessageConsumerFactory;
_options = options;
_logger = logger;
RabbitMqMessageConsumerDic = new ConcurrentDictionary <string, IRabbitMqMessageConsumer>();
messageHandlerManager.OnEventRemoved += SubsManager_OnEventRemoved;
}
public DefaultMessageDispatcher(
ITypeNameProvider typeNameProvider,
IMessageHandlerProvider handlerProvider,
ITwoMessageHandlerProvider twoMessageHandlerProvider,
IThreeMessageHandlerProvider threeMessageHandlerProvider,
IOHelper ioHelper,
ILoggerFactory loggerFactory)
{
_typeNameProvider = typeNameProvider;
_handlerProvider = handlerProvider;
_twoMessageHandlerProvider = twoMessageHandlerProvider;
_threeMessageHandlerProvider = threeMessageHandlerProvider;
_ioHelper = ioHelper;
_logger = loggerFactory.Create(GetType().FullName);
}
/// <summary>
/// 处理中消息邮箱
/// </summary>
/// <param name="businessKey">业务键</param>
/// <param name="subscriber">订阅者</param>
/// <param name="messageHandlerProvider">消息处理器提供者</param>
/// <param name="processingMessageHandler">处理中消息处理器</param>
/// <param name="continueWhenHandleFail">相同BusinessKey的消息处理失败后，是否继续推进</param>
/// <param name="retryIntervalSeconds">重试间隔秒数（-1 表示不重试）</param>
/// <param name="batchSize">批量处理大小</param>
public DefaultProcessingMessageMailbox(
string businessKey,
string subscriber,
IMessageHandlerProvider messageHandlerProvider,
IProcessingMessageHandler processingMessageHandler,
bool continueWhenHandleFail,
int retryIntervalSeconds,
int batchSize)
{
if (string.IsNullOrEmpty(businessKey))
{
throw new ArgumentNullException(nameof(businessKey));
}
_processingMessageDict = new ConcurrentDictionary <long, ProcessingMessage>();
_problemProcessingMessages = new ConcurrentDictionary <long, ProcessingMessageWithCreatedTime>();
_logger = LoggerManager.GetLogger(GetType());
_nextSequence = 1;
_consumingSequence = 1;
LastActiveTime = DateTime.Now;
Locker = new SpinLock();
BusinessKey = businessKey;
Subscriber = subscriber;
_messageHandlerProvider = messageHandlerProvider;
_processingMessageHandler = processingMessageHandler;
_continueWhenHandleFail = continueWhenHandleFail;
if (retryIntervalSeconds != -1)
{
_retryIntervalSeconds = retryIntervalSeconds <= 0 ? 1 : retryIntervalSeconds;
_retryEnabled = true;
}
else
{
_retryIntervalSeconds = Int32.MaxValue;
_retryEnabled = false;
}
_batchSize = batchSize <= 0 ? 1000 : batchSize;
_ctsWhenDisposing = new CancellationTokenSource();
if (_continueWhenHandleFail && _retryEnabled)
{
ProcessProblemMessage();
}
}
/// <summary>
/// 默认消息处理器
/// </summary>
/// <param name="subscriber">订阅者</param>
/// <param name="messageHandlerProvider">消息处理器提供者</param>
/// <param name="mailboxProvider">Mailbox提供者</param>
/// <param name="continueWhenHandleFail">相同BusinessKey的消息处理失败后，是否继续推进</param>
/// <param name="retryIntervalSeconds">重试间隔秒数（-1 表示不重试）</param>
/// <param name="mailboxEliminationStrategy">mailbox淘汰策略，默认为LFU</param>
/// <param name="mailboxTimeoutSeconds">mailbox超时秒数</param>
/// <param name="cleanInactiveMailboxIntervalSeconds">清理不活跃邮箱间隔秒数</param>
/// <param name="batchSize">批量处理大小</param>
public DefaultMessageProcessor(
string subscriber,
IMessageHandlerProvider messageHandlerProvider,
IProcessingMessageMailboxProvider mailboxProvider,
bool continueWhenHandleFail,
int retryIntervalSeconds,
IEliminationStrategy mailboxEliminationStrategy = null,
int mailboxTimeoutSeconds = 600,
int cleanInactiveMailboxIntervalSeconds = 10,
int batchSize = 1000)
{
if (messageHandlerProvider == null)
{
throw new ArgumentNullException(nameof(messageHandlerProvider));
}
if (mailboxProvider == null)
{
throw new ArgumentNullException(nameof(mailboxProvider));
}
_mailboxDict = new ConcurrentDictionary <string, IProcessingMessageMailbox>();
_logger = LoggerManager.GetLogger(GetType());
_cleanInactiveMailboxTimer = new Timer(CleanInactiveMailbox);
_subscriber = subscriber;
_messageHandlerProvider = messageHandlerProvider;
_mailboxProvider = mailboxProvider;
_mailboxEliminationStrategy = mailboxEliminationStrategy ?? new LfuStrategy();
_eliminationKeyDict = new ConcurrentDictionary <string, bool>();
_continueWhenHandleFail = continueWhenHandleFail;
_retryIntervalSeconds = retryIntervalSeconds;
_mailboxTimeoutSeconds = mailboxTimeoutSeconds;
_cleanInactiveMailboxIntervalSeconds = cleanInactiveMailboxIntervalSeconds;
_batchSize = batchSize;
_mailboxEliminationStrategy.OnKnockedOut += (sender, e) =>
{
foreach (var key in e.Keys)
{
_eliminationKeyDict.TryAdd(key, false);
}
};
}
public JoinedLobby(LobbyPlugin owner, LobbyDataPacket data, IMessageHandlerProvider client)
{
Data = data;
client.SetHandler((ushort)OpCodes.LobbyMemberPropertyChanged, HandleMemberPropertyChanged);
client.SetHandler((ushort)OpCodes.LeftLobby, HandleLeftLobbyMsg);
client.SetHandler((ushort)OpCodes.LobbyChatMessage, HandleLobbyChatMessageMsg);
client.SetHandler((ushort)OpCodes.LobbyMemberJoined, HandleLobbyMemberJoinedMsg);
client.SetHandler((ushort)OpCodes.LobbyMemberLeft, HandleLobbyMemberLeftMsg);
client.SetHandler((ushort)OpCodes.LobbyStateChange, HandleLobbyStateChangeMsg);
client.SetHandler((ushort)OpCodes.LobbyStatusTextChange, HandleLobbyStatusTextChangeMsg);
client.SetHandler((ushort)OpCodes.LobbyMemberChangedTeam, HandlePlayerTeamChangeMsg);
client.SetHandler((ushort)OpCodes.LobbyMemberReadyStatusChange, HandleLobbyMemberReadyStatusChangeMsg);
client.SetHandler((ushort)OpCodes.LobbyMasterChange, HandleLobbyMasterChangeMsg);
client.SetHandler((ushort)OpCodes.LobbyPropertyChanged, HandleLobbyPropertyChanged);
Properties = data.LobbyProperties;
Members = data.Players;
Teams = data.Teams;
_lobbyServer = owner;
}
public NotifyController(IMessageHandlerProvider handlerProvider)
{
_provider = handlerProvider;
}
public async Task <bool> HandleAsync(string subscriber, ProcessingMessage processingMessage, IMessageHandlerProvider messageHandlerProvider)
{
_queue.Enqueue(processingMessage);
await Task.Delay(10);
await processingMessage.CompleteAsync(new MessageExecutingResult(MessageExecutingStatus.Success, processingMessage.Message, subscriber));
return(true);
}
// TODO: Do we allow handler reload? How can consistency be guaranteed for the remote routing system?
private ValueTask ReloadHandlersAsync()
{
_messageHandlerProvider = null; // Volatile write op.
return(default);
public MessagePipeline(IMessageHandlerProvider messageHandlerProvider, IMessageFormatter messageFormatter, ILifetimeScope lifetimeScope, RabbitMessage rabbitMsg, Logger logger)
: base(messageHandlerProvider, lifetimeScope, GetMessage(messageFormatter, rabbitMsg.Body), logger)
{
}
private HandlerFindResult GetMessageHandler(string subscriber, ProcessingMessage processingMessage, IMessageHandlerProvider messageHandlerProvider, out IDictionary <IMessage, IEnumerable <IMessageHandlerProxy> > messageHandlerProxyDict)
{
messageHandlerProxyDict = new Dictionary <IMessage, IEnumerable <IMessageHandlerProxy> >();
var messageGroup = processingMessage.Message as MessageGroup;
if (messageGroup != null)
{
if (messageGroup.Messages == null || !messageGroup.Messages.Any())
{
return(HandlerFindResult.NoMessage);
}
foreach (var message in messageGroup.Messages)
{
var messageType = message.GetType();
var handlerProxyList = messageHandlerProvider.GetHandlers(messageType, subscriber);
if (handlerProxyList != null && handlerProxyList.Any())
{
messageHandlerProxyDict.Add(message, handlerProxyList);
}
else if (!messageGroup.NoHandlerAllowed)
{
messageHandlerProxyDict.Clear();
return(HandlerFindResult.NotFound);
}
}
return(HandlerFindResult.Found);
}
else
{
var messageType = processingMessage.Message.GetType();
var handlerProxyList = messageHandlerProvider.GetHandlers(messageType, subscriber);
if (handlerProxyList == null || handlerProxyList.Count() == 0)
{
return(HandlerFindResult.NotFound);
}
else
{
messageHandlerProxyDict.Add(processingMessage.Message, handlerProxyList);
return(HandlerFindResult.Found);
}
}
}
/// <summary>
/// 创建邮箱
/// </summary>
/// <param name="businessKey">业务键</param>
/// <param name="subscriber">订阅者</param>
/// <param name="messageHandlerProvider">消息处理器提供者</param>
/// <param name="continueWhenHandleFail">相同BusinessKey的消息处理失败后，是否继续推进</param>
/// <param name="retryIntervalSeconds">重试间隔秒数（-1 表示不重试）</param>
/// <param name="batchSize">批量处理大小</param>
/// <returns></returns>
public IProcessingMessageMailbox CreateMailbox(string businessKey, string subscriber, IMessageHandlerProvider messageHandlerProvider, bool continueWhenHandleFail, int retryIntervalSeconds, int batchSize)
{
return(new DefaultProcessingMessageMailbox(businessKey, subscriber, messageHandlerProvider, _processingMessageHandler, continueWhenHandleFail, retryIntervalSeconds, batchSize));
}
protected abstract void AddBrokerHandlers(IMessageHandlerProvider provider);
protected override void AddBrokerHandlers(IMessageHandlerProvider provider)
{
}
public RpcMessagePipeline(IMessageHandlerProvider messageHandlerProvider, ILifetimeScope lifetimeScope, IMessage message, Logger logger)
: base(messageHandlerProvider, lifetimeScope, message, logger)
{
}
/// <summary>
/// 处理
/// </summary>
/// <param name="subscriber">订阅者</param>
/// <param name="processingMessage">处理中消息</param>
/// <param name="messageHandlerProvider">消息处理器提供者</param>
/// <returns></returns>
public async Task <bool> HandleAsync(string subscriber, ProcessingMessage processingMessage, IMessageHandlerProvider messageHandlerProvider)
{
var message = processingMessage.Message;
var messageTypeName = message.GetMessageTypeName();
var findResult = GetMessageHandler(subscriber, processingMessage, messageHandlerProvider, out IDictionary <IMessage, IEnumerable <IMessageHandlerProxy> > messageHandlerProxyDict);
if (findResult == HandlerFindResult.Found)
{
return(await HandleInternal(subscriber, processingMessage, messageHandlerProxyDict).ConfigureAwait(false));
}
else if (findResult == HandlerFindResult.NotFound)
{
var warnMessage = $"No message handler found of message, businessKey: {message.BusinessKey}, subscriber: {subscriber}, messageId: {message.Id}, messageType: {messageTypeName}";
await CompleteMessageAsync(subscriber, processingMessage, MessageExecutingStatus.HandlerNotFound, typeof(string).FullName, warnMessage).ConfigureAwait(false);
return(true);
}
else
{
await CompleteMessageAsync(subscriber, processingMessage, MessageExecutingStatus.Success, string.Empty, string.Empty).ConfigureAwait(false);
return(true);
}
}
private static IEnumerable <RouteRegistration> GetRouteRegistrations(IMessageHandlerProvider messageHandlerProvider)
{
if (messageHandlerProvider == null)
{
throw new ArgumentNullException(nameof(messageHandlerProvider));
}
Route GetRoute(IMessageHandlerRegistration handlerRegistration)
{
return(new Route(handlerRegistration.MessageType.GetUnqualifiedTypeName()));
}
RouteRegistrationOptions GetRouteOptions(IMessageHandlerRegistration handlerRegistration)
{
var result = RouteRegistrationOptions.Default;
if (handlerRegistration.IsPublishOnly())
{
result |= RouteRegistrationOptions.PublishOnly;
}
if (handlerRegistration.IsTransient())
{
result |= RouteRegistrationOptions.Transient;
}
if (handlerRegistration.IsLocalDispatchOnly())
{
result |= RouteRegistrationOptions.LocalDispatchOnly;
}
return(result);
}
RouteRegistrationOptions CombineRouteOptions(IEnumerable <RouteRegistrationOptions> options)
{
var result = RouteRegistrationOptions.Default;
var firstOption = true;
foreach (var option in options)
{
if (firstOption)
{
result = option;
}
else
{
result &= option;
}
firstOption = false;
}
return(result);
}
return(messageHandlerProvider
.GetHandlerRegistrations()
.GroupBy(GetRoute, (route, handlerRegistrations) => new RouteRegistration(route, CombineRouteOptions(handlerRegistrations.Select(GetRouteOptions)))));
}
public SocketClient(string remoteName, IMessageHandlerProvider messageHandlerFactory)
{
Contract.Requires(messageHandlerFactory != null);
this.RemoteName = remoteName;
this._messageHandler = messageHandlerFactory.Create();
}
public RpcServer(IMessageHandlerProvider messageHandlerProvider, RabbitMQ.Client.MessagePatterns.Subscription subscription, ConcurrentQueue<RabbitMessage> queue)
: base(subscription)
{
_messageHandlerProvider = messageHandlerProvider;
_queue = queue;
}
public MessageSubscriber(IMessageHandlerProvider messageHandlerProvider, IRabbitConnection connection, IMessageFormatter messageFormatter, Logger logger)
: base(messageHandlerProvider, connection, messageFormatter, logger)
{
}
