gridool.util.xfer.RecievedFileWriter.java Source code

Introduction

Here is the source code for gridool.util.xfer.RecievedFileWriter.java

Source

/*
 * @(#)$Id$
 *
 * Copyright 2006-2008 Makoto YUI
 *
 * Licensed 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.
 * 
 * Contributors:
 *     Makoto YUI - initial implementation
 */
package gridool.util.xfer;

import gridool.util.collections.SoftHashMap;
import gridool.util.datetime.StopWatch;
import gridool.util.io.FileUtils;
import gridool.util.io.IOUtils;
import gridool.util.nio.NIOUtils;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 
 * <DIV lang="en"></DIV>
 * <DIV lang="ja"></DIV>
 * 
 * @author Makoto YUI (yuin405@gmail.com)
 */
public class RecievedFileWriter implements TransferRequestListener {
    private static final Log LOG = LogFactory.getLog(RecievedFileWriter.class);

    @Nonnull
    private final File baseDir;
    @GuardedBy("locks")
    private final Map<String, ReadWriteLock> locks;

    public RecievedFileWriter(@Nonnull String baseDirPath) {
        this(new File(baseDirPath));
    }

    public RecievedFileWriter(@Nonnull File baseDir) {
        if (!baseDir.exists()) {
            throw new IllegalArgumentException("Directory not found: " + baseDir.getAbsolutePath());
        }
        if (!baseDir.isDirectory()) {
            throw new IllegalArgumentException(baseDir.getAbsolutePath() + " is not directory");
        }
        if (!baseDir.canWrite()) {
            throw new IllegalArgumentException(baseDir.getAbsolutePath() + " is not writable");
        }
        this.baseDir = baseDir;
        this.locks = new SoftHashMap<String, ReadWriteLock>(32);
    }

    public final void handleRequest(@Nonnull final SocketChannel inChannel, @Nonnull final Socket socket)
            throws IOException {
        final StopWatch sw = new StopWatch();
        if (!inChannel.isBlocking()) {
            inChannel.configureBlocking(true);
        }

        InputStream in = socket.getInputStream();
        DataInputStream dis = new DataInputStream(in);

        String fname = IOUtils.readString(dis);
        String dirPath = IOUtils.readString(dis);
        long len = dis.readLong();
        boolean append = dis.readBoolean();
        boolean ackRequired = dis.readBoolean();
        boolean hasAdditionalHeader = dis.readBoolean();
        if (hasAdditionalHeader) {
            readAdditionalHeader(dis, fname, dirPath, len, append, ackRequired);
        }

        final File file;
        if (dirPath == null) {
            file = new File(baseDir, fname);
        } else {
            File dir = FileUtils.resolvePath(baseDir, dirPath);
            file = new File(dir, fname);
        }

        preFileAppend(file, append);
        final FileOutputStream dst = new FileOutputStream(file, append);
        final String fp = file.getAbsolutePath();
        final ReadWriteLock filelock = accquireLock(fp, locks);
        final FileChannel fileCh = dst.getChannel();
        final long startPos = file.length();
        try {
            NIOUtils.transferFully(inChannel, 0, len, fileCh); // REVIEWME really an atomic operation?
        } finally {
            IOUtils.closeQuietly(fileCh, dst);
            releaseLock(fp, filelock, locks);
            postFileAppend(file, startPos, len);
        }
        if (ackRequired) {
            OutputStream out = socket.getOutputStream();
            DataOutputStream dos = new DataOutputStream(out);
            dos.writeLong(len);
            postAck(file, startPos, len);
        }

        if (LOG.isDebugEnabled()) {
            SocketAddress remoteAddr = socket.getRemoteSocketAddress();
            LOG.debug("Received a " + (append ? "part of file '" : "file '") + file.getAbsolutePath() + "' of "
                    + len + " bytes from " + remoteAddr + " in " + sw.toString());
        }
    }

    protected void readAdditionalHeader(@Nonnull DataInputStream in, @Nonnull String fname,
            @Nullable String dirPath, long len, boolean append, boolean sync) throws IOException {
    }

    protected void preFileAppend(@Nonnull File file, boolean append) throws IOException {
    }

    protected void postFileAppend(@Nonnull File file, long startPos, long len) throws IOException {
    }

    protected void postAck(@Nonnull File file, long startPos, long len) throws IOException {
    }

    private static ReadWriteLock accquireLock(final String key, final Map<String, ReadWriteLock> locks) {
        ReadWriteLock lock;
        synchronized (locks) {
            lock = locks.get(key);
            if (lock == null) {
                lock = new ReentrantReadWriteLock();
                locks.put(key, lock);
            }
        }
        lock.writeLock().lock();
        return lock;
    }

    private static void releaseLock(final String key, final ReadWriteLock lock,
            final Map<String, ReadWriteLock> locks) {
        lock.writeLock().unlock();
    }
}