Quadcap Embeddable Database

com/quadcap/sql/file/BlockStore.java

Go to the documentation of this file.

package com.quadcap.sql.file;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.File;
import java.io.FileDescriptor;
import java.io.IOException;
import java.io.RandomAccessFile;

import java.util.BitSet;

import com.quadcap.util.Debug;
import com.quadcap.util.Util;

import com.quadcap.sql.Version;

/**
 * Below the cache, this class handles the actual I/O to the underlying file.
 * Block write operations are logged by this class.
 *
 * @author Stan Bailes
 */
public class BlockStore {
    File                                file;
    FileRandomAccess                    fra;
    boolean                             readOnly;
    Log                                 log;
    int                                 blockSize;
    BitSet                              modified = new BitSet();
    Object                              lock;
    boolean                             encrypted = false;
    boolean                             isTempFile = false;

    /**
     * Create a new BlockStore object using the specified file and
     * blocksize.
     *
     * @param file the underlying file.
     * @param mode "r" for readonly access, otherwise "rw"
     * @param blocksize the block size to use when creating the file.
     * @param the synchronization object
     */
    public BlockStore() {
    }

    public String getName() {
        return file == null ? "null" : file.getName();
    }

    public void init(File file, String mode, int blockSize, Object lock)
        throws IOException
    {
        this.file = file;
        boolean exists = file.exists();
        RandomAccessFile ra = new RandomAccessFile(file.getAbsolutePath(), mode);
        this.fra = new FileRandomAccess(ra, 1024L * 1024L * 1024L * 1024L);
        this.readOnly = mode.equalsIgnoreCase("r");
        this.lock = lock;
        if (!exists) {
            createHeader(blockSize);
        } else {
            readHeader();
        }
        isTempFile = !(file.getPath().endsWith("datafile"));
    }

    /**
     * Specify the log used for recovery operations.
     */
    public void setLog(Log log) { this.log = log; }

    /**
     * Return the logger
     */
    public Log getLog() { return log; }

    /**
     * Return the block size of this store.
     */
    public int blockSize() { return blockSize; }

    /**
     * Return the underlying file
     */
    public File getFile() { return file; }

    /**
     * Read a block into a buffer.  If the specified block is beyond the
     * current end of file, then grow the file
     *
     * @param blockNum the number of the block to read.
     * @param buf the buffer into which the data is read.
     */
    public void read(long blockNum, byte[] buf) throws IOException {
        read(blockNum, buf, 0);
    }
    
    public void read(long blockNum, byte[] buf, int off)
        throws IOException
    {
        synchronized (lock) {
            readCount++;
            fra.read(blockNum * blockSize, buf, off, blockSize);
        }
    }

    public static int writeCount = 0;
    public static int readCount = 0;
    /**
     * Write a block from a buffer into the file.
     *
     * @param blockNum the number of the block to write.
     * @param buf the buffer from which the data is written.
     * @exception IOException if an I/O error occurs.
     */
    public void write(long blockNum, byte[] buf)
        throws IOException
    {
        synchronized (lock) {
            writeCount++;
            if (readOnly) {
                throw new IOException("Attempt to write readonly file: " +
                                      file.getName());
            }
            long pos = blockNum * blockSize;
            if (log != null && !modified.get((int)blockNum)) {
                modified.set((int)blockNum);
                if (pos < fra.size()) {
                    log.saveBlock(blockNum);
                }
            }
            //#ifdef DEBUG
            if (Trace.bit(20)) {
                Debug.println(toString() + ".write(" + blockNum + "," +
                              Block.signature(buf) + ") " + Util.stackTrace());
            }
            //#endif
            fra.write(blockNum * blockSize, buf, 0, buf.length);
        }
    }

    /**
     * Restore a block image
     */
    public void restore(long blockNum, byte[] buf, int off)
        throws IOException
    {
        synchronized (lock) {
            //#ifdef DEBUG
            if (Trace.bit(20)) {
                Debug.println(toString() + ".restore(" + blockNum + "," +
                              Block.signature(buf, off, blockSize) + ")");
            }
            //#endif
            fra.write(blockNum * blockSize, buf, off, blockSize);
        }
        
    }
    
    public void clearModified() throws IOException {
        modified = new BitSet();
        if (log != null) log.resetBlocks();
    }


    public void setLength(long length) throws IOException {
        if (readOnly) {
            throw new IOException("Attempt to write readonly file: " +
                                  file.getName());
        }
        fra.resize(length);
    }

    public boolean isEncrypted() {
        return encrypted;
    }
    
    private void readHeader() throws IOException {
        byte[] buf = new byte[32];
        fra.read(0, buf, 0, buf.length);
        int v = ((buf[0] & 0xff) << 8) + (buf[1] & 0xff);
        switch (v) {
        case 0x040c:              // QED.
            encrypted = false;
            break;
        case 0x0e0c:              // Encrypted QED.
            encrypted = true;
            break;
        default:
            throw new IOException("BlockFile: bad magic");
        }
        // XXX This is hokey.  We've tied database versions to the
        // XXX product version numbers somehow, so we complain about
        // XXX incompatibility based on the wrong version.  Need
        // XXX BlockFile, Database, versions....
        if (buf[2] != Version.majorVersion) {
            throw new IOException("BlockFile: bad version (" +
                                  (int)buf[2] + "." + (int)buf[3] +
                                  " vs " +
                                  Version.majorVersion + "." +
                                  Version.minorVersion + ")");
        }
        this.blockSize = ByteUtil.getInt(buf, BlockFile.oBLOCKSIZE);
    }

    private void createHeader(int blockSize) throws IOException {
        this.blockSize = blockSize;
        byte[] buf = newHeader(blockSize, 2);
        fra.write(0, buf, 0, buf.length);
    }

    protected final byte[] newHeader(int blockSize, long lastBlock) {
        byte[] buf = new byte[blockSize];
        for (int i = 0; i < blockSize; i++) buf[i] = (byte)0;
        buf[0] = 0x4; buf[1] = 0xc;             // magic
        buf[2] = Version.majorVersion;
        buf[3] = Version.minorVersion;
        ByteUtil.putInt(buf, BlockFile.oBLOCKSIZE, blockSize);
        ByteUtil.putLong(buf, BlockFile.oLASTBLOCK, lastBlock); // allocated one block
        return buf;
    }

    public void close() throws IOException {
        try {
            if (fra != null) fra.close();
        } finally {
            fra = null;
        }
    }

    public void flush() throws IOException {
        try {
            fra.flush();
            readCount = writeCount = 0;
        } catch (Throwable t) {}
    }

    //#ifdef JDK14
    public void setKey(com.quadcap.crypto.SymmetricKey key)
        throws IOException
    {
        throw new IOException("Not encrypted");
    }
    //#endif
    
    //#ifdef DEBUG
    public String toString() {
        return "BlockStore(" + file.getPath() + ")";
    }

    public static String rw() {
        return "(r=" + BlockStore.readCount +
            " w=" + BlockStore.writeCount + ")";
    }
                   
    //#endif

}