private void flush(LinkedList<Request> toFlush) throws IOException, RequestProcessorException { if (toFlush.isEmpty()) return; zks.getZKDatabase().commit(); while (!toFlush.isEmpty()) { Request i = toFlush.remove(); if (nextProcessor != null) { nextProcessor.processRequest(i); } } if (nextProcessor != null && nextProcessor instanceof Flushable) { ((Flushable)nextProcessor).flush(); } }
@ApiMethod @Comment(value = "Simply calls stream.flush() but throws RuntimeException instead of IOException") public static void flush(Flushable stream) { try { if (stream != null) { stream.flush(); } } catch (Exception ex) { Lang.rethrow(ex); } }
private void flush(GaugeWriter writer) { if (writer instanceof CompositeMetricWriter) { for (MetricWriter child : (CompositeMetricWriter) writer) { flush(child); } } try { if (ClassUtils.isPresent("java.io.Flushable", null)) { if (writer instanceof Flushable) { ((Flushable) writer).flush(); return; } } Method method = ReflectionUtils.findMethod(writer.getClass(), "flush"); if (method != null) { ReflectionUtils.invokeMethod(method, writer); } } catch (Exception ex) { logger.warn("Could not flush MetricWriter: " + ex.getClass() + ": " + ex.getMessage()); } }
/** * Flushes the formatter, writing any cached data to the output * stream. If the underlying output stream supports the * {@link Flushable} interface, it is also flushed. * * @throws FormatterClosedException if the formatter is closed. */ public void flush() { if (closed) throw new FormatterClosedException(); try { if (out instanceof Flushable) ((Flushable) out).flush(); } catch (IOException _) { // FIXME: do we ignore these or do we set ioException? // The docs seem to indicate that we should ignore. } }
private void flush(MetricWriter writer) { if (writer instanceof CompositeMetricWriter) { for (MetricWriter child : (CompositeMetricWriter) writer) { flush(child); } } try { if (ClassUtils.isPresent("java.io.Flushable", null)) { if (writer instanceof Flushable) { ((Flushable) writer).flush(); return; } } Method method = ReflectionUtils.findMethod(writer.getClass(), "flush"); if (method != null) { ReflectionUtils.invokeMethod(method, writer); } } catch (Exception ex) { logger.warn("Could not flush MetricWriter: " + ex.getClass() + ": " + ex.getMessage()); } }
@Override public String readLine(String prompt, Character mask) throws IOException { String line; interrupted = false; try { line = super.readLine(prompt, mask); } catch (UserInterruptException e) { interrupted = true; return null; } if (getHistory() instanceof Flushable) { ((Flushable) getHistory()).flush(); } return line; }
@Override public void handleNotification(Notification notification, Object handback) { if(!notification.getType().equals(MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED)) return; logger.info("MemoryNotifier::activate"); //--- copy the list of listener's in a thread-safe way; doesn't matter if we get an update while we're notifying this way. final List<Flushable> toNotify = new ArrayList<>(); synchronized (instance) { toNotify.addAll(listeners); } //--- spawn a thread to handle flushing; don't do multiple because threads can be heavy on the memory usage. Thread deferred = new Thread() { public void run() { for (final Flushable flushable : toNotify) { try { flushable.flush(); } catch (IOException e) { e.printStackTrace(); } } } }; deferred.start(); }
/** * Test method flush */ @Test public void testFlush () { // flush null stream assertFalse (StreamHelper.flush ((Flushable) null).isSuccess ()); // flush stream with exception assertFalse (StreamHelper.flush (new MockThrowingFlushable ()).isSuccess ()); // flush without exception assertTrue (StreamHelper.flush (new MockFlushable ()).isSuccess ()); final MockCloseableWithState c = new MockCloseableWithState (); assertTrue (StreamHelper.flush (c).isSuccess ()); assertFalse (c.isClosed ()); assertTrue (c.isFlushed ()); StreamHelper.close (new FilterOutputStream (null)); }
/** * @tests java.util.Formatter#flush() */ public void test_flush() throws IOException { Formatter f = null; f = new Formatter(notExist); assertTrue(f instanceof Flushable); f.close(); try { f.flush(); fail("should throw FormatterClosedException"); } catch (FormatterClosedException e) { // expected } f = new Formatter(); // For destination that does not implement Flushable // No exception should be thrown f.flush(); }
public static void flush(Flushable paramFlushable, boolean paramBoolean) throws IOException { try { paramFlushable.flush(); return; } catch (IOException localIOException) { if (paramBoolean) { logger.log(Level.WARNING, "IOException thrown while flushing Flushable.", localIOException); return; } } throw localIOException; }
@Test public void testAppendAndFlush() throws Exception { final StringBuilder progress = new StringBuilder(); Flushable flushable = new Flushable() { @Override public void flush() { progress.append("F"); } }; CountingFlushableAppendable c = new CountingFlushableAppendable(progress, flushable); assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(0); c.append("12"); assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(2); c.append("3"); assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(3); c.flush(); assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(0); c.append('c'); assertThat(c.getAppendedCountSinceLastFlush()).isEqualTo(1); c.append("123", 1, 2); assertThat(progress.toString()).isEqualTo("123Fc2"); }
@Override public synchronized void flush() { // thread safe flush of the writers if (writer != null) { writer.flush(); } if (this.callback instanceof Flushable) { try { ((Flushable) callback).flush(); } catch (final IOException e) { LOGGER.error( "Cannot flush callbacks", e); } } }
public AnsiConsole(Appendable target, Flushable flushable, ColorMap colorMap, boolean forceAnsi) { this.target = target; this.flushable = flushable; this.colorMap = colorMap; textArea = new TextAreaImpl(textCursor); statusBar = new LabelImpl(statusBarCursor); this.forceAnsi = forceAnsi; }
public static void flushQuietly(Flushable flushable) { if (flushable == null) return; try { flushable.flush(); } catch (Exception e) { OkLogger.printStackTrace(e); } }
public static void flushQuietly(Flushable flushable) { if (flushable == null) return; try { flushable.flush(); } catch (Exception e) { e.printStackTrace(); } }
/** * Closes 'closeable', ignoring any checked exceptions. Does nothing if 'closeable' is null. */ public static void flushQuietly(Flushable flushable) { if (flushable != null) { try { flushable.flush(); } catch (RuntimeException rethrown) { throw rethrown; } catch (Exception ignored) { } } }
/** * Equivalent to calling {@code flush(flushable, true)}, but with no {@code IOException} in the * signature. * * @param flushable the {@code Flushable} object to be flushed. */ public static void flushQuietly(Flushable flushable) { try { flush(flushable, true); } catch (IOException e) { logger.log(Level.SEVERE, "IOException should not have been thrown.", e); } }
@Override public void flush() throws IOException { checkNotClosed(); if (target instanceof Flushable) { ((Flushable) target).flush(); } }
private void setupFlushable(boolean shouldThrowOnFlush) throws IOException { mockFlushable = mock(Flushable.class); if (shouldThrowOnFlush) { doThrow(new IOException("This should only appear in the " + "logs. It should not be rethrown.")).when(mockFlushable).flush(); } }
private void doFlush(Flushable flushable, boolean swallowException, boolean expectThrown) throws IOException { try { Flushables.flush(flushable, swallowException); if (expectThrown) { fail("Didn't throw exception."); } } catch (IOException e) { if (!expectThrown) { fail("Threw exception"); } } verify(flushable).flush(); }
protected void done() throws IOException { if (this.closeable instanceof Flushable) { ((Flushable) this.closeable).flush(); } if (this.ignoreCloseExceptions) { try { this.closeable.close(); return; } catch (IOException e) { return; } } this.closeable.close(); }
public static void flushOrLog(Flushable f, String message) { if (f != null) { try { f.flush(); } catch (IOException e) { Fabric.getLogger().e(Fabric.TAG, message, e); } } }
@Override protected void done() throws IOException { if (closeable instanceof Flushable) ((Flushable) closeable).flush(); if (ignoreCloseExceptions) try { closeable.close(); } catch (IOException e) { // Ignored } else closeable.close(); }
/** * Flushes the {@code Formatter}. If the output destination is {@link Flushable}, * then the method {@code flush()} will be called on that destination. * * @throws FormatterClosedException * if the {@code Formatter} has been closed. */ public void flush() { checkClosed(); if (out instanceof Flushable) { try { ((Flushable) out).flush(); } catch (IOException e) { lastIOException = e; } } }
@Override public void flush() throws IOException { if (this.out instanceof Flushable) { ((Flushable) this.out).flush(); } }
