source: 3thparty/jupload/src/main/java/wjhk/jupload2/upload/UploadFileData.java @ 3951

//
// $Id: UploadFileData.java 1360 2010-06-28 11:35:55Z etienne_sf $
//
// jupload - A file upload applet.
// Copyright 2007 The JUpload Team
//
// Created: 2006-11-20
// Creator: etienne_sf
// Last modified: $Date: 2010-06-28 08:35:55 -0300 (Seg, 28 Jun 2010) $
//
// This program is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation; either version 2 of the License, or (at your option) any later
// version. This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
// details. You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software Foundation, Inc.,
// 675 Mass Ave, Cambridge, MA 02139, USA.

package wjhk.jupload2.upload;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;

import wjhk.jupload2.exception.JUploadException;
import wjhk.jupload2.exception.JUploadIOException;
import wjhk.jupload2.exception.JUploadInterrupted;
import wjhk.jupload2.filedata.FileData;
import wjhk.jupload2.policies.UploadPolicy;
import wjhk.jupload2.upload.helper.ByteArrayEncoder;

/**
 * This class implements the FileData interface, and is responsible to do the
 * actual upload of the files.
 * 
 * @author etienne_sf
 */
public class UploadFileData implements FileData {

        /**
         * The {@link FileData} instance that contains all information about the
         * file to upload.
         */
        private FileData fileData = null;

        /**
         * The value of the fileData InputStream. It's main use is to allow chunk
         * upload, to reuse the previous InputStream, that is: each chunk will start
         * reading the stream where the previous one stopped.
         */
        InputStream uploadInputStream = null;

        /**
         * Indicates the position of the file in the current upload (from 0 to
         * max-1). It is mainly used by the
         * ProgressBarManager.updateUploadProgressBarText() method, to display the
         * upload status to the user.
         */
        int numOfFileInCurrentUpload = -1;

        // FIXME numOfFileInCurrentUpload should be from 1 to max

        /**
         * Instance of the fileUploadManagerThread. This allow this class to send
         * feedback to the thread.
         * 
         * @see FileUploadManagerThread#nbBytesUploaded(long)
         */
        private FileUploadManagerThread fileUploadManagerThread = null;

        /**
         * The number of bytes to upload, for this file (without the head and tail
         * defined for the HTTP multipart body).
         */
        private long uploadRemainingLength = -1;

        /**
         * The current {@link UploadPolicy}
         */
        private UploadPolicy uploadPolicy = null;

        private final static int BUFLEN = 4096;

        /**
         * This field is no more static, as we could decide to upload two files
         * simultaneously.
         */
        private final byte readBuffer[] = new byte[BUFLEN];

        // /////////////////////////////////////////////////////////////////////////////////////////////////////
        // //////////////////////////////////// CONSTRUCTOR
        // ///////////////////////////////////////////
        // /////////////////////////////////////////////////////////////////////////////////////////////////////

        /**
         * Standard constructor for the UploadFileData class.
         * 
         * @param fileDataParam
         *            The file data the this instance must transmist.
         * @param numOfFileInCurrentUpload
         * @param fileUploadManagerThreadParam
         *            The current instance of {@link FileUploadThread}
         * @param uploadPolicyParam
         *            The current upload policy, instance of {@link UploadPolicy}
         */
        public UploadFileData(FileData fileDataParam, int numOfFileInCurrentUpload,
                        FileUploadManagerThread fileUploadManagerThreadParam,
                        UploadPolicy uploadPolicyParam) {
                if (fileDataParam == null && !(this instanceof UploadFileDataPoisonned)) {
                        throw new NullPointerException(
                                        "fileData is null in UploadFileData(FileData, FileUploadManagerThread, UploadPolicy) constructor");
                }
                this.fileData = fileDataParam;
                this.numOfFileInCurrentUpload = numOfFileInCurrentUpload;
                this.fileUploadManagerThread = fileUploadManagerThreadParam;
                this.uploadPolicy = uploadPolicyParam;
        }

