public void Can_Get_Total_Channel_Messages()
{
const long chatId = 2424;
const string userName = "******";
var firstMessage = new MessageStatistic
{
ChatId = chatId,
CharsCount = 10,
MessagesCount = 23,
UserName = userName,
Day = DateTime.UtcNow
};
var secondMessage = new MessageStatistic
{
ChatId = chatId,
CharsCount = 33,
MessagesCount = 66,
UserName = userName,
Day = DateTime.UtcNow
};
messageStatisticCollection.InsertMany(new[] { firstMessage, secondMessage });
var result = statisticWrapper.GetTotalOrderedStatisticsAsync(chatId).Result.Single();
result.ChatId.Should().Be(chatId);
result.UserName.Should().Be(userName);
result.CharsCount.Should().Be(firstMessage.CharsCount + secondMessage.CharsCount);
result.MessagesCount.Should().Be(firstMessage.MessagesCount + secondMessage.MessagesCount);
}
public MyPeriodicalHandler(ILog log, MessageStatistic messageStatistic, RabbitTradeMonitoringSettings settings) :
// TODO: Sometimes, it is enough to hardcode the period right here, but sometimes it's better to move it to the settings.
// Choose the simplest and sufficient solution
base(nameof(MyPeriodicalHandler), (int)settings.TimeoutForReport.TotalMilliseconds, log)
{
_log = log;
_messageStatistic = messageStatistic;
_settings = settings;
}
private MessageStatistic RunStatistics(CliClient client, MessageControlFlags flags, string domain, int messageCount, Func <ulong, BaseCommand> createCommand)
{
ConcurrentDictionary <ulong, MessageEntry> messages = new ConcurrentDictionary <ulong, MessageEntry>();
client.OnCommand = (cmd) => ProcessCommandMessage(client, domain, messages, cmd);
DateTime startTimeStamp = DateTime.Now;
ulong objectId = (ulong)(client.ClientId * messageCount);
for (int i = 0; i < messageCount; i++)
{
objectId++;
BaseCommand command = createCommand(objectId);
ObjectCommandEnvelope commandEnv = new ObjectCommandEnvelope(client.ClientId, command, objectId);
messages.TryAdd(objectId, new MessageEntry {
RequestTimeStamp = DateTime.Now, ResponseTimeStamp = DateTime.MinValue, CommandEnvelope = commandEnv
});
client.ReliableMessaging.SendCommandEnvelope(commandEnv, flags);
TimeSpan waitTime = client.ReliableMessaging.SynchronizeMessages();
if (waitTime > TimeSpan.Zero)
{
Thread.Sleep((int)waitTime.TotalMilliseconds);
}
}
for (; ;)
{
if (DateTime.Now - client.LastMessageReceived > TimeSpan.FromSeconds(5))
{
break;
}
Thread.Sleep(200);
TimeSpan waitTime = client.ReliableMessaging.SynchronizeMessages();
if (waitTime > TimeSpan.Zero)
{
Thread.Sleep((int)waitTime.TotalMilliseconds);
}
}
TimeSpan sumLatency = TimeSpan.Zero;
int countSuccess = 0;
foreach (var value in messages.Values)
{
if (value.ResponseTimeStamp == DateTime.MinValue)
{
break;
}
countSuccess++;
sumLatency += value.ResponseTimeStamp - value.RequestTimeStamp;
}
MessageStatistic messageStatistic = new MessageStatistic();
messageStatistic.Duration = client.LastMessageReceived - startTimeStamp;
messageStatistic.MessagesTotal = messageCount;
messageStatistic.MessagesAnswered = countSuccess;
return(messageStatistic);
}
public MyRabbitSubscriber(
ILog log,
MessageStatistic messageStatistic,
string connectionString,
string exchangeName)
{
_log = log;
_messageStatistic = messageStatistic;
_connectionString = connectionString;
_exchangeName = exchangeName;
}
public async Task Run(CommandArgs args)
{
MessageStatistic data = Configuration.GetConfig <MessageStatistic>();
if (!await args.Source.CheckPermission())
{
string[] splits = args.Arg.Trim().Split(' ');
if (splits.Length > 0)
{
switch (splits[0])
{
case "reset":
lock (data.t)
data.t = new Dictionary <long, Dictionary <long, int> >();
data.Save();
await args.Callback("Record has been reset successfully.");
return;
case "set":
long gr = splits[1] == "~" ? args.Source.FromGroup : long.Parse(splits[1]);
long qq = splits[1] == "~" ? args.Source.FromQQ : long.Parse(splits[2]);
int val = int.Parse(splits[3]);
if (gr > 0 && qq > 0)
{
lock (data.t)
data.t[gr][qq] = val;
data.Save();
await args.Callback($"data changed [{gr},{qq}] => {val}.");
}
else
{
await args.Callback("Invalid argument.");
}
return;
}
}
}
string arg = args.Arg.Trim();
long group = 0L;
if (string.IsNullOrEmpty(arg))
{
group = args.Source.FromGroup;
}
else
{
long.TryParse(arg, out group);
}
if (group == 0L)
{
await args.Callback("Invalid group number specified");
return;
}
List <Tuple <long, int> > sort;
lock (data.t)
{
if (!data.t.ContainsKey(group))
{
args.Callback($"No record from the group {group} till now.");
return;
}
sort = new List <Tuple <long, int> >();
foreach (KeyValuePair <long, int> num in data.t[group])
{
sort.Add(new Tuple <long, int> (num.Key, num.Value));
}
}
sort.Sort(delegate(Tuple <long, int> var1, Tuple <long, int> var2)
{
return(var2.Item2 - var1.Item2);
});
string result = "";
try
{
for (int i = 0; i < 10; ++i)
{
result += $"{i + 1}.{await args.Source.Session.GetName(group, sort[i].Item1)} {sort[i].Item2}pcs\n";
}
}
catch (ArgumentOutOfRangeException) { }
await args.Callback(result);
}
