Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2004 University of New Mexico and the

 *                  Regents of the University of California

 *     '$Date$'

 * '$Revision$'

 *

 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

package edu.ucsb.nceas.metacat.harvesterClient;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.net.MalformedURLException;

import java.net.URL;

import java.sql.SQLException;

import java.sql.Statement;

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.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 String harvestSiteStartTime;

  private String ldapDN;

  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 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 dateLastHarvest,

                              int    updateFrequency,

                              String unit,

                              String contactEmail

                            )

  {

    this.harvester = harvester;

    this.siteScheduleID = siteScheduleID;

    this.documentListURL = documentListURL;

    this.ldapDN = ldapDN;

    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;

    }

  }

  /**

   * 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.

    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;

    dateNextHarvest = new Date(timeNextHarvest);

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

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

		try {

			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);

		}

    catch(SQLException e) {

  }

  /**

   * 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 {

      timeNextHarvest = dnh.getTime();

      if (timeNextHarvest < currentTime) {

        dueForHarvest = true;

      else {

    }

    catch (ParseException e) {

  /**

   * Harvests each document in the site document list.

   *

   * @throws SAXException

   * @throws IOException

   * @throws ParserConfigurationException

   */

  public void harvestDocumentList() {

    HarvestDocument harvestDocument;

    if (dueForHarvest()) {

      try {

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

         * the documents

         */

        if (success) {

          metacatLogin();

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

              harvestDocument.harvestDocument();

            }

          metacatLogout();

      }

      catch (ParserConfigurationException e) {

      reportToSite();

    }

  }

  /**

  private void metacatLogin() {

    Metacat metacat = harvester.metacat;

    if (harvester.connectToMetacat()) {

      try {

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

        //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

    DocumentListHandler documentListHandler = new DocumentListHandler();

    InputStream inputStream;

    InputStreamReader inputStreamReader;

    "eml://ecoinformatics.org/harvestList ../../lib/harvester/harvestList.xsd";

    try {

      url = new URL(documentListURL);

      inputStream = url.openStream();

                            "Retrieved: " + documentListURL,

                            "GetDocListSuccess",

                            siteScheduleID,

                            null,

                            "");

      documentListHandler.runParser(inputStreamReader, schemaLocation);

                            "Validated: " + documentListURL,

                            "ValidateDocListSuccess",

                            siteScheduleID,

                            null,

                            "");

    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.

   * @param out   the PrintStream to write to

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

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

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

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

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

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

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

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

  /**

   * that site.

  void reportToSite() {

    String maxCodeLevel = "info";

    if (!to.equals("")) {

      System.out.println("Sending report to siteScheduleID=" + siteScheduleID +

                         " at address: " + contactEmail);

      try {

        msg.to(to);

        msg.setSubject(subject);

        body = msg.getPrintStream();

        msg.sendAndClose();

      catch (IOException e) {

        System.out.println("There was a problem sending email to " + to);

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

      }

    }

  /**

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

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

   * end tag.

   */

    public String scope;

    public int identifier;

    public String documentType;

    private String currentQname;

           "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

     *

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

      if (length > 0) {

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

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

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

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

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

      }

    /**

     * 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;

        identifier = Integer.parseInt(identifierString);

      }

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

        revision = Integer.parseInt(revisionString);

      }

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

                                              harvester,

                                              HarvestSiteSchedule.this,

                                              scope,

                                              identifier,

                                              revision,

                                              documentType,

                                              documentURL

                                             );

      currentQname = "";

     * Method for handling errors during a parse

     *

     * @param exception         The parsing error

     * @exception SAXException  Description of Exception

        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 = "";

      }

}