How to use co.cask.coopr.common.queue

private SolverRunner(GroupElement gElement) {
 this.solveElement = gElement.getElement();
 this.queueName = gElement.getQueueName();
 this.clusterId = solveElement.getId();
 this.solverJob = null;
 this.plannerJob = null;
}

 private String getZKPathForQueue(String queueName) {
  return queueType.getPath() + "/" + queueName;
 }
}

 @Override
 public void run() {
  try {
   callbackQueues.recordProgress(id, gElement.getQueueName(), element.getId(),
                  TrackingQueue.ConsumingStatus.FINISHED_SUCCESSFULLY, "Executed");
  } catch (Exception e) {
   LOG.error("Exception processing callback", e);
  }
 }
}, executorService);

@Test
public void testOneQueueAddTakeWithoutQueueName() {
 QueueGroup queues = getQueueGroup(QueueType.PROVISIONER);
 String queueName = "tenant1";
 String consumerId = "worker.0";
 queues.add(queueName, new Element("id", "val"));
 GroupElement taken = queues.takeIterator(consumerId).next();
 Assert.assertEquals(queueName, taken.getQueueName());
 Assert.assertEquals("id", taken.getElement().getId());
 Assert.assertEquals("val", taken.getElement().getValue());
}

@Test
public void testOneQueueAddTakeWithQueueName() {
 QueueGroup queues = getQueueGroup(QueueType.PROVISIONER);
 String queueName = "tenant1";
 String consumerId = "worker.0";
 queues.add(queueName, new Element("id", "val"));
 Element taken = queues.take(queueName, consumerId);
 Assert.assertEquals("id", taken.getId());
 Assert.assertEquals("val", taken.getValue());
}

 @Override
 public QueueMetrics load(String tenantId) {
  int numQueued = Iterators.size(taskQueues.getQueued(tenantId));
  int numInProgress = Iterators.size(taskQueues.getBeingConsumed(tenantId));
  return new QueueMetrics(numQueued, numInProgress);
 }
});

private void deleteProvisioner(Provisioner provisioner) throws IOException {
 for (String tenant : provisioner.getAssignedTenants()) {
  balanceQueue.add(new Element(tenant));
 }
 provisionerStore.deleteProvisioner(provisioner.getId());
}

 private Set<String> getIds(Iterator<QueuedElement> iter) {
  Set<String> out = Sets.newHashSet();
  while (iter.hasNext()) {
   out.add(iter.next().getElement().getId());
  }
  return out;
 }
}

@Override
public TrackingQueue.PossessionState recordProgress(String consumerId, String elementId,
                          TrackingQueue.ConsumingStatus status, String result) {
 return getQueue().recordProgress(consumerId, elementId, status, result);
}

private GroupElement getNextElement() {
 while (currentBatch.hasNext()) {
  Map.Entry<String, TrackingQueue> currentQueueEntry = currentBatch.next();
  TrackingQueue queue = currentQueueEntry.getValue();
  String queueName = currentQueueEntry.getKey();
  Element element = queue.take(consumerId);
  if (element != null) {
   return new GroupElement(queueName, element);
  }
 }
 return null;
}

@After
public void testCleanup() {
 // cleanup
 solverQueues.removeAll();
 clusterQueues.removeAll();
 callbackQueues.removeAll();
 jobQueues.removeAll();
 provisionerQueues.removeAll();
}

 @Override
 public int size() {
  return getQueue().size();
 }
}

@Override
protected void startUp() throws Exception {
 for (QueueGroup queueGroup : queueGroups.values()) {
  queueGroup.startAndWait();
 }
}

private void stopAndReschedule(Entry entry) throws Exception {
 entry.consumerId = NO_CONSUMER_ASSIGNED;
 entry.lastProgressReportTs = 0;
 queueElements.put(entry.element.getId(), entry);
}

@Override
public TrackingQueue.PossessionState recordProgress(String consumerId, String queueName, String elementId,
                          TrackingQueue.ConsumingStatus status, String result) {
 return queueMap.getUnchecked(queueName).recordProgress(consumerId, elementId, status, result);
}

@Override
public ListenableFuture<String> add(String queueName, Element element) {
 return queueMap.getUnchecked(queueName).add(element);
}

@Override
public boolean removeAll(String queueName) {
 return queueMap.getUnchecked(queueName).removeAll();
}

@Override
public Iterator<QueuedElement> getBeingConsumed(String queueName) {
 return queueMap.getUnchecked(queueName).getBeingConsumed();
}

 @Override
 public void run() {
  try {
   solverQueues.recordProgress(id, gElement.getQueueName(), solveElement.getId(),
                 TrackingQueue.ConsumingStatus.FINISHED_SUCCESSFULLY, future.get());
  } catch (Exception e) {
   LOG.error("Unable to record progress for cluster {}", solveElement.getId());
  }
 }
}, executorService);

@Before
public void clearData() {
 jobQueues.removeAll();
 provisionerQueues.removeAll();
}