Exemple #1
0
  public String recvFromMessagequeue() {

    RabbitmqClientConf client = new RabbitmqClientConf();
    Channel channel = client.getChannel();

    try {
      channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    } catch (IOException e) {
      e.printStackTrace();
    }

    System.out.println(" [*] Waiting for messages, To exit press CTRL+C");

    QueueingConsumer consumer = new QueueingConsumer(channel);

    try {
      channel.basicConsume(QUEUE_NAME, true, consumer);
    } catch (IOException e) {
      e.printStackTrace();
    }

    System.out.println("ready to receive");

    QueueingConsumer.Delivery delivery = null;
    try {
      delivery = consumer.nextDelivery();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    String message = new String(delivery.getBody());
    System.out.println("[x] Received'" + message + "'");

    return message;
  }
Exemple #2
0
  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[] argv)
      throws java.io.IOException, java.lang.InterruptedException, TimeoutException {
    // 创建连接和频道
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
    // 声明direct类型转发器
    channel.exchangeDeclare(EXCHANGE_NAME, "direct");

    String queueName = channel.queueDeclare().getQueue();
    String severity = getSeverity();
    // 指定binding_key
    channel.queueBind(queueName, EXCHANGE_NAME, severity);
    System.out.println(" [*] Waiting for " + severity + " logs. To exit press CTRL+C");

    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(queueName, true, consumer);

    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());

      System.out.println(" [x] Received '" + message + "'");
    }
  }
  public void receiveMessage(String qName) {
    try {
      CachingConnectionFactory factory = new CachingConnectionFactory();
      factory.setAddresses("10.30.135.103:5672,10.30.135.101:5672");
      org.springframework.amqp.rabbit.connection.Connection connection = factory.createConnection();
      Channel channel = connection.createChannel(false);

      // channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
      // ring queueName = channel.queueDeclare().getQueue();
      // channel.queueBind(queueName, EXCHANGE_NAME, "");

      System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

      QueueingConsumer consumer = new QueueingConsumer(channel);
      channel.basicConsume(qName, true, consumer);

      while (true) {
        QueueingConsumer.Delivery delivery = consumer.nextDelivery();
        String message = new String(delivery.getBody());

        System.out.println(" [x] Received '" + message + "'");
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  @Test
  public void testBasicConnectivity() {
    String sentMsg = "sent";
    String recvdMsg = "received";
    try {
      channel.queueDeclare(basicTestQueue, false, false, false, null);
      sentMsg = "testBasicConnectivity";
      channel.basicPublish("", basicTestQueue, null, sentMsg.getBytes());

      QueueingConsumer consumer = new QueueingConsumer(channel);
      channel.basicConsume(basicTestQueue, true, consumer);
      QueueingConsumer.Delivery delivery = consumer.nextDelivery(1500);
      if (delivery != null) {
        recvdMsg = new String(delivery.getBody());
      }

    } catch (Exception ex) {
      fail("Connectivity error to MQ while running Test" + ex);
    } finally {
      try {
        channel.close();
        connection.close();
      } catch (Exception ex) {
        fail("Connectivity error to MQ while running Test" + ex);
      }
    }
    assertEquals(sentMsg, recvdMsg);
  }
  public static void main(String[] arg) throws IOException, InterruptedException {

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.exchangeDeclare(EXCHANGE_NAME, "direct");
    String queueName = channel.queueDeclare().getQueue();

    if (arg.length < 1) {
      System.err.println("Usage: ReceiveLogsDirect [info] [warning] [error]");
      System.exit(1);
    }

    for (String severity : arg) {
      channel.queueBind(queueName, EXCHANGE_NAME, severity);
    }

    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(queueName, true, consumer);

    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      String routingKey = delivery.getEnvelope().getRoutingKey();

      System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");
    }
  }
Exemple #7
0
  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);
    }
  }
  /** Test that an AMQP client can connect to and use the broker. */
  @Test(groups = {"Integration", "WIP"})
  public void testClientConnection() throws Exception {
    rabbit = app.createAndManageChild(EntitySpec.create(RabbitBroker.class));
    rabbit.start(ImmutableList.of(testLocation));
    EntityTestUtils.assertAttributeEqualsEventually(rabbit, Startable.SERVICE_UP, true);

    byte[] content = "MessageBody".getBytes(Charsets.UTF_8);
    String queue = "queueName";
    Channel producer = null;
    Channel consumer = null;
    try {
      producer = getAmqpChannel(rabbit);
      consumer = getAmqpChannel(rabbit);

      producer.queueDeclare(queue, true, false, false, ImmutableMap.<String, Object>of());
      producer.queueBind(queue, AmqpExchange.DIRECT, queue);
      producer.basicPublish(AmqpExchange.DIRECT, queue, null, content);

      QueueingConsumer queueConsumer = new QueueingConsumer(consumer);
      consumer.basicConsume(queue, true, queueConsumer);

      QueueingConsumer.Delivery delivery =
          queueConsumer.nextDelivery(60 * 1000l); // one minute timeout
      assertEquals(delivery.getBody(), content);
    } finally {
      closeSafely(producer, 10 * 1000);
      closeSafely(consumer, 10 * 1000);
    }
  }
