protected void checkTestDelay() { if (testDelayDuringCompaction != null) { try { if (logger.fineEnabled()) { logger.fine("Waiting for testDelayDuringCompaction"); } testDelayDuringCompaction.await(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }
private void fineLog(Object... strings) { if (logger.fineEnabled()) { StringBuffer sb = new StringBuffer(); for (Object str : strings) { sb.append(str.toString()); } logger.fine(sb.toString()); } } }
protected void releaseTestDelay() { if (testDelayDuringCompaction != null) { if (logger.fineEnabled()) { logger.fine("Releasing testDelayDuringCompaction"); } testDelayDuringCompaction.countDown(); } }
@Override public void close() throws IOException { if (logger.fineEnabled()) { logger.fine("Closing buffer"); } synchronized (this) { flushAction = null; } }
private void checkTestDelay() { if (testDelayDuringFlush != null) { try { if (logger.fineEnabled()) { logger.fine("Waiting for testDelayDuringFlush"); } testDelayDuringFlush.await(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }
private void releaseTestDelay() { if (testDelayDuringFlush != null) { if (logger.fineEnabled()) { logger.fine("Releasing testDelayDuringFlush"); } testDelayDuringFlush.countDown(); } }
/** * Defers the flush completion to a later time. This is used to ensure correct * ordering of soplogs during parallel flushes. * * @param action the action to perform when ready */ public synchronized void defer(Runnable action) { assert flushAction == null; if (logger.fineEnabled()) { logger.fine("Deferring flush completion"); } flushAction = action; }
@Override public Thread newThread(Runnable r) { Thread thread = new Thread(r, name + ":" + count.getAndIncrement()); thread.setDaemon(true); if (logger.fineEnabled()) { fineLog("New thread:", name, " poolSize:", getPoolSize(), " active:", getActiveCount()); } return thread; } }
@Override public void closeAndDelete() throws IOException { if (logger.fineEnabled()) { logger.fine("Closing writer and deleting " + path); } writer.close(); new File(writer.getPath().toUri()).delete(); }
@Override public void close() throws IOException { if (logger.fineEnabled()) { logger.fine("Closing reader on " + path); } reader.close(); closed = true; }
@Override public SortedOplogReader createReader() throws IOException { if (logger.fineEnabled()) { logger.fine("Creating an HFile reader on " + path); } return new HFileSortedOplogReader(); }
@Override public SortedOplogWriter createWriter() throws IOException { if (logger.fineEnabled()) { logger.fine("Creating an HFile writer on " + path); } return new HFileSortedOplogWriter(); }
private SortedBuffer<Integer> flipBuffer() { final SortedBuffer<Integer> sb; sb = getCurrent(); SortedBuffer<Integer> next = new SortedBuffer<Integer>( factory.getConfiguration(), bufferCount.incrementAndGet()); current.set(next); if (logger.fineEnabled()) { logger.fine(String.format("Switching from buffer %s to %s", sb, next)); } return sb; }
protected void markAsInactive(Iterable<TrackedReference<SortedOplogReader>> snapshot, T attach) throws IOException { for (Iterator<TrackedReference<SortedOplogReader>> iter = snapshot.iterator(); iter.hasNext(); ) { TrackedReference<SortedOplogReader> tr = iter.next(); if (logger.fineEnabled()) { logger.fine(String.format("Marking %s as inactive", tr)); } inactive.add(tr); tracker.fileRemoved(tr.get().getFile(), attach); factory.getConfiguration().getStatistics().incActiveFiles(-1); factory.getConfiguration().getStatistics().incInactiveFiles(1); } }
@Override public <T> Future<T> submit(Callable<T> task) { HDFSCompactionConfig config; config = HDFSCompactionManager.this.storeConfig.getHDFSCompactionConfig(); throwIfStopped((CompactionRequest) task, config); throwIfPoolSizeChanged((CompactionRequest) task, config); if (logger.fineEnabled()) { fineLog("New:", task, " pool:", getPoolSize(), " active:", getActiveCount()); } return super.submit(task); }
public SortedOplogSetImpl(final SortedOplogFactory factory, Executor exec, Compactor ctor) throws IOException { this.factory = factory; this.flusher = new AbortableTaskService(exec); this.compactor = ctor; rwlock = new ReentrantReadWriteLock(); bufferCount = new AtomicInteger(0); unflushed = new ArrayDeque<SortedBuffer<Integer>>(); current = new AtomicReference<SortedBuffer<Integer>>( new SortedBuffer<Integer>(factory.getConfiguration(), 0)); logger = ComponentLogWriter.getSoplogLogWriter(factory.getConfiguration().getName(), LogService.logger()); if (logger.fineEnabled()) { logger.fine("Creating soplog set"); } }
@Override protected void add(SortedOplog soplog) throws IOException { SortedOplogReader rdr = soplog.createReader(); synchronized (this) { soplogs.addFirst(new TrackedReference<SortedOplogReader>(rdr)); } if (logger.fineEnabled()) { logger.fine(String.format("Added file %s to level %d", rdr, level)); } tracker.fileAdded(rdr.getFile(), level); factory.getConfiguration().getStatistics().incActiveFiles(1); }
/** * Clears the buffer of all entries. */ public void clear() { if (logger.fineEnabled()) { logger.fine("Clearing buffer"); } buffer.clear(); stats.clear(); metadata.clear(); synchronized (this) { flushAction = null; } }
@Override public void close() throws IOException { if (logger.fineEnabled()) { logger.fine("Closing soplog set"); } unsetCurrent(); releaseTestDelay(); flusher.waitForCompletion(); compactor.close(); }
private void deleteInactive(TrackedReference<SortedOplogReader> tr) throws IOException { tr.get().close(); if (tr.get().getFile().delete()) { if (logger.fineEnabled()) { logger.fine("Deleted inactive soplog " + tr.get().getFile()); } tracker.fileDeleted(tr.get().getFile()); factory.getConfiguration().getStatistics().incInactiveFiles(-1); } }