Metacat

/*

 * HarvestSiteSchedule.java

 *

 * Created on January 14, 2004, 4:47 PM

 */

package edu.ucsb.nceas.metacat.harvesterClient;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.net.MalformedURLException;

import java.net.URL;

import java.sql.Connection;

import java.sql.SQLException;

import java.sql.Statement;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import javax.xml.parsers.ParserConfigurationException;

import org.xml.sax.Attributes;

import org.xml.sax.ContentHandler;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.DefaultHandler;

import org.xml.sax.helpers.XMLReaderFactory;

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

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

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

/**

 * HarvestSiteSchedule manages a single entry in the HARVEST_SITE_SCHEDULE

 * table, determining when and how to harvest the documents for a given site.

 * 

 * @author  costa

 */

class HarvestSiteSchedule {

  private String contactEmail;

  private String dateLastHarvest;

  private String dateNextHarvest;

  private long delta;

  private String documentListURL;

  private Harvester harvester;

  private ArrayList harvestDocumentList = new ArrayList();

  private String harvestSiteEndTime;

  private String harvestSiteStartTime;

  private String ldapDN;

  private String ldapPwd;

  final private long millisecondsPerDay = (1000 * 60 * 60 * 24);

  int siteScheduleID;

  private String unit;

  private int updateFrequency;

  /**

   * Creates a new instance of HarvestSiteSchedule. Initialized with the data

   * that was read from a single row in the HARVEST_SITE_SCHEDULE table.

   * 

   * @param harvester       the parent Harvester object

   * @param siteScheduleID  the value of the SITE_SCHEDULE_ID field

   * @param documentListURL the value of the DOCUMENTLISTURL field

   * @param ldapDN          the value of the LDAPDN field

   * @param ldapPwd    the value of the LDAPPASSWORD field

   * @param dateNextHarvest the value of the DATENEXTHARVEST field

   * @param dateLastHarvest the value of the DATELASTHARVEST field

   * @param updateFrequency the value of the UPDATEFREQUENCY field

   * @param unit            the value of the UNIT field

   * @param contactEmail    the value of the CONTACT_EMAIL field

   */

  public HarvestSiteSchedule(

                              Harvester harvester,

                              int    siteScheduleID,

                              String documentListURL,

                              String ldapDN,

                              String ldapPwd,

                              String dateNextHarvest,

                              String dateLastHarvest,

                              int    updateFrequency,

                              String unit,

                              String contactEmail

                            )

  {

    this.harvester = harvester;

    this.siteScheduleID = siteScheduleID;

    this.documentListURL = documentListURL;

    this.ldapDN = ldapDN;

    this.ldapPwd = ldapPwd;

    this.dateNextHarvest = dateNextHarvest;

    this.dateLastHarvest = dateLastHarvest;

    this.updateFrequency = updateFrequency;

    this.unit = unit;

    this.contactEmail = contactEmail;

    // Calculate the value of delta, the number of milliseconds between the

    // last harvest date and the next harvest date.

    delta = updateFrequency * millisecondsPerDay;

    if (unit.equals("weeks")) {

      delta *= 7;

    }

    else if (unit.equals("months")) {

      delta *= 30;

    }

  }

  /**

   * Updates the DATELASTHARVEST value of the HARVEST_SITE_SCHEDULE table

   * after a harvest operation has completed. Calculates the date of the next 

   * harvest based on today's date and the update frequency.

   */

  private void dbUpdateHarvestSiteSchedule() {

		Connection conn;

    long currentTime;                    // Current time in milliseconds

    Date dateNextHarvest;                // Date of next harvest

    String lastHarvest;

    String nextHarvest;

    Date now = new Date();

    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MMM-yyyy");

		Statement stmt;

    long timeNextHarvest;

    conn = harvester.conn;

    now = new Date();

    currentTime = now.getTime();

    timeNextHarvest = currentTime + delta;

    dateNextHarvest = new Date(timeNextHarvest);

    nextHarvest = "'" + simpleDateFormat.format(dateNextHarvest) + "'";

    lastHarvest = "'" + simpleDateFormat.format(now) + "'";

		try {

			stmt = conn.createStatement();							

			stmt.executeUpdate("UPDATE HARVEST_SITE_SCHEDULE SET DATENEXTHARVEST = " +

                         nextHarvest +

                         " WHERE SITE_SCHEDULE_ID = " +

                         siteScheduleID);

			stmt.executeUpdate("UPDATE HARVEST_SITE_SCHEDULE SET DATELASTHARVEST = " +

                         lastHarvest +

                         " WHERE SITE_SCHEDULE_ID = " +

                         siteScheduleID);

			stmt.close();

		}

    catch(SQLException e) {

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

		}

  }

  /**

   * Boolean to determine whether this site is currently due for its next

   * harvest.

   * 

   * @retrun     true if due for harvest, otherwise false

   */

