public async Task<UpdateMessageResponse> UpdateMessageAsync(string queueName, string messageId, string popReceipt, int visibilityTimeout = 30, string messageData = null)
{
var request = new UpdateMessageRequest(_account, queueName, messageId, popReceipt, visibilityTimeout, messageData);
var response = await request.ExecuteAsync(_optionalRetryPolicy);
return response.Payload;
}
private Task RunEditQueue(CancellationToken cancelToken)
{
return Task.Run(async () =>
{
try
{
while (!cancelToken.IsCancellationRequested)
{
MessageEdit edit;
while (_pendingEdits.TryPeek(out edit) && edit.Message.State != MessageState.Queued)
{
if (_pendingEdits.TryDequeue(out edit))
{
DecrementCount();
if (edit.Message.State == MessageState.Normal)
{
try
{
var request = new UpdateMessageRequest(edit.Message.Channel.Id, edit.Message.Id)
{
Content = edit.NewText
};
await _rest.Send(request).ConfigureAwait(false);
}
catch (Exception ex) { _logger.Error($"Failed to edit message {edit.Message.Path}", ex); }
}
}
}
await Task.Delay(Discord.DiscordConfig.MessageQueueInterval).ConfigureAwait(false);
}
}
catch (OperationCanceledException) { }
});
}
internal async Task Edit(Message msg, string text)
{
if (msg.State == MessageState.Normal)
{
try
{
var request = new UpdateMessageRequest(msg.Channel.Id, msg.Id)
{
Content = text
};
await _client.ClientAPI.Send(request).ConfigureAwait(false);
}
catch (Exception ex) { msg.State = MessageState.Failed; _logger.Error("Failed to edit message", ex); }
}
}
public async Task Edit(string text)
{
if (text == null) throw new ArgumentNullException(nameof(text));
var channel = Channel;
if (text.Length > DiscordConfig.MaxMessageSize)
throw new ArgumentOutOfRangeException(nameof(text), $"Message must be {DiscordConfig.MaxMessageSize} characters or less.");
if (Client.Config.UseMessageQueue)
Client.MessageQueue.QueueEdit(this, text);
else
{
var request = new UpdateMessageRequest(Channel.Id, Id)
{
Content = text
};
await Client.ClientAPI.Send(request).ConfigureAwait(false);
}
}
internal Task Run(CancellationToken cancelToken, int interval)
{
_nextWarning = WarningStart;
return Task.Run(async () =>
{
MessageQueueItem queuedMessage;
while (!cancelToken.IsCancellationRequested)
{
await Task.Delay(interval).ConfigureAwait(false);
Count = _pending.Count;
if (Count >= _nextWarning)
{
_nextWarning *= 2;
_logger.Warning($"Queue is backed up, currently at {Count} messages.");
}
else if (Count < WarningStart) //Reset once the problem is solved
_nextWarning = WarningStart;
while (_pending.TryDequeue(out queuedMessage))
{
try
{
if (queuedMessage.Id == 0)
{
var request = new SendMessageRequest(queuedMessage.ChannelId)
{
Content = queuedMessage.Text,
Nonce = GenerateNonce().ToIdString(),
IsTTS = queuedMessage.IsTTS
};
await _client.ClientAPI.Send(request).ConfigureAwait(false);
}
else
{
var request = new UpdateMessageRequest(queuedMessage.ChannelId, queuedMessage.Id)
{
Content = queuedMessage.Text
};
await _client.ClientAPI.Send(request).ConfigureAwait(false);
}
}
catch (WebException) { break; }
catch (HttpException) { /*msg.State = MessageState.Failed;*/ }
catch (Exception ex) { _logger.Error(ex); }
}
}
});
}
