How to use

DynoQueue

in

com.netflix.dyno.queues

@Override
public boolean ack(String queueName, String messageId) {
  return queues.get(queueName).ack(messageId);
}

@Override
public void flush(String queueName) {
  DynoQueue queue = queues.get(queueName);
  if (queue != null) {
    queue.clear();
  }
}

@Override
public boolean pushIfNotExists(String queueName, String id, long offsetTimeInSecond) {
  DynoQueue queue = queues.get(queueName);
  if (queue.get(id) != null) {
    return false;
  }
  Message msg = new Message(id, null);
  msg.setTimeout(offsetTimeInSecond, TimeUnit.SECONDS);
  queue.push(Collections.singletonList(msg));
  return true;
}

@Override
public Map<String, Long> queuesDetail() {
  Map<String, Long> map = queues.queues().stream().collect(Collectors.toMap(queue -> queue.getName(), q -> q.size()));
  return map;
}

rdq.clear();
assertEquals(0, rdq.size());
rdq.push(messages);
messages = rdq.peek(count);
long size = rdq.size();
assertEquals(count, size);
List<Message> messages2 = rdq.peek(count);
assertNotNull(messages2);
assertEquals(messages, messages2);
List<Message> poped = rdq.pop(count, 1, TimeUnit.SECONDS);
assertNotNull(poped);
assertEquals(count, poped.size());
rdq.processUnacks();
  Message found = rdq.get(msg.getId());
  assertNotNull(found);
  assertEquals(msg.getId(), found.getId());
  assertEquals(msg.getTimeout(), found.getTimeout());
assertNull(rdq.get("some fake id"));
List<Message> messages3 = rdq.pop(count, 1, TimeUnit.SECONDS);
if (messages3.size() < count) {

@Test
public void testClearQueues() {
  rdq.clear();
  int count = 10;
  List<Message> messages = new LinkedList<>();
  for (int i = 0; i < count; i++) {
    Message msg = new Message("x" + i, "Hello World-" + i);
    msg.setPriority(count - i);
    messages.add(msg);
  }
  rdq.push(messages);
  assertEquals(count, rdq.size());
  rdq.clear();
  assertEquals(0, rdq.size());
}

List<Message> popped = queue.pop(1, 1, TimeUnit.SECONDS);
  messages.add(msg);
queue.push(messages);
assertEquals(10, queue.size());
Map<String, Map<String, Long>> shards = queue.shardSizes();
assertEquals(2, shards.keySet().size());        //a and b
popped = queue.pop(2, 1, TimeUnit.SECONDS);
elapsedTime = System.currentTimeMillis() - start;
assertEquals(2, popped.size());
popped = queue.pop(5, 5, TimeUnit.SECONDS);
elapsedTime = System.currentTimeMillis() - start;
assertEquals(3, popped.size());     //3 remaining in the current shard

public void consume() {
  try {
    Set<String> ids = new HashSet<>();
    long s = System.currentTimeMillis();
    int loopCount = 100;
    int batchSize = 3500;
    int count = 0;
    for (int i = 0; i < loopCount; i++) {
      List<Message> popped = queue.pop(batchSize, 1, TimeUnit.MILLISECONDS);
      queue.ack(popped);
      Set<String> poppedIds = popped.stream().map(Message::getId).collect(Collectors.toSet());
      if (popped.size() != poppedIds.size()) {
        //We consumed dups
        throw new RuntimeException("Count does not match.  expected:  " + popped.size() + ", but actual was : " + poppedIds.size() + ", i: " + i);
      }
      ids.addAll(poppedIds);
      count += popped.size();
    }
    long e = System.currentTimeMillis();
    long diff = e - s;
    long throughput = 1000 * ((count) / diff);
    if (count != ids.size()) {
      //We consumed dups
      throw new RuntimeException("There were duplicate messages consumed... expected messages to be consumed " + count + ", but actual was : " + ids.size());
    }
    System.out.println("Consume time: " + diff + ", read throughput: " + throughput + " msg/sec, messages read: " + count);
  } catch (Exception e) {
    e.printStackTrace();
  }
}

@Test
public void testConcurrency() throws InterruptedException, ExecutionException {
  rdq.clear();
  List<Message> more = rdq.pop(1, 1, TimeUnit.SECONDS);
  assertEquals(0, more.size());

@Override
public void push(String queueName, List<com.netflix.conductor.core.events.queue.Message> messages) {
  List<Message> msgs = messages.stream()
      .map(msg -> new Message(msg.getId(), msg.getPayload()))
      .collect(Collectors.toList());
  queues.get(queueName).push(msgs);
}

  @Override
  public boolean exists(String queueName, String id) {
    DynoQueue queue = queues.get(queueName);
    return Optional.ofNullable(queue.get(id)).isPresent();
  }
}

@Override
public int getSize(String queueName) {
  return (int) queues.get(queueName).size();
}

@Override
public List<String> pop(String queueName, int count, int timeout) {
  List<Message> msg = queues.get(queueName).pop(count, timeout, TimeUnit.MILLISECONDS);
  return msg.stream()
      .map(Message::getId)
      .collect(Collectors.toList());
}

@Override
public void remove(String queueName, String messageId) {
  queues.get(queueName).remove(messageId);
}

@Override
public boolean setOffsetTime(String queueName, String id, long offsetTimeInSecond) {
  DynoQueue queue = queues.get(queueName);
  return queue.setTimeout(id, offsetTimeInSecond);
}

@Override
public boolean setUnackTimeout(String queueName, String messageId, long timeout) {
  return queues.get(queueName).setUnackTimeout(messageId, timeout);
}

@Test
public void testGetName() {
  assertEquals(queueName, rdq.getName());
}

@Override
public Map<String, Long> queuesDetail() {
  Map<String, Long> map = queues.queues().stream().collect(Collectors.toMap(queue -> queue.getName(), q -> q.size()));
  return map;
}

@Override
public void push(String queueName, String id, long offsetTimeInSecond) {
  Message msg = new Message(id, null);
  msg.setTimeout(offsetTimeInSecond, TimeUnit.SECONDS);
  queues.get(queueName).push(Collections.singletonList(msg));
}

@Override
public Message get(String messageId) {
  for (DynoQueue q : queues.values()) {
    Message msg = q.get(messageId);
    if (msg != null) {
      return msg;
    }
  }
  return null;
}