Exemple #9
0
  public static void main(String[] args) throws IOException, InterruptedException {
    Random random = new Random();
    int i = random.nextInt(10);
    String clientName = "client-" + i;

    Channel channel = RabbitUtil.getChannel();
    // 申明交换器
    channel.exchangeDeclare(C.FANOUT_EXCHANGE, "fanout");

    // 匿名队列
    String queueName = channel.queueDeclare().getQueue();
    System.err.println("queueName:" + queueName);

    // 绑定队列到交换器
    AMQP.Queue.BindOk bindOk = channel.queueBind(queueName, C.FANOUT_EXCHANGE, "");
    System.err.println("bindOk:" + bindOk);

    System.out.println(clientName + "  Waiting for messages. To exit press CTRL+C");

    QueueingConsumer consumer = new QueueingConsumer(channel);

    channel.basicConsume(queueName, true, consumer);

    while (true) {

      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());

      System.out.println(clientName + " Received :" + message + "");
      Thread.sleep(1000);
    }
  }
Exemple #10
0
  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();
  }
  /**
   * 从指定队列接收消息,然后通过观察者对象处理
   *
   * @param queueName
   * @param observer
   * @throws Exception
   */
  public void receive(String queueName, IObserver observer) throws Exception {
    try {
      this.init();

      // 指定队列
      channel.queueDeclare(queueName, true, false, false, null);

      // 绑定队列到指定的交换机
      // channel.queueBind(queueName, mqExchangeName, queueName);
      // log.info("Bind queue {} to {} success! ", queueName, mqExchangeName);

      QueueingConsumer consumer = new QueueingConsumer(channel);
      channel.basicConsume(queueName, true, consumer);

      while (true) {
        // 阻塞,直到接收到一条消息
        QueueingConsumer.Delivery delivery = consumer.nextDelivery();
        String message = new String(delivery.getBody());
        log.info("Received a message: " + message);

        observer.update(message);
      }

    } finally {
      this.destory();
    }
  }
  @Override
  protected String doInBackground(Object... params) {
    Context = (Activity) params[1];
    try {

      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("192.168.1.3");
      Connection connection = factory.newConnection();
      channel = connection.createChannel();

      channel.queueDeclare("helloWorld", false, false, false, null);

      System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

      QueueingConsumer consumer = new QueueingConsumer(channel);
      channel.basicConsume("helloWorld", true, consumer);

      while (!isCancelled()) {
        try {
          QueueingConsumer.Delivery delivery = consumer.nextDelivery(5000);
          final String message = new String(delivery.getBody());

          final ConsumeData data = new ConsumeData(message);

          Context.runOnUiThread(
              new Runnable() {

                @Override
                public void run() {
                  TextView mOutput = (TextView) Context.findViewById(R.id.output);

                  mOutput.setMovementMethod(new ScrollingMovementMethod());

                  for (String item : data.Messages) {
                    mOutput.setText(item + "\n" + mOutput.getText());
                  }
                }
              });

          System.out.println(" [x] Received '" + message + "'");
        } catch (Exception ex) {

        }
      }

    } catch (Exception ex) {

    }

    return "";
  }
  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 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 main(String[] argv) {
    Connection connection = null;
    Channel channel = null;
    try {
      ConnectionFactory factory = new ConnectionFactory();
      factory.setHost("localhost");

      connection = factory.newConnection();
      channel = connection.createChannel();

      channel.exchangeDeclare(EXCHANGE_NAME, "topic");
      String queueName = channel.queueDeclare().getQueue();

      if (argv.length < 1) {
        System.err.println("Usage: ReceiveLogsTopic [binding_key]...");
        System.exit(1);
      }

      for (String bindingKey : argv) {
        channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
      }

      System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

      QueueingConsumer consumer = new QueueingConsumer(channel);
      channel.basicConsume(queueName, true, consumer);

      while (true) {
        QueueingConsumer.Delivery delivery = consumer.nextDelivery();
        String message = new String(delivery.getBody());
        String routingKey = delivery.getEnvelope().getRoutingKey();

        System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      if (connection != null) {
        try {
          connection.close();
        } catch (Exception ignore) {
        }
      }
    }
  }
Exemple #16
0
  /**
   * Emits the next message from the queue as a tuple.
   *
   * <p>Serialization schemes returning null will immediately ack and then emit unanchored on the
   * {@link #ERROR_STREAM_NAME} stream for further handling by the consumer.
   *
   * <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.
   */
  @Override
  public void nextTuple() {
    if (spoutActive && 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();

        /////////////////// new rpc
        BasicProperties props = delivery.getProperties();
        BasicProperties replyProps =
            new BasicProperties.Builder().correlationId(props.getCorrelationId()).build();
        //////////////////////////////
        List<Object> deserializedMessage = serialisationScheme.deserialize(message);
        if (deserializedMessage != null && deserializedMessage.size() > 0) {
          // let's see what's inside the Object List (checking)
          /*System.out.println("Lenght of the list : "+ deserializedMessage.size() +"\n");
          for (int i =0; i< deserializedMessage.size(); i++){
          	Object obj=deserializedMessage.get(i);
          	System.out.println("Object value: "+  obj + "\n" );
          }*/
          ArrayList li = new ArrayList();
          li.add(deserializedMessage.get(0));
          li.add(props);
          li.add(replyProps);
          deserializedMessage = li;
          collector.emit(deserializedMessage, deliveryTag);
          /////////// new for AMQPSpout RPC+JSON
          try {
            String response = "your name was: " + deserializedMessage.get(0) + " ";
            this.amqpChannel.basicPublish(
                "", props.getReplyTo(), replyProps, response.getBytes("UTF-8"));
            // this.amqpChannel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            this.amqpChannel.basicAck(deliveryTag, false);
          }
          /// publishjson(props, replyProps, delivery.detEnvelope().getDeliveryTag());
          // try{
          //	publishjson(props, replyProps);
          // }
          catch (IOException e) {
            log.error("Error when publishing to the response queue", e);
          }
          ////////////////
        } else {
          handleMalformedDelivery(deliveryTag, message);
        }
      } 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
      }
    }
  }
