protected override void BindQueue <T>(RabbitMQ.Client.IModel model, QueueSetupData queue, string exchangeName, string queueName, string routingKey)
{
if (queue is PriorityQueueSetupData)
{
var maxPriority = (queue as PriorityQueueSetupData).MaxPriorityLevel;
for (uint i = 0; i <= maxPriority; i++)
{
try
{
IDictionary arguments = new HybridDictionary();
arguments.Add("x-match", "all");
arguments.Add("Priority", i.ToString(CultureInfo.InvariantCulture));
arguments.Add("RoutingKey", routingKey);
//http://www.rabbitmq.com/tutorials/amqp-concepts.html
//http://lostechies.com/derekgreer/2012/03/28/rabbitmq-for-windows-exchange-types/
model.QueueBind(GetPriorityQueueName <T>(queueName, i), exchangeName, routingKey /*It'll be ignored as AMQP spec*/, arguments);
}
catch (Exception ex)
{
_watcher.Error(ex);
}
}
}
else
{
base.BindQueue <T>(model, queue, exchangeName, queueName, routingKey);
}
}
protected override void DeleteQueue <T>(RabbitMQ.Client.IModel model, QueueSetupData queue, string queueName)
{
if (queue is PriorityQueueSetupData)
{
var maxPriority = (queue as PriorityQueueSetupData).MaxPriorityLevel;
for (uint i = 0; i <= maxPriority; i++)
{
try
{
model.QueueDelete(GetPriorityQueueName <T>(queueName, i));
}
catch (OperationInterruptedException oie)
{
if (oie.ShutdownReason.ReplyText.StartsWith("NOT_FOUND - no queue "))
{
_watcher.WarnFormat(oie.ShutdownReason.ReplyText);
}
else
{
_watcher.Error(oie);
}
}
catch (Exception ex)
{
_watcher.Error(ex);
}
}
}
else
{
base.DeleteQueue <T>(model, queue, queueName);
}
}
private void PullMQ()
{
Console.WriteLine("Begin pull msg with new thread");
var MQQueueName = ConfigurationManager.AppSettings["MQQueueName"];
var factory = MQUtils.MQFactory;
using (var conn = factory.CreateConnection())
{
using (RabbitMQ.Client.IModel channel = conn.CreateModel())
{
IDictionary <string, object> queueArgs = new Dictionary <string, object>
{
{ "x-ha-policy", "all" }
};
channel.QueueDeclare(queue: MQQueueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: queueArgs);
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
while (true)
{
if (!MQUtils.Pull(channel, ExcuteMessage))
{
Console.WriteLine("{0} - Queue is empty!", Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(1000);
}
}
}
}
}
public IBasicGetResult Get(IQueue queue)
{
Preconditions.CheckNotNull(queue, "queue");
//var result = clientCommandDispatcher.Invoke(x => x.BasicGet(queue.Name, false));
RabbitMQ.Client.IModel model = connection.CreateModel();
model.ContinuationTimeout = connectionConfiguration.ContinuationTimeout;
var result = model.BasicGet(queue.Name, false);
if (result == null)
{
return(null);
}
else
{
model.BasicAck(result.DeliveryTag, false);
}
var getResult = new BasicGetResult(
result.Body,
new MessageProperties(result.BasicProperties),
new MessageReceivedInfo(
"",
result.DeliveryTag,
result.Redelivered,
result.Exchange,
result.RoutingKey,
queue.Name
)
);
logger.DebugWrite("Message Get from queue '{0}'", queue.Name);
return(getResult);
}
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);
}
protected virtual Task PublishToErrorExchangeAsync(IPipeContext context, IModel channel, Exception exception, ExchangeDeclaration exchange)
{
var args = context.GetDeliveryEventArgs();
args.BasicProperties.Headers?.TryAdd(PropertyHeaders.Host, Environment.MachineName);
args.BasicProperties.Headers?.TryAdd(PropertyHeaders.ExceptionType, exception.GetType().Name);
args.BasicProperties.Headers?.TryAdd(PropertyHeaders.ExceptionStackTrace, exception.StackTrace);
channel.BasicPublish(exchange.Name, args.RoutingKey, false, args.BasicProperties, args.Body);
return(Task.FromResult(0));
}
protected override void DeclareExchange(ExchangeSetupData exchange, RabbitMQ.Client.IModel model, string exchangeName)
{
if (exchange != null && exchange.ExchangeType == "headers")
{
base.DeclareExchange(exchange, model, exchangeName);
}
else
{
throw new Exception("Expect exchange type headers");
}
}
public QueuePushHandle()
{
sqlDb = new SqlDb(QT.Entities.Server.ConnectionStringCrawler);
factory = new RabbitMQ.Client.ConnectionFactory()
{
HostName = QT.Entities.Server.RabbitMQ_Host,
Port = QT.Entities.Server.RabbitMQ_Port,
UserName = QT.Entities.Server.RabbitMQ_User,
Password = QT.Entities.Server.RabbitMQ_Pass
};
connection = factory.CreateConnection();
chanel = connection.CreateModel();
}
public void Dispose()
{
if (_model != null)
{
_model.Dispose();
_model = null;
}
if (_connection != null)
{
_connection.Dispose();
_connection = null;
}
}
public void Dispose()
{
if (_model != null)
{
_model.Dispose();
_model = null;
}
if (_connection != null)
{
_connection.Dispose();
_connection = null;
}
}
private static void CreateAndBind_TopicExchange(RabbitMQ.Client.IModel RabbitMqModel)
{
var topicExchange1 = rabbitMqDefinationFunctions.CreateAndBindExchange(
RabbitMqModel,
new ExchangeModel
{
ExchangeName = "topicExchange1",
ExchangeType = ExchangeType.Topic
},
"topicExchange1routeKey1",
new QueueModel
{
QueueName = "queue4"
}
);
}
private static void CreateAndBind_HeadersExchange(RabbitMQ.Client.IModel RabbitMqModel)
{
var headresExchange1 = rabbitMqDefinationFunctions.CreateAndBindExchange(
RabbitMqModel,
new ExchangeModel
{
ExchangeName = "headresExchange1",
ExchangeType = ExchangeType.Headers
},
"headresExchange1routeKey1",
new QueueModel
{
QueueName = "queue3"
}
);
}
private static void CreateAndBind_FanoutExchange(RabbitMQ.Client.IModel RabbitMqModel)
{
var fanoutExchange1 = rabbitMqDefinationFunctions.CreateAndBindExchange(
RabbitMqModel,
new ExchangeModel
{
ExchangeName = "fanoutExchange1",
ExchangeType = ExchangeType.Fanout
},
"fanoutExchange1routeKey1",
new QueueModel
{
QueueName = "queue2"
}
);
}
void Start_Example()
{
if (UseMQ)
{
try
{
_mq = new mQ(MQ_ServerAddress, MQ_Login, MQ_Password);
_channel = _mq.getChannel();
MQ = new mQActions(_channel);
Debug.Log(" [MQ] connection init done");
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
}
private static void CreateAndBind_DirectExchange(RabbitMQ.Client.IModel RabbitMqModel)
{
var directExchange1 = rabbitMqDefinationFunctions.CreateAndBindExchange(
RabbitMqModel,
new ExchangeModel
{
ExchangeName = "directExchange1",
ExchangeType = ExchangeType.Direct,
Durable = true,
AutoDelete = false
},
"directExchange1routeKey1",
new QueueModel
{
QueueName = "queue1",
Durable = true,
Exclusive = false,
AutoDelete = false
}
);
}
public MessageReceivedInfo(
string consumerTag,
ulong deliverTag,
bool redelivered,
string exchange,
string routingKey,
string queue,
RabbitMQ.Client.IModel model)
{
Preconditions.CheckNotNull(consumerTag, "consumerTag");
Preconditions.CheckNotNull(exchange, "exchange");
Preconditions.CheckNotNull(routingKey, "routingKey");
Preconditions.CheckNotNull(queue, "queue");
ConsumerTag = consumerTag;
DeliverTag = deliverTag;
Redelivered = redelivered;
Exchange = exchange;
RoutingKey = routingKey;
Queue = queue;
Model = model;
}
public void Connect()
{
_connection = _connectionFactory.CreateConnection(_configurationSettings);
_model = _connection.CreateModel();
}
public ResourceBootstrapService(MinioClient minio, RabbitMQ.Client.IModel model)
{
this.minio = minio;
this.model = model;
}
protected override void DeclareQueue <T>(QueueSetupData queue, string queueName, RabbitMQ.Client.IModel model)
{
IDictionary arguments = new Dictionary <string, object>();
if (queue.MessageTimeToLive > 0)
{
arguments.Add("x-message-ttl", queue.MessageTimeToLive);
}
if (queue.AutoExpire > 0)
{
arguments.Add("x-expires", queue.AutoExpire);
}
if (queue is PriorityQueueSetupData)
{
var maxPriority = (queue as PriorityQueueSetupData).MaxPriorityLevel;
for (uint i = 0; i <= maxPriority; i++)
{
try
{
model.QueueDeclare(GetPriorityQueueName <T>(queueName, i), queue.Durable, false,
queue.AutoDelete, arguments);
}
catch (OperationInterruptedException oie)
{
if (oie.ShutdownReason.ReplyText.StartsWith("PRECONDITION_FAILED - "))
{
_watcher.WarnFormat(oie.ShutdownReason.ReplyText);
}
else
{
_watcher.Error(oie);
}
}
catch (Exception ex)
{
_watcher.Error(ex);
}
}
}
else
{
base.DeclareQueue <T>(queue, queueName, model);
}
}
public void Start()
{
while (true)
{
try
{
RabbitMQServer rabbitMqServer = RabbitMQManager.GetRabbitMQServer(ConfigCrawler.KeyRabbitMqCrawler);
RabbitMQ.Client.IModel channel = null;
while (channel == null)
{
channel = rabbitMqServer.CreateChannel();
}
channel.ExchangeDeclare("CrawlerProduct", "topic", true);
channel.QueueDeclare(ConfigCrawler.QueueErrorCrawler, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueErrorCrawler, ConfigCrawler.ExchangeErorrCrawler, ConfigCrawler.RoutingKeyErrorCrawler);
channel.QueueDeclare(ConfigCrawler.QueueHistoryToSolr, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueHistoryToSolr, ConfigCrawler.ExchangeChangeProduct, ConfigCrawler.RoutingkeyChangeProduct);
channel.QueueDeclare(ConfigCrawler.QueueVisitedLinkFindNewToSolr, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueVisitedLinkFindNewToSolr, ConfigCrawler.ExchangeVisitedLinkFindNew, ConfigCrawler.RoutingKeyVisitedLinkFindNew);
channel.ExchangeDeclare(ConfigCrawler.ExchangeSessionRunning, "topic", true);
channel.QueueDeclare(ConfigCrawler.QueueTrackRunning, true, false, false, null);
channel.QueueDeclare(ConfigCrawler.QueueUpdateSessionRunning, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueUpdateSessionRunning, ConfigCrawler.ExchangeSessionRunning, ConfigCrawler.RoutingkeySessionRunning);
channel.QueueBind(ConfigCrawler.QueueTrackRunning, ConfigCrawler.ExchangeSessionRunning, ConfigCrawler.RoutingkeySessionRunning);
channel.QueueDeclare(ConfigCrawler.QueueCompanyFindnew, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueCompanyFindnew, ConfigCrawler.ExchangeCompanyFindNew, ConfigCrawler.RoutingkeyCompanyFindNew);
channel.QueueDeclare(ConfigCrawler.QueueCompanyReload, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueCompanyReload, ConfigCrawler.ExchangeCompanyReload, ConfigCrawler.RoutingkeyCompanyReload);
channel.QueueDeclare(ConfigCrawler.QueueEndSessionToSql, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueEndSessionToSql, ConfigCrawler.ExchangeEndSession, ConfigCrawler.RoutingEndSession);
channel.QueueDeclare(ConfigCrawler.QueueProductChangeToSql, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueProductChangeToSql, ConfigCrawler.ExchangeChangeProduct, ConfigCrawler.RoutingkeyChangeProduct);
channel.QueueDeclare(ConfigCrawler.QueueResetDuplicate, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueResetDuplicate, ConfigCrawler.ExchangeResetDuplicate, ConfigCrawler.RoutingkeyResetDuplicate);
channel.QueueDeclare(ConfigCrawler.QueueDuplicateToCache, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueDuplicateToCache, ConfigCrawler.ExchangeDuplicateProductToCache, ConfigCrawler.RoutingKeyDuplicateProductToCache);
channel.QueueDeclare(ConfigCrawler.QueueProductChangeToCache, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueProductChangeToCache, ConfigCrawler.ExchangeChangeProduct, ConfigCrawler.RoutingkeyChangeProduct);
channel.QueueDeclare(ConfigCrawler.QueueChangeDesc, true, false, false, null);
channel.QueueBind(ConfigCrawler.QueueChangeDesc, ConfigCrawler.ExchangeChangeDesc, ConfigCrawler.RoutingkeyChangeDesc);
channel.QueueDeclare(ConfigCrawler.QueueAddClassification, true, false, false, null);
return;
}
catch (Exception ex)
{
}
}
}
public RabbitMQ.Client.Content.IMessageBuilder WriteMessage(RabbitMQ.Client.IModel ch, Mono.Messaging.IMessage msg)
{
throw null;
}
public void Connect()
{
_connection = _connectionFactory.CreateConnection(_configurationSettings);
_model = _connection.CreateModel();
}
