Quadcap Embeddable Server

com/quadcap/http/servlets/file/HttpFile.java

Go to the documentation of this file.

package com.quadcap.http.servlets.file;

/* Copyright 1998 - 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.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;

import java.net.URL;
import java.net.URLConnection;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.quadcap.util.collections.Cacheable;

import com.quadcap.io.IO;

import com.quadcap.io.dir.Directory;
import com.quadcap.io.dir.Entry;

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

/**
 * This class represents a single cached file.
 *
 * @author Stan Bailes
 */
public class HttpFile extends Cacheable {
    ServletContext              context;
    String                      contentType     = "text/plain";
    File                        file;
    URL                         url;
    long                        lastMod;
    long                        lastCheck       = -1;
    byte[]                      buf             = null;

    static int                  MAX_CACHED      = 16 * 1024;
    
    /**
     * Default constructor 
     */
    public HttpFile() {}

    public void init(Object store, Object key) throws IOException {
        super.init(store, key);
        FileServlet fs = (FileServlet)store;
        this.context = fs.getServletContext();
        String path = key.toString();
        this.contentType = context.getMimeType(path);
        this.file = new File(path);
        if (!file.exists()) {
            this.file = null;
            this.url = fs.getURL(path);
            if (url == null) {
                throw new FileNotFoundException("Not found: " + path);
            }
        }
        compile();
    }

    public synchronized void compile() throws IOException {
        if (file != null) {
            if (!file.exists()) {
                throw new FileNotFoundException("Not found: " + file);
            }
            if (file.isDirectory()) {
                File g = new File(file, "index.html");
                if (g.canRead()) {
                    file = g;
                    contentType = "text/html";
                } else {
                    throw new FileNotFoundException("Not found: " + file);
                }
            }
            if (file.canRead() && file.length() < MAX_CACHED) {
                buf = new byte[(int)file.length()];
                FileInputStream is = new FileInputStream(file);
                try {
                    IO.readFully(is, buf);
                } finally {
                    is.close();
                }
                this.lastMod = file.lastModified();
            } else {
                buf = null;
            }
        } else {
            URLConnection conn = url.openConnection();
            long len = conn.getContentLength();
            if (len < MAX_CACHED) {
                buf = new byte[(int)len];
                try {
                    this.lastMod = conn.getLastModified();
                    InputStream is = conn.getInputStream();
                    try {
                        IO.readFully(is, buf);
                    } finally {
                        is.close();
                    }
                } catch (IOException e) {
                    buf = null;
                    throw e;
                }
            } else {
                buf = null;
            }
        }
    }

    public synchronized void service(HttpServletRequest req,
                                     HttpServletResponse res)
        throws IOException
    {
        //Jni j = new Jni("file");
        res.setContentType(contentType);
        //j.dump("setContentType");
        OutputStream os = res.getOutputStream();
        //j.dump("getOutputStream");
        if (buf != null) {
            res.setContentLength(buf.length);
            //j.dump("setContentLength");
            os.write(buf);
            //j.dump("os.write(buf)");
        } else if (file != null) {
            res.setContentLength((int)file.length());
            try {
                FileInputStream is = new FileInputStream(file);
                try {
                    IO.copyStream(is, os);
                } finally {
                    is.close();
                }
            } catch (FileNotFoundException fe) {
                res.sendError(res.SC_NOT_FOUND, "Not found: " +
                              file.getName());
            }
        } else {
            URLConnection conn = url.openConnection();
            res.setContentLength(conn.getContentLength());
            InputStream is = conn.getInputStream();
            try {
                IO.copyStream(is, os);
            } finally {
                is.close();
            }
        }
        //j.dump("done");
    }

    public synchronized void checkModified() throws Exception {
        long now = System.currentTimeMillis();
        if (now - lastCheck > 2000) {
            lastCheck = now;
            if (file != null) {
                if (file.lastModified() > lastMod) {
                    compile();
                }
            } else {
                URLConnection conn = url.openConnection();
                if (conn.getLastModified() > lastMod) {
                    compile();
                }
            }
        }
    }

    public Object getData() {
        return this;
    }

    public void setData(Object obj) {
        throw new RuntimeException("not implemented");
    }
}