private async static void OnTimedEvent(object source, ElapsedEventArgs e)
{
var sqs = new AmazonSQSClient(RegionEndpoint.SAEast1);
var queueUrl = sqs.GetQueueUrlAsync("BariMessagesQueue").Result.QueueUrl;
var receiveMessageRequest = new ReceiveMessageRequest
{
QueueUrl = queueUrl,
MaxNumberOfMessages = 10
};
Console.WriteLine("Checking for new messages in the queue BariMessagesQueue...\n");
var receiveMessageResponse = sqs.ReceiveMessageAsync(receiveMessageRequest).Result;
var counter = receiveMessageResponse.Messages.Count;
foreach (var message in receiveMessageResponse.Messages)
{
Console.WriteLine("Message \n");
Console.WriteLine($" MessageId: {message.MessageId} \n");
Console.WriteLine($" ReceiptHandle: {message.ReceiptHandle} \n");
Console.WriteLine($" MD5OfBody: {message.MD5OfBody} \n");
Console.WriteLine($" Body: {message.Body} \n");
foreach (var atribute in message.Attributes)
{
Console.WriteLine($" Key:{atribute.Key} ");
Console.WriteLine($" Value:{atribute.Value} \n");
}
Console.WriteLine($" Cleaning a Message in Queue... \n");
var messageReceptHandle = message.ReceiptHandle;
var deleteResquest = new DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = messageReceptHandle
};
await sqs.DeleteMessageAsync(deleteResquest);
}
if (counter == 0)
{
Console.WriteLine("There is no new messages.\n");
}
else
{
Console.WriteLine($" {counter} New Messages Received. \n");
}
}
private static async Task <string> DeleteMessage(List <string> results, Message message, string queueUrl)
{
var deleteMessageRequest = new DeleteMessageRequest()
{
QueueUrl = queueUrl,
ReceiptHandle = message.ReceiptHandle
};
DeleteMessageResponse delResponse = await _sqsClient.DeleteMessageAsync(deleteMessageRequest);
return($"Message {message.Body} deleted with status {delResponse.HttpStatusCode}");
}
public static string Delete(string queue_url, string msg_id)
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
DeleteMessageRequest d_msgreq = new DeleteMessageRequest();
d_msgreq.QueueUrl = queue_url;
d_msgreq.ReceiptHandle = msg_id;
DeleteMessageResponse d_msgres = sqs.DeleteMessage(d_msgreq);
return("Deleted Message \n" + d_msgres.ResponseMetadata.ToString());
}
private void DeleteMessage(Message message)
{
Console.WriteLine($"\nDeleting message {message.MessageId} from queue...");
DeleteMessageRequest request = new DeleteMessageRequest
{
QueueUrl = _configuration["AWS:SQS:QueueUrl"],
ReceiptHandle = message.ReceiptHandle
};
Task.Run(async() => await _sqsClient.DeleteMessageAsync(request));
}
public bool DeleteMessage(DeleteMessageRequest request)
{ // Handle still has to be valid
if (request.ReceiptHandle.Equals(FakeBatchItemFailString, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
var item = GetInFlightItem(request.ReceiptHandle);
return(inFlighItems.TryRemove(request.ReceiptHandle, out item));
}
public bool Delete(DeleteMessageRequest request)
{
if (request == null)
{
return(false);
}
var response = SqsClient.DeleteMessage(request);
return(response != null);
}
void ReceiveMessageCallback(IAsyncResult ar)
{
try
{
var nativeQueue = (Queue)ar.AsyncState;
var response = nativeQueue.EndReceiveMessage(ar);
message = response.Message;
#if DEBUG
//Console.WriteLine("Async Receive message successfully, status code: {0}", response.HttpStatusCode);
//Console.WriteLine("----------------------------------------------------");
//Console.WriteLine("MessageId: {0}", message.Id);
//Console.WriteLine("ReceiptHandle: {0}", message.ReceiptHandle);
//Console.WriteLine("MessageBody: {0}", message.Body);
//Console.WriteLine("MessageBodyMD5: {0}", message.BodyMD5);
//Console.WriteLine("EnqueueTime: {0}", message.EnqueueTime);
//Console.WriteLine("NextVisibleTime: {0}", message.NextVisibleTime);
//Console.WriteLine("FirstDequeueTime: {0}", message.FirstDequeueTime);
//Console.WriteLine("DequeueCount: {0}", message.DequeueCount);
//Console.WriteLine("Priority: {0}", message.Priority);
//Console.WriteLine("----------------------------------------------------\n");
#endif
lock (lockObj)
{
ParseMessage(message.Body);
}
if (RunningState != null)
{
runCurrentDateTime = DateTime.Now;
RunningState("消息接受成功：" + runCurrentDateTime.ToString() + "，MessageBody：" + GetBase64ToString(message.Body));
}
_receiptHandle = message.ReceiptHandle;
var deleteMessageRequest = new DeleteMessageRequest(_receiptHandle);
nativeQueue.BeginDeleteMessage(deleteMessageRequest, DeleteMessageCallback, nativeQueue);
_autoSetEvent.Set();
}
catch (Exception ex)
{
if (RunningState != null)
{
runCurrentDateTime = DateTime.Now;
RunningState("ReceiveMessageCallback异常：" + runCurrentDateTime.ToString() + "，Exception：" + ex.Message + (ex.InnerException).Message);
}
Console.WriteLine("Async Receive message failed, exception info: " + ex.Message + ex.GetType().Name);
_autoSetEvent.Set();
}
}
/// <summary>
/// delete a message from the queue
/// </summary>
/// <param name="messageId"></param>
public bool DeleteMessage(string recieptHandle)
{
DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest
{
QueueUrl = _QueueUrl,
ReceiptHandle = recieptHandle
};
DeleteMessageResponse awsResp = _AmazonSQSClient.DeleteMessageAsync(deleteMessageRequest).Result;
return(awsResp.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
private void DeleteMessge(Amazon.SQS.Model.Message message)
{
DeleteMessageResponse objDeleteMessageResponse = new DeleteMessageResponse();
var deleteMessageRequest = new DeleteMessageRequest()
{
QueueUrl = sellerInfo.QueueUrl, ReceiptHandle = message.ReceiptHandle
};
objDeleteMessageResponse = sqsClient.DeleteMessage(deleteMessageRequest);
nLogger.Log(LogLevel.Info, string.Format("Message deleted: {0}", message.MessageId));
}
public async Task Listen()
{
IAmazonSQS sqs = new AmazonSQSClient(RegionEndpoint.USEast2);
//var queueUrl = sqs.GetQueueUrlAsync(Configuration.GetValue<string>("DASAppointmentsQueueName")).Result.QueueUrl;
var queueUrl = sqs.GetQueueUrlAsync(DASAppointmentsQueueName).Result.QueueUrl;
//while (!stoppingToken.IsCancellationRequested)
//{
try
{
var receiveMessageRequest = new ReceiveMessageRequest
{
QueueUrl = queueUrl
};
var receiveMessageResponse = sqs.ReceiveMessageAsync(receiveMessageRequest).Result;
foreach (var message in receiveMessageResponse.Messages)
{
var messageObj = JsonConvert.DeserializeObject <SQSMessageModel>(message.Body);
if (messageObj.Op == "bookAppointment")
{
if (AppointmentStorageService.Book(messageObj.Appointment).Result)
{
await AppointmentOpLogStorageService.AddLogEntry(messageObj.Appointment, "book");
await ConflictsManager.CheckAndAddConflict(messageObj.Appointment);
}
}
else
{
if (messageObj.Op == "cancelAppointment")
{
if (AppointmentStorageService.Cancel(messageObj.Appointment).Result)
{
await AppointmentOpLogStorageService.AddLogEntry(messageObj.Appointment, "cancel");
await ConflictsManager.RemoveConflicts(messageObj.Appointment);
}
}
}
var messageReceiveHandle = receiveMessageResponse.Messages.FirstOrDefault()?.ReceiptHandle;
var deleteRequest = new DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = messageReceiveHandle
};
await sqs.DeleteMessageAsync(deleteRequest);
}
}
catch (Exception ex)
{
//await Task.Delay(TimeSpan.FromSeconds(3),stoppingToken);
}
//}
}
public IRequestContext Marshall(DeleteMessageRequest input)
{
IRequestContext context = new RequestContext();
context.AddParametr("Action", input.ActionName);
context.AddParametr("Version", YandexMqConfig.DEFAULT_SERVICE_VERSION);
context.AddParametr("QueueUrl", input.QueueUrl);
context.AddParametr("ReceiptHandle", input.ReceiptHandle);
return(context);
}
/// <summary>
/// Delete message using ReceiptHandle
/// </summary>
/// <param name="input">Delete parameters</param>
/// <param name="awsOptions">AWS options</param>
/// <param name="cancellationToken"></param>
/// <returns>DeleteMessageResponse</returns>
public static async Task <dynamic> DeleteMessage([PropertyTab] DeleteParameters input, [PropertyTab] AWSOptions awsOptions, CancellationToken cancellationToken)
{
var sqsClient = GetAmazonSQSClient(awsOptions.UseDefaultCredentials, awsOptions.AWSCredentials, awsOptions.Region);
var delRequest = new DeleteMessageRequest
{
QueueUrl = input.QueueUrl,
ReceiptHandle = input.ReceiptHandle
};
return(await sqsClient.DeleteMessageAsync(delRequest, cancellationToken));
}
private bool DeleteRecordSQS(string QueueUrl, Message InMessage)
{
DeleteMessageRequest DeleteRequest = new DeleteMessageRequest
{
QueueUrl = QueueUrl,
ReceiptHandle = InMessage.ReceiptHandle
};
var DeleteResponse = SqsClient.DeleteMessage(DeleteRequest);
return(DeleteResponse.HttpStatusCode == HttpStatusCode.OK);
}
public virtual void RemoveMessage(AmazonSQSClient sqsClient, string queueUrl, string receiptHandle)
{
// Create the request
var deleteMessageRequest = new DeleteMessageRequest
{
ReceiptHandle = receiptHandle,
QueueUrl = queueUrl
};
// Submit the request
sqsClient.DeleteMessage(deleteMessageRequest);
}
public DeleteMessageResponse DeleteMessage(string receiptHandle)
{
var request = new DeleteMessageRequest
{
QueueUrl = this._queueUrl,
ReceiptHandle = receiptHandle
};
var response = this.SQSClient.DeleteMessage(request);
return(response);
}
public bool DeleteMessage(string receiptHandle)
{
DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest(this.queueUrl, receiptHandle);
DeleteMessageResponse deleteMessageResponse = this.sqsClient.DeleteMessage(deleteMessageRequest);
if (deleteMessageResponse.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
return(false);
}
public void DeleteMessage()
{
DeleteMessageRequest request = new DeleteMessageRequest {
QueueUrl = QueueUrl, ReceiptHandle = ReceiptHandle
};
var response = client.DeleteMessage(request);
if (response.HttpStatusCode.IsSuccess())
{
Console.WriteLine("Message Deleted Succsessfully");
}
}
public async Task <DeleteMessageResponse> DeletarMensagemSqsAsync(string queueUrl, Message message,
CancellationToken stoppingToken)
{
var deleteMessageRequest = new DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = message.ReceiptHandle
};
var result = await _amazonSqs.DeleteMessageAsync(deleteMessageRequest, stoppingToken);
return(result);
}
private static async Task ReceiveMessage(int state)
{
//Receiving a message
var receiveMessageRequest = new ReceiveMessageRequest {
QueueUrl = _myQueueUrl
};
var receiveMessageResponse = await _sqs.ReceiveMessageAsync(receiveMessageRequest);
if (receiveMessageResponse.Messages != null)
{
Console.WriteLine($"Receiever {state} Printing received message.\n");
foreach (var message in receiveMessageResponse.Messages)
{
Console.WriteLine($"Receiever {state} Message");
if (!string.IsNullOrEmpty(message.MessageId))
{
Console.WriteLine($"Receiever {state} MessageId: {message.MessageId}");
}
if (!string.IsNullOrEmpty(message.ReceiptHandle))
{
Console.WriteLine($"Receiever {state} ReceiptHandle: {message.ReceiptHandle}");
}
if (!string.IsNullOrEmpty(message.MD5OfBody))
{
Console.WriteLine($"Receiever {state} MD5OfBody: {message.MD5OfBody}");
}
if (!string.IsNullOrEmpty(message.Body))
{
Console.WriteLine($"Receiever {state} Body: {message.Body}");
}
foreach (string attributeKey in message.Attributes.Keys)
{
Console.WriteLine(" Attribute");
Console.WriteLine(" Name: {0}", attributeKey);
var value = message.Attributes[attributeKey];
Console.WriteLine(" Value: {0}", string.IsNullOrEmpty(value) ? "(no value)" : value);
}
}
var messageRecieptHandle = receiveMessageResponse.Messages[0].ReceiptHandle;
if (_receieverShouldDeleteMessage)
{
//Deleting a message
Console.WriteLine("Deleting the message.\n");
var deleteRequest = new DeleteMessageRequest {
QueueUrl = _myQueueUrl, ReceiptHandle = messageRecieptHandle
};
_sqs.DeleteMessage(deleteRequest);
}
}
}
public async Task DeleteMessageAsync(string receiptHandle)
{
var request = new DeleteMessageRequest()
{
QueueUrl = _queueUrl,
ReceiptHandle = receiptHandle
};
var response = await _amazonSqsClient.DeleteMessageAsync(request);
response.ThrowIfNotSuccess();
}
internal async Task DeleteMessageAsync(
string receiptHandle,
CancellationToken cancellationToken)
{
var deleteRequest = new DeleteMessageRequest
{
QueueUrl = _sqsQueue.Uri.AbsoluteUri,
ReceiptHandle = receiptHandle,
};
await _sqsQueue.Client.DeleteMessageAsync(deleteRequest, cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Deletes a message from the queue
/// </summary>
/// <param name="queueName">The name of the queue</param>
/// <param name="receiptHandle">The identifier of the operation that received the message</param>
/// <returns></returns>
public async Task DeleteMessageAsync(string queueName, string receiptHandle)
{
var queueUrl = await GetQueueUrlAsync(queueName);
var request = new DeleteMessageRequest
{
QueueUrl = queueUrl,
ReceiptHandle = receiptHandle
};
await _client.DeleteMessageAsync(request);
}
private async Task DeleteTransaction(string recieptHandle)
{
var deleteMessageRequest = new DeleteMessageRequest {
ReceiptHandle = recieptHandle
};
var response = await _sqsClient.DeleteMessageAsync(deleteMessageRequest);
if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
throw new System.Exception($"Failed to delete message: {recieptHandle}");
}
}
/// <summary>
/// This endpoint deletes a specific messages
/// </summary>
/// <param name="request">DeleteMessageRequest object.</param>
/// <returns></returns>
public async Task <DeleteMessageResponse> DeleteMessageAsync(DeleteMessageRequest request)
{
var requestObject = httpClient.GetRequest(endpointUrl + "/{domain}/inboxes/{inbox}/messages/{messageId}", Method.DELETE);
requestObject.AddUrlSegment("domain", request.Domain);
requestObject.AddUrlSegment("inbox", request.Inbox);
requestObject.AddUrlSegment("messageId", request.MessageId);
var response = await httpClient.ExecuteAsync <DeleteMessageResponse>(requestObject);
return(response);
}
private async Task Confirm(string receipt, string queueName)
{
var client = GetClient;
var delete = new DeleteMessageRequest
{
ReceiptHandle = receipt,
QueueUrl = await GetQueueUrl(client, queueName),
};
await client.DeleteMessageAsync(delete);
}
public void DeleteAsync(string receiptHandle, AsyncCallback deleteMessageCallback)
{
try
{
var deleteMessageRequest = new DeleteMessageRequest(receiptHandle);
Queue.BeginDeleteMessage(deleteMessageRequest, deleteMessageCallback, Queue);
}
catch (Exception ex)
{
Console.WriteLine("AsyncDeleteMessage failed, exception info: " + ex.Message);
}
}
public async Task <Result> DeleteMessageAsync(string receiptHandle, CancellationToken cancellationToken)
{
var deleteMessageRequest = new DeleteMessageRequest(_provider.QueueUrl, receiptHandle);
var deleteMessageResponse = await _amazonSqs.DeleteMessageAsync(deleteMessageRequest, cancellationToken);
if (deleteMessageResponse.HttpStatusCode == HttpStatusCode.OK) //todo
{
return(new Result());
}
return(new Result(false, "An error occured during delete message"));
}
private void Handle(sqs.Message sqsMessage, Action <Message> onMessageReceived)
{
var message = Message.FromJson(sqsMessage.Body);
onMessageReceived(message);
var deleteRequest = new DeleteMessageRequest();
deleteRequest.QueueUrl = Address;
deleteRequest.ReceiptHandle = sqsMessage.ReceiptHandle;
_sqsClient.DeleteMessage(deleteRequest);
}
public async Task DeleteSQSMessage(string messageRecieptHandle)
{
//Deleting a message
Console.WriteLine("Deleting the message.\n");
DeleteMessageRequest deleteRequest = new DeleteMessageRequest();
deleteRequest.QueueUrl = myQueueUrl;
deleteRequest.ReceiptHandle = messageRecieptHandle;
await sqs.DeleteMessageAsync(deleteRequest);
return;
}
public async Task DeleteMessage(DeleteMessageRequest request, string SourceId)
{
if (await _chatRepository.GetSentUserId(request.MessageId) != SourceId)
{
throw new ChatPermissionException("Not sent by this user");
}
if (!await _chatRepository.IsMessageDeleted(request.MessageId))
{
await _chatRepository.DeleteMessage(request);
}
}
public async Task DeleteMessageAsync(string queueName, string messageId, string popReceipt)
{
var request = new DeleteMessageRequest(_account, queueName, messageId, popReceipt);
await request.ExecuteAsync(_optionalRetryPolicy);
}
public void DeleteMessage(string queueName, string messageId, string popReceipt)
{
var request = new DeleteMessageRequest(_account, queueName, messageId, popReceipt);
request.Execute(_optionalRetryPolicy);
}
