private void GenericSubscriptionQueue_MessageReceived
(RabbitMQ.Client.IBasicConsumer sender, RabbitMQ.Client.Events.BasicDeliverEventArgs args)
{
RabbitMQ.Client.Events.EventingBasicConsumer consumer = (RabbitMQ.Client.Events.EventingBasicConsumer)sender;
try
{
// don't reprocess items that have been processed
if (_genericSubscriptionQueue.GetLastProcessedUndelivered() != args.DeliveryTag)
{
string rawOrder = Encoding.ASCII.GetString(args.Body);
ProcessOrder(rawOrder);
}
_genericSubscriptionQueue.Ack(consumer, args.DeliveryTag);
}
catch (QueueDataError <string> serializationEx)
{
_log.WriteErrorLog("Serializing problem with order update.", serializationEx);
}
catch (Exception ex)
{
_log.WriteErrorLog("Unhandled error processing order update.", ex);
}
}
public void Consume()
{
QueueingBasicConsumer consumer = new QueueingBasicConsumer(Model);
String consumerTag = Model.BasicConsume(QueueName, false, consumer);
while (isConsuming)
{
try
{
RabbitMQ.Client.Events.BasicDeliverEventArgs e = (RabbitMQ.Client.Events.BasicDeliverEventArgs)consumer.Queue.Dequeue();
IBasicProperties props = e.BasicProperties;
byte[] body = e.Body;
// ... process the message
onMessageReceived(body);
Model.BasicAck(e.DeliveryTag, false);
}
catch (OperationInterruptedException ex)
{
// The consumer was removed, either through
// channel or connection closure, or through the
// action of IModel.BasicCancel().
// break;
}
}
}
public void Consume()
{
QueueingBasicConsumer consumer = new QueueingBasicConsumer(Model);
String consumerTag = Model.BasicConsume(QueueName, true, consumer);
while (isListening)
{
try
{
RabbitMQ.Client.Events.BasicDeliverEventArgs e = (RabbitMQ.Client.Events.BasicDeliverEventArgs)consumer.Queue.Dequeue();
IBasicProperties props = e.BasicProperties;
byte[] body = e.Body;
onMessageReceived(body);
//Model.BasicAck(e.DeliveryTag, false);
}
catch (EndOfStreamException ex) {
break;
}
catch (OperationInterruptedException ex)
{
break;
}
}
}
private void ReceiveHandler(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs args)
{
string rs = Encoding.UTF8.GetString(args.Body.ToArray());
Console.WriteLine(rs);
rcvMq.Ack(args.DeliveryTag);
}
public void Dispose()
{
isConsuming = false;
if (consumer != null)
{
consumer = null;
}
if (Connection.IsOpen)
{
Connection.Close();
}
if (Model != null)
{
Model.Abort();
}
if (connectionFactory != null)
{
connectionFactory = null;
}
if (Connection != null)
{
Connection.Abort();
}
if (e != null)
{
e = null;
}
}
private void GenericSubscriptionQueue_MessageReceived
(RabbitMQ.Client.IBasicConsumer sender, RabbitMQ.Client.Events.BasicDeliverEventArgs args)
{
RabbitMQ.Client.Events.EventingBasicConsumer consumer = (RabbitMQ.Client.Events.EventingBasicConsumer)sender;
try {
// don't reprocess items that have been processed
if (genericSubscriptionQueue.GetLastProcessedUndelivered() != args.DeliveryTag)
{
BaseNotification notification = NotificationExtension.Deserialize(Encoding.ASCII.GetString(args.Body));
eventLogRepository.WriteInformationLog("Processing notification type: {NotificationType}. Data: {QueueMessage}".Inject(new { QueueMessage = notification.ToJson(), NotificationType = notification.NotificationType.ToString() }));
var handler = notificationHandlerFactory(notification.NotificationType); // autofac will get the right handler
handler.ProcessNotification(notification);
// Always clear the context at the end of a transaction
_uow.ClearContext();
}
genericSubscriptionQueue.Ack(consumer, args.DeliveryTag);
} catch (QueueDataError <string> serializationEx) {
eventLogRepository.WriteErrorLog("Serializing problem with notification.", serializationEx);
} catch (QueueDataError <BaseNotification> notificationEx) {
eventLogRepository.WriteErrorLog("Error processing notification.", notificationEx);
PublishToQueue(notificationEx.ProcessingObject, Configuration.RabbitMQNotificationErrorQueue);
} catch (Exception ex) {
eventLogRepository.WriteErrorLog("Unhandled error processing notification.", ex);
}
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
ReportSessionRunning report = ReportSessionRunning.GetFromJson(message.Body);
tracks.AddItem(report);
this.GetChannel().BasicAck(message.DeliveryTag, true);
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
long companyId = Convert.ToInt64(UTF8Encoding.UTF8.GetString(message.Body));
ResetForCompany(companyId);
this.GetChannel().BasicAck(message.DeliveryTag, true);
}
public void Consume()
{
QueueingBasicConsumer consumer = new QueueingBasicConsumer(Model);
bool autoAck = false;
String consumerTag = Model.BasicConsume(QueueName, autoAck, consumer);
while (isConsuming)
{
try
{
RabbitMQ.Client.Events.BasicDeliverEventArgs e = (RabbitMQ.Client.Events.BasicDeliverEventArgs)consumer.Queue.Dequeue();
if (e != null)
{
IBasicProperties props = e.BasicProperties;
byte[] body = e.Body;
// ... process the message
bool bProcessed = onMessageReceived(body);
if (bProcessed)
{
Model.BasicAck(e.DeliveryTag, false);
}
}
}
catch (Exception ex)
{
Log.Error("Consum Error", ex);
break;
}
}
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
var jobDownloadHtml = JobDownloadHtml.FromArByte(message.Body);
if (jobDownloadHtml != null)
{
var url = jobDownloadHtml.Url;
var html = HttpUtility.HtmlDecode(GABIZ.Base.HtmlUrl.HTMLTransmitter.getHTML(jobDownloadHtml.Url, 45, 2));
if (!string.IsNullOrEmpty(html))
{
_noSqlHtml.SaveHtm(jobDownloadHtml.Id, jobDownloadHtml.CompanyId, html, jobDownloadHtml.Url);
_producerAfterDownload.PublishString(new JobWaitAS()
{
Id = jobDownloadHtml.Id, CompanyId = jobDownloadHtml.CompanyId, Url = url
}.ToJson());
_log.Info(string.Format("Download html for job:{0}", jobDownloadHtml.ToJSON()));
}
else
{
_log.Info(string.Format("Can't download html of job:{0}", jobDownloadHtml.ToJSON()));
}
}
else
{
_log.Info("JobErrorParse");
}
GetChannel().BasicAck(message.DeliveryTag, true);
}
private void SubscriptionQueue_MessageReceived(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs args)
{
RabbitMQ.Client.Events.EventingBasicConsumer consumer = (RabbitMQ.Client.Events.EventingBasicConsumer)sender;
try {
ConfirmationFile confirmation = DeserializeConfirmation(args.Body);
ProcessIncomingConfirmation(confirmation);
//Try to save the confirmation 5 times. Several threads are modifying the order history table, so there are occasional concurrency errors.
KeithLink.Svc.Impl.Helpers.Retry.Do(() => _conversionLogic.SaveConfirmationAsOrderHistory(confirmation), TimeSpan.FromSeconds(1), 5);
genericSubscriptionQueue.Ack(consumer, args.DeliveryTag);
}
catch (QueueDataError <ConfirmationFile> dataException) {
// Move to errror queue
PublishToQueue(dataException.ProcessingObject, ConfirmationQueueLocation.Error);
_log.WriteErrorLog(dataException.Message);
}
catch (Exception ex) {
// Send NACK
_log.WriteErrorLog("Error processing confirmation.", ex);
genericSubscriptionQueue.Nack(consumer, args.DeliveryTag);
}
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
JobCrlProperties jobDownloadHtml = JobCrlProperties.FromJson(UTF8Encoding.UTF8.GetString(Decompress(message.Body)));
_handlerParserProperties.ProcessJob(jobDownloadHtml.ProductId, jobDownloadHtml.Html);
this.GetChannel().BasicAck(message.DeliveryTag, true);
Logger.InfoFormat("Processed {0}", jobDownloadHtml.ProductId);
}
protected override void Implement(RabbitMQ.Client.IModel channel, RabbitMQ.Client.Events.BasicDeliverEventArgs ea)
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" worker1 Received {0}", message);
System.Threading.Thread.Sleep(10000);
channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
//var lstProperties = _cacheMan.Get<List<KeyValuePair<string, string>>>("prs:" + 7359876249405784780, true);
var msRootProduct = MsRootProduct.FromJson(Encoding.UTF8.GetString(message.Body));
var isSave = MapProperties(msRootProduct.RootID);
this.GetChannel().BasicAck(message.DeliveryTag, true);
}
private async void ConsumerReceived(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
var message = Encoding.UTF8.GetString(e.Body.ToArray());
var messageSend = JsonConvert.DeserializeObject <MessageDTO>(message);
await _hub.Clients.Group(messageSend.GroupId.ToString()).SendAsync("newMessage", message);
_consumer.SetAcknowledge(e.DeliveryTag, true);
}
private async void ConsumerReceived(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
var message = Encoding.UTF8.GetString(e.Body.ToArray());
var statusChange = JsonConvert.DeserializeObject <StatusChangeDto>(message);
await _statusesHub.Clients.Group(statusChange.UserId.ToString()).SendAsync("statusChange", message);
_consumer.SetAcknowledge(e.DeliveryTag, true);
}
void startServer()
{
ConnectionFactory factory = new ConnectionFactory();
factory.HostName = ip;
IConnection connection = factory.CreateConnection();
channel = connection.CreateModel();
connection.AutoClose = true;
string queuename = channel.QueueDeclare().QueueName;
channel.ExchangeDeclare("MyZone", "direct");
channel.QueueBind(queuename, "MyZone", name);
channel.QueueBind(queuename, "MyZone", name + "." + selfname);
QueueingBasicConsumer consumer = new QueueingBasicConsumer(channel);
string tag = channel.BasicConsume(queuename, true, consumer);
while (true)
{
try
{
RabbitMQ.Client.Events.BasicDeliverEventArgs e =
(RabbitMQ.Client.Events.BasicDeliverEventArgs)consumer.Queue.Dequeue();
byte[] body = e.Body;
string message = System.Text.Encoding.UTF8.GetString(body);
if (message.Trim().StartsWith("+showuser"))
{
int index = message.IndexOf(" ");
string to = message.Substring(index + 1);
sendMessage("-" + selfname, false, to);
}
else if (message.Trim().StartsWith("update"))
{
;
}
else if (message.EndsWith("enter the room"))
{
int index = message.IndexOf(" ");
string to = message.Substring(0, index);
sendMessage("update " + selfname, false, to);
Console.WriteLine(message);
}
else
{
Console.WriteLine(message);
}
}
catch (System.IO.EndOfStreamException ex)
{
break;
}
}
}
private async void Consumer_Received(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
var key = e.RoutingKey;
var message = Encoding.UTF8.GetString(e.Body.ToArray());
var executeBuild = JsonConvert.DeserializeObject <ExecutiveBuildDTO>(message);
SendBuildStatus(BuildStatus.InProgress, executeBuild.BuildHistoryId, executeBuild.UserId);
await BuildProjectAsync(executeBuild).ContinueWith(t => SendBuildStatus(BuildStatus.Success, executeBuild.BuildHistoryId, executeBuild.UserId));
_consumer.SetAcknowledge(e.DeliveryTag, true);
}
private static void BroadcastUserInfoConsumer_Received(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
if (wsPool != null)
{
var result = Encoding.UTF8.GetString(e.Body);
foreach (var item in wsPool.WebSocketList.Where(x => x.QueryString["key"] == "userSocket"))
{
item.OryxWebSocket.SendAsync(result).Wait();
}
}
}
/// <summary>
/// 注册消息接收处理器
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void Consumer_Received(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
//var wsToken = Guid.Parse(e.RoutingKey);
var wsLsit = wsPool.GetByQuery(SocialMsgManager.SocialMsgWSClientKey, e.RoutingKey);
var arrByte = new ArraySegment <byte>(e.Body);
wsLsit.ForEach(wsItem =>
{
wsItem.OryxWebSocket.SendAsync(arrByte, System.Net.WebSockets.WebSocketMessageType.Text, true, CancellationToken.None).ConfigureAwait(false);
});
}
private static void BroadcastWxqPicPicConsumer_Received(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
var result = Encoding.UTF8.GetString(e.Body);
var wsList = wsPool.WebSocketList.Where(x => x.QueryString.Any(c => c.Value == "wxqpic"));
if (wsList != null && wsList.Count() > 0)
{
foreach (var wsItem in wsList)
{
wsItem.OryxWebSocket.SendAsync(result).Wait();
}
}
}
private async void ConsumerReceived(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
var message = Encoding.UTF8.GetString(e.Body.ToArray());
var statusChange = JsonConvert.DeserializeObject <StatusChangeDto>(message);
using (var scope = _serviceProvider.CreateScope())
{
using var buildService = scope.ServiceProvider.GetService <IBuildService>();
await buildService.ChangeStatus(statusChange);
}
_consumer.SetAcknowledge(e.DeliveryTag, true);
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
MsProduct ms = JsonConvert.DeserializeObject <MsProduct>(message.Body.ToString());
Keyword = ms.ProductName;
KeywordID = QT.Entities.Common.GetID_Keywords(Keyword);
sqldb.RunQuery("if not exists (select ID from KeywordFindNewWebsite where ID = @ID) begin insert into KeywordFindNewWebsite (ID,Keyword) Values (@ID,@Keyword) end", CommandType.Text, new SqlParameter[] {
SqlDb.CreateParamteterSQL("@ID", KeywordID, SqlDbType.Int),
SqlDb.CreateParamteterSQL("@Keyword", Keyword, SqlDbType.NVarChar)
});
Console.WriteLine(string.Format("Inserted: {0}", count));
count++;
this.GetChannel().BasicAck(message.DeliveryTag, true);
}
private async System.Threading.Tasks.Task Consumer_Received
(object sender, RabbitMQ.Client.Events.BasicDeliverEventArgs e)
{
string queueName = e.RoutingKey;
string eventTypeName = queueName;
byte[] body = e.Body.ToArray();
string message =
System.Text.Encoding.UTF8.GetString(body);
System.Console.WriteLine($"Received message: { message }");
await ProcessEvent(eventTypeName, message).ConfigureAwait(false);
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
var ProductAds = Newtonsoft.Json.JsonConvert.DeserializeObject <ProductAdsScore>(Encoding.UTF8.GetString(message.Body));
using (IDbConnection db = new SqlConnection(_connectionString))
{
db.Execute("Insert into Product_AdsScore_Deleted (ProductId, CompanyId, Keyword) values (@ProductId, @CompanyId, @Keyword)",
new
{
ProductId = ProductAds.ProductId,
CompanyId = ProductAds.CompanyId,
Keyword = ProductAds.Keyword
});
}
this.GetChannel().BasicAck(message.DeliveryTag, true);
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
string json = UTF8Encoding.UTF8.GetString(message.Body);
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Comment> >(json); foreach (var commentData in obj)
{
string author = commentData.Author ?? "";
string title = commentData.Title ?? "";
string conntent = commentData.Content ?? "";
long hash = Common.CrcProductID(Newtonsoft.Json.JsonConvert.SerializeObject(commentData));
bool bok = _sqlDb.RunQuery(@"
DELETE FROM Product_Comment Where Id = @ID;
INSERT INTO [dbo].[Product_Comment]
([Id]
,[Title]
,[Content]
,[ProductId]
,[CompanyId]
, [Author]
, DateComment
)
values (@Id, @Title, @Content, @ProductId, @CompanyId, @Author, @DateComment
)
", CommandType.Text,
new SqlParameter[]
{
SqlDb.CreateParamteterSQL("@Id", hash, SqlDbType.BigInt), SqlDb.CreateParamteterSQL("@Title", title, SqlDbType.NVarChar),
SqlDb.CreateParamteterSQL("@Content", conntent, SqlDbType.NVarChar), SqlDb.CreateParamteterSQL("@ProductId", commentData.ProductId, SqlDbType.BigInt),
SqlDb.CreateParamteterSQL("@CompanyId", commentData.CompanyId, SqlDbType.BigInt), SqlDb.CreateParamteterSQL("@Author", author, SqlDbType.NVarChar),
SqlDb.CreateParamteterSQL("@DateComment", commentData.DatePublish, SqlDbType.DateTime),
});
if (!bok)
{
Logger.Error("Can't insert:" + json);
}
else
{
Logger.Info(string.Format("Saved mss {0}", countMss++));
}
}
GetChannel().BasicAck(message.DeliveryTag, true);
}
public override void ProcessMessage(RabbitMQ.Client.Events.BasicDeliverEventArgs message)
{
if (typeof(T) == typeof(string))
{
var t = Encoding.UTF8.GetString(message.Body);
Logger.InfoFormat("Get mss: {0}", t);
_eventProcessJob?.Invoke((T)Convert.ChangeType(t, typeof(T)));
this.GetChannel().BasicAck(message.DeliveryTag, true);
}
else
{
var t = Newtonsoft.Json.JsonConvert.DeserializeObject <T>(Encoding.UTF8.GetString(message.Body));
Logger.InfoFormat("Get mss: {0}", t);
_eventProcessJob?.Invoke(t);
this.GetChannel().BasicAck(message.DeliveryTag, true);
}
}
public void Consume()
{
consumer = new QueueingBasicConsumer(Model);
bool autoAck = false;
String consumerTag = Model.BasicConsume(QueueName, autoAck, consumer);
while (isConsuming)
{
try
{
if (consumer != null)
{
e =
(RabbitMQ.Client.Events.BasicDeliverEventArgs)
consumer.Queue.Dequeue();
IBasicProperties props = e.BasicProperties;
byte[] body = e.Body;
string cade = System.Text.Encoding.UTF8.GetString(body);
Console.WriteLine("cade: " + cade);
try
{
System.Text.Encoding.UTF8.GetString(body);
onMessageReceived(body);
Model.BasicAck(e.DeliveryTag, false);
}
catch (Exception e)
{
Console.WriteLine("Error: en combertir el JSON");
}
}
}
catch (OperationInterruptedException ex)
{
break;
}
}
}
} // ModelShutdown
private void MessageReceived(object sender, RmqCl.Events.BasicDeliverEventArgs eventArgs)
{
// This event handler is run when a message arrives
try
{
// No callbacks when already disposed.
// If the dispose call occurs right after checking, the callback can come
// after dispose, but this is considered unlikely and unimportant.
if (!m_disposed.Value)
{
b_messageReceivedCallback(ConnectionRequestObj.Host, ConnectionRequestObj.Exchange,
eventArgs.RoutingKey, eventArgs.Body);
}
}
catch {}
} // MessageReceived
public void StartConsumer()
{
iCount = 0;
string hostName = QT.Entities.Server.RabbitMQ_Host;
int Port = QT.Entities.Server.RabbitMQ_Port;
string userName = QT.Entities.Server.RabbitMQ_User;
string password = QT.Entities.Server.RabbitMQ_Pass;
string queueName = QT.Entities.Server.RabbitMQ_QueueTask;
sqlDb = new SqlDb(QT.Entities.Server.ConnectionStringCrawler);
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.UserName = userName;
connectionFactory.Password = password;
connectionFactory.Protocol = Protocols.DefaultProtocol;
connectionFactory.HostName = hostName;
connectionFactory.Port = Port;
connection = connectionFactory.CreateConnection();
connectionToPublish = connectionFactory.CreateConnection();
ModelToPublish = connection.CreateModel();
ModelToPublish.BasicQos(0, 1, false);
ModelToPublish.QueueDeclare("CrawlerProduct_ReloadPrice", true, false, false, null);
changeReport = connection.CreateModel();
changeReport.BasicQos(0, 1, false);
bool durable = true;
changeReport.QueueDeclare("CrawlerProduct_ReloadPrice", durable, false, false, null);
QueueingBasicConsumer consumer = new QueueingBasicConsumer(changeReport);
bool autoAck = false;
String consumerTag = changeReport.BasicConsume("CrawlerProduct_ReloadPrice", autoAck, consumer);
while (true)
{
RabbitMQ.Client.Events.BasicDeliverEventArgs e = (RabbitMQ.Client.Events.BasicDeliverEventArgs)consumer.Queue.Dequeue();
iCount++;
IBasicProperties props = e.BasicProperties;
byte[] body = e.Body;
ProcessATaskMQ(body);
changeReport.BasicAck(e.DeliveryTag, false);
}
}
