Metacat

package edu.ucsb.nceas.metacat.harvesterClient;

import java.io.*;

import java.util.*;

import javax.servlet.ServletConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import javax.servlet.http.HttpUtils;

import javax.servlet.ServletOutputStream;

import com.oreilly.servlet.multipart.FilePart;

import com.oreilly.servlet.multipart.MultipartParser;

import com.oreilly.servlet.multipart.ParamPart;

import com.oreilly.servlet.multipart.Part;

import edu.ucsb.nceas.metacat.client.*;

import edu.ucsb.nceas.utilities.IOUtil;

/**

 *  MetUpload implements a Harvester servlet to insert, update, or delete

 *  a single file to Metacat.

 */

public class MetUpload extends HttpServlet {

  /**

   *  Handle POST requests made to the Harvester MetUpload servlet.

   *

   *  @param  req   The request

   *  @param  res   The response

   *  @throws IOException

   */

  public void doPost(HttpServletRequest req, HttpServletResponse res) 

          throws IOException {

    Part            aPart;

    boolean         delete = false;

    String          docid = "";

    String          fieldName;

    String          fieldValue;

    String          fileName = "";

    FilePart        fPart = null;

    String          metacatUrl;

    PrintWriter     out = res.getWriter();

    MultipartParser parser = new MultipartParser(req, 1024 * 1024);

    ParamPart       pPart;

    HttpSession     sess = req.getSession(true);

    String          password = (String) sess.getAttribute("Mpassword");

    Properties      properties = loadProperties(out);

    StringReader    sr = null;

    boolean         upload = false;

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

    res.setContentType("text/plain");

    metacatUrl = properties.getProperty("metacatURL", "");

    try {

      while ((aPart = parser.readNextPart()) != null) {

        if (aPart.isParam() == true) {

          pPart = (ParamPart) aPart;

          fieldName = pPart.getName();

          if (fieldName != null) {

            if (fieldName.equals("docid")) {

              docid = pPart.getStringValue();

            }

            else if (fieldName.equals("Upload")) {

              upload = true;

            }

            else if (fieldName.equals("Delete")) {

              delete = true;

            }            

          }

        }

        else if (aPart.isFile() == true) {

          fPart = (FilePart) aPart;

          fieldName = fPart.getName();

          fileName = fPart.getFileName();

          sr = writeTempFile(fPart, out, docid, fileName);

        }

      }

    }

    catch (Exception e) {

      System.out.println("Error parsing parameters: " + e.getMessage());

    }

    if (upload) {

      upload(out, docid, sr, metacatUrl, username, password);

    }

    if (delete) {

      delete(out, docid, metacatUrl, username, password);

    }

  }

  /**

   * Deletes a file from Metacat based on its docid.

   * 

   * @param out        the PrintWriter output stream

   * @param docid      the Metacat document id, e.g. document.1.1

   * @param metacatUrl the Metacat URL

   * @param username   the Metacat username

   * @param password   the Metacat password

   */

  private void delete(PrintWriter out, 

                      String docid,

                      String metacatUrl,

                      String username,

                      String password

                     ) {

    Metacat  metacat;

    String   metacatResponse;

    if (docid.equals("")) {

      out.println("Error deleting document: No DocID specified");

      return;

    }

    try {    

      metacat = MetacatFactory.createMetacatConnection(metacatUrl);

      metacat.login(username, password);

      metacatResponse = metacat.delete(docid);

      out.println(metacatResponse);

    }

    catch (MetacatAuthException e) {

      out.println("Metacat delete failed: MetacatAuthException:" + 

                  e.getMessage());

    }

    catch (MetacatInaccessibleException e) {

      out.println("Metacat delete failed:  MetacatInaccessibleException:" + 

                  e.getMessage());

    }

    catch (InsufficientKarmaException e) {

      out.println("Metacat delete failed: InsufficientKarmaException:" + 

                   e.getMessage());

    }

    catch (MetacatException e) {

      out.println("Metacat delete failed: MetacatException:" + 

                  e.getMessage());

    }

  }

  /**

   * Loads Harvester properties from a configuration file.

   * 

   * @param  out          the PrintWriter output stream

   * @return properties   Properties object containing the loaded properties

   */

