Metacat

/*

 * HarvestSiteSchedule.java

 *

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

 */

package edu.ucsb.nceas.metacat.harvesterClient;

import java.io.*;

import java.sql.Connection;

import java.sql.SQLException;

import java.sql.Statement;

import java.text.*;

import java.util.*;

import javax.xml.parsers.*;

import org.xml.sax.*;

import org.xml.sax.helpers.*;

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

/**

 * 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 int harvestDocumentIndex = 0;

  private HarvestDocument[] harvestDocumentList = new HarvestDocument[30];

  private String harvestSiteEndTime;

  private String harvestSiteStartTime;

  private String ldapDN;

  private String ldapPassword;

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

  private 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 ldapPassword    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 ldapPassword,

                              String dateNextHarvest,

                              String dateLastHarvest,

                              int    updateFrequency,

                              String unit,

                              String contactEmail

                            )

  {

    this.harvester = harvester;

    this.siteScheduleID = siteScheduleID;

    this.documentListURL = documentListURL;

    this.ldapDN = ldapDN;

    this.ldapPassword = ldapPassword;

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

    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;

    con = harvester.conn;

    now = new Date();

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

    timeNextHarvest = currentTime + delta;

    dateNextHarvest = new Date(timeNextHarvest);

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

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

    System.out.println("Date of next harvest: " + nextHarvest);

    System.out.println("Date of last harvest: " + lastHarvest);

		try {

			stmt = con.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.err.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 dlh;                          // Date of last harvest

    Date dnh;                          // Date of next harvest

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

    long timeNextHarvest = 0;

    try {

      dlh = dateFormat.parse(dateLastHarvest);

      timeNextHarvest = dlh.getTime() + delta;

      dnh = new Date(timeNextHarvest);

      if (timeNextHarvest < currentTime) {

        dueForHarvest = true;

      }

      else {

        System.out.println("Next harvest date: " + dnh.toString());

      }

    }

    catch (ParseException e) {

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

    }

    //return dueForHarvest;

    return true;

  }

  /**

   * Harvests each document in the site document list.

   * 

   * @throws SAXException

   * @throws IOException

   * @throws ParserConfigurationException

   */

  public void harvestDocumentList() {

    HarvestDocument harvestDocument;

    if (dueForHarvest()) {

      try {

        parseDocumentList();

        metacatLogin();

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

          harvestDocument = harvestDocumentList[i];

          if (harvestDocument != null) {

            harvestDocument.printOutput();

            harvestDocument.harvestDocument();

          }

        }

        metacatLogout();      

        dbUpdateHarvestSiteSchedule();

      }

      catch (ParserConfigurationException e) {

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

      }

      catch (SAXException e) {

        System.err.println("SAXException: " + e.getMessage());

      }

      catch (IOException e) {

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

      }

      reportToSite();

    }

  }

  /**

   * Login to Metacat using the ldapDN and ldapPassword

   */

  private void metacatLogin() {

    Metacat metacat = harvester.metacat;

    if (harvester.connectToMetacat()) {

      try {

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

        metacat.login(ldapDN, ldapPassword);

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

      }

    }

    else {

      System.out.println("Not logging in to Metacat");

    }

  }

  /**

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

      }

    }

    else {

      System.out.println("Not logging out from Metacat");

    }

  }

  /**

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

   * 

   * @throws SAXException

   * @throws IOException

   * @throws ParserConfigurationException

   */

  private void parseDocumentList() 

    throws SAXException, IOException, ParserConfigurationException {

    // Create a parser factory and use it to create a parser

    SAXParserFactory parserFactory = SAXParserFactory.newInstance();

    SAXParser parser = parserFactory.newSAXParser();

    // Instantiate a DefaultHandler subclass to do your counting for you

    DocumentListHandler handler = new DocumentListHandler();

    // Start the parser. It reads the document list and calls methods of the handler.

    parser.parse(documentListURL, handler);

  }

  /**

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

   */

  void printOutput() {

    System.out.println("");

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

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

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

    System.out.println("ldapPassword: " + ldapPassword);

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

  }

  /**

   * Pushes a HarvestDocument object onto the harvestDocumentList.

   * 

   * @param harvestDocument    a new HarvestDocument object to add to the list

   */

  void pushHarvestDocument(HarvestDocument harvestDocument) {

    harvestDocumentList[harvestDocumentIndex] = harvestDocument;

    harvestDocumentIndex++;

  }

  /**

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

   * operation.

   */

  void reportToSite() {

    System.out.println("Sending report to site.\n");

  }

  /**

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

    public String scope;

    public int identifier;

    public int revision;

    public String documentType;

    public String documentURL;

    private String currentQname;

    /**

     * Handles a start-of-document event.

     */

    public void startDocument () {

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

    }

    /** 

     * Handles an end-of-document event.

     */

    public void endDocument () {

      System.out.println("Finished 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;

    }

    /** 

     * 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("document")) {

        harvestDocument = new HarvestDocument(

                                              harvester,

                                              HarvestSiteSchedule.this,

                                              scope,

                                              identifier,

                                              revision,

                                              documentType,

                                              documentURL

                                             );

        pushHarvestDocument(harvestDocument);

      }

    }

	  /**

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

          identifier = Integer.parseInt(s);

        }

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

          revision = Integer.parseInt(s);

        }

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

          documentType = s;

        }

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

          documentURL = s;

        }

        currentQname = "";

      }

    }

  }

}