How to use

getResultWithTimeout

method

in

org.jgroups.util.Promise

public T getResult(long timeout, boolean reset) {
  try {
    return getResultWithTimeout(timeout, reset);
  }
  catch(TimeoutException e) {
    return null;
  }
}

public T getResult() {
  try {
    return getResultWithTimeout(0);
  }
  catch(TimeoutException e) {
    return null;
  }
}

public boolean waitForAllAcks(long timeout) throws TimeoutException {
  if(missing_acks.isEmpty())
    return true;
  Boolean result=all_acks_received.getResultWithTimeout(timeout);
  return result != null && result;
}

private void waitForUnblock() {
  try {
    flush_unblock_promise.reset();
    flush_unblock_promise.getResultWithTimeout(end_flush_timeout);
  } catch (TimeoutException t) {
    if (log.isWarnEnabled())
      log.warn(localAddress + ": waiting for UNBLOCK timed out after " + end_flush_timeout + " ms");
  }
}

public Counter getOrCreateCounter(String name, long initial_value) {
  if(local_addr == null)
    throw new IllegalArgumentException("the channel needs to be connected before creating or getting a counter");
  Owner owner=getOwner();
  GetOrCreateRequest req=new GetOrCreateRequest(owner, name, initial_value);
  Promise<long[]> promise=new Promise<>();
  pending_requests.put(owner, new Tuple<>(req, promise));
  sendRequest(coord, req);
  long[] result=new long[0];
  try {
    result=promise.getResultWithTimeout(timeout);
    long value=result[0], version=result[1];
    if(!coord.equals(local_addr))
      counters.put(name, new VersionedValue(value, version));
    return new CounterImpl(name);
  }
  catch(TimeoutException e) {
    throw new RuntimeException(e);
  }
}

FlushStartResult r = flush_promise.getResultWithTimeout(start_flush_timeout);
if(r.failed())
  throw new RuntimeException(r.getFailureCause());

@Override
public long addAndGet(long delta) {
  if(local_addr.equals(coord)) {
    VersionedValue val=getCounter(name);
    long retval=val.addAndGet(delta)[0];
    if(backup_coords != null)
      updateBackups(name, val.value, val.version);
    return retval;
  }
  Owner owner=getOwner();
  Request req=new AddAndGetRequest(owner, name, delta);
  Promise<long[]> promise=new Promise<>();
  pending_requests.put(owner, new Tuple<>(req, promise));
  sendRequest(coord, req);
  Object obj=null;
  try {
    obj=promise.getResultWithTimeout(timeout);
    if(obj instanceof Throwable)
      throw new IllegalStateException((Throwable)obj);
    long[] result=(long[])obj;
    long value=result[0], version=result[1];
    if(!coord.equals(local_addr))
      counters.put(name, new VersionedValue(value, version));
    return value;
  }
  catch(TimeoutException e) {
    throw new RuntimeException(e);
  }
}

