/** * The returned output stream is shared among all uses. * Once closed no further writing can occur * @return */ public FileStoreOutputStream getOuputStream(int maxMemorySize) { if (fsos == null) { fsos = lobBuffer.createOutputStream(maxMemorySize); } return fsos; }
@Override public InputStream getInputStream() throws IOException { return store.createInputStream(lobOffset, lobLength); }
public int read(long fileOffset, byte[] b, int offSet, int length) throws IOException { checkRemoved(); return readWrite(fileOffset, b, offSet, length, false); }
StreamFactoryReference sfr = streams.get(streamIndex); sfr.setStreamFactory(new FileStoreInputStreamFactory(store, Streamable.ENCODING)); this.stream = new BufferedOutputStream(store.createOutputStream()); continue; if (store.getLength() + streamDataToRead > maxLobSize) { if (error == null) { error = new StreamCorruptedException( "lob too big: " + (store.getLength() + streamDataToRead) + " (max: " + maxLobSize + ')'); //$NON-NLS-1$ //$NON-NLS-2$
OutputStream out = store.createOutputStream(); out.write(contentOrig.getBytes(), 0, contentOrig.getBytes().length); out.close(); out = store.createOutputStream(); long start = store.getLength(); byte[] bytesOrig = new byte[2048]; r.nextBytes(bytesOrig); InputStream in = store.createInputStream(0, contentOrig.getBytes().length); int c = in.read(readContent, 0, 3000); assertEquals(contentOrig, new String(readContent, 0, c)); in.close(); in = store.createInputStream(start, 2048); c = in.read(readContent, 0, 3000); assertTrue(Arrays.equals(bytesOrig, readContent));
LogManager.logDetail(LogConstants.CTX_BUFFER_MGR, "Defraging store", i, "segment", segment, "length", blockStore.stores[segment].getLength()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ InputStream is = blockStore.stores[segment].createInputStream(relativeBlockToMove * blockStore.blockSize, blockStore.blockSize); Long gid = null; Long oid = null;
static byte[] writeBytes(FileStore store, long start) throws IOException { byte[] bytes = new byte[2048]; r.nextBytes(bytes); store.write(start, bytes, 0, bytes.length); byte[] bytesRead = new byte[2048]; store.readFully(start, bytesRead, 0, bytesRead.length); assertTrue(Arrays.equals(bytes, bytesRead)); return bytes; }
@Override public synchronized void setLength(long length) throws IOException { if (length > len) { ensureLength(length); } else { int numFiles = (int)(length/maxFileSize); long lastFileSize = length%maxFileSize; if (lastFileSize > 0) { numFiles++; } int toRemove = storageFiles.size() - numFiles; for (int i = 0; i < toRemove; i++) { FileStore store = storageFiles.remove(storageFiles.size() -1); store.remove(); } if (lastFileSize > 0) { storageFiles.get(storageFiles.size() - 1).setLength(lastFileSize); } } len = length; }
public long getDiskUsage() { long result = 0; for (int i = 0; i < sizeBasedStores.length; i++) { BlockStore blockStore = sizeBasedStores[i]; for (int segment = 0; segment < blockStore.stores.length; segment++) { result += blockStore.stores[segment].getLength(); } } return result; }
@Override protected void removeDirect() { file.remove(); }
@Override protected int readWrite(long fileOffset, byte[] b, int offSet, int length, boolean write) throws IOException { FileStore store = null; if (!write) { synchronized (this) { if (fileOffset > len) { throw new IOException("Invalid file position " + fileOffset + " length " + length); //$NON-NLS-1$ //$NON-NLS-2$ } store = storageFiles.get((int)(fileOffset/maxFileSize)); } return store.read(fileOffset%maxFileSize, b, offSet, length); } synchronized (this) { ensureLength(fileOffset + length); store = storageFiles.get((int)(fileOffset/maxFileSize)); } long fileBegin = fileOffset%maxFileSize; length = Math.min(length, (int)Math.min(Integer.MAX_VALUE, maxFileSize - fileBegin)); store.write(fileBegin, b, offSet, length); return length; }
@Override public int read(long fileOffset, byte[] b, int offSet, int length) throws IOException { return delegate.read(fileOffset, b, offSet, length); }
@Override public void write(byte[] b, int off, int len) throws IOException { FileStore.this.write(b, off, len); } };
@Test public void testPositionalWrite() throws Exception { FileStorageManager sm = getStorageManager(null, null); String tsID = "0"; //$NON-NLS-1$ FileStore store = sm.createFileStore(tsID); byte[] expectedBytes = writeBytes(store, 2048); assertEquals(4096, sm.getUsedBufferSpace()); writeBytes(store, 4096); assertEquals(6144, sm.getUsedBufferSpace()); byte[] bytesRead = new byte[2048]; store.readFully(2048, bytesRead, 0, bytesRead.length); assertArrayEquals(expectedBytes, bytesRead); store.remove(); assertEquals(0, sm.getUsedBufferSpace()); }
@Override public void readFully(long fileOffset, byte[] b, int offSet, int length) throws IOException { delegate.readFully(fileOffset, b, offSet, length); }
long offset = store.getLength(); OutputStream fsos = store.createOutputStream(); byteLength = ObjectConverterUtil.write(fsos, is, bytes, -1);