/** * Returns a flattened list of Throwables from tree-like CompositeException chain. * @param t the starting throwable * @return the list of Throwables flattened in a depth-first manner */ public static List<Throwable> flatten(Throwable t) { List<Throwable> list = new ArrayList<Throwable>(); ArrayDeque<Throwable> deque = new ArrayDeque<Throwable>(); deque.offer(t); while (!deque.isEmpty()) { Throwable e = deque.removeFirst(); if (e instanceof CompositeException) { CompositeException ce = (CompositeException) e; List<Throwable> exceptions = ce.getExceptions(); for (int i = exceptions.size() - 1; i >= 0; i--) { deque.offerFirst(exceptions.get(i)); } } else { list.add(e); } } return list; }
private void queueResponse( final long correlationId, final long relevantId, final ControlResponseCode code, final String message) { queuedResponses.offer(() -> controlResponseProxy.sendResponse( controlSessionId, correlationId, relevantId, code, message, controlPublication)); } }
@Override public void onNext(T t) { if (index++ % skip == 0) { U b; try { b = ObjectHelper.requireNonNull(bufferSupplier.call(), "The bufferSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources."); } catch (Throwable e) { buffers.clear(); upstream.dispose(); downstream.onError(e); return; } buffers.offer(b); } Iterator<U> it = buffers.iterator(); while (it.hasNext()) { U b = it.next(); b.add(t); if (count <= b.size()) { it.remove(); downstream.onNext(b); } } }
/** * Returns a flattened list of Throwables from tree-like CompositeException chain. * @param t the starting throwable * @return the list of Throwables flattened in a depth-first manner */ public static List<Throwable> flatten(Throwable t) { List<Throwable> list = new ArrayList<Throwable>(); ArrayDeque<Throwable> deque = new ArrayDeque<Throwable>(); deque.offer(t); while (!deque.isEmpty()) { Throwable e = deque.removeFirst(); if (e instanceof CompositeException) { CompositeException ce = (CompositeException) e; List<Throwable> exceptions = ce.getExceptions(); for (int i = exceptions.size() - 1; i >= 0; i--) { deque.offerFirst(exceptions.get(i)); } } else { list.add(e); } } return list; }
@Override public void onNext(T t) { final ArrayDeque<UnicastSubject<T>> ws = windows; long i = index; long s = skip; if (i % s == 0 && !cancelled) { wip.getAndIncrement(); UnicastSubject<T> w = UnicastSubject.create(capacityHint, this); ws.offer(w); downstream.onNext(w); } long c = firstEmission + 1; for (UnicastSubject<T> w : ws) { w.onNext(t); } if (c >= count) { ws.poll().onComplete(); if (ws.isEmpty() && cancelled) { this.upstream.dispose(); return; } firstEmission = c - s; } else { firstEmission = c; } index = i + 1; }
@Override public void onNext(T t) { if (index++ % skip == 0) { U b; try { b = ObjectHelper.requireNonNull(bufferSupplier.call(), "The bufferSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources."); } catch (Throwable e) { buffers.clear(); s.dispose(); actual.onError(e); return; } buffers.offer(b); } Iterator<U> it = buffers.iterator(); while (it.hasNext()) { U b = it.next(); b.add(t); if (count <= b.size()) { it.remove(); actual.onNext(b); } } }
@Override protected void doPut(Event event) throws InterruptedException { channelCounter.incrementEventPutAttemptCount(); putCalled = true; int eventByteSize = (int) Math.ceil(estimateEventSize(event) / avgEventSize); if (!putList.offer(event)) { throw new ChannelFullException("Put queue in " + getName() + " channel's Transaction having capacity " + putList.size() + " full, consider reducing batch size of sources"); } putListByteCount += eventByteSize; }
@Override public void onNext(T t) { final ArrayDeque<UnicastSubject<T>> ws = windows; long i = index; long s = skip; if (i % s == 0 && !cancelled) { wip.getAndIncrement(); UnicastSubject<T> w = UnicastSubject.create(capacityHint, this); ws.offer(w); actual.onNext(w); } long c = firstEmission + 1; for (UnicastSubject<T> w : ws) { w.onNext(t); } if (c >= count) { ws.poll().onComplete(); if (ws.isEmpty() && cancelled) { this.s.dispose(); return; } firstEmission = c - s; } else { firstEmission = c; } index = i + 1; }
private void commitPutsToPrimary() { synchronized (queueLock) { for (Event e : putList) { if (!memQueue.offer(e)) { throw new ChannelException("Unable to insert event into memory " + "queue in spite of spare capacity, this is very unexpected"); } } drainOrder.putPrimary(putList.size()); maxMemQueueSize = (memQueue.size() > maxMemQueueSize) ? memQueue.size() : maxMemQueueSize; channelCounter.setChannelSize(memQueue.size() + drainOrder.overflowCounter); } // update counters and semaphores totalStored.release(putList.size()); channelCounter.addToEventPutSuccessCount(putList.size()); }
windows.offer(w);
@Test public void postCompleteWithRequest() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); ArrayDeque<Integer> queue = new ArrayDeque<Integer>(); AtomicLong state = new AtomicLong(); BooleanSupplier isCancelled = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return false; } }; ts.onSubscribe(new BooleanSubscription()); queue.offer(1); state.getAndIncrement(); QueueDrainHelper.postComplete(ts, queue, state, isCancelled); ts.assertResult(1); }
@Test public void postCompleteCancelled() { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); ArrayDeque<Integer> queue = new ArrayDeque<Integer>(); AtomicLong state = new AtomicLong(); BooleanSupplier isCancelled = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return ts.isCancelled(); } }; ts.onSubscribe(new BooleanSubscription()); queue.offer(1); state.getAndIncrement(); ts.cancel(); QueueDrainHelper.postComplete(ts, queue, state, isCancelled); ts.assertEmpty(); }
windows.offer(w);
@Test public void postCompleteCancelledAfterOne() { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); cancel(); } }; ArrayDeque<Integer> queue = new ArrayDeque<Integer>(); AtomicLong state = new AtomicLong(); BooleanSupplier isCancelled = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return ts.isCancelled(); } }; ts.onSubscribe(new BooleanSubscription()); queue.offer(1); state.getAndIncrement(); QueueDrainHelper.postComplete(ts, queue, state, isCancelled); ts.assertValue(1).assertNoErrors().assertNotComplete(); }
@Test public void completeRequestRace() { for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { final TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); final ArrayDeque<Integer> queue = new ArrayDeque<Integer>(); final AtomicLong state = new AtomicLong(); final BooleanSupplier isCancelled = new BooleanSupplier() { @Override public boolean getAsBoolean() throws Exception { return false; } }; ts.onSubscribe(new BooleanSubscription()); queue.offer(1); Runnable r1 = new Runnable() { @Override public void run() { QueueDrainHelper.postCompleteRequest(1, ts, queue, state, isCancelled); } }; Runnable r2 = new Runnable() { @Override public void run() { QueueDrainHelper.postComplete(ts, queue, state, isCancelled); } }; TestHelper.race(r1, r2); ts.assertResult(1); } }
observers.offer(inner);