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); } }