Object obj=null;
try {
  obj=promise.getResultWithTimeout(timeout);
  if(obj instanceof Throwable)
    throw new IllegalStateException((Throwable)obj);

@Override
public void set(long new_value) {
  if(local_addr.equals(coord)) {
    VersionedValue val=getCounter(name);
    val.set(new_value);
    if(backup_coords != null)
      updateBackups(name, val.value, val.version);
    return;
  }
  Owner owner=getOwner();
  Request req=new SetRequest(owner, name, new_value);
  Promise<long[]> promise=new Promise<>();
  pending_requests.put(owner, new Tuple<>(req, promise));
  sendRequest(coord, req);
  Object obj=null;
  try {
    obj=promise.getResultWithTimeout(timeout);
    if(obj instanceof Throwable)
      throw new IllegalStateException((Throwable)obj);
    long[] result=(long[])obj;
    long value=result[0], version=result[1];
    if(!coord.equals(local_addr))
      counters.put(name, new VersionedValue(value, version));
  }
  catch(TimeoutException e) {
    throw new RuntimeException(e);
  }
}

public Object getResult() {
  try {
    return getResultWithTimeout(0);
  }
  catch(TimeoutException e) {
    return null;
  }
}

public T getResult() {
  try {
    return getResultWithTimeout(0);
  }
  catch(TimeoutException e) {
    return null;
  }
}

public T getResult(long timeout, boolean reset) {
  try {
    return getResultWithTimeout(timeout, reset);
  }
  catch(TimeoutException e) {
    return null;
  }
}

/**
 * Returns the result, but never throws a TimeoutException; returns null instead.
 * @param timeout
 * @return Object
 */
public Object getResult(long timeout) {
  try {
    return getResultWithTimeout(timeout);
  }
  catch(TimeoutException e) {
    return null;
  }
}

public boolean waitForAllAcks(long timeout) throws TimeoutException {
  if(missing_acks.isEmpty())
    return true;
  Boolean result=all_acks_received.getResultWithTimeout(timeout);
  return result != null && result;
}

public boolean waitForAllAcks(long timeout) throws TimeoutException {
  if(missing_acks.size() == 0)
    return true;
  Object result=all_acks_received.getResultWithTimeout(timeout);
  return result != null && result instanceof Boolean && ((Boolean)result).booleanValue();
}

public void stopFlush() {
  if(!flush_supported) {
    throw new IllegalStateException("Flush is not supported, add pbcast.FLUSH protocol to your configuration");
  }
  
  flush_unblock_promise.reset();
  down(new Event(Event.RESUME));
  
  //do not return until UNBLOCK event is received        
  boolean shouldWaitForUnblock = receive_blocks;        
  if(shouldWaitForUnblock){
    try{              
     flush_unblock_promise.getResultWithTimeout(5000);
    }
    catch (TimeoutException te){              
    }
  }
}

private void waitForUnblock() {
  try {
    flush_unblock_promise.reset();
    flush_unblock_promise.getResultWithTimeout(end_flush_timeout);
  } catch (TimeoutException t) {
    if (log.isWarnEnabled())
      log.warn(localAddress + ": waiting for UNBLOCK timed out after " + end_flush_timeout + " ms");
  }
}

public Counter getOrCreateCounter(String name, long initial_value) {
  if(local_addr == null)
    throw new IllegalArgumentException("the channel needs to be connected before creating or getting a counter");
  Owner owner=getOwner();
  GetOrCreateRequest req=new GetOrCreateRequest(owner, name, initial_value);
  Promise<long[]> promise=new Promise<>();
  pending_requests.put(owner, new Tuple<>(req, promise));
  sendRequest(coord, req);
  long[] result=new long[0];
  try {
    result=promise.getResultWithTimeout(timeout);
    long value=result[0], version=result[1];
    if(!coord.equals(local_addr))
      counters.put(name, new VersionedValue(value, version));
    return new CounterImpl(name);
  }
  catch(TimeoutException e) {
    throw new RuntimeException(e);
  }
}

if(shouldWaitForUnblock){
  try{
   flush_unblock_promise.getResultWithTimeout(FLUSH_UNBLOCK_TIMEOUT);

@Override
public void set(long new_value) {
  if(local_addr.equals(coord)) {
    VersionedValue val=getCounter(name);
    val.set(new_value);
    if(backup_coords != null)
      updateBackups(name, val.value, val.version);
    return;
  }
  Owner owner=getOwner();
  Request req=new SetRequest(owner, name, new_value);
  Promise<long[]> promise=new Promise<>();
  pending_requests.put(owner, new Tuple<>(req, promise));
  sendRequest(coord, req);
  Object obj=null;
  try {
    obj=promise.getResultWithTimeout(timeout);
    if(obj instanceof Throwable)
      throw new IllegalStateException((Throwable)obj);
    long[] result=(long[])obj;
    long value=result[0], version=result[1];
    if(!coord.equals(local_addr))
      counters.put(name, new VersionedValue(value, version));
  }
  catch(TimeoutException e) {
    throw new RuntimeException(e);
  }
}