Exemple #17
0
  public static void main(String[] argv) throws java.io.IOException, InterruptedException {

    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();

    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(QUEUE_NAME, true, consumer);

    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      System.out.println(" [x] Received '" + message + "'");
    }
  }
  public void run() throws IOException, InterruptedException {
    final Connection connection = m_connFactory.newConnection();
    final Channel channel = connection.createChannel();

    try {
      channel.exchangeDeclare(m_exchangeName, "topic", true);
      String dataQueue = channel.queueDeclare().getQueue();
      channel.queueBind(dataQueue, m_exchangeName, "EXPORT_PARTITIONED_TABLE.#");
      channel.queueBind(dataQueue, m_exchangeName, "EXPORT_PARTITIONED_TABLE2.#");
      channel.queueBind(dataQueue, m_exchangeName, "EXPORT_REPLICATED_TABLE.#");
      channel.queueBind(dataQueue, m_exchangeName, "EXPORT_PARTITIONED_TABLE_FOO.#");
      channel.queueBind(dataQueue, m_exchangeName, "EXPORT_PARTITIONED_TABLE2_FOO.#");
      channel.queueBind(dataQueue, m_exchangeName, "EXPORT_REPLICATED_TABLE_FOO.#");
      String doneQueue = channel.queueDeclare().getQueue();
      channel.queueBind(doneQueue, m_exchangeName, "EXPORT_DONE_TABLE.#");
      channel.queueBind(doneQueue, m_exchangeName, "EXPORT_DONE_TABLE_FOO.#");

      // Setup callback for data stream
      channel.basicConsume(dataQueue, false, createConsumer(channel));

      // Setup callback for the done message
      QueueingConsumer doneConsumer = new QueueingConsumer(channel);
      channel.basicConsume(doneQueue, true, doneConsumer);

      // Wait until the done message arrives, then verify count
      final QueueingConsumer.Delivery doneMsg = doneConsumer.nextDelivery();
      final long expectedRows =
          Long.parseLong(
              ExportOnServerVerifier.RoughCSVTokenizer.tokenize(
                  new String(doneMsg.getBody(), Charsets.UTF_8))[6]);

      while (expectedRows > m_verifiedRows) {
        Thread.sleep(1000);
        System.err.println("Expected " + expectedRows + " " + m_verifiedRows);
      }
    } finally {
      tearDown(channel);
      channel.close();
      connection.close();
    }
  }
