public void processFollowings() { while (true) { QueueingConsumer.Delivery delivery; try { delivery = consumer.nextDelivery(); String message = new String(delivery.getBody()); Long tag = delivery.getEnvelope().getDeliveryTag(); String[] split = message.split(" "); Long followerVkId = Long.valueOf(split[0]); Long followingVkId = Long.valueOf(split[1]); Follower follower = dbService.getFollowerByVkId(followerVkId); Following following = follower.getFollowingByVkId(followingVkId); refreshFollowing(follower, following); channel.basicAck(tag, false); System.out.println("Ok"); } catch (InterruptedException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }
public static void t1() throws Exception { Channel channel = generateChannel(); // channel.exchangeDeclare(TestAmqp.ExchangerName, "direct", true, false, null); // channel.exchangeDeclare(TestAmqp.FanoutExchangerName, "fanout", true, false, null); channel.exchangeDeclare(TestAmqp.TopicExchangerName, "topic", false, false, null); channel.queueDeclare(TestAmqp.TopicQueueName, false, false, false, null); // channel.queueBind(TestAmqp.TopicQueueName, TestAmqp.TopicExchangerName, // TestAmqp.RouteingName); // channel.queueBind(TestAmqp.TopicQueueName, TestAmqp.TopicExchangerName, "*"); channel.queueBind(TestAmqp.TopicQueueName, TestAmqp.TopicExchangerName, "#.*"); // channel.basicPublish(TestAmqp.ExchangerName, TestAmqp.RouteingName, null, "haha".getBytes()); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume(TestAmqp.TopicQueueName, queueingConsumer); while (true) { QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery(); System.out.println(new String(delivery.getBody())); long deliveryTag = delivery.getEnvelope().getDeliveryTag(); System.out.println("start basicAck:" + deliveryTag); // if (true)throw new RuntimeException("xxxxx"); channel.basicAck(deliveryTag, false); } // channel.close(); // connection.close(); }
private void consumeMessages() { while (true) { QueueingConsumer.Delivery delivery; try { delivery = consumer.nextDelivery(); final String message = new String(delivery.getBody()); runOnUiThread( new Runnable() { public void run() { Toast.makeText(ReceiveActivity.this, message, Toast.LENGTH_LONG).show(); } }); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } catch (ShutdownSignalException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } catch (ConsumerCancelledException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
public static void main(String[] args) throws IOException, InterruptedException { ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); boolean durable = true; channel.queueDeclare(QUEUE_NAME, durable, false, false, null); System.out.println("[*] waiting for messages.To exit press ctrl+z"); // 公平分发 // 告知RabbitMQ不要同时给一个工作者超过一个任务 // 1个工作者处理完成,发送确认之前不要给它分发一个新的消息 int prefetchcount = 1; channel.basicQos(prefetchcount); QueueingConsumer consumer = new QueueingConsumer(channel); boolean autoAck = false; channel.basicConsume(QUEUE_NAME, false, consumer); while (true) { QueueingConsumer.Delivery delivery = consumer.nextDelivery(); String message = new String(delivery.getBody()); System.out.println(" [x] Received '" + message + "'"); // 模拟工作 doWork(message); System.out.println(" [x] Done"); // 发送确认消息 channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } }
public static void main(String[] args) throws Exception { // 获取到连接以及mq通道 Connection connection = ConnectionUtil.getConnection(); Channel channel = connection.createChannel(); // 声明队列 channel.queueDeclare(QUEUE_NAME, false, false, false, null); // 绑定队列到交换机 channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "#.#"); // 同一时刻服务器只会发一条消息给消费者 channel.basicQos(1); // 定义队列的消费者 QueueingConsumer consumer = new QueueingConsumer(channel); // 监听队列,手动返回完成 channel.basicConsume(QUEUE_NAME, false, consumer); // 获取消息 while (true) { QueueingConsumer.Delivery delivery = consumer.nextDelivery(); String message = new String(delivery.getBody()); System.out.println(" [x] Received '" + message + "'"); Thread.sleep(10); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } }
public void ack(Long msgId) { try { channel.basicAck(msgId, false); } catch (Exception e) { logger.error("could not ack for msgId: " + msgId, e); reporter.reportError(e); } }
public void ack(Object msgId) { System.out.println("Acking msg: " + msgId); if (msgId instanceof Long) { final long deliveryTag = (Long) msgId; if (amqpChannel != null) { try { amqpChannel.basicAck(deliveryTag, false /* not multiple */); } catch (IOException e) { log.warn("Failed to ack delivery-tag " + deliveryTag, e); } } } else { log.warn(String.format("don't know how to ack(%s: %s)", msgId.getClass().getName(), msgId)); } }
public void run() { System.out.println(" [x] Awaiting RPC requests"); while (run.get()) { QueueingConsumer.Delivery delivery; try { delivery = consumer.nextDelivery(2000); } catch (ShutdownSignalException e2) { break; } catch (ConsumerCancelledException e2) { break; } catch (InterruptedException e2) { continue; } BasicProperties props = delivery.getProperties(); BasicProperties replyProps = new BasicProperties.Builder().correlationId(props.getCorrelationId()).build(); try { Object o; synchronized (registry) { o = Rmivm.deserialise(delivery.getBody(), registry); } byte[] outBytes = Rmivm.serialize(o); synchronized (channel) { channel.basicPublish("", props.getReplyTo(), replyProps, outBytes); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } } catch (Exception e) { try { synchronized (channel) { channel.basicPublish( "", props.getReplyTo(), replyProps, Rmivm.serialize(new Exception("Boom!"))); } } catch (IOException e1) { // panic } } } System.out.println(" [x] Shutting Down"); }
/** Acks the message with the AMQP broker. */ @Override public void ack(Object msgId) { if (msgId instanceof Long) { final long deliveryTag = (Long) msgId; if (amqpChannel != null) { try { amqpChannel.basicAck(deliveryTag, false /* not multiple */); } catch (IOException e) { log.warn("Failed to ack delivery-tag " + deliveryTag, e); } catch (ShutdownSignalException e) { log.warn("AMQP connection failed. Failed to ack delivery-tag " + deliveryTag, e); } } } else { log.warn(String.format("don't know how to ack(%s: %s)", msgId.getClass().getName(), msgId)); } }
public void serveRequests() { while (true) { try { Delivery delivery = consumer.nextDelivery(); BasicProperties props = delivery.getProperties(); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); System.out.println("Received API call...replying..."); channel.basicPublish("", props.getReplyTo(), null, getResponse(delivery).getBytes("UTF-8")); } catch (Exception e) { System.out.println(e.toString()); } } }
public static void t3() throws Exception { Channel channel = generateChannel(); channel.exchangeDeclare(TestAmqp.PingExchangerName, "direct", true, false, null); channel.queueDeclare("rpc", false, false, false, null); // channel.queueBind(TestAmqp.TopicQueueName, TestAmqp.TopicExchangerName, // TestAmqp.RouteingName); // channel.queueBind(TestAmqp.TopicQueueName, TestAmqp.TopicExchangerName, "*"); channel.queueBind("rpc", TestAmqp.PingExchangerName, "ping"); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); channel.basicConsume("rpc", false, queueingConsumer); while (true) { QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery(); System.out.println("log: " + new String(delivery.getBody())); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); System.out.println("reply to :" + delivery.getProperties().getReplyTo()); channel.basicPublish("", delivery.getProperties().getReplyTo(), null, "asfasdfas".getBytes()); } }
public static void t2() throws Exception { Channel channel = generateChannel(); AMQP.Queue.DeclareOk declareOk1 = channel.queueDeclare(); AMQP.Queue.DeclareOk declareOk2 = channel.queueDeclare(); AMQP.Queue.DeclareOk declareOk3 = channel.queueDeclare(); String exchange = "amq.rabbitmq.log"; channel.queueBind(declareOk1.getQueue(), exchange, "error"); channel.queueBind(declareOk2.getQueue(), exchange, "waring"); channel.queueBind(declareOk3.getQueue(), exchange, "info"); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); channel.basicConsume(declareOk1.getQueue(), false, queueingConsumer); channel.basicConsume(declareOk2.getQueue(), false, queueingConsumer); channel.basicConsume(declareOk3.getQueue(), false, queueingConsumer); while (true) { QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery(); System.out.println("log: " + new String(delivery.getBody())); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } }
public static void main(String[] args) { Options options = new Options(); options.addOption(new Option("h", "uri", true, "AMQP URI")); options.addOption(new Option("q", "queue", true, "queue name")); options.addOption(new Option("t", "type", true, "exchange type")); options.addOption(new Option("e", "exchange", true, "exchange name")); options.addOption(new Option("k", "routing-key", true, "routing key")); options.addOption(new Option("d", "directory", true, "output directory")); CommandLineParser parser = new GnuParser(); try { CommandLine cmd = parser.parse(options, args); String uri = strArg(cmd, 'h', "amqp://localhost"); String requestedQueueName = strArg(cmd, 'q', ""); String exchangeType = strArg(cmd, 't', "direct"); String exchange = strArg(cmd, 'e', null); String routingKey = strArg(cmd, 'k', null); String outputDirName = strArg(cmd, 'd', "."); File outputDir = new File(outputDirName); if (!outputDir.exists() || !outputDir.isDirectory()) { System.err.println("Output directory must exist, and must be a directory."); System.exit(2); } ConnectionFactory connFactory = new ConnectionFactory(); connFactory.setUri(uri); Connection conn = connFactory.newConnection(); final Channel ch = conn.createChannel(); String queueName = (requestedQueueName.equals("") ? ch.queueDeclare() : ch.queueDeclare(requestedQueueName, false, false, false, null)) .getQueue(); if (exchange != null || routingKey != null) { if (exchange == null) { System.err.println("Please supply exchange name to bind to (-e)"); System.exit(2); } if (routingKey == null) { System.err.println("Please supply routing key pattern to bind to (-k)"); System.exit(2); } ch.exchangeDeclare(exchange, exchangeType); ch.queueBind(queueName, exchange, routingKey); } QueueingConsumer consumer = new QueueingConsumer(ch); ch.basicConsume(queueName, consumer); while (true) { QueueingConsumer.Delivery delivery = consumer.nextDelivery(); Map<String, Object> headers = delivery.getProperties().getHeaders(); byte[] body = delivery.getBody(); Object headerFilenameO = headers.get("filename"); String headerFilename = (headerFilenameO == null) ? UUID.randomUUID().toString() : headerFilenameO.toString(); File givenName = new File(headerFilename); if (givenName.getName().equals("")) { System.out.println("Skipping file with empty name: " + givenName); } else { File f = new File(outputDir, givenName.getName()); System.out.print("Writing " + f + " ..."); FileOutputStream o = new FileOutputStream(f); o.write(body); o.close(); System.out.println(" done."); } ch.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } } catch (Exception ex) { System.err.println("Main thread caught exception: " + ex); ex.printStackTrace(); System.exit(1); } }
@Override public void run() { while (true) { if (closed) { break; } try { connection = connectionFactory.newConnection(rabbitAddresses); channel = connection.createChannel(); } catch (Exception e) { if (!closed) { logger.warn("failed to created a connection / channel", e); } else { continue; } cleanup(0, "failed to connect"); try { Thread.sleep(5000); } catch (InterruptedException e1) { // ignore, if we are closing, we will exit later } } QueueingConsumer consumer = null; // define the queue try { if (rabbitQueueDeclare) { // only declare the queue if we should channel.queueDeclare( rabbitQueue /*queue*/, rabbitQueueDurable /*durable*/, false /*exclusive*/, rabbitQueueAutoDelete /*autoDelete*/, rabbitQueueArgs /*extra args*/); } if (rabbitExchangeDeclare) { // only declare the exchange if we should channel.exchangeDeclare( rabbitExchange /*exchange*/, rabbitExchangeType /*type*/, rabbitExchangeDurable); } channel.basicQos( rabbitQosPrefetchSize /*qos_prefetch_size*/, rabbitQosPrefetchCount /*qos_prefetch_count*/, false); if (rabbitQueueBind) { // only bind queue if we should channel.queueBind( rabbitQueue /*queue*/, rabbitExchange /*exchange*/, rabbitRoutingKey /*routingKey*/); } consumer = new QueueingConsumer(channel); channel.basicConsume(rabbitQueue /*queue*/, false /*noAck*/, consumer); } catch (Exception e) { if (!closed) { logger.warn("failed to create queue [{}]", e, rabbitQueue); } cleanup(0, "failed to create queue"); continue; } // now use the queue to listen for messages while (true) { if (closed) { break; } QueueingConsumer.Delivery task; try { task = consumer.nextDelivery(); } catch (Exception e) { if (!closed) { logger.error("failed to get next message, reconnecting...", e); } cleanup(0, "failed to get message"); break; } if (task != null && task.getBody() != null) { final List<Long> deliveryTags = Lists.newArrayList(); BulkRequestBuilder bulkRequestBuilder = client.prepareBulk(); try { processBody(task, bulkRequestBuilder); } catch (Exception e) { logger.warn( "failed to parse request for delivery tag [{}], ack'ing...", e, task.getEnvelope().getDeliveryTag()); try { channel.basicAck(task.getEnvelope().getDeliveryTag(), false); } catch (IOException e1) { logger.warn("failed to ack [{}]", e1, task.getEnvelope().getDeliveryTag()); } continue; } deliveryTags.add(task.getEnvelope().getDeliveryTag()); if (bulkRequestBuilder.numberOfActions() < bulkSize) { // try and spin some more of those without timeout, so we have a bigger bulk (bounded // by the bulk size) try { while ((task = consumer.nextDelivery(bulkTimeout.millis())) != null) { try { processBody(task, bulkRequestBuilder); deliveryTags.add(task.getEnvelope().getDeliveryTag()); } catch (Throwable e) { logger.warn( "failed to parse request for delivery tag [{}], ack'ing...", e, task.getEnvelope().getDeliveryTag()); try { channel.basicAck(task.getEnvelope().getDeliveryTag(), false); } catch (Exception e1) { logger.warn( "failed to ack on failure [{}]", e1, task.getEnvelope().getDeliveryTag()); } } if (bulkRequestBuilder.numberOfActions() >= bulkSize) { break; } } } catch (InterruptedException e) { if (closed) { break; } } catch (ShutdownSignalException sse) { logger.warn( "Received a shutdown signal! initiatedByApplication: [{}], hard error: [{}]", sse, sse.isInitiatedByApplication(), sse.isHardError()); if (!closed && sse.isInitiatedByApplication()) { logger.error("failed to get next message, reconnecting...", sse); } cleanup(0, "failed to get message"); break; } } if (logger.isTraceEnabled()) { logger.trace( "executing bulk with [{}] actions", bulkRequestBuilder.numberOfActions()); } // if we have no bulk actions we might have processed custom commands, so ack them if (ordered || bulkRequestBuilder.numberOfActions() == 0) { try { if (bulkRequestBuilder.numberOfActions() > 0) { BulkResponse response = bulkRequestBuilder.execute().actionGet(); if (response.hasFailures()) { // TODO write to exception queue? logger.warn("failed to execute: " + response.buildFailureMessage()); } } } catch (Exception e) { logger.warn("failed to execute bulk", e); } for (Long deliveryTag : deliveryTags) { try { channel.basicAck(deliveryTag, false); } catch (Exception e1) { logger.warn("failed to ack [{}]", e1, deliveryTag); } } } else { if (bulkRequestBuilder.numberOfActions() > 0) { bulkRequestBuilder.execute( new ActionListener<BulkResponse>() { @Override public void onResponse(BulkResponse response) { if (response.hasFailures()) { // TODO write to exception queue? logger.warn("failed to execute: " + response.buildFailureMessage()); } for (Long deliveryTag : deliveryTags) { try { channel.basicAck(deliveryTag, false); } catch (Exception e1) { logger.warn("failed to ack [{}]", e1, deliveryTag); } } } @Override public void onFailure(Throwable e) { logger.warn( "failed to execute bulk for delivery tags [{}], not ack'ing", e, deliveryTags); } }); } } } } } cleanup(0, "closing river"); }
@Override protected void executeListener(Channel channel, Message message) throws Throwable { super.executeListener(channel, message); channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); if (log.isDebugEnabled()) log.debug("Acknowledging message: " + new String(message.getBody())); }
/** * @param args * @throws IOException * @throws FileNotFoundException * @throws UnsupportedEncodingException * @throws InterruptedException */ public static void main(String[] args) throws UnsupportedEncodingException, FileNotFoundException, IOException, InterruptedException { Properties ps = new Properties(); ps.load( new InputStreamReader( FileUtil.openPropertiesInputStream("log4j.properties"), FileUtil.fileEncode)); PropertyConfigurator.configure(ps); // 创建线程池 HSCloudEventHandler job = new HSCloudEventHandler(job_name, max_thread); // 从RabbitMQ接收消息并处理 try { // 初始化RabbitMQ连接 ConnectionFactory factory = new ConnectionFactory(); factory.setHost(host); factory.setUsername(username); factory.setPassword(SecurityHelper.DecryptData(password, securityKey)); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); channel.exchangeDeclare(exchange, "fanout", durable); DeclareOk ok = channel.queueDeclare(queue, durable, false, false, null); String queueName = ok.getQueue(); channel.queueBind(queueName, exchange, ""); channel.basicQos(1); // 消息分发处理 QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicConsume(queueName, false, consumer); logger.info( "Begin to receive RabbitMQ event: host[" + host + "] exchange[" + exchange + "] queue[" + queueName + "] max-thread[" + max_thread + "]"); while (true) { Date now = new Date(); if (expirationDate.before(now)) { logger.error("证书失效,系统终止服务。"); System.exit(-1); } QueueingConsumer.Delivery delivery = consumer.nextDelivery(); if (FileUtil.stopProcess()) { logger.info("JobServer receive stop process event and will be end....."); break; } String message = new String(delivery.getBody()); logger.debug(" [" + queue + "] Received '" + message + "'"); // 处理创建虚拟机的消息,创建虚拟机需要分配ip,多以单独放在一个队列里面处理。 if (jobServerType.equals("master")) { if (message.indexOf("createVM_") != -1) { // 根据消息内容判断消息类型 try { // 对创建vm的消息进行处理,分配ip并填充到消息中 message = handleMessage(message); // 创建线程去向openstack请求创建vm job.Handler(message); } catch (Exception e) { // 如果在分配ip过程中出现异常则捕获,把消息中的result:3,置换为result:4,error_info:错误信息 logger.error(e.getMessage(), e); try { // 对消息填充和置换ip分配失败的信息 message = saveGetIpExceptionLog(message, e.getMessage()); // 即使ip分配失败仍然创建线程去向openstack请求创建vm job.Handler(message); } catch (Exception ex) { logger.error(ex.getMessage(), e); } channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); continue; } } channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } else if (jobServerType.equals("slaver")) { // 执行非创建vm的任务 if (message.indexOf("createVM_") == -1) { job.Handler(message); } channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } else if (jobServerType.equals("all")) { try { message = handleMessage(message); job.Handler(message); } catch (Exception e) { logger.error(e.getMessage(), e); try { saveGetIpExceptionLog(message, e.getMessage()); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); continue; } catch (Exception ex) { logger.error(ex.getMessage(), ex); } } channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } TimeUnit.MILLISECONDS.sleep(sleepTime); } } catch (Exception e) { logger.error(e.getMessage(), e); } // 退出线程池 job.Shutdown(); while (!job.IsTerminate()) { logger.info("Waiting for JobServer finished!"); } logger.info("JobServer finished!"); System.exit(0); }
/** {@inheritDoc} */ @Override public SampleResult sample(Entry entry) { SampleResult result = new SampleResult(); result.setSampleLabel(getName()); result.setSuccessful(false); result.setResponseCode("500"); QueueingConsumer consumer; String consumerTag; trace("AMQPConsumer.sample()"); try { initChannel(); consumer = new QueueingConsumer(channel); channel.basicQos(1); // TODO: make prefetchCount configurable? consumerTag = channel.basicConsume(getQueue(), autoAck(), consumer); } catch (IOException ex) { log.error("Failed to initialize channel", ex); return result; } result.setSampleLabel(getTitle()); /* * Perform the sampling */ result.sampleStart(); // Start timing try { QueueingConsumer.Delivery delivery = consumer.nextDelivery(getReceiveTimeoutAsInt()); if (delivery == null) { log.warn("nextDelivery timed out"); return result; } /* * Set up the sample result details */ result.setSamplerData(new String(delivery.getBody())); result.setResponseData("OK", null); result.setDataType(SampleResult.TEXT); result.setResponseCodeOK(); result.setResponseMessage("OK"); result.setSuccessful(true); if (!autoAck()) channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } catch (ShutdownSignalException e) { log.warn("AMQP consumer failed to consume", e); result.setResponseCode("400"); result.setResponseMessage(e.toString()); interrupt(); } catch (ConsumerCancelledException e) { log.warn("AMQP consumer failed to consume", e); result.setResponseCode("300"); result.setResponseMessage(e.toString()); interrupt(); } catch (InterruptedException e) { log.info("interuppted while attempting to consume"); result.setResponseCode("200"); result.setResponseMessage(e.toString()); } catch (IOException e) { log.warn("AMQP consumer failed to consume", e); result.setResponseCode("100"); result.setResponseMessage(e.toString()); } finally { try { channel.basicCancel(consumerTag); } catch (IOException e) { log.error("Couldn't safely cancel the sample's consumer", e); } } result.sampleEnd(); // End timimg trace("AMQPConsumer.sample ended"); return result; }
@Override public PollableSource.Status process() throws EventDeliveryException { if (null == _Connection) { try { if (log.isInfoEnabled()) log.info( this.getName() + " - Opening connection to " + _ConnectionFactory.getHost() + ":" + _ConnectionFactory.getPort()); _Connection = _ConnectionFactory.newConnection(); _CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_NEW_CONNECTION); _Channel = null; } catch (Exception ex) { if (log.isErrorEnabled()) log.error(this.getName() + " - Exception while establishing connection.", ex); resetConnection(); return Status.BACKOFF; } } if (null == _Channel) { try { if (log.isInfoEnabled()) log.info(this.getName() + " - creating channel..."); _Channel = _Connection.createChannel(); _CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_NEW_CHANNEL); if (log.isInfoEnabled()) log.info( this.getName() + " - Connected to " + _ConnectionFactory.getHost() + ":" + _ConnectionFactory.getPort()); if (StringUtils.isNotEmpty(_ExchangeName)) { try { // declare an exchange _Channel.exchangeDeclarePassive(_ExchangeName); // only grab a default queuename if one is not specified in config if (StringUtils.isEmpty(_QueueName)) { _QueueName = _Channel.queueDeclare().getQueue(); } // for each topic, bind to the key if (null != _Topics) { for (String topic : _Topics) { _Channel.queueBind(_QueueName, _ExchangeName, topic); } } } catch (Exception ex) { if (log.isErrorEnabled()) log.error(this.getName() + " - Exception while declaring exchange.", ex); resetConnection(); return Status.BACKOFF; } } } catch (Exception ex) { if (log.isErrorEnabled()) log.error(this.getName() + " - Exception while creating channel.", ex); resetConnection(); return Status.BACKOFF; } } GetResponse response; try { response = _Channel.basicGet(_QueueName, false); _CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_GET); } catch (Exception ex) { _CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_EXCEPTION); if (log.isErrorEnabled()) log.error(this.getName() + " - Exception thrown while pulling from queue.", ex); resetConnection(); return Status.BACKOFF; } if (null == response) { _CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_GET_MISS); return Status.BACKOFF; } try { Map<String, String> properties = RabbitMQUtil.getHeaders(response.getProps()); Event event = new SimpleEvent(); event.setBody(response.getBody()); event.setHeaders(properties); getChannelProcessor().processEvent(event); } catch (Exception ex) { if (log.isErrorEnabled()) log.error(this.getName() + " - Exception thrown while processing event", ex); return Status.BACKOFF; } try { _Channel.basicAck(response.getEnvelope().getDeliveryTag(), false); _CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_ACK); } catch (Exception ex) { _CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_EXCEPTION); if (log.isErrorEnabled()) log.error(this.getName() + " - Exception thrown while sending ack to queue", ex); resetConnection(); return Status.BACKOFF; } return Status.READY; }