How to use

isQuorate

method

in

org.apache.brooklyn.util.collections.QuorumCheck

@Override
public boolean apply(T input) {
  if (input==null) return false;
  int sizeHealthy = 0, totalSize = 0;
  for (I item: input) {
    totalSize++;
    if (itemCheck.apply(item)) sizeHealthy++;
  }
  return quorumCheck.isQuorate(sizeHealthy, totalSize);
}
@Override

  @Override
  public Boolean apply(Collection<Boolean> input) {
    int numTrue = 0;
    for (Boolean inputVal : input)
      if (Boolean.TRUE.equals(inputVal))
        numTrue++;
    return Boolean.valueOf(quorumCheck.isQuorate(numTrue, totalSize));
  }
}

@Test
public void testAtLeastOneUnlessEmpty() {
  QuorumCheck q = QuorumChecks.atLeastOneUnlessEmpty();
  Assert.assertFalse(q.isQuorate(0, 2));
  Assert.assertTrue(q.isQuorate(1, 2));
  Assert.assertTrue(q.isQuorate(0, 0));
}

@Test
public void testAtLeastOneUnlessEmptyString() {
  QuorumCheck q = QuorumChecks.of("atLeastOneUnlessEmpty");
  Assert.assertFalse(q.isQuorate(0, 2));
  Assert.assertTrue(q.isQuorate(1, 2));
  Assert.assertTrue(q.isQuorate(0, 0));
}

@Test
public void testAlwaysTrue() {
  QuorumCheck q = QuorumChecks.alwaysTrue();
  Assert.assertTrue(q.isQuorate(0, 2));
  Assert.assertTrue(q.isQuorate(1, 2));
  Assert.assertTrue(q.isQuorate(0, 0));
}

@Test
public void testAll() {
  QuorumCheck q = QuorumChecks.all();
  Assert.assertTrue(q.isQuorate(2, 2));
  Assert.assertFalse(q.isQuorate(1, 2));
  Assert.assertTrue(q.isQuorate(0, 0));
}

@Test
public void testLinearNeedHalfToTenAndTenPercentAtHundred() {
  QuorumCheck q = QuorumChecks.of("[ [0,0], [10,5], [100,10], [200, 20] ]");
  Assert.assertTrue(q.isQuorate(2, 2));
  Assert.assertTrue(q.isQuorate(1, 2));
  Assert.assertTrue(q.isQuorate(0, 0));
  Assert.assertFalse(q.isQuorate(1, 10));
  Assert.assertTrue(q.isQuorate(6, 10));
  Assert.assertFalse(q.isQuorate(7, 50));
  Assert.assertTrue(q.isQuorate(8, 50));
  Assert.assertFalse(q.isQuorate(9, 100));
  Assert.assertTrue(q.isQuorate(11, 100));
  Assert.assertFalse(q.isQuorate(19, 200));
  Assert.assertTrue(q.isQuorate(21, 200));
  Assert.assertFalse(q.isQuorate(29, 300));
  Assert.assertTrue(q.isQuorate(31, 300));
}

  @Test
  public void testConstantQuorum() {
    QuorumCheck q = QuorumChecks.of("2");
    Assert.assertTrue(q.isQuorate(2, 2));
    Assert.assertTrue(q.isQuorate(2, 10));
    Assert.assertFalse(q.isQuorate(1, 1));
  }     
}

@Test
public void testLinearTwoPointsNeedMinTwo() {
  QuorumCheck q = QuorumChecks.of("[ [0,2], [1,2] ]");
  Assert.assertTrue(q.isQuorate(2, 2));
  Assert.assertTrue(q.isQuorate(2, 10));
  Assert.assertFalse(q.isQuorate(1, 1));
}

@Test
public void testAtLeastOne() {
  QuorumCheck q = QuorumChecks.atLeastOne();
  Assert.assertTrue(q.isQuorate(2, 2));
  Assert.assertTrue(q.isQuorate(1, 2));
  Assert.assertFalse(q.isQuorate(0, 0));
}

@Test
public void testAllAndAtLeastOne() {
  QuorumCheck q = QuorumChecks.atLeastOne();
  Assert.assertFalse(q.isQuorate(0, 2));
  Assert.assertTrue(q.isQuorate(1, 2));
  Assert.assertFalse(q.isQuorate(0, 0));
}

if (qc.isQuorate(numUp, violators.size()+numUp))

protected Object computeServiceProblems() {
  Map<Entity, Lifecycle> values = getValues(SERVICE_STATE_ACTUAL);
  int numRunning=0;
  List<Entity> onesNotHealthy=MutableList.of();
  Set<Lifecycle> ignoreStates = getConfig(IGNORE_ENTITIES_WITH_THESE_SERVICE_STATES);
  for (Map.Entry<Entity,Lifecycle> state: values.entrySet()) {
    if (state.getValue()==Lifecycle.RUNNING) numRunning++;
    else if (!ignoreStates.contains(state.getValue()))
      onesNotHealthy.add(state.getKey());
  }
  QuorumCheck qc = getConfig(RUNNING_QUORUM_CHECK);
  if (qc!=null) {
    if (qc.isQuorate(numRunning, onesNotHealthy.size()+numRunning))
      // quorate
      return null;
    if (onesNotHealthy.isEmpty())
      return "Not enough entities running to be quorate";
  } else {
    if (onesNotHealthy.isEmpty())
      return null;
  }
  return "Required entit"+Strings.ies(onesNotHealthy.size())+" not healthy: "+
    (onesNotHealthy.size()>3 ? nameOfEntity(onesNotHealthy.get(0))+" and "+(onesNotHealthy.size()-1)+" others"
      : Strings.join(nameOfEntity(onesNotHealthy), ", "));
}

if (qc.isQuorate(numUp, violators.size()+numUp)) {

if (qc.isQuorate(numRunning, violators.size()+numRunning+numTransitioning)) {
boolean canEverBeQuorate = qc.isQuorate(numRunning+numTransitioning, violators.size()+numRunning+numTransitioning);
if (expectedState == Lifecycle.STARTING && canEverBeQuorate) {

  allExceptions.add(new IllegalStateException("Dangling references ("+totalDangling+" of "+totalItems+") present without rebind context"));
} else {
  if (!danglingRefsQuorumRequiredHealthy.isQuorate(totalFound, totalItems)) {
    warn("Dangling item"+Strings.s(totalDangling)+" ("+totalDangling+" of "+totalItems+") found on rebind exceeds quorum, assuming failed: "+danglingIds);
    allExceptions.add(new IllegalStateException("Too many dangling references: "+totalDangling+" of "+totalItems));