  private Properties loadProperties(PrintWriter out) {

    InputStream inputStream;

    String path = "/harvester/harvester.properties";

    Properties properties = new Properties();

    ServletContext servletContext = getServletContext();

    try {

      inputStream = servletContext.getResourceAsStream(path);

      properties.load(inputStream);

    }

    catch (IOException e) {

      out.println("IOException: " + e.getMessage());

    }

    return properties;

  }

  /**

   * Uploads a file to Metacat for insertion or updating. This implementation

   * is limited by the fact that all ".1" documents are inserted while all

   * other revisions are updated. This logic can be improved after the Metacat

   * interface is extended with additional methods to query information about

   * revisions, for example, hasDocument() and highestRevision().

   * 

   * @param out        the PrintWriter output stream

   * @param docid      the docid, e.g. "document.1.1"

   * @param sr         the StringReader containing the contents of the document

   * @param metacatUrl the Metacat URL

   * @param username   the Metacat username

   * @param password   the Metacat password

   */

  private void upload(PrintWriter out, 

                      String docid,

                      StringReader sr,

                      String metacatUrl,

                      String username,

                      String password

                     ) {

    FileReader      fr;

    Metacat         metacat;

    String          metacatResponse;

    String          revision;

    int             strLen;

    if (docid.equals("")) {

      out.println("Error uploading: No docid specified");

      return;

    }

    if (sr == null) {

      out.println("Error uploading: No EML file specified");

      return;

    }

    try {

      metacat = MetacatFactory.createMetacatConnection(metacatUrl);

      metacat.login(username, password);

      strLen = docid.length();

      revision = docid.substring((strLen - 2), strLen);

      if (revision.equals(".1")) {

        metacatResponse = metacat.insert(docid, sr, null);

      }

      else {

        metacatResponse = metacat.update(docid, sr, null);

      }

      out.println(metacatResponse);

    }

    catch (MetacatAuthException e) {

      out.println("Metacat upload failed: MetacatAuthException:" + 

                  e.getMessage());

    }

    catch (MetacatInaccessibleException e) {

      out.println("Metacat upload failed:  MetacatInaccessibleException:" + 

                  e.getMessage());

    }

    catch (InsufficientKarmaException e) {

      out.println("Metacat upload failed: InsufficientKarmaException:" + 

                   e.getMessage());

    }

    catch (MetacatException e) {

      out.println("Metacat upload failed: MetacatException:" + 

                  e.getMessage());

    }

    catch (IOException e) {

      out.println("Metacat upload failed: IOException:" + 

                  e.getMessage());

    }

  }

  /**

   * Writes the uploaded file to disk and then reads it into a StringReader for

   * subsequent upload to Metacat.

   * 

   * @param fPart     the FilePart object containing the file form parameter

   * @param out       the PrintWriter output stream

   * @param docid     the document id, e.g. "document.1.1"

   * @param fileName  the name of the file to be written to disk

   * @return sr       a StringReader containing the contents of the file

   */

  private StringReader writeTempFile(FilePart fPart,

                                     PrintWriter out, 

                                     String docid,

                                     String fileName

                                    ) {

    FileReader      fr;

    String          metacatResponse;

    StringReader    sr = null;

    File            tmpDir;

    String          tmpDirPath;

    File            tmpFile;

    String          tmpFilePath = "";

    String          xmlString = "";

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

      return sr;

    }

    tmpDirPath = System.getProperties().getProperty("java.io.tmpdir");

    tmpDir = new File(tmpDirPath);

    // Create the temporary directory if it doesn't exist

    try {

      if (!tmpDir.exists()) {

        tmpDir.mkdirs();

      }

    }

    catch (SecurityException e) {

      out.println("Can't create directory: " + tmpDir.getPath());

      out.println(e.getMessage());

    }

    // Write the image to a file

    try {

      tmpFile = new File(tmpDirPath, fileName);

      fPart.writeTo(tmpFile);

      tmpFilePath = tmpDirPath + File.separator + fileName;

      fr = new FileReader(tmpFilePath);

      xmlString = IOUtil.getAsString(fr, true);

      sr = new StringReader(xmlString);

      tmpFile.delete();           // Clean up the temporary file from disk

    }

    catch (IOException e) {

      out.println("IOException: " + tmpFilePath + e.getMessage());

    }

    return sr;

  }

}