@Override public boolean hasMore() { nextRow = null; try { if (nextIterator.hasNext()) { nextRow = nextIterator.next(); return true; } // Wait for the next delivery. This will block until something is available. final Delivery delivery = consumer.nextDelivery(); if (delivery != null) { lastDeliveryTag = delivery.getEnvelope().getDeliveryTag(); nextIterator = firehoseParser.parseBatch(ByteBuffer.wrap(delivery.getBody())).iterator(); if (nextIterator.hasNext()) { nextRow = nextIterator.next(); // If delivery is non-null, we report that there is something more to process. return true; } } } catch (InterruptedException e) { // A little unclear on how we should handle this. // At any rate, we're in an unknown state now so let's log something and return false. log.wtf(e, "Got interrupted while waiting for next delivery. Doubt this should ever happen."); } // This means that delivery is null or we caught the exception above so we report that we have // nothing more to process. return false; }
@Override public void run(SourceContext<OUT> ctx) throws Exception { while (running) { QueueingConsumer.Delivery delivery = consumer.nextDelivery(); synchronized (ctx.getCheckpointLock()) { OUT result = schema.deserialize(delivery.getBody()); if (schema.isEndOfStream(result)) { break; } if (!autoAck) { final long deliveryTag = delivery.getEnvelope().getDeliveryTag(); if (usesCorrelationId) { final String correlationId = delivery.getProperties().getCorrelationId(); Preconditions.checkNotNull(correlationId, "RabbitMQ source was instantiated " + "with usesCorrelationId set to true but a message was received with " + "correlation id set to null!"); if (!addId(correlationId)) { // we have already processed this message continue; } } sessionIds.add(deliveryTag); } ctx.collect(result); } } }
//Consumer - executed in a Thread QueueingConsumer consumer = new QueueingConsumer(connection.createChannel()); boolean autoAck = false; channel.basicConsume("hello", autoAck, consumer); while (!Thread.current().isInterrupted())) { QueueingConsumer.Delivery delivery = consumer.nextDelivery(); //... channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); }
msgContext.getChannel().basicAck(delivery.getEnvelope().getDeliveryTag(), false);
parent.channel.basicPublish("", props.getReplyTo(), replyProps, buildResponse(0, pngBys)); if (Visage.trace) Visage.log.finest("Published response"); parent.channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); if (Visage.trace) Visage.log.finest("Ack'd message");
@Override protected boolean process() throws IOException, InterruptedException { channelConnect(); final QueueingConsumer consumer = consumerHolder.get(); if (consumer == null) { // When the channel is not connected, this can happen. Simulate a tick. LOG.warn("Channel not connected!"); Thread.sleep(tickTimeout); return true; } else { final QueueingConsumer.Delivery delivery = consumer.nextDelivery(tickTimeout); if (delivery != null) { try { return consumerCallback.withDelivery(delivery); } finally { final Channel channel = getChannel(); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } } else { LOG.trace("Tick..."); } return true; } } }
/** * Emits the next message from the queue as a tuple. * * <p>If no message is ready to emit, this will wait a short time * ({@link #WAIT_FOR_NEXT_MESSAGE}) for one to arrive on the queue, * to avoid a tight loop in the spout worker.</p> */ @Override public void nextTuple() { if (amqpConsumer != null) { try { final QueueingConsumer.Delivery delivery = amqpConsumer.nextDelivery(WAIT_FOR_NEXT_MESSAGE); if (delivery == null) return; final long deliveryTag = delivery.getEnvelope().getDeliveryTag(); final byte[] message = delivery.getBody(); collector.emit(serialisationScheme.deserialize(message), deliveryTag); /* * TODO what to do about malformed messages? Skip? * Avoid infinite retry! * Maybe we should output them on a separate stream. */ } catch (ShutdownSignalException e) { log.warn("AMQP connection dropped, will attempt to reconnect..."); Utils.sleep(WAIT_AFTER_SHUTDOWN_SIGNAL); reconnect(); } catch (InterruptedException e) { // interrupted while waiting for message, big deal } } }
public void run() { try { Channel channel = connection.createChannel(); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume("flow.q", false, consumer); while (true) { QueueingConsumer.Delivery msg = consumer.nextDelivery(); boolean controlFlow = new Boolean(new String(msg.getBody())).booleanValue(); channel.basicAck(msg.getEnvelope().getDeliveryTag(), false); if (controlFlow) { System.out.println("notification received to slow down..."); synchronized(delay) { delay = 3000l; } } else { System.out.println("system back to normal..."); synchronized(delay) { delay = 1000l; } } } } catch (Exception e) { e.printStackTrace(); } }}.start(); }
@Override public boolean hasMore() { delivery = null; try { // Wait for the next delivery. This will block until something is available. delivery = consumer.nextDelivery(); if (delivery != null) { lastDeliveryTag = delivery.getEnvelope().getDeliveryTag(); // If delivery is non-null, we report that there is something more to process. return true; } } catch (InterruptedException e) { // A little unclear on how we should handle this. // At any rate, we're in an unknown state now so let's log something and return false. log.wtf(e, "Got interrupted while waiting for next delivery. Doubt this should ever happen."); } // This means that delivery is null or we caught the exception above so we report that we have // nothing more to process. return false; }
private DeliveredMessage(QueueingConsumer.Delivery delivery) { super(delivery.getBody()); redelivery = delivery.getEnvelope().isRedeliver(); deliveryTag = delivery.getEnvelope().getDeliveryTag(); routingKey = delivery.getEnvelope().getRoutingKey(); exchange = delivery.getEnvelope().getExchange(); className = delivery.getProperties().getClassName(); clusterId = delivery.getProperties().getClusterId(); contentEncoding = delivery.getProperties().getContentEncoding(); contentType = delivery.getProperties().getContentType(); correlationId = delivery.getProperties().getCorrelationId(); deliveryMode = delivery.getProperties().getDeliveryMode(); expiration = delivery.getProperties().getExpiration(); headers = delivery.getProperties().getHeaders(); messageId = delivery.getProperties().getMessageId(); priority = delivery.getProperties().getPriority(); replyTo = delivery.getProperties().getReplyTo(); timestamp = delivery.getProperties().getTimestamp(); type = delivery.getProperties().getType(); userId = delivery.getProperties().getUserId(); }
ConnectionFactory factory = new ConnectionFactory(); factory.setHost("localhost"); Connection connection = factory.newConnection(); Channel channel = connection.createChannel(); channel.basicQos(1); channel.queueDeclare(QUEUE_NAME, true, false, false, null); System.out.println("[*] waiting for messages. To exit press CTRL+C"); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicConsume(QUEUE_NAME, consumer); while(true) { QueueingConsumer.Delivery delivery = consumer.nextDelivery(); int n = channel.queueDeclarePassive(QUEUE_NAME).getMessageCount(); System.out.println(n); if(delivery != null) { byte[] bs = delivery.getBody(); System.out.println(new String(bs)); //String message= new String(delivery.getBody()); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); //System.out.println("[x] Received '"+message); } }
public void start(Connection connection) { try { active = true; Channel channel = connection.createChannel(); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume("trade.eq.q", false, consumer); while (active) { QueueingConsumer.Delivery msg = consumer.nextDelivery(); System.out.println("message received: " + new String(msg.getBody())); Thread.sleep(1000); channel.basicAck(msg.getEnvelope().getDeliveryTag(), false); } channel.close(); } catch (Exception e) { e.printStackTrace(); } }
public static void main(String[] args) throws Exception { Channel channel = AMQPCommon.connect(); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume("trade.eq.q", false, consumer); int numMsgs = args.length > 0 ? new Integer(args[0]).intValue() : 1; for (int i=0; i<numMsgs; i++) { QueueingConsumer.Delivery msg = consumer.nextDelivery(); System.out.println("message received: " + new String(msg.getBody())); Thread.sleep(1000); channel.basicAck(msg.getEnvelope().getDeliveryTag(), false); } AMQPCommon.close(channel); } }
public static void main(String[] args) throws Exception { Channel channel = AMQPCommon.connect(); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume(args[0], false, consumer); while (true) { QueueingConsumer.Delivery msg = consumer.nextDelivery(1000); if (msg == null) break; System.out.println("message received: " + new String(msg.getBody())); Thread.sleep(100); channel.basicAck(msg.getEnvelope().getDeliveryTag(), false); } System.exit(0); } }
public void dispatchMessages() throws Exception { Channel channel = AMQPCommon.connect(); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume("trade.eq.q", false, consumer); while (true) { QueueingConsumer.Delivery msg = consumer.nextDelivery(); channel.basicAck(msg.getEnvelope().getDeliveryTag(), false); new Thread(new POJOThreadProcessor( this, new String(msg.getBody()))).start(); numThreads++; System.out.println("Threads: " + numThreads); } }
public static void main(String[] args) throws Exception { Channel channel = AMQPCommon.connect(); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume("trade.eq.q", false, consumer); while (true) { QueueingConsumer.Delivery msg = consumer.nextDelivery(); Thread.sleep(2000); System.out.println("Trade placed: " + new String(msg.getBody())); channel.basicAck(msg.getEnvelope().getDeliveryTag(), false); } } }
public static void main(String[] args) throws Exception { Channel channel = AMQPCommon.connect(); QueueingConsumer consumer = new QueueingConsumer(channel); channel.basicQos(1); channel.basicConsume("trade.eq.q", false, consumer); while (true) { QueueingConsumer.Delivery msg = consumer.nextDelivery(); System.out.println("message received: " + new String(msg.getBody())); Thread.sleep(2000); channel.basicAck(msg.getEnvelope().getDeliveryTag(), false); } } }
QueueingConsumer.Delivery queueMessage = consumer.nextDelivery(); String message = new String(queueMessage.getBody()); // if auto-ack is not set channel.basicAck(queueMessage.getEnvelope().getDeliveryTag(), false);
QueueingConsumer.Delivery delivery = consumer.nextDelivery(); //...do something with the message... channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); //the false flag is to do with multiple message acknowledgement
public MQItem recv() throws InterruptedException, IOException { QueueingConsumer.Delivery delivery = consumer.nextDelivery(); MQItem item = gson.fromJson(new String(delivery.getBody()), MQItem.class); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); return item; }