Metacat

 * action value is quite specific. This documentation will be reorganized to

 * reflect this information.

 */

    private static Hashtable sessionHash = new Hashtable();

    private Timer timer = null;

    private static boolean sitemapScheduled;

    public static final String EML2KEYWORD = ":eml";

    public static final String XMLFORMAT = "xml";

    private static final String CONFIG_DIR = "WEB-INF";

    /**

     * Initialize the servlet by creating appropriate database connections

     */

        try {

            super.init(config);

            Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

            ServletContext context = config.getServletContext();

            // Initialize the properties file for our options

            String dirPath = context.getRealPath(CONFIG_DIR);

            File propertyFile = new File(dirPath, CONFIG_NAME);

                logMetacat.error("Error in loading options: "

                        + ioe.getMessage());

            }

            // Check if the servlet was configured, and if not stop the

            // metacat is called

            boolean configured = options.getOption("configured").equals("true");

            if (!configured) {

            // Index the paths specified in the metacat.properties

            checkIndexPaths();

            // initiate the indexing Queue

            IndexingQueue.getInstance();

            int indexingTimerTaskTime = Integer.parseInt(MetaCatUtil.getOption("indexingTimerTaskTime"));

            int delayTime = Integer.parseInt(MetaCatUtil.getOption("indexingInitialDelay"));

            if(indexingTimerTaskTime > 0){

            }

            Vector skins = MetaCatUtil.getOptionList(MetaCatUtil.getOption("skinconfigfiles"));

            String skinName, skinDirPath = null;

            File skinPropertyFile = null;

            for (int i = 0; i < skins.size(); i++) {

                skinDirPath = context.getRealPath(CONFIG_DIR + "/skin.configs/" + skinName);

                Properties skinOption = null;

                try	{

                    FileInputStream fis = new FileInputStream(skinPropertyFile);

                    skinOption.load(fis);

                    fis.close();

                } catch (IOException ioe) {

                    logMetacat.error("Error in loading options for skin " + "skinName" +" : "

                            + ioe.getMessage());

                MetaCatUtil.skinconfigs.put(skinName, skinOption);

            }

            /*

             *  If spatial option is turned on and set to regenerate the

             */

            if ( MetaCatUtil.getOption("runSpatialOption").equals("true") &&

                // Begin timer

                long before = System.currentTimeMillis();

                // regenerate the entire spatial cache

                // may be expensive with many documents

                SpatialHarvester sh = new SpatialHarvester();

                sh.regenerate();

                sh.destroy();

                // End timer

                long after = System.currentTimeMillis();

                logMetacat.info(" ------ Spatial Harvester Time  " + (after - before) + "ms");

                logMetacat.info(" \n **** Spatial cache is not set to regenerate on restart");

            }

            sitemapScheduled = false;

            logMetacat.info("Metacat (" + Version.getVersion()

        } catch (ServletException ex) {

            throw ex;

        } catch (SQLException e) {

                    + ie.getMessage());

        }

    }

    /**

     * Close all db connections from the pool

     */

        // Close all db connection

        System.out.println("Destroying MetacatServlet");

        timer.cancel();

        IndexingQueue.getInstance().setMetacatRunning(false);

        DBConnectionPool.release();

    }

    /** Handle "GET" method requests from HTTP clients */

    public void doGet(HttpServletRequest request, HttpServletResponse response)

        // Process the data and send back the response

        handleGetOrPost(request, response);

    }

    /** Handle "POST" method requests from HTTP clients */

    public void doPost(HttpServletRequest request, HttpServletResponse response)

        // Process the data and send back the response

        handleGetOrPost(request, response);

    }

    /**

     * Index the paths specified in the metacat.properties

     */

    private void checkIndexPaths() {

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        MetaCatUtil.pathsForIndexing

        if (MetaCatUtil.pathsForIndexing != null) {

            logMetacat.debug("Indexing paths specified in metacat.properties....");

            DBConnection conn = null;

            int serialNumber = -1;

            PreparedStatement pstmt = null;

            PreparedStatement pstmt1 = null;

            ResultSet rs = null;

            for (int i = 0; i < MetaCatUtil.pathsForIndexing.size(); i++) {

                logMetacat.debug("Checking if '"

                try {

                    //check out DBConnection

                    conn = DBConnectionPool.

                    serialNumber = conn.getCheckOutSerialNumber();

                    pstmt = conn.prepareStatement(

                    pstmt.setString(1, (String) MetaCatUtil.pathsForIndexing

                    pstmt.execute();

                    rs = pstmt.getResultSet();

                    if (!rs.next()) {

                        logMetacat.debug(".....not indexed yet.");

                        rs.close();

                        pstmt.close();

                        conn.increaseUsageCount(1);

                        logMetacat.debug(

                        pstmt.setString(1, (String) MetaCatUtil.

                        pstmt.execute();

                        rs = pstmt.getResultSet();

                        int count = 0;

                        logMetacat.debug(

                        try {

                            while (rs.next()) {

                                String docid = rs.getString(1);

                                String nodedata = rs.getString(2);

                                float nodedatanumerical = rs.getFloat(3);

                                int parentnodeid = rs.getInt(4);

                                if (!nodedata.trim().equals("")) {

                                    pstmt1 = conn.prepareStatement(

                                    pstmt1.setString(1, docid);

                                    pstmt1.setString(2, (String) MetaCatUtil.

                                    pstmt1.setString(3, nodedata);

                                    pstmt1.setFloat(4, nodedatanumerical);

                                    pstmt1.setInt(5, parentnodeid);

                                    pstmt1.execute();

                                    pstmt1.close();

                                    count++;

                                }

                            }

                            System.out.println("Exception:" + e.getMessage());

                            e.printStackTrace();

                        }

                        rs.close();

                        pstmt.close();

                        conn.increaseUsageCount(1);

                        logMetacat.info("Indexed " + count

                                + " records from xml_nodes for '"

                                + (String) MetaCatUtil.pathsForIndexing.elementAt(i)

                                + "'");

                    } else {

                    }

                    rs.close();

                    pstmt.close();

                    conn.increaseUsageCount(1);

                } catch (Exception e) {

                    logMetacat.error("Error in MetaCatServlet.checkIndexPaths: "

                }finally {

                    //check in DBonnection

                    DBConnectionPool.returnDBConnection(conn, serialNumber);

                }

            }

            logMetacat.debug("Path Indexing Completed");

        }

    /**

     * Control servlet response depending on the action parameter specified

     */

    private void handleGetOrPost(HttpServletRequest request,

        MetaCatUtil util = new MetaCatUtil();

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        //size is greater than initial value, shrink the connection pool

        //size to initial value

        DBConnectionPool.shrinkDBConnectionPoolSize();

        //Debug message to print out the method which have a busy DBConnection

        try {

            DBConnectionPool pool = DBConnectionPool.getInstance();

                    + e.getMessage());

            e.printStackTrace();

        }

        String ctype = request.getContentType();

        if (ctype != null && ctype.startsWith("multipart/form-data")) {

            handleMultipartForm(request, response);

        } else {

            String name = null;

            String[] value = null;

            String[] docid = new String[3];

            //     e.g.,  http://localhost:8180/knb/metacat/test.1.1/knb

            String pathInfo = request.getPathInfo();

            if (pathInfo != null) {

                    handleReadAction(params, request, response, "public", null, null);

                    return;

            }

            Enumeration paramlist = request.getParameterNames();

            while (paramlist.hasMoreElements()) {

                name = (String) paramlist.nextElement();

                value = request.getParameterValues(name);

                // Decode the docid and mouse click information

                // THIS IS OBSOLETE -- I THINK -- REMOVE THIS BLOCK 4/12/2007 MBJ

                if (name.endsWith(".y")) {

                if (name.endsWith(".x")) {

                    name = "xpos";

                }

                params.put(name, value);

            }

            //handle param is emptpy

            if (params.isEmpty() || params == null) { return; }

            //if the user clicked on the input images, decode which image

            //was clicked then set the action.

            if(params.get("action") == null){

                out.close();

                return;

            }

            String action = ((String[]) params.get("action"))[0];

            logMetacat.info("Action is: " + action);

            // This block handles session management for the servlet

            // by looking up the current session information for all actions

            // other than "login" and "logout"

                PrintWriter out = response.getWriter();

                handleLoginAction(out, params, request, response);

                out.close();

                // handle logout action

            }   else if (action.equals("logout")) {

                PrintWriter out = response.getWriter();

                handleLogoutAction(out, params, request, response);

                out.close();

                // handle shrink DBConnection request

            } else if (action.equals("shrink")) {

                PrintWriter out = response.getWriter();

                }

                //close out put

                out.close();

                // aware of session expiration on every request

            } else {

                HttpSession sess = request.getSession(true);

                    username = "public";

                    sess.setAttribute("username", username);

                    sess_id = (String)sess.getId();

                    sessionHash.put(sess_id, sess);

                } else {

                    logMetacat.info("The session is either old or "

                                sess = (HttpSession) sessionHash.get(sess_id);

                            }

                        } else {

                        }

                    } catch (IllegalStateException ise) {

                        logMetacat.error(

                                + "happen: the session should be valid: "

                                + ise.getMessage());

                    }

                    username = (String) sess.getAttribute("username");

                    logMetacat.info("The user name from session is: "

                            + username);

                    out.close();

                }

            } else if ( action.trim().equals("spatial_query")) {

            } else if (action.equals("export")) {

                handleExportAction(params, response, username,

                        groupnames, password);

            } else if (action.equals("read")) {

                out.println(username);

                out.println("\n</username>\n");

                if(name!=null){

                }

                if(MetaCatUtil.isAdministrator(username, groupnames)){

                }

                if(MetaCatUtil.isModerator(username, groupnames)){

                }

                out.println("\n</user>\n");

                out.close();

                    mue.printStackTrace(out);

                    out.close();

                }

            } else {

                PrintWriter out = response.getWriter();

                out.println("<?xml version=\"1.0\"?>");

                out.println("<error>");

                out.println(

                out.println("</error>");

                out.close();

            }

            //util.closeConnections();

            // Close the stream to the client

            //out.close();

            scheduleSitemapGeneration(request);

        }

    }

    /////////////////////////////// METACAT SPATIAL ///////////////////////////

    /**

     * queries supported by the WFS / WMS standards

     * handleSQuery(out, params, response, username, groupnames,

     *                        sess_id);

     */

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

         * Perform spatial query against spatial cache

         */

        float _xmax = Float.valueOf( ((String[]) params.get("xmax"))[0] ).floatValue();

        Vector docids = sq.filterByBbox( _xmin, _ymin, _xmax, _ymax );

        // logMetacat.info(" --- Spatial Query completed. Passing on the SQuery handler");

        // logMetacat.warn("\n\n ******* after spatial query, we've got " + docids.size() + " docids \n\n");

        /*

         * Create an array matching docids

         */

        String [] docidArray = new String[docids.size()];

        docids.toArray(docidArray);

        /*

         * Create squery string

         */

        String[] queryArray = new String[1];

        queryArray[0] = squery;

        params.put("query", queryArray);

        /*

         * Determine qformat

         */

            qformatArray[0] = "knp";

        }

        params.put("qformat", qformatArray);

        // change the action

        String[] actionArray = new String[1];

        actionArray[0] = "squery";

        params.put("action", actionArray);

        /*

         * Pass the docids to the DBQuery contructor

         */

        // Otherwise dbquery sees no docidOverrides and does a full % percent query

        if (docids.size() == 0)

            docids.add("");

        DBQuery queryobj = new DBQuery(docids);

        queryobj.findDocuments(response, out, params, username, groupnames, sess_id);

    // LOGIN & LOGOUT SECTION

    /**

     * Handle the login request. Create a new session object. Do user

     * authentication through the session.

     */

    private void handleLoginAction(PrintWriter out, Hashtable params,

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        AuthSession sess = null;

        if(params.get("username") == null){

            response.setContentType("text/xml");

            out.println("<?xml version=\"1.0\"?>");

            out.println("</error>");

            return;

        }

        //}

        if(params.get("password") == null){

            response.setContentType("text/xml");

            out.println("<?xml version=\"1.0\"?>");

            out.println("</error>");

            return;

        }

        String un = ((String[]) params.get("username"))[0];

        logMetacat.info("user " + un + " is trying to login");

        String pw = ((String[]) params.get("password"))[0];

        String qformat = "xml";

        if(params.get("qformat") != null){

            qformat = ((String[]) params.get("qformat"))[0];

        }

        try {

            sess = new AuthSession();

        } catch (Exception e) {

            return;

        }

        boolean isValid = sess.authenticate(request, un, pw);

        //if it is authernticate is true, store the session

        if (isValid) {

            HttpSession session = sess.getSessions();

                    + " into hash in login method");

            sessionHash.put(id, session);

        }

        // format and transform the output

        if (qformat.equals("xml")) {

            response.setContentType("text/xml");

                        "-//NCEAS//login//EN", "-//W3C//HTML//EN", qformat,

                        out, null);

            } catch (Exception e) {

                logMetacat.error(

                        "Error in MetaCatServlet.handleLoginAction: "

            }

        }

    }

    /**

     * Handle the logout request. Close the connection.

     */

    private void handleLogoutAction(PrintWriter out, Hashtable params,

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        String qformat = "xml";

        if(params.get("qformat") != null){

            qformat = ((String[]) params.get("qformat"))[0];

        }

        // close the connection

        HttpSession sess = request.getSession(false);

        logMetacat.info("After get session in logout request");

        if (sess != null) {

            logMetacat.info("The session id " + sess.getId()

            logMetacat.info("The session contains user "

                    + sess.getAttribute("username")

                    + " will be invalidate in logout action");

            sess.invalidate();

        }

        // produce output

        StringBuffer output = new StringBuffer();

        output.append("<?xml version=\"1.0\"?>");

        output.append("<logout>");

        output.append("User logged out");

        output.append("</logout>");

        //format and transform the output

        if (qformat.equals("xml")) {

            response.setContentType("text/xml");

            } catch (Exception e) {

                logMetacat.error(

                        "Error in MetaCatServlet.handleLogoutAction"

            }

        }

    }

    // END OF LOGIN & LOGOUT SECTION

    // SQUERY & QUERY SECTION

    /**

     * Retreive the squery xml, execute it and display it

     */

    private void handleSQuery(PrintWriter out, Hashtable params,

            HttpServletResponse response, String user, String[] groups,

        double startTime = System.currentTimeMillis() / 1000;

        DBQuery queryobj = new DBQuery();

        queryobj.findDocuments(response, out, params, user, groups, sessionid);

        logMetacat.warn("Total search time for action 'squery': "

                + (outPutTime - startTime));

        MetaCatUtil.writeDebugToFile("---------------------------------------------------------------------------------"+

                + (outPutTime - startTime));

        MetaCatUtil.writeDebugToDelimiteredFile(" "+ (outPutTime - startTime), true);

    }

    /**

     * Create the xml query, execute it and display the results.

     *

     */

    private void handleQuery(PrintWriter out, Hashtable params,

            HttpServletResponse response, String user, String[] groups,

        //create the query and run it

        String xmlquery = DBQuery.createSQuery(params);

        String[] queryArray = new String[1];

        logMetacat.warn("Total search time for action 'query': "

                + (outPutTime - startTime));

        MetaCatUtil.writeDebugToFile("---------------------------------------------------------------------------------"+

                + (outPutTime - startTime));

        MetaCatUtil.writeDebugToDelimiteredFile(" "+ (outPutTime - startTime), true);

        //handleSQuery(out, params, response,user, groups, sessionid);

    }

    // END OF SQUERY & QUERY SECTION

    //Exoport section

    /**

     * Handle the "export" request of data package from Metacat in zip format

     */

    private void handleExportAction(Hashtable params,

            HttpServletResponse response,

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        // Output stream

        ServletOutputStream out = null;

        // Zip output stream

        ZipOutputStream zOut = null;

        DBQuery queryObj = null;

        String[] docs = new String[10];

        String docId = "";

        try {

            // read the params

            if (params.containsKey("docid")) {

            // Get output stream

            out = response.getOutputStream();

            response.setContentType("application/zip"); //MIME type

            zOut = new ZipOutputStream(out);

            zOut = queryObj

                    .getZippedPackage(docId, out, user, groups, passWord);

            zOut.finish(); //terminate the zip file

            zOut.close(); //close the zip stream

        } catch (Exception e) {

            try {

                response.setContentType("text/xml"); //MIME type

                        + "in MetacatServlet.handleExportAction: "

                        + ioe.getMessage());

            }

            logMetacat.error(

                    "Error in MetacatServlet.handleExportAction: "

            e.printStackTrace(System.out);

        }

    }

    /**

     * In eml2 document, the xml can have inline data and data was stripped off

     * and store in file system. This action can be used to read inline data

     */

    private void handleReadInlineDataAction(Hashtable params,

            HttpServletRequest request, HttpServletResponse response,

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        String[] docs = new String[10];

        String inlineDataId = null;

        String docId = "";

        ServletOutputStream out = null;

        try {

            // read the params

            if (params.containsKey("inlinedataid")) {

            // Make sure the client specify docid

            if (inlineDataId == null || inlineDataId.equals("")) {

                throw new Exception("You didn't specify requested inlinedataid"); }

            // check for permission

            docId = MetaCatUtil

                    .getDocIdWithoutRevFromInlineDataID(inlineDataId);

            PermissionController controller = new PermissionController(docId);

            // check top level read permission

            if (!controller.hasPermission(user, groups,

                throw new Exception("User " + user

                        + " doesn't have permission " + " to read document "

                        + docId);

            }//else

            // Get output stream

            out = response.getOutputStream();

            // read the inline data from the file

                bytes = input.read(buffer);

            }

            out.close();

            EventLog.getInstance().log(request.getRemoteAddr(), user,

                    inlineDataId, "readinlinedata");

        } catch (Exception e) {

            }

            logMetacat.error(

                    "Error in MetacatServlet.handleReadInlineDataAction: "

        }

    }

    /*

     * Get the nodeid from xml_nodes for the inlinedataid

     */

    private long getInlineDataNodeId(String inLineDataId, String docId)

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        long nodeId = 0;

        String INLINE = "inline";

                + "AND nodetype='TEXT' AND parentnodeid IN "

                + "(SELECT nodeid FROM xml_nodes WHERE docid=? AND "

                + "nodetype='ELEMENT' AND nodename='" + INLINE + "')";

        try {

            //check out DBConnection

            conn = DBConnectionPool

                    .getDBConnection("AccessControlList.isAllowFirst");

            serialNumber = conn.getCheckOutSerialNumber();

            pStmt = conn.prepareStatement(sql);

            //bind value

            pStmt.setString(1, docId);//docid

            if (hasRow) {

                nodeId = rs.getLong(1);

            }//if

        } catch (SQLException e) {

            throw e;

        } finally {

                + " is: " + nodeId);

        return nodeId;

    }

    /**

     * Handle the "read" request of metadata/data files from Metacat or any

     * files from Internet; transformed metadata XML document into HTML

     */

    private void handleReadAction(Hashtable params, HttpServletRequest request,

            HttpServletResponse response, String user, String passWord,

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        ServletOutputStream out = null;

        ZipOutputStream zout = null;

        PrintWriter pw = null;

        boolean zip = false;

        boolean withInlineData = true;

        try {

            String[] docs = new String[0];

            String docid = "";

            String qformat = "";

            String abstrpath = null;

            // read the params

            if (params.containsKey("docid")) {

                docs = (String[]) params.get("docid");

            // the param for only metadata (eml)

            // we don't support read a eml document without inline data now.

            /*if (params.containsKey("inlinedata")) {

                String inlineData = ((String[]) params.get("inlinedata"))[0];

                if (inlineData.equalsIgnoreCase("false")) {

                    withInlineData = false;

            // go through the list of docs to read

            for (int i = 0; i < docs.length; i++) {

                try {

                    URL murl = new URL(docs[i]);

                    Hashtable murlQueryStr = MetaCatUtil.parseQuery(

                            murl.getQuery());

                                    abstrpath, user, groups, zip, zout,

                                    withInlineData, params);

                        }

                        // case docid="http://.../filename"

                    } else {

                        docid = docs[i];

                            readFromURLConnection(response, docid);

                        }

                    }

                } catch (MalformedURLException mue) {

                    docid = docs[i];

                    if (zip) {

                    }

                }

            }

            if (zip) {

                zout.finish(); //terminate the zip file

                zout.close(); //close the zip stream

            }

        } catch (McdbDocNotFoundException notFoundE) {

            // To handle doc not found exception

            // the docid which didn't be found

                if (out != null) {

                    out.close();

                }

            } catch (Exception exc) {

                logMetacat.error(

                        "Erorr in MetacatServlet.hanldReadAction: "

                try {

                    if (out != null) {

                        response.setContentType("text/xml");

                        pw.println("</error>");

                        pw.close();

                        out.close();

                    } else {

                        response.setContentType("text/xml"); //MIME type

                        // Send back error message if out = null

            }

        } catch (Exception e) {

            try {

                if (out != null) {

                    response.setContentType("text/xml"); //MIME type

                    pw = new PrintWriter(out);

                    pw.println(e.getMessage());

                    pw.println("</error>");

                    pw.close();

                }

                // Close zip output stream

                if (zout != null) {

                    zout.close();

                }

            } catch (IOException ioe) {

                logMetacat.error("Problem with the servlet output "

                        + "in MetacatServlet.handleReadAction: "

                        + ioe.getMessage());

                ioe.printStackTrace(System.out);

            }

            logMetacat.error(

                    "Error in MetacatServlet.handleReadAction: "

            //e.printStackTrace(System.out);

        }

    }

    /** read metadata or data from Metacat

     */

    private void readFromMetacat(HttpServletRequest request,

            String abstrpath, String user, String[] groups, boolean zip,

            ZipOutputStream zout, boolean withInlineData, Hashtable params)

            throws ClassNotFoundException, IOException, SQLException,

        Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        try {

            // seperator here, if only one, we will append the rev in xml_documents

            // to the id.

            docid = appendRev(docid);

            DocumentImpl doc = new DocumentImpl(docid);

            //check the permission for read

            if (!DocumentImpl.hasReadPermission(user, groups, docid)) {

                Exception e = new Exception("User " + user

                        + " does not have permission"

                        + " to read the document with the docid " + docid);

                throw e;

            }

            if (doc.getRootNodeID() == 0) {

                // this is data file

                String filepath = MetaCatUtil.getOption("datafilepath");

                String filename = filepath + docid;

                FileInputStream fin = null;

                fin = new FileInputStream(filename);

                //MIME type

                String contentType = getServletContext().getMimeType(filename);

                if (contentType == null) {

                    logMetacat.info("Final contenttype is: "

                            + contentType);

                }

                response.setContentType(contentType);

                // if we decide to use "application/octet-stream" for all data

                // returns

                // response.setContentType("application/octet-stream");

                // or if that is unavailable, use the docid alone

                String docname = doc.getDocname();

                if (docname == null || docname.equals("")) {

                } else {

                    docname = docid + "-" + docname;

                }

                        "attachment; filename=" + docname);

                try {

                } finally {

                    if (fin != null) fin.close();

                }

            } else {

                // this is metadata doc

                if (qformat.equals("xml") || qformat.equals("")) {

                    // by default the document should be returned in xml format

                    // set content type first

                    response.setContentType("text/xml"); //MIME type

                            "attachment; filename=" + docid + ".xml");

                    PrintWriter out = response.getWriter();

                    doc.toXml(out, user, groups, withInlineData);

                } else {

                    response.setContentType("text/html"); //MIME type

                    PrintWriter out = response.getWriter();

                    // Look up the document type

                    String doctype = doc.getDoctype();

                    // Transform the document to the new doctype

                            withInlineData), doctype, "-//W3C//HTML//EN",

                            qformat, out, params);

                }

            }

            EventLog.getInstance().log(request.getRemoteAddr(), user,

                    docid, "read");

            throw except;

        }

    }

    /**

     * read data from URLConnection

     */

    private void readFromURLConnection(HttpServletResponse response,

        ServletOutputStream out = response.getOutputStream();

        String contentType = getServletContext().getMimeType(docid); //MIME

        if (contentType == null) {

            if (docid.endsWith(".xml")) {

                contentType = "text/xml";

        response.setContentType(contentType);

        // if we decide to use "application/octet-stream" for all data returns

        // response.setContentType("application/octet-stream");

        // this is http url

        URL url = new URL(docid);

        BufferedInputStream bis = null;

        } finally {

            if (bis != null) bis.close();

        }

    }

    /**

     * read file/doc and write to ZipOutputStream

     *

    private void addDocToZip(HttpServletRequest request, String docid,

            ZipOutputStream zout, String user, String[] groups) throws

            ClassNotFoundException, IOException, SQLException, McdbException,

        byte[] bytestring = null;

        ZipEntry zentry = null;

        try {

            URL url = new URL(docid);

            // this http url; read from URLConnection; add to zip

            zentry = new ZipEntry(docid);

            zout.putNextEntry(zentry);

                if (bis != null) bis.close();

            }

            zout.closeEntry();

        } catch (MalformedURLException mue) {

            // this is metacat doc (data file or metadata doc)

            try {

                DocumentImpl doc = new DocumentImpl(docid);

                //check the permission for read

                if (!DocumentImpl.hasReadPermission(user, groups, docid)) {

                    Exception e = new Exception("User " + user

                            + docid);

                    throw e;

                }

                if (doc.getRootNodeID() == 0) {

                    // this is data file; add file to zip

                    String filepath = MetaCatUtil.getOption("datafilepath");

                    FileInputStream fin = null;

                    fin = new FileInputStream(filename);

                    try {

                        zentry = new ZipEntry(docid);

                        zout.putNextEntry(zentry);

                        byte[] buf = new byte[4 * 1024]; // 4K buffer

                        if (fin != null) fin.close();

                    }

                    zout.closeEntry();

                } else {

                    // this is metadata doc; add doc to zip

                    bytestring = doc.toString().getBytes();

            }