public MqttMessage Publish(MqttMessage mqttMessage)
{
// todo: Check for connectivity? Or QoS level if message will be retained
if (mqttMessage.GetRawMessage() == null || mqttMessage.GetRawMessage().Length == 0)
{
mqttMessage.messageId = client.Publish(mqttMessage.GetRawTopic(),
Encoding.UTF8.GetBytes(mqttMessage.message),
MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE,
mqttMessage.retain);
}
else
{
mqttMessage.messageId = client.Publish(mqttMessage.GetRawTopic(),
mqttMessage.rawMessage,
MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE,
mqttMessage.retain);
}
if (mqttMessage.messageId > 0)
{
MessagePublished?.Invoke(mqttMessage);
}
return(mqttMessage);
}
public MqttMessage Publish(MqttMessage message)
{
var success = SometimesFalse();
if (!success)
{
Log.Verbose($"Randomly failing Publish call for {message.GetRawTopic()}: {message.message}");
}
if (success)
{
message.messageId = _messageId++;
MessagePublished?.Invoke(message);
message.messageId = _messageId++;
/*
* Task.Run(() =>
* {
* //System.Threading.Thread.Sleep(GetRandom());
* //message.prependDeviceId = false;
* MessageReceivedString?.Invoke(message);
* });
*/
System.Threading.Thread.Sleep(GetRandom(100));
MessageReceivedString?.Invoke(message);
}
return(message);
}
public void Run()
{
new TaskFactory().StartNew(() =>
{
while (true)
{
// Send messages only if we have something to send and Relay is ready to receive messages
if (_backpressureNeeded || _systemEvents.Count < 1)
{
// wait for load on relay to slow down
Thread.Sleep(2000);
continue;
}
var systemEvent = _systemEvents.Dequeue();
Thread.Sleep(100);
Console.WriteLine($"Passing message with command {systemEvent.Command} of type {systemEvent.MessageType} to relay");
MessagePublished?.Invoke(this, new Message
{
Command = systemEvent.Command,
MessageType = systemEvent.MessageType
});
}
});
}
private void OnMessagePublished(string topic, string payload)
{
MessagePublished?.Invoke(this, new MessagePublishedEventArgs()
{
Topic = topic, Payload = payload
});
}
public void PublishMessage(RabbitMessage message)
{
var queueMessage = message.Copy();
queueMessage.Queue = Name;
Messages.Enqueue(queueMessage);
MessagePublished?.Invoke(this, queueMessage);
}
private void DispatchMulticastMessage(MulticastTransportOperation multicastTransportOperation)
{
try
{
MessagePublished?.Invoke(multicastTransportOperation);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public async Task <IActionResult> PublishMessage(PublishMessageViewModel model)
{
var currentUser = await GetCurrentUserAsync();
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.File1 != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "Files");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.File1.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.File1.CopyTo(new FileStream(filePath, FileMode.Create));
}
MessagePublished message = new MessagePublished
{
Content = model.Content,
DatePublished = DateTime.Now,
YoutubeLink1 = model.YoutubeLink1,
File1 = uniqueFileName,
UserEmail = currentUser.Email,
Year = currentUser.Year
};
database.Add(message);
database.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "It wasn't possible to send your message.");
}
return(View(model));
}
public void Publish(object sender, MQTTMessageArgs args)
{
numPublishedMessages++;
receivedMessages.Add(args);
MessagePublished?.Invoke(this, args);
}
private void When(MessagePublished evt)
{
Id = evt.Id;
_publishers.Add(evt.Author);
}
public static Message Publish(IEventPublisher eventPublisher, UserId author, string content)
{
var messagePublished = new MessagePublished(MessageId.Generate(), author, content);
return(new Message(eventPublisher, messagePublished));
}
private Message(IEventPublisher eventPublisher, MessagePublished evt)
{
PublishEvent(eventPublisher, evt);
}
protected virtual void OnMessagePublished(PublishMessageEventArgs e)
{
MessagePublished?.Invoke(this, e);
}
public TimelineMessageProjection(UserId ownerId, MessagePublished evt)
: this(ownerId, evt.Author, evt.Content, evt.Id)
{
}
public MessageDescription(MessagePublished evt)
: this(evt.Author, evt.Content)
{
}