public void NewChirpArrived(ChirperMessage chirp)
{
if (!this.IsPublisher)
{
Console.WriteLine(
@"New chirp from @{0} at {1} on {2}: {3}",
chirp.PublisherAlias,
chirp.Timestamp.ToShortTimeString(),
chirp.Timestamp.ToShortDateString(),
chirp.Message);
}
}
private ChirperMessage CreateNewChirpMessage(string message)
{
ChirperMessage chirp = new ChirperMessage();
chirp.PublisherId = State.UserId;
chirp.PublisherAlias = State.UserAlias;
chirp.Timestamp = DateTime.Now;
chirp.Message = message;
if (chirp.Message.Length > MAX_MESSAGE_LENGTH)
{
chirp.Message = message.Substring(0, MAX_MESSAGE_LENGTH);
}
return(chirp);
}
private void ManagerOnMNewMessages(IChirperMessage message)
{
try {
var msg = new ChirperMessage {
SenderID = (int)message.senderID,
SenderName = message.senderName,
Text = message.text
};
_messages.Add(msg);
}
catch (Exception ex) {
WebServer.Log($"ChirpRetriever OnMNewMessages: {ex}");
}
}
public async Task PublishMessage(string message)
{
ChirperMessage chirp = CreateNewChirpMessage(message);
if (logger.IsVerbose)
{
logger.Verbose("{0} Publishing new chirp message = {1}.", Me, chirp);
}
State.MyPublishedMessages.Enqueue(chirp);
// only relevant when not using fixed queue
while (State.MyPublishedMessages.Count > PublishedMessagesCacheSize) // to keep not more than the max number of messages
{
State.MyPublishedMessages.Dequeue();
}
await WriteStateAsync();
List <Task> promises = new List <Task>();
if (State.Followers.Count > 0)
{
// Notify any subscribers that a new chirp has published
if (logger.IsVerbose)
{
logger.Verbose("{0} Sending new chirp message to {1} subscribers.", Me, State.Followers.Count);
}
foreach (IChirperSubscriber subscriber in State.Followers.Values)
{
promises.Add(subscriber.NewChirp(chirp));
}
}
if (viewers.Count > 0)
{
// Notify any viewers that a new chirp has published
if (logger.IsVerbose)
{
logger.Verbose("{0} Sending new chirp message to {1} viewers.", Me, viewers.Count);
}
viewers.Notify(
v => v.NewChirpArrived(chirp)
);
}
await Task.WhenAll(promises.ToArray());
}
/// <summary>
/// Invoked when the Chirper receives a new message
/// </summary>
/// <param name="message">New message.</param>
public void OnNewMessage(IChirperMessage message)
{
try {
var msg = new ChirperMessage {
SenderID = (int)message.senderID,
SenderName = message.senderName,
Text = message.text,
Time = Singleton <SimulationManager> .instance.m_currentGameTime,
};
messages.Add(msg);
SendJson(msg);
}
catch (Exception ex) {
Log($"OnNewMessage: {ex}");
}
}
private void ManagerOnMNewMessages(IChirperMessage message)
{
try
{
var msg = new ChirperMessage
{
SenderID = (int)message.senderID,
SenderName = message.senderName,
Text = message.text
};
_messages.Add(msg);
}
catch (Exception ex)
{
OnLogMessage(ex.ToString());
}
}
public Task NewChirp(ChirperMessage chirp)
{
if (logger.IsVerbose)
{
logger.Verbose("{0} Received chirp message = {1}", Me, chirp);
}
State.RecentReceivedMessages.Enqueue(chirp);
// only relevant when not using fixed queue
while (State.MyPublishedMessages.Count > State.PublishedMessagesCacheSize) // to keep not more than the max number of messages
{
State.MyPublishedMessages.Dequeue();
}
if (viewers.Count > 0)
{
// Notify any viewers that a new chirp has published
if (logger.IsVerbose)
{
logger.Verbose("{0} Sending received chirp message to {1} viewers", Me, viewers.Count);
}
viewers.Notify(
v => v.NewChirpArrived(chirp)
);
}
#if DEBUG
const string busywait = "#busywait";
var i = chirp.Message.IndexOf(busywait, StringComparison.Ordinal);
int n;
if (i >= 0 && Int32.TryParse(chirp.Message.Substring(i + busywait.Length + 1), out n))
{
var watch = new Stopwatch();
watch.Start();
while (watch.ElapsedMilliseconds < n)
{
// spin
}
watch.Stop();
}
#endif
return(TaskDone.Done);
}
public async Task NewChirpAsync(ChirperMessage chirp)
{
this.logger.LogInformation("{@GrainType} {@GrainKey} received chirp message = {@Chirp}",
this.GrainType, this.GrainKey, chirp);
this.State.RecentReceivedMessages.Enqueue(chirp);
// only relevant when not using fixed queue
while (this.State.MyPublishedMessages.Count > PublishedMessagesCacheSize) // to keep not more than the max number of messages
{
this.State.MyPublishedMessages.Dequeue();
}
await this.WriteStateAsync();
// notify any viewers that a new chirp has been received
this.logger.LogInformation("{@GrainType} {@GrainKey} sending received chirp message to {@ViewerCount} viewers",
this.GrainType, this.GrainKey, this.viewers.Count);
this.viewers.ForEach(_ => _.NewChirp(chirp));
}
/// <inheritdoc />
public void NewChirp(ChirperMessage message)
{
AnsiConsole.MarkupLine("[[[dim]{0}[/]]] [aqua]{1}[/] [bold yellow]chirped:[/] {2}", message.Timestamp.LocalDateTime, message.PublisherUserName, message.Message);
}
/// <inheritdoc />
public void NewChirp(ChirperMessage message)
{
Console.WriteLine($"Observed: Account {message.PublisherUserName} chirped '{message.Message}'");
}