  private boolean dueForHarvest() {

    boolean dueForHarvest = false;

    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");

    Date now = new Date();

    Date dnh;                          // Date of next harvest

    long currentTime = now.getTime();  // Current time in milliseconds

    long timeNextHarvest = 0;

    try {

      dnh = dateFormat.parse(dateNextHarvest);

      timeNextHarvest = dnh.getTime();

      if (timeNextHarvest < currentTime) {

        dueForHarvest = true;

        System.out.println("Due for harvest: " + documentListURL);

      }

      else {

        System.out.println("Not due for harvest: " + documentListURL);

      }

    }

    catch (ParseException e) {

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

    }

    return dueForHarvest;

  }

  /**

   * Harvests each document in the site document list.

   * 

   * @throws SAXException

   * @throws IOException

   * @throws ParserConfigurationException

   */

  public void harvestDocumentList() {

    HarvestDocument harvestDocument;

    boolean success;

    if (dueForHarvest()) {

      try {

        success = parseDocumentList();

        /* If the document list was validated, then proceed with harvesting

         * the documents

         */

        if (success) {

          metacatLogin();

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

            harvestDocument = (HarvestDocument) harvestDocumentList.get(i);

            if (harvestDocument != null) {

              harvestDocument.harvestDocument();

            }

          }

          metacatLogout();      

          dbUpdateHarvestSiteSchedule();  // Update the schedule

        }

      }

      catch (ParserConfigurationException e) {

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

      }

      reportToSite();

    }

  }

  /**

   * Login to Metacat using the ldapDN and ldapPwd

   */

  private void metacatLogin() {

    Metacat metacat = harvester.metacat;

    if (harvester.connectToMetacat()) {

      try {

        System.out.println("Logging in to Metacat: " + ldapDN);

        metacat.login(ldapDN, ldapPwd);

        //System.out.println("Metacat login response: " + response);

        //sessionId = metacat.getSessionId();

        //System.out.println("Session ID: " + sessionId);

      } 

      catch (MetacatInaccessibleException e) {

        System.out.println("Metacat login failed." + e.getMessage());

      } 

      catch (Exception e) {

        System.out.println("Metacat login failed." + e.getMessage());

      }

    }    

  }

  /**

   * Logout from Metacat

   */

  private void metacatLogout() {

    Metacat metacat = harvester.metacat;

    if (harvester.connectToMetacat()) {

      try {    

        // Log out from the Metacat session

        System.out.println("Logging out from Metacat");

        metacat.logout();

      }

      catch (MetacatInaccessibleException e) {

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

      }

      catch (MetacatException e) {

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

      }

    }

  }

  /**

   * Parse the site document list to find out which documents to harvest.

   * 

   * @return  true if successful, otherwise false

   */

  private boolean parseDocumentList() 

          throws ParserConfigurationException {

    DocumentListHandler documentListHandler = new DocumentListHandler();

    InputStream inputStream;

    InputStreamReader inputStreamReader;

    String schemaLocation = ".";

    boolean success = false;

    URL url;

    try {

      url = new URL(documentListURL);

      inputStream = url.openStream();

      harvester.addLogEntry(0, "", "GetDocListSuccess", 

                            siteScheduleID, null, "");

      inputStreamReader = new InputStreamReader(inputStream);

      documentListHandler.runParser(inputStreamReader, schemaLocation);

      harvester.addLogEntry(0, "", "ValidateDocListSuccess", 

                            siteScheduleID, null, "");

      success = true;

    }

    catch (MalformedURLException e){

      harvester.addLogEntry(1, "MalformedURLException: " + e.getMessage(), 

                            "GetDocListError", siteScheduleID, null, "");

    }

    catch (FileNotFoundException e) {

      harvester.addLogEntry(1, "FileNotFoundException: " + e.getMessage(), 

                            "GetDocListError", siteScheduleID, null, "");

    }

    catch (SAXException e) {

      harvester.addLogEntry(1, "SAXException: " + e.getMessage(), 

                            "ValidateDocListError", siteScheduleID, null, "");

    }

    catch (ClassNotFoundException e) {

      harvester.addLogEntry(1, "ClassNotFoundException: " + e.getMessage(),

                            "ValidateDocListError", siteScheduleID, null, "");

    }

    catch (IOException e) {

      harvester.addLogEntry(1, "IOException: " + e.getMessage(), 

                            "GetDocListError", siteScheduleID, null, "");

    }

    return success;

  }

  /**

   * Prints the data that is stored in this HarvestSiteSchedule object.

   */

  void printOutput() {

    System.out.println("* siteScheduleID:       " + siteScheduleID);

    System.out.println("* documentListURL:      " + documentListURL);

    System.out.println("* ldapDN:               " + ldapDN);

    System.out.println("* dateNextHarvest:      " + dateNextHarvest);

    System.out.println("* dateLastHarvest:      " + dateLastHarvest);

    System.out.println("* updateFrequency:      " + updateFrequency);

    System.out.println("* unit:                 " + unit);

    System.out.println("* contactEmail:         " + contactEmail);

  }

  /**

   * Sends a report to the site summarizing the results of the harvest

   * operation.

   */

  void reportToSite() {

    System.out.println("Sending report to site: " + contactEmail);

  }

  /**

   * This inner class extends DefaultHandler. It parses the document list,

   * creating a new HarvestDocument object every time it finds a </Document>

   * end tag.

   */

  class DocumentListHandler extends DefaultHandler implements ErrorHandler {

    public String scope;

    public int identifier;

    public String identifierString;

    public String documentType;

    public int revision;

    public String revisionString;

    public String documentURL;

    private String currentQname;

    public final static String DEFAULT_PARSER = 

           "org.apache.xerces.parsers.SAXParser";

    private boolean schemaValidate = true;

	  /**

     * This method is called for any plain text within an element.

     * It parses the value for any of the following elements:

     * <scope>, <identifier>, <revision>, <documentType>, <documentURL>

     * 

     * @param ch          the character array holding the parsed text

     * @param start       the start index

     * @param length      the text length

     * 

     */

    public void characters (char ch[], int start, int length) {

      String s = new String(ch, start, length);

      if (length > 0) {           

        if (currentQname.equals("scope")) {

          scope += s;

        }

        else if (currentQname.equals("identifier")) {

          identifierString += s;

        }

        else if (currentQname.equals("revision")) {

          revisionString += s;

        }

        else if (currentQname.equals("documentType")) {

          documentType += s;

        }

        else if (currentQname.equals("documentURL")) {

          documentURL += s;

        }

      }

    }

    /** 

     * Handles an end-of-document event.

     */

    public void endDocument () {

      System.out.println("Finished parsing " + documentListURL);

    }

    /** 

     * Handles an end-of-element event. If the end tag is </Document>, then

     * creates a new HarvestDocument object and pushes it to the document

     * list.

     * 

     * @param uri

     * @param localname

     * @param qname

     */

    public void endElement(String uri, 

                           String localname,

                           String qname) {

      HarvestDocument harvestDocument;

      if (qname.equals("identifier")) {

        identifier = Integer.parseInt(identifierString);

      }

      else if (qname.equals("revision")) {

        revision = Integer.parseInt(revisionString);

      }

      else if (qname.equals("document")) {

        harvestDocument = new HarvestDocument(

                                              harvester,

                                              HarvestSiteSchedule.this,

                                              scope,

                                              identifier,

                                              revision,

                                              documentType,

                                              documentURL

                                             );

        harvestDocumentList.add(harvestDocument);

      }

      currentQname = "";

    }

    /**

     * Method for handling errors during a parse

     *

     * @param exception         The parsing error

     * @exception SAXException  Description of Exception

     */

     public void error(SAXParseException e) throws SAXParseException {

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

        throw e;

    }

    /**

     * Run the validating parser

     *

     * @param xml             the xml stream to be validated

     * @schemaLocation        relative path the to XML Schema file, e.g. "."

     * @exception IOException thrown when test files can't be opened

     * @exception ClassNotFoundException thrown when SAX Parser class not found

     * @exception SAXException

     * @exception SAXParserException

     */

    public void runParser(Reader xml, String schemaLocation)

           throws IOException, ClassNotFoundException,

                  SAXException, SAXParseException {

      // Get an instance of the parser

      XMLReader parser;

      parser = XMLReaderFactory.createXMLReader(DEFAULT_PARSER);

      // Set Handlers in the parser

      parser.setContentHandler((ContentHandler)this);

      parser.setErrorHandler((ErrorHandler)this);

      parser.setFeature("http://xml.org/sax/features/namespaces", true);

      parser.setFeature("http://xml.org/sax/features/namespace-prefixes", true);

      parser.setFeature("http://xml.org/sax/features/validation", true);

      parser.setProperty(

              "http://apache.org/xml/properties/schema/external-schemaLocation", 

              schemaLocation);

      if (schemaValidate) {

        parser.setFeature("http://apache.org/xml/features/validation/schema", 

                          true);

      }

      // Parse the document

      parser.parse(new InputSource(xml));

    }

    /**

     * Handles a start-of-document event.

     */

    public void startDocument () {

      System.out.println("Started parsing " + documentListURL);

    }

    /** 

     * Handles a start-of-element event.

     * 

     * @param uri

     * @param localname

     * @param qname

     * @param attributes

     */

    public void startElement(String uri, 

                             String localname,

                             String qname,

                             Attributes attributes) {

      currentQname = qname;

      if (qname.equals("scope")) {

        scope = "";

      }

      else if (qname.equals("identifier")) {

        identifierString = "";

      }

      else if (qname.equals("revision")) {

        revisionString = "";

      }

      else if (qname.equals("documentType")) {

        documentType = "";

      }

      else if (qname.equals("documentURL")) {

        documentURL = "";

      }

    }

  }

}