org.apache.hadoop.hdfs.server.datanode.DatanodeBlockWriter.java Source code

Introduction

Here is the source code for org.apache.hadoop.hdfs.server.datanode.DatanodeBlockWriter.java

Source

/**
 * 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.
 */
package org.apache.hadoop.hdfs.server.datanode;

import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.concurrent.Future;
import java.util.concurrent.locks.Lock;

import org.apache.commons.logging.Log;
import org.apache.hadoop.hdfs.protocol.Block;
import org.apache.hadoop.hdfs.server.datanode.FSDataset.FSVolume;
import org.apache.hadoop.hdfs.util.InjectionEvent;
import org.apache.hadoop.io.nativeio.NativeIO;
import org.apache.hadoop.util.DataChecksum;
import org.apache.hadoop.util.InjectionHandler;

/**
 * Base class for block writing in data node. It reads input packet
 * buffer and write data and checksum to local files.
 *
 */
abstract class DatanodeBlockWriter implements java.io.Closeable {
    static final Log LOG = DataNode.LOG;
    static final Log ClientTraceLog = DataNode.ClientTraceLog;

    protected int bytesPerChecksum;
    protected int checksumSize;
    protected Block block; // the block to receive
    protected String inAddr;
    protected int namespaceId;
    protected DataNode datanode = null;

    protected int partialCrcInt;
    protected int firstChunkOffset;

    public abstract void initializeStreams(int bytesPerChecksum, int checksumSize, Block block, String inAddr,
            int namespaceId, DataNode datanode) throws FileNotFoundException, IOException;

    protected void setParameters(int bytesPerChecksum, int checksumSize, Block block, String inAddr,
            int namespaceId, DataNode datanode) {
        this.bytesPerChecksum = bytesPerChecksum;
        this.checksumSize = checksumSize;
        this.block = block;
        this.inAddr = inAddr;
        this.namespaceId = namespaceId;
        this.datanode = datanode;
    }

    /**
     * Write out checksum header
     * 
     * @param checksum
     * @throws IOException
     */
    public abstract void writeHeader(DataChecksum checksum) throws IOException;

    /**
     * Write the data in the packet buffer to local disk.
     * 
     * Input format:
     * Both of data and checksum are in pktBuf.
     * data has len bytes and are from dataOff.
     * checksums are from checksumOff, followed by checksums of chunks. 
     * 
     * @param pktBuf        packet buffer
     * @param len           length of data in the buffer
     * @param dataOff       starting data offset in pktBuf
     * @param checksumOff   starting checksum offset in pktBuf
     * @param numChunks     number of chunks expected in the pktBuf
     * @throws IOException
     */
    public abstract void writePacket(byte pktBuf[], int len, int dataOff, int pktBufStartOff, int numChunks,
            int packetVersion) throws IOException;

    public abstract void setPosAndRecomputeChecksumIfNeeded(long offsetInBlock, DataChecksum checksum)
            throws IOException;

    public abstract void flush(boolean forceSync) throws IOException;

    /**
     * Issue a file range sync with the last bytes of the data stream it is
     * writing to
     * 
     * @param lastBytesToSync
     *          the number of bytes to sync in the end of the block. It's counted
     *          as block sizes instead of bytes on disk, for inline checksum, it
     *          may translate to more bytes to sync.
     * @param flags
     *          the flags for sync_file_range
     * @throws IOException
     */
    public abstract void fileRangeSync(long lastBytesToSync, int flags) throws IOException;

    public abstract void fadviseStream(int advise, long offset, long len) throws IOException;

    public abstract void fadviseStream(int advise, long offset, long len, boolean sync) throws IOException;

    /**
     * Sets the posix fadvise for the caching behavior required from block after
     * we finalize the block.
     * 
     * @param fadvise
     *          the type of advice
     * @throws IOException
     */
    public abstract void close(int fadvise) throws IOException;
}