private void cleanupIncompleteFiles() throws Exception { if (largeMessagesFactory != null) { List<String> tmpFiles = largeMessagesFactory.listFiles("tmp"); for (String tmpFile : tmpFiles) { SequentialFile file = largeMessagesFactory.createSequentialFile(tmpFile); file.delete(); } } }
@Override public int calculateBlockStart(final int position) { int alignment = factory.getAlignment(); int pos = (position / alignment + (position % alignment != 0 ? 1 : 0)) * alignment; return pos; }
final ByteBuffer zeroPage = this.factory.newBuffer(zeroPageCapacity); try { int bytesToWrite = size; writePosition += writtenBytes; if (factory.isDatasync()) { channel.force(true); } finally { this.factory.releaseBuffer(zeroPage); factory.onIOError(new ActiveMQIOErrorException(e.getMessage(), e), e.getMessage(), this); throw e;
@Override protected ByteBuffer newBuffer(int size, int limit) { size = factory.calculateBlockSize(size); limit = factory.calculateBlockSize(limit); ByteBuffer buffer = factory.newBuffer(size); buffer.limit(limit); return buffer; }
private static ByteBuffer allocateDirectBufferIfNeeded(final SequentialFileFactory fileFactory, final int requiredCapacity, final AtomicReference<ByteBuffer> bufferRef) { ByteBuffer buffer = bufferRef != null ? bufferRef.get() : null; if (buffer != null && buffer.capacity() < requiredCapacity) { fileFactory.releaseDirectBuffer(buffer); buffer = null; } if (buffer == null) { buffer = fileFactory.allocateDirectBuffer(requiredCapacity); } else { buffer.clear().limit(requiredCapacity); } if (bufferRef != null) { bufferRef.lazySet(buffer); } return buffer; }
fileFactory.start(); List<String> files = fileFactory.listFiles(fileExtension); SequentialFile file = fileFactory.createSequentialFile(fileStr); ByteBuffer buffer = fileFactory.newBuffer(JournalImpl.SIZE_HEADER); fileFactory.stop();
System.out.println("Using " + factory.getClass().getName() + " to calculate sync times, alignment=" + factory.getAlignment()); SequentialFile file = factory.createSequentialFile(fileName); factory.releaseDirectBuffer(bufferBlock); factory.stop(); } catch (Exception e) {
@Test public void testBuffer() throws Exception { SequentialFile file = factory.createSequentialFile("filtetmp.log"); file.open(); ByteBuffer buff = factory.newBuffer(10); Assert.assertEquals(factory.getAlignment(), buff.limit()); file.close(); factory.releaseBuffer(buff); }
@Test public void testWriteandRead() throws Exception { SequentialFile sf = factory.createSequentialFile("write.amq"); long bytesWritten = sf.position() - initialPos; Assert.assertEquals(calculateRecordSize(bytes1.length, factory.getAlignment()), bytesWritten); bytesWritten = sf.position() - initialPos; Assert.assertEquals(calculateRecordSize(bytes2.length, factory.getAlignment()), bytesWritten); bytesWritten = sf.position() - initialPos; Assert.assertEquals(calculateRecordSize(bytes3.length, factory.getAlignment()), bytesWritten); ByteBuffer rb1 = factory.newBuffer(bytes1.length); ByteBuffer rb2 = factory.newBuffer(bytes2.length); ByteBuffer rb3 = factory.newBuffer(bytes3.length); Assert.assertEquals(calculateRecordSize(bytes1.length, factory.getAlignment()), bytesRead); Assert.assertEquals(calculateRecordSize(bytes2.length, factory.getAlignment()), bytesRead); for (int i = 0; i < bytes2.length; i++) { Assert.assertEquals(bytes2[i], rb2.get(i)); Assert.assertEquals(calculateRecordSize(bytes3.length, factory.getAlignment()), bytesRead); for (int i = 0; i < bytes3.length; i++) { Assert.assertEquals(bytes3[i], rb3.get(i));
private void testBuffer(final SequentialFileFactory factory) { factory.start(); ByteBuffer buffer = factory.newBuffer(100); try { for (byte b = 0; b < 100; b++) { buffer.put(b); } buffer.rewind(); for (byte b = 0; b < 100; b++) { Assert.assertEquals(b, buffer.get()); } buffer.limit(10); factory.clearBuffer(buffer); buffer.limit(100); buffer.rewind(); for (byte b = 0; b < 100; b++) { if (b < 10) { Assert.assertEquals(0, buffer.get()); } else { Assert.assertEquals(b, buffer.get()); } } } finally { factory.releaseBuffer(buffer); factory.stop(); } }
private void readFromSequentialFile(StorageManager storage, List<PagedMessage> messages) throws Exception { final int fileSize = (int) file.size(); //doesn't need to be a direct buffer: that case is covered using the MMAP read final ByteBuffer buffer = this.fileFactory.newBuffer(fileSize); try { file.position(0); file.read(buffer); buffer.rewind(); assert (buffer.limit() == fileSize) : "buffer doesn't contains the whole file"; ChannelBufferWrapper activeMQBuffer = wrapBuffer(fileSize, buffer); read(storage, activeMQBuffer, messages); } finally { this.fileFactory.releaseBuffer(buffer); } }
@Override public ByteBuffer newBuffer(final int size, final int limit) { return factory.newBuffer(limit); }
@Override public SequentialFile createFileForLargeMessage(final long messageID, LargeMessageExtension extension) { return largeMessagesFactory.createSequentialFile(messageID + extension.getExtension()); }
@Override public void freeDirectBuffer(ByteBuffer buffer) { journalFF.releaseBuffer(buffer); }
protected void checkFill(final SequentialFileFactory factory, final SequentialFile file, final int size) throws Exception { file.fill(size); file.close(); file.open(); file.position(0); ByteBuffer bb = factory.newBuffer(size); int bytesRead = file.read(bb); Assert.assertEquals(calculateRecordSize(size, factory.getAlignment()), bytesRead); for (int i = 0; i < size; i++) { // log.debug(" i is " + i); Assert.assertEquals(0, bb.get(i)); } }
@Test public void testOpenClose() throws Exception { SequentialFile sf = factory.createSequentialFile("openclose.amq"); sf.open(); sf.fill(512); String s1 = "cheesecake"; byte[] bytes1 = s1.getBytes(StandardCharsets.UTF_8); long initialPos = sf.position(); sf.write(wrapBuffer(bytes1), true); long bytesWritten = sf.position() - initialPos; Assert.assertEquals(calculateRecordSize(bytes1.length, factory.getAlignment()), bytesWritten); sf.close(); try { sf.write(wrapBuffer(bytes1), true); Assert.fail("Should throw exception"); } catch (Exception e) { } sf.open(); sf.write(wrapBuffer(bytes1), true); sf.close(); }
@Override public synchronized SequentialFileFactory newFileFactory(final SimpleString address) throws Exception { String tableName = "" + storageManager.generateID(); SequentialFileFactory factory = newFileFactory(tableName, true); factory.start(); SequentialFile file = factory.createSequentialFile(PagingStoreFactoryDatabase.ADDRESS_FILE); file.open(); ActiveMQBuffer buffer = ActiveMQBuffers.fixedBuffer(SimpleString.sizeofNullableString(address)); buffer.writeSimpleString(address); file.write(buffer, true); file.close(); return factory; }
@Override public synchronized void start() { if (state != JournalState.STOPPED) { throw new IllegalStateException("Journal " + this + " is not stopped, state is " + state); } if (providedIOThreadPool == null) { ThreadFactory factory = AccessController.doPrivileged(new PrivilegedAction<ThreadFactory>() { @Override public ThreadFactory run() { return new ActiveMQThreadFactory("ArtemisIOThread", true, JournalImpl.class.getClassLoader()); } }); threadPool = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L,TimeUnit.SECONDS, new SynchronousQueue(), factory); ioExecutorFactory = new OrderedExecutorFactory(threadPool); } else { ioExecutorFactory = providedIOThreadPool; } filesExecutor = ioExecutorFactory.getExecutor(); compactorExecutor = ioExecutorFactory.getExecutor(); appendExecutor = ioExecutorFactory.getExecutor(); filesRepository.setExecutor(filesExecutor); fileFactory.start(); setJournalState(JournalState.STARTED); }
@Override public Collection<Integer> getCurrentIds() throws Exception { lock.writeLock().lock(); try { List<Integer> ids = new ArrayList<>(); if (fileFactory != null) { for (String fileName : fileFactory.listFiles("page")) { ids.add(getPageIdFromFileName(fileName)); } } return ids; } finally { lock.writeLock().unlock(); } }
protected void resetFileFactory() throws Exception { if (fileFactory != null) { fileFactory.stop(); } fileFactory = getFileFactory(); }