Exemple #19
0
  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());
    }
  }
Exemple #20
0
  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);
    }
  }
    @Override
    public void run() {
      try {
        Connection connection = factory.newConnection();
        String uuid = UUID.randomUUID().toString();
        String queueName = RPC_QUEUE_NAME + uuid;
        Map<String, Channel> result =
            this.server.initChannel(connection, this.assignedNumber, queueName);
        Channel consumerChannel = result.get("consumer");

        Channel publisherChannel = result.get("publisher");

        QueueingConsumer consumer = new QueueingConsumer(consumerChannel);
        consumerChannel.basicConsume(queueName, true, consumer);
        System.out.println("in server ");
        while (true) {
          QueueingConsumer.Delivery delivery = consumer.nextDelivery();
          // System.out.printf("delivery is %s, body is %s", delivery, new
          // String(delivery.getBody()));
          BasicProperties props = delivery.getProperties();
          // System.out.printf("correlationId is %s", props.getCorrelationId());
          BasicProperties replyProps =
              new BasicProperties.Builder()
                  .correlationId(props.getCorrelationId())
                  .messageId(props.getMessageId())
                  .build();

          String response = new String(delivery.getBody());
          // System.out.printf("response is %s", new String(delivery.getBody()));
          // System.out.printf("reply to is %s",  props.getReplyTo()        );
          publisherChannel.basicPublish(
              PUBLISHER_EXCHANGE_NAME, props.getReplyTo(), replyProps, response.getBytes());

          // consumerChannel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  @Override
  public void run() {
    while (true) {
      Channel ch = null;
      try {
        ch = RabbitConnection.getInstance().newChanel();
        ch.basicQos(1);
        AMQP.Queue.DeclareOk q = ch.queueDeclare();
        ch.queueBind(q.getQueue(), "amq.direct", routingKey);
        QueueingConsumer consumer = new QueueingConsumer(ch);
        ch.basicConsume(q.getQueue(), true, consumer);

        // Process deliveries
        while (true) {
          QueueingConsumer.Delivery delivery = consumer.nextDelivery();

          String message = new String(delivery.getBody());

          Message msg = handler.obtainMessage();
          Bundle bundle = new Bundle();

          bundle.putString("msg", message);
          msg.setData(bundle);
          handler.sendMessage(msg);
        }
      } catch (InterruptedException e) {
        break;
      } catch (Exception e1) {
        try {
          Thread.sleep(INTERVAL_RECOVERY); // sleep and then try again
        } catch (InterruptedException e) {
          break;
        }
      } finally {
        RabbitConnection.getInstance().closeChanel(ch);
      }
    }
  }
Exemple #23
0
  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");
  }
Exemple #24
0
  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());
      }
    }
  }
    @Override
    public void run() {

      while (isRunning) {
        try {
          QueueingConsumer.Delivery delivery = consumer.nextDelivery();
          String body = new String(delivery.getBody(), "UTF-8");
          Log.d("Aptoide-RabbitMqService", "MESSAGE: " + body);
          handleMessage(body);
          channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } catch (IOException e) {
          isRunning = false;
          e.printStackTrace();
        } catch (ShutdownSignalException e) {
          isRunning = false;
          try {
            Log.d(
                "Aptoide-WebInstall", "Connection closed with reason " + e.getReason().toString());
          } catch (NullPointerException e1) {
            e1.printStackTrace();
            Log.d("Aptoide-WebInstall", "Connection closed with unkonwn reason");
          }
        } catch (ConsumerCancelledException e) {
          isRunning = false;
          Log.d("Aptoide-WebInstall", "Connection was canceled");
        }
      }
      try {
        if (channel != null && channel.isOpen()) {
          channel.close();
          connection.disconnectChannel(channel);
        }

        if (connection != null && connection.isOpen()) {
          connection.close();
        }

      } catch (Exception e) {
        e.printStackTrace();
      }
    }
 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();
       log.debug("Sending message:" + new String(message));
       log.debug("Getting next tuple - " + (messageCount++));
       if (messageCount < 0) {
         log.debug("You just get a number of messages = max value of long! Wow! Reseting to 0");
         this.messageCount = 0;
       }
       collector.emit(serialisationScheme.deserialize(message), deliveryTag);
     } catch (InterruptedException e) {
       // interrupted while waiting for message, big deal
     }
   }
 }
 public Message nextMessage() {
   reinitIfNecessary();
   if (consumerTag == null || consumer == null) return Message.NONE;
   try {
     return Message.forDelivery(consumer.nextDelivery(MS_WAIT_FOR_MESSAGE));
   } catch (ShutdownSignalException sse) {
     reset();
     logger.error("shutdown signal received while attempting to get next message", sse);
     reporter.reportError(sse);
     return Message.NONE;
   } catch (InterruptedException ie) {
     /* nothing to do. timed out waiting for message */
     logger.debug("interruepted while waiting for message", ie);
     return Message.NONE;
   } catch (ConsumerCancelledException cce) {
     /* if the queue on the broker was deleted or node in the cluster containing the queue failed */
     reset();
     logger.error("consumer got cancelled while attempting to get next message", cce);
     reporter.reportError(cce);
     return Message.NONE;
   }
 }
  /** {@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 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");
    }
 protected void consumeNoDuplicates(QueueingConsumer consumer)
     throws ShutdownSignalException, InterruptedException {
   assertNotNull(consumer.nextDelivery(TIMEOUT));
   Delivery markerDelivery = consumer.nextDelivery(TIMEOUT);
   assertEquals(new String(MARKER), new String(markerDelivery.getBody()));
 }