@Override public void put(byte[] key, byte[] value) { assert key != null; assert value != null; long start = factory.getConfiguration().getStatistics().getPut().begin(); getCurrent().put(key, value); factory.getConfiguration().getStatistics().getPut().end(value.length, start); }
public void testScanAfterClose() throws IOException { SortedIterator<ByteBuffer> iter = set.scan(); set.close(); assertFalse(iter.hasNext()); }
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); } }
@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); }
protected void validateEmpty(SortedOplogSet sos) throws IOException { assertEquals(0, sos.bufferSize()); assertEquals(0, sos.unflushedSize()); SortedIterator<ByteBuffer> iter = sos.scan(); assertFalse(iter.hasNext()); iter.close(); sos.close(); }
@Override protected synchronized void close() throws IOException { for (TrackedReference<SortedOplogReader> tr : soplogs) { tr.get().close(); factory.getConfiguration().getStatistics().incActiveFiles(-1); } soplogs.clear(); }
@Override public void abortBeforeRun() { handler.complete(); factory.getConfiguration().getStatistics().getFlush().end(start); }
public void testWithCompaction() throws IOException, InterruptedException { FlushCounter handler = new FlushCounter(); SortedOplogSet sos = createSoplogSet("compact"); for (int i = 0; i < 1000; i++) { sos.put(wrapInt(i), wrapInt(i)); if (i % 100 == 0) { sos.flush(null, handler); } } flushAndWait(handler, sos); compactAndWait(sos, false); validate(sos, 1000); sos.close(); }
protected SortedOplog createSoplog(int start, int count, int id) throws IOException { SortedOplog soplog = factory.createSortedOplog(new File("test-" + id + ".soplog")); SortedOplogWriter wtr = soplog.createWriter(); try { for (int i = start; i < start + count; i++) { wtr.append(SortedReaderTestCase.wrapInt(i), SortedReaderTestCase.wrapInt(i)); } } finally { wtr.close(null); } return soplog; }
private void compactAndWait(SortedOplogSet sos, boolean force) throws InterruptedException { WaitingHandler wh = new WaitingHandler(); sos.getCompactor().compact(force, wh); wh.waitForCompletion(); assertNull(wh.getError()); } }
@Override public void close() throws IOException { if (logger.fineEnabled()) { logger.fine("Closing soplog set"); } unsetCurrent(); releaseTestDelay(); flusher.waitForCompletion(); compactor.close(); }
@Override public void close() { sopConfig.getStatistics().getScan().end(bytes, start); }
public void testDestroy() throws IOException { set.destroy(); assertTrue(((SortedOplogSetImpl) set).isClosed()); try { set.scan(); fail(); } catch (IllegalStateException e) { } }
public void testMaxCompaction() throws Exception { for (int i = 0; i < 100; i += 2) { compactor.add(createSoplog(0, 100, i)); compactor.add(createSoplog(100, 100, i+1)); WaitingHandler wh = new WaitingHandler(); compactor.compact(false, wh); wh.waitForCompletion(); } WaitingHandler wh = new WaitingHandler(); compactor.compact(true, wh); wh.waitForCompletion(); }
public void testScanAfterClear() throws IOException { SortedIterator<ByteBuffer> iter = set.scan(); set.clear(); assertFalse(iter.hasNext()); }
@Override public void close() { for (SortedIterator<ByteBuffer> iter : iters) { iter.close(); } // TODO release the reference as soon as the iterator is finished TrackedReference.decrementAll(soplogs); }
@Override public SerializedComparator getComparator() { return factory.getConfiguration().getComparator(); }
@Override public SortedIterator<ByteBuffer> scan( byte[] from, boolean fromInclusive, byte[] to, boolean toInclusive, boolean ascending, MetadataFilter filter) throws IOException { return delegate.scan(from, fromInclusive, to, toInclusive, ascending, filter); } }