        /**
         * This particular constructor is posted by the
         * {@link FilePreparationThread} in the preparedFileQueue to indicate that
         * the last file has been prepared.
         * 
         * @param poisonned
         *            This parameter is here to avoid this constructor to be the
         *            default constructor. Its value must be 'true'.
         */
        public UploadFileData(boolean poisonned) {
                if (!poisonned) {
                        throw new IllegalArgumentException(
                                        "poisonned must be true in UploadFileData(boolean) constructor");
                }
        }

        /**
         * Get the number of files that are still to upload. It is initialized at
         * the creation of the file, by a call to the
         * {@link FileData#getUploadLength()}. <BR>
         * <B>Note:</B> When the upload for this file is finish and you want to send
         * it again (for instance the upload failed, and you want to do a retry),
         * you should not reuse this instance, but, instead, create a new
         * UploadFileData instance.
         * 
         * @return Number of bytes still to upload.
         * @see #getInputStream()
         */
        long getRemainingLength() {
                return this.uploadRemainingLength;
        }

        /**
         * This methods writes the file data (see {@link FileData#getInputStream()}
         * to the given outputStream (the output toward the HTTP server).
         * 
         * @param outputStream
         *            The stream on which the data is to be written.
         * @param amount
         *            The number of bytes to write.
         * @throws JUploadException
         *             if an I/O error occurs.
         * @throws JUploadInterrupted
         *             Thrown when an interruption of the thread is detected.
         */
        void uploadFile(OutputStream outputStream, long amount)
                        throws JUploadException, JUploadInterrupted {
                this.uploadPolicy.displayDebug("in UploadFileData.uploadFile (amount:"
                                + amount + ", getUploadLength(): " + getUploadLength() + ")",
                                30);

                // getInputStream will put a new fileInput in the inputStream attribute,
                // or leave it unchanged if it is not null.
                InputStream inputStream = getInputStream();

                while (amount > 0 && !this.fileUploadManagerThread.isUploadFinished()) {
                        // Are we interrupted ?
                        if (Thread.interrupted()) {
                                throw new JUploadInterrupted(getClass().getName()
                                                + ".uploadFile [" + this.getFileName() + "]",
                                                this.uploadPolicy);
                        }

                        int toread = (amount > BUFLEN) ? BUFLEN : (int) amount;
                        int towrite = 0;

                        try {
                                towrite = inputStream.read(this.readBuffer, 0, toread);
                        } catch (IOException e) {
                                throw new JUploadIOException(e);
                        }
                        if (towrite > 0) {
                                try {
                                        outputStream.write(this.readBuffer, 0, towrite);
                                        this.fileUploadManagerThread.nbBytesUploaded(towrite, this);
                                        amount -= towrite;
                                        this.uploadRemainingLength -= towrite;

                                        // For debug reason, I may need to simulate upload, that are
                                        // on a real network. We then slow down the upload. This can
                                        // occurs only when given a 'high' debugLevel (higher than
                                        // what can be set with the applet GUI.
                                        if (this.uploadPolicy.getDebugLevel() > 100) {
                                                try {
                                                        Thread.sleep(20);
                                                } catch (InterruptedException e) {
                                                        // Nothing to do. We'll just take a look at the loop
                                                        // condition.
                                                }
                                        }
                                } catch (IOException ioe) {
                                        throw new JUploadIOException(this.getClass().getName()
                                                        + ".uploadFile()", ioe);
                                } catch (Exception e) {
                                        // When the user may not override an existing file, I got a
                                        // NullPointerException. Let's trap all errors here.
                                        throw new JUploadException(
                                                        this.getClass().getName()
                                                                        + ".uploadFile()  (check the user permission on the server)",
                                                        e);
                                }
                        }
                }// while
        }

        /**
         * Just transmit to {@link FileData#afterUpload()}.
         * 
         * @see FileData#afterUpload()
         */
        public void afterUpload() {
                // Transmission to the 'real' FileData
                this.fileData.afterUpload();
        }

        /** {@inheritDoc} */
        public void appendFileProperties(ByteArrayEncoder bae, int index)
                        throws JUploadIOException {
                this.fileData.appendFileProperties(bae, index);
        }

        /** {@inheritDoc} */
        public void beforeUpload() throws JUploadException {
                this.fileData.beforeUpload();

                // Calculation of some internal variables.
                this.uploadRemainingLength = this.fileData.getUploadLength();
        }

        /** {@inheritDoc} */
        public boolean canRead() {
                return this.fileData.canRead();
        }

        /** {@inheritDoc} */
        public String getDirectory() {
                return this.fileData.getDirectory();
        }

        /** {@inheritDoc} */
        public File getFile() {
                return this.fileData.getFile();
        }

        /** {@inheritDoc} */
        public String getFileExtension() {
                return this.fileData.getFileExtension();
        }

        /** {@inheritDoc} */
        public long getFileLength() {
                return this.fileData.getFileLength();
        }

        /** {@inheritDoc} */
        public String getFileName() {
                return this.fileData.getFileName();
        }

        /** {@inheritDoc} */
        public InputStream getInputStream() throws JUploadException {
                if (this.uploadInputStream == null) {
                        this.uploadInputStream = this.fileData.getInputStream();
                }
                return this.uploadInputStream;
        }

        /** {@inheritDoc} */
        public Date getLastModified() {
                return this.fileData.getLastModified();
        }

        /** {@inheritDoc} */
        public String getMD5() throws JUploadException {
                return this.fileData.getMD5();
        }

        /** {@inheritDoc} */
        public String getMimeType() {
                return this.fileData.getMimeType();
        }

        /** {@inheritDoc} */
        public String getRelativeDir() {
                return this.fileData.getRelativeDir();
        }

        /**
         * Retrieves the file name, that should be used in the server application.
         * Default is to send the original filename.
         * 
         * @param index
         *            The index of this file in the current request to the server.
         * @return The real file name. Not used in FTP upload.
         * @throws JUploadException
         *             Thrown when an error occurs.
         * @see UploadPolicy#getUploadFilename(FileData, int)
         */
        public String getUploadFilename(int index) throws JUploadException {
                return this.uploadPolicy.getUploadFilename(this.fileData, index);
        }

        /**
         * Retrieves the upload file name, that should be sent to the server. It's
         * the technical name used to retrieve the file content. Default is File0,
         * File1... This method just calls the
         * {@link UploadPolicy#getUploadFilename(FileData, int)} method.
         * 
         * @param index
         *            The index of this file in the current request to the server.
         * @return The technical upload file name. Not used in FTP upload.
         * @throws JUploadException
         * @see UploadPolicy#getUploadName(FileData, int)
         */
        public String getUploadName(int index) throws JUploadException {
                return this.uploadPolicy.getUploadName(this.fileData, index);
        }

        /**
         * This methods stores locally the upload length. So, on the contrary of the
         * {@link FileData} interface, this method may be called after
         * {@link #afterUpload()}, at one condition: that it has been called once
         * before {@link #afterUpload()} is called.
         * 
         * @see FileData#getUploadLength()
         */
        public long getUploadLength() {
                return this.fileData.getUploadLength();
        }

        /** {@inheritDoc} */
        public boolean isPreparedForUpload() {
                return this.fileData.isPreparedForUpload();
        }

        /**
         * @return the poisonned status. Returns always false, as this instance is a
         *         true one. false indicates the 'End Of Queue' marker in the
         *         preparedFileQueue, which is not the case here
         * @see UploadFileDataPoisonned
         */
        public boolean isPoisonned() {
                return false;
        }

        /**
         * @return the numOfFileInCurrentUpload
         */
        public int getNumOfFileInCurrentUpload() {
                return numOfFileInCurrentUpload;
        }

}