commons-jcs-core/src/main/java/org/apache/commons/jcs3/auxiliary/disk/indexed/IndexedDisk.java - commons-jcs - Git at Google

 package org.apache.commons.jcs3.auxiliary.disk.indexed;

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.file.StandardOpenOption;

 import org.apache.commons.jcs3.engine.behavior.IElementSerializer;
 import org.apache.commons.jcs3.log.Log;
 import org.apache.commons.jcs3.log.LogManager;

 /** Provides thread safe access to the underlying random access file. */
 public class IndexedDisk implements AutoCloseable
 {
     /** The size of the header that indicates the amount of data stored in an occupied block. */
     public static final byte HEADER_SIZE_BYTES = 4;

     /** The serializer. */
     private final IElementSerializer elementSerializer;

     /** The logger */
     private static final Log log = LogManager.getLog(IndexedDisk.class);

     /** The path to the log directory. */
     private final String filepath;

     /** The data file. */
     private final FileChannel fc;

     /**
      * Constructor for the Disk object
      * <p>
      * @param file
      * @param elementSerializer
      * @throws IOException
      */
     public IndexedDisk(final File file, final IElementSerializer elementSerializer)
         throws IOException
     {
         this.filepath = file.getAbsolutePath();
         this.elementSerializer = elementSerializer;
         this.fc = FileChannel.open(file.toPath(),
                 StandardOpenOption.CREATE,
                 StandardOpenOption.READ,
                 StandardOpenOption.WRITE);
     }

     /**
      * This reads an object from the given starting position on the file.
      * <p>
      * The first four bytes of the record should tell us how long it is. The data is read into a byte
      * array and then an object is constructed from the byte array.
      * <p>
      * @return Serializable
      * @param ded
      * @throws IOException
      * @throws ClassNotFoundException
      */
     protected <T> T readObject(final IndexedDiskElementDescriptor ded)
         throws IOException, ClassNotFoundException
     {
         String message = null;
         boolean corrupted = false;
         final long fileLength = fc.size();
         if (ded.pos > fileLength)
         {
             corrupted = true;
             message = "Record " + ded + " starts past EOF.";
         }
         else
         {
             final ByteBuffer datalength = ByteBuffer.allocate(HEADER_SIZE_BYTES);
             fc.read(datalength, ded.pos);
             datalength.flip();
             final int datalen = datalength.getInt();
             if (ded.len != datalen)
             {
                 corrupted = true;
                 message = "Record " + ded + " does not match data length on disk (" + datalen + ")";
             }
             else if (ded.pos + ded.len > fileLength)
             {
                 corrupted = true;
                 message = "Record " + ded + " exceeds file length.";
             }
         }

         if (corrupted)
         {
             log.warn("\n The file is corrupt: \n {0}", message);
             throw new IOException("The File Is Corrupt, need to reset");
         }

         final ByteBuffer data = ByteBuffer.allocate(ded.len);
         fc.read(data, ded.pos + HEADER_SIZE_BYTES);
         data.flip();

         return elementSerializer.deSerialize(data.array(), null);
     }

     /**
      * Moves the data stored from one position to another. The descriptor's position is updated.
      * <p>
      * @param ded
      * @param newPosition
      * @throws IOException
      */
     protected void move(final IndexedDiskElementDescriptor ded, final long newPosition)
         throws IOException
     {
         final ByteBuffer datalength = ByteBuffer.allocate(HEADER_SIZE_BYTES);
         fc.read(datalength, ded.pos);
         datalength.flip();
         final int length = datalength.getInt();

         if (length != ded.len)
         {
             throw new IOException("Mismatched memory and disk length (" + length + ") for " + ded);
         }

         // TODO: more checks?

         long readPos = ded.pos;
         long writePos = newPosition;

         // header len + data len
         int remaining = HEADER_SIZE_BYTES + length;
         final ByteBuffer buffer = ByteBuffer.allocate(16384);

         while (remaining > 0)
         {
             // chunk it
             final int chunkSize = Math.min(remaining, buffer.capacity());
             buffer.limit(chunkSize);
             fc.read(buffer, readPos);
             buffer.flip();
             fc.write(buffer, writePos);
             buffer.clear();

             writePos += chunkSize;
             readPos += chunkSize;
             remaining -= chunkSize;
         }

         ded.pos = newPosition;
     }

     /**
      * Writes the given byte array to the Disk at the specified position.
      * <p>
      * @param data
      * @param ded
      * @return true if we wrote successfully
      * @throws IOException
      */
     protected boolean write(final IndexedDiskElementDescriptor ded, final byte[] data)
         throws IOException
     {
         final long pos = ded.pos;
         if (log.isTraceEnabled())
         {
             log.trace("write> pos={0}", pos);
             log.trace("{0} -- data.length = {1}", fc, data.length);
         }

         if (data.length != ded.len)
         {
             throw new IOException("Mismatched descriptor and data lengths");
         }

         final ByteBuffer headerBuffer = ByteBuffer.allocate(HEADER_SIZE_BYTES);
         headerBuffer.putInt(data.length);
         // write the header
         headerBuffer.flip();
         int written = fc.write(headerBuffer, pos);
         assert written == HEADER_SIZE_BYTES;

         //write the data
         final ByteBuffer dataBuffer = ByteBuffer.wrap(data);
         written = fc.write(dataBuffer, pos + HEADER_SIZE_BYTES);

         return written == data.length;
     }

     /**
      * Serializes the object and write it out to the given position.
      * <p>
      * TODO: make this take a ded as well.
      * @param obj
      * @param pos
      * @throws IOException
      */
     protected <T> void writeObject(final T obj, final long pos)
         throws IOException
     {
         final byte[] data = elementSerializer.serialize(obj);
         write(new IndexedDiskElementDescriptor(pos, data.length), data);
     }

     /**
      * Returns the raf length.
      *
      * @return the length of the file.
      * @throws IOException If an I/O error occurs.
      */
     protected long length()
         throws IOException
     {
         return fc.size();
     }

     /**
      * Closes the raf.
      * <p>
      * @throws IOException
      */
     @Override
     public void close()
         throws IOException
     {
         fc.close();
     }

     /**
      * Sets the raf to empty.
      * <p>
      * @throws IOException
      */
     protected synchronized void reset()
         throws IOException
     {
         log.debug("Resetting Indexed File [{0}]", filepath);
         fc.truncate(0);
         fc.force(true);
     }

     /**
      * Truncates the file to a given length.
      * <p>
      * @param length the new length of the file
      * @throws IOException
      */
     protected void truncate(final long length)
         throws IOException
     {
         log.info("Truncating file [{0}] to {1}", filepath, length);
         fc.truncate(length);
     }

     /**
      * This is used for debugging.
      * <p>
      * @return the file path.
      */
     protected String getFilePath()
     {
         return filepath;
     }

     /**
      * Tests if the length is 0.
      * @return true if the if the length is 0.
      * @throws IOException If an I/O error occurs.
      * @since 3.1
      */
     protected boolean isEmpty() throws IOException
     {
         return length() == 0;
     }
 }
	package org.apache.commons.jcs3.auxiliary.disk.indexed;

	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	import java.io.File;
	import java.io.IOException;
	import java.nio.ByteBuffer;
	import java.nio.channels.FileChannel;
	import java.nio.file.StandardOpenOption;

	import org.apache.commons.jcs3.engine.behavior.IElementSerializer;
	import org.apache.commons.jcs3.log.Log;
	import org.apache.commons.jcs3.log.LogManager;

	/** Provides thread safe access to the underlying random access file. */
	public class IndexedDisk implements AutoCloseable
	{
	/** The size of the header that indicates the amount of data stored in an occupied block. */
	public static final byte HEADER_SIZE_BYTES = 4;

	/** The serializer. */
	private final IElementSerializer elementSerializer;

	/** The logger */
	private static final Log log = LogManager.getLog(IndexedDisk.class);

	/** The path to the log directory. */
	private final String filepath;

	/** The data file. */
	private final FileChannel fc;

	/**
	* Constructor for the Disk object
	* <p>
	* @param file
	* @param elementSerializer
	* @throws IOException
	*/
	public IndexedDisk(final File file, final IElementSerializer elementSerializer)
	throws IOException
	{
	this.filepath = file.getAbsolutePath();
	this.elementSerializer = elementSerializer;
	this.fc = FileChannel.open(file.toPath(),
	StandardOpenOption.CREATE,
	StandardOpenOption.READ,
	StandardOpenOption.WRITE);
	}

	/**
	* This reads an object from the given starting position on the file.
	* <p>
	* The first four bytes of the record should tell us how long it is. The data is read into a byte
	* array and then an object is constructed from the byte array.
	* <p>
	* @return Serializable
	* @param ded
	* @throws IOException
	* @throws ClassNotFoundException
	*/
	protected <T> T readObject(final IndexedDiskElementDescriptor ded)
	throws IOException, ClassNotFoundException
	{
	String message = null;
	boolean corrupted = false;
	final long fileLength = fc.size();
	if (ded.pos > fileLength)
	{
	corrupted = true;
	message = "Record " + ded + " starts past EOF.";
	}
	else
	{
	final ByteBuffer datalength = ByteBuffer.allocate(HEADER_SIZE_BYTES);
	fc.read(datalength, ded.pos);
	datalength.flip();
	final int datalen = datalength.getInt();
	if (ded.len != datalen)
	{
	corrupted = true;
	message = "Record " + ded + " does not match data length on disk (" + datalen + ")";
	}
	else if (ded.pos + ded.len > fileLength)
	{
	corrupted = true;
	message = "Record " + ded + " exceeds file length.";
	}
	}

	if (corrupted)
	{
	log.warn("\n The file is corrupt: \n {0}", message);
	throw new IOException("The File Is Corrupt, need to reset");
	}

	final ByteBuffer data = ByteBuffer.allocate(ded.len);
	fc.read(data, ded.pos + HEADER_SIZE_BYTES);
	data.flip();

	return elementSerializer.deSerialize(data.array(), null);
	}

	/**
	* Moves the data stored from one position to another. The descriptor's position is updated.
	* <p>
	* @param ded
	* @param newPosition
	* @throws IOException
	*/
	protected void move(final IndexedDiskElementDescriptor ded, final long newPosition)
	throws IOException
	{
	final ByteBuffer datalength = ByteBuffer.allocate(HEADER_SIZE_BYTES);
	fc.read(datalength, ded.pos);
	datalength.flip();
	final int length = datalength.getInt();

	if (length != ded.len)
	{
	throw new IOException("Mismatched memory and disk length (" + length + ") for " + ded);
	}

	// TODO: more checks?

	long readPos = ded.pos;
	long writePos = newPosition;

	// header len + data len
	int remaining = HEADER_SIZE_BYTES + length;
	final ByteBuffer buffer = ByteBuffer.allocate(16384);

	while (remaining > 0)
	{
	// chunk it
	final int chunkSize = Math.min(remaining, buffer.capacity());
	buffer.limit(chunkSize);
	fc.read(buffer, readPos);
	buffer.flip();
	fc.write(buffer, writePos);
	buffer.clear();

	writePos += chunkSize;
	readPos += chunkSize;
	remaining -= chunkSize;
	}

	ded.pos = newPosition;
	}

	/**
	* Writes the given byte array to the Disk at the specified position.
	* <p>
	* @param data
	* @param ded
	* @return true if we wrote successfully
	* @throws IOException
	*/
	protected boolean write(final IndexedDiskElementDescriptor ded, final byte[] data)
	throws IOException
	{
	final long pos = ded.pos;
	if (log.isTraceEnabled())
	{
	log.trace("write> pos={0}", pos);
	log.trace("{0} -- data.length = {1}", fc, data.length);
	}

	if (data.length != ded.len)
	{
	throw new IOException("Mismatched descriptor and data lengths");
	}

	final ByteBuffer headerBuffer = ByteBuffer.allocate(HEADER_SIZE_BYTES);
	headerBuffer.putInt(data.length);
	// write the header
	headerBuffer.flip();
	int written = fc.write(headerBuffer, pos);
	assert written == HEADER_SIZE_BYTES;

	//write the data
	final ByteBuffer dataBuffer = ByteBuffer.wrap(data);
	written = fc.write(dataBuffer, pos + HEADER_SIZE_BYTES);

	return written == data.length;
	}

	/**
	* Serializes the object and write it out to the given position.
	* <p>
	* TODO: make this take a ded as well.
	* @param obj
	* @param pos
	* @throws IOException
	*/
	protected <T> void writeObject(final T obj, final long pos)
	throws IOException
	{
	final byte[] data = elementSerializer.serialize(obj);
	write(new IndexedDiskElementDescriptor(pos, data.length), data);
	}

	/**
	* Returns the raf length.
	*
	* @return the length of the file.
	* @throws IOException If an I/O error occurs.
	*/
	protected long length()
	throws IOException
	{
	return fc.size();
	}

	/**
	* Closes the raf.
	* <p>
	* @throws IOException
	*/
	@Override
	public void close()
	throws IOException
	{
	fc.close();
	}

	/**
	* Sets the raf to empty.
	* <p>
	* @throws IOException
	*/
	protected synchronized void reset()
	throws IOException
	{
	log.debug("Resetting Indexed File [{0}]", filepath);
	fc.truncate(0);
	fc.force(true);
	}

	/**
	* Truncates the file to a given length.
	* <p>
	* @param length the new length of the file
	* @throws IOException
	*/
	protected void truncate(final long length)
	throws IOException
	{
	log.info("Truncating file [{0}] to {1}", filepath, length);
	fc.truncate(length);
	}

	/**
	* This is used for debugging.
	* <p>
	* @return the file path.
	*/
	protected String getFilePath()
	{
	return filepath;
	}

	/**
	* Tests if the length is 0.
	* @return true if the if the length is 0.
	* @throws IOException If an I/O error occurs.
	* @since 3.1
	*/
	protected boolean isEmpty() throws IOException
	{
	return length() == 0;
	}
	}