private async Task AnalyseFileRows(ConsumerConnectedArgs obj, List <Model.Entities.Message> rows)
{
foreach (var row in rows)
{
var consumerMessage = new ConsumerMessage()
{
Consumer = obj.ConsumerName,
Message = new Message()
{
Tenant = obj.Tenant,
Product = obj.Product,
Component = obj.Component,
Topic = obj.Topic,
Id = row.MessageId,
MessageRaw = row.Payload.JsonToObject <object>()
}
};
foreach (var xNode in _xNodeEventService.GetXNodeConnectionRepository().GetAllServices())
{
//Transmit the message to the other nodes.
await xNode.Value.Values.ToList()[0].GetHubConnection().SendAsync("TransmitMessagesToConsumer", consumerMessage);
}
}
}
//TODO:
//private IOutageMapper _outageMapper;
//public ConsumerMapper(IOutageMapper outageMapper)
//{
// //_outageMapper = outageMapper;
//}
public ConsumerViewModel MapConsumer(ConsumerMessage consumer)
=> new ConsumerViewModel
{
Id = consumer.ConsumerId,
Mrid = consumer.ConsumerMRID,
FirstName = consumer.FirstName,
LastName = consumer.LastName,
ActiveOutages = new List <ActiveOutageViewModel>(), //TODO: _outageMapper.MapActiveOutages(consumer.ActiveOutages),
ArchivedOutages = new List <ArchivedOutageViewModel>(), //TODO: _outageMapper.MapArchivedOutages(consumer.ArchivedOutages)
};
/// <summary>
/// Inner actor message routing to their handling methods.
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
private async Task ProcessMessage(ConsumerMessage message)
{
try
{
switch (message.MessageType)
{
case ConsumerMessageType.Start:
await HandleStart(message.MessageValue.Topic);
break;
case ConsumerMessageType.Stop:
HandleStop(message.MessageValue.Topic);
break;
case ConsumerMessageType.FetchResponse:
await HandleFetchResponse(message.MessageValue.FetchResponse);
break;
case ConsumerMessageType.OffsetResponse:
await HandleOffsetResponse(message.MessageValue.OffsetResponse);
break;
case ConsumerMessageType.CheckPostponed:
await EnsureHasRoutingTable();
goto case ConsumerMessageType.CheckPostponedAfterRoutingTableChange;
case ConsumerMessageType.CheckPostponedAfterRoutingTableChange:
CheckPostponed();
break;
case ConsumerMessageType.StartSubscription:
await HandleStartSubscription(message.MessageValue.Subscription);
break;
case ConsumerMessageType.Heartbeat:
await HandleHeartbeat();
break;
case ConsumerMessageType.Commit:
await CheckCommit(message.MessageValue.CommitMsg);
break;
}
}
catch (Exception ex)
{
InternalError(ex);
}
}
public Measure(ConsumerMessage message) : this()
{
Produced = message.Produced;
MapperActivated = message.MapperActivated;
MapperConnected = message.MapperConnected;
MapperPreDequeued = message.MapperPreDequeued;
MapperPostDequeued = message.MapperPostDequeued;
MapperReceived = message.MapperReceived;
MapperSent = message.MapperSent;
ServiceReceived = message.ServiceReceived;
ServiceSent = message.ServiceSent;
ServiceResponded = message.ServiceResponded;
Consumed = message.Consumed;
}
public ConsumerMessage MapConsumer(Consumer consumer)
{
ConsumerMessage consumerMessage = new ConsumerMessage()
{
ConsumerId = consumer.ConsumerId,
ConsumerMRID = consumer.ConsumerMRID,
FirstName = consumer.FirstName,
LastName = consumer.LastName,
ActiveOutages = new List <ActiveOutageMessage>(), //TODO: outageMapper.MapActiveOutages(consumer.ActiveOutages),
ArchivedOutages = new List <ArchivedOutageMessage>(), //TODO: outageMapper.MapArchivedOutages(consumer.ArchivedOutages)
};
return(consumerMessage);
}
/// <summary>
/// 异步获取队列消息
/// ConsumerMessage.ConsumerMessageHandler void xxx(string msg)
/// </summary>
/// <param name="queue_name"></param>
/// <param name="AsyncCallBack"></param>
/// <returns></returns>
public Boolean ReceiveMessageAsync(string queue_name, ConsumerMessage.ConsumerMessageHandler AsyncCallBack)
{
try
{
var client = new ConsumerMessage(uri, userName, passWord, queue_name);
client.ConsumerMessageEvent += AsyncCallBack;
return(true);
}
catch (Exception ex)
{
Logger.Exception(ex);
throw;
}
}
public Measure(ConsumerMessage message)
: this()
{
Produced = message.Produced;
MapperActivated = message.MapperActivated;
MapperConnected = message.MapperConnected;
MapperPreDequeued = message.MapperPreDequeued;
MapperPostDequeued = message.MapperPostDequeued;
MapperReceived = message.MapperReceived;
MapperSent = message.MapperSent;
ServiceReceived = message.ServiceReceived;
ServiceSent = message.ServiceSent;
ServiceResponded = message.ServiceResponded;
Consumed = message.Consumed;
}
public override async Task <bool> OnMessageReceived(ConsumerMessage <T> message)
{
using var s = this.provider.CreateScope();
var consumers = s.ServiceProvider.ResolveConsumerOptional <T>();
var model = message.MessageModel;
foreach (var c in consumers)
{
#if DEBUG
this.logger.LogInformation($"消费：{model.ToJson()}");
#endif
var data = new BasicMessageConsumeContext <T>(model);
await c.Consume(data);
}
return(true);
}
public async Task TransmitMessageToConsumer(ConsumerMessage consumerMessage)
{
string consumerId = $"{consumerMessage.Message.Tenant}{consumerMessage.Message.Product}{consumerMessage.Message.Component}{consumerMessage.Message.Topic}|{consumerMessage.Consumer}";
var consumer = _consumerHubRepository.GetConsumerById(consumerId);
if (consumer != null)
{
// skip external consumers
if (consumer.Connections.Count == 0)
{
return;
}
if (consumer.CurrentConnectionIndex >= consumer.Connections.Count)
{
consumer.CurrentConnectionIndex = 0;
}
if (consumer.SubscriptionType == SubscriptionType.Exclusive || consumer.SubscriptionType == SubscriptionType.Failover)
{
consumer.CurrentConnectionIndex = 0;
}
await _hub.Clients.Client(consumer.Connections[consumer.CurrentConnectionIndex]).MessageSent(new Model.Consumers.Events.MessageSentDetails()
{
Id = consumerMessage.Message.Id,
Tenant = consumerMessage.Message.Tenant,
Product = consumerMessage.Message.Product,
Component = consumerMessage.Message.Component,
Topic = consumerMessage.Message.Topic,
MessageRaw = consumerMessage.Message.MessageRaw,
Headers = consumerMessage.Message.Headers,
SentDate = consumerMessage.Message.SentDate
});
consumer.CountMessagesConsumedSinceConnected++;
if (consumer.SubscriptionType == SubscriptionType.Shared)
{
consumer.CurrentConnectionIndex++;
}
}
}
public MainViewModel()
{
Messages = new ObservableCollection <GetMessage>();
//Disp = Dispatcher.CurrentDispatcher;
_consumer = new ConsumerMessage();
}
public abstract Task <bool> OnMessageReceived(ConsumerMessage <T> message);
