Metacat

/*

 * HarvestDetailLog.java

 *

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

 */

package edu.ucsb.nceas.metacat.harvesterClient;

/**

 * HarvestDetailLog manages data and operations corresponding to the

 * HARVEST_DETAIL_LOG table. It records errors encountered while attempting

 * to harvest a particular document.

 * 

 * @author  costa

 */

public class HarvestDetailLog {

  private int detailLogID;

  private String errorMessage;

  private Object harvestDocument;

  private int harvestLogID;

  /** 

   * Creates a new instance of HarvestDetailLog.

   */

  public HarvestDetailLog() {

  }

  /**

   * Inserts a new entry into the HARVEST_DETAIL_LOG table, based on the 

   * contents of this HarvestDetailLog object. Not yet implemented.

   */

  public void dnInsertHarvestDetailLogEntry() {

  }

}

/*

 * Harvester.java

 *

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

 */

package edu.ucsb.nceas.metacat.harvesterClient;

import java.io.*;

import java.sql.*;

import java.util.*;

import javax.xml.parsers.*;

import org.xml.sax.*;

import org.xml.sax.helpers.*;

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

/**

 * Harvester is the main class for the Harvester application. The main

 * method creates a single Harvester object which drives the application.

 * 

 * @author    costa

 * 

 */

public class Harvester {

  /*

   * Class fields

   */

  /* 

   * Class methods

   */

  /**

   * Constructor. Creates a new instance of Harvester.

   */

  public Harvester() {

  }

  /**

   * Determines whether Harvester is running on a Win32 platform. Used

   * during development to aid in resolving platform dependencies.

   * 

   * @return    true if this in Win32, false otherwise

   */

  public static boolean isWin32 () {

    boolean isWin32;

    String osName = System.getProperty("os.name");

    isWin32 = (osName.startsWith("Windows"));

    return isWin32;

  }

  /**

    * Harvester main method.

    * 

    * @param args        the command line arguments

    * @throws SAXException

    * @throws IOException

    * @throws ParserConfigurationException

    */

  public static void main(String[] args) {

    Harvester harvester = new Harvester();

    harvester.startup();                  // Start up Harvester

    harvester.readHarvestSiteSchedule();  // Read the database table

    harvester.harvest();                  // Harvest the documents

    harvester.shutdown();                 // Shut down Harvester

  }

  /*

   * Object fields

   */

  Connection conn;

  private Object harvestEndTime;

  private Object harvestLogList;

  private HarvestSiteSchedule[] harvestSiteScheduleList = 

          new HarvestSiteSchedule[20];

  private int harvestSiteScheduleIndex = 0;

  private Object harvestStartTime;

  Metacat metacat;

  Properties properties;

  /*

   * Object methods

   */

  /**

   * Determines whether Harvester should attempt to connect to Metacat.

   * Used during development and testing.

   * 

   * @return     true if Harvester should connect, otherwise false

   */

  boolean connectToMetacat () {

    boolean connectToMetacat = Harvester.isWin32() ? false : true;

    return connectToMetacat;

  }

  /**

   * For every Harvest site schedule in the database, harvest the

   * documents for that site if they are due to be harvested.

   * 

   * @throws SAXException

   * @throws IOException

   * @throws ParserConfigurationException

   */

  private void harvest() {

    HarvestSiteSchedule harvestSiteSchedule;

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

      harvestSiteSchedule = harvestSiteScheduleList[i];

      if (harvestSiteSchedule != null) {

        harvestSiteSchedule.printOutput();

        harvestSiteSchedule.harvestDocumentList();

      }

    }

    reportToAdministrator();

  }

  /**

   * Loads Harvester properties

   */

  private void loadProperties() {

    String homedir = System.getProperty("user.home");

    File configfile = new File(homedir, "harvester.properties");

    properties = new Properties();

    try {

      properties.load(new FileInputStream(configfile));

      properties.list(System.out);

    }

    catch (IOException e) {

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

      System.exit(1);

    }

  }

  /**

   * Reads the HARVEST_SITE_SCHEDULE table in the database, creating

   * a HarvestSiteSchedule object for each row in the table.

   */

  private void readHarvestSiteSchedule() {

    HarvestSiteSchedule harvestSiteSchedule;

    ResultSet rs;

    SQLWarning warn;

    Statement stmt;

    String contactEmail;

    String dateLastHarvest;

    String dateNextHarvest;

    String documentListURL;

    String ldapDN;

    String ldapPassword;

    int siteScheduleID;

    String unit;

    int updateFrequency;

    try {

      // Read the HARVEST_SITE_SCHEDULE table

      stmt = conn.createStatement();

      rs = stmt.executeQuery("SELECT * FROM HARVEST_SITE_SCHEDULE");

      warn = rs.getWarnings();

      if (warn != null) {

        System.out.println("\n---Warning---\n");

        while (warn != null) {

          System.out.println("Message: " + warn.getMessage());

          System.out.println("SQLState: " + warn.getSQLState());

          System.out.print("Vendor error code: ");

          System.out.println(warn.getErrorCode());

          System.out.println("");

          warn = warn.getNextWarning();

        }

      }

      while (rs.next()) {

        siteScheduleID = rs.getInt("SITE_SCHEDULE_ID");

        documentListURL = rs.getString("DOCUMENTLISTURL");

        ldapDN = rs.getString("LDAPDN");

//        ldapPassword = rs.getString("LDAPPASSWORD");

        ldapPassword = "ntre4dc";

        dateNextHarvest = rs.getString("DATENEXTHARVEST");

        dateLastHarvest = rs.getString("DATELASTHARVEST");

        updateFrequency = rs.getInt("UPDATEFREQUENCY");

        unit = rs.getString("UNIT");

        contactEmail = rs.getString("CONTACT_EMAIL");

        warn = rs.getWarnings();

        if (warn != null) {

          System.out.println("\n---Warning---\n");

          while (warn != null) {

            System.out.println("Message: " + warn.getMessage());

            System.out.println("SQLState: " + warn.getSQLState());

            System.out.print("Vendor error code: ");

            System.out.println(warn.getErrorCode());

            System.out.println("");

            warn = warn.getNextWarning();

          }

        }

        harvestSiteSchedule = new HarvestSiteSchedule(

                                                      this,

                                                      siteScheduleID,

                                                      documentListURL,

                                                      ldapDN,

                                                      ldapPassword,

                                                      dateNextHarvest,

                                                      dateLastHarvest,

                                                      updateFrequency,

                                                      unit,

                                                      contactEmail

                                                     );

        harvestSiteScheduleList[harvestSiteScheduleIndex] = harvestSiteSchedule;

        harvestSiteScheduleIndex++;

      }

    } 

    catch (SQLException e) {

      System.out.println("Database access failed " + e);

      System.exit(1);

    }

  }

  /**

   * Sends a report to the Harvester administrator.

   */

  void reportToAdministrator() {

    System.out.println("\nSending report to administrator.");

  }

  /**

   * Shuts down Harvester. Performs cleanup operations such as logging out

   * of Metacat and disconnecting from the database.

   */

  private void shutdown() {

    // Log shutdown operation

    System.out.println("Shutting Down Harvester");

    try {

      // Close the database connection

      System.out.println("Closing the database connection");

      conn.close();

    }

    catch (SQLException e) {

      System.out.println("Database access failed " + e);

    }

  }

  /**

   * Initializes Harvester at startup. Connects to the database and to Metacat.

   */

  private void startup() {

    String dbDriver;

    String metacatURL;

    String osName = Harvester.isWin32() ? "Windows" : "Unix";

    String password;

//    String response;

    String sessionId;

		String url;

    String user;

    String userName = System.getProperty("user.name");

    SQLWarning warn;

    // Log startup operation

    System.out.println("*****************************************************");

    System.out.println("Starting Up Harvester");

    System.out.println("OS is " + osName);

    loadProperties();

    dbDriver = properties.getProperty("dbDriver");

    url = properties.getProperty("url");

    user = properties.getProperty("user");

    password = properties.getProperty("password");

    metacatURL = properties.getProperty("metacatURL");

    // Load the jdbc driver

    try {

      Class.forName(dbDriver);

    }

    catch (ClassNotFoundException e) {

      System.out.println("Can't load driver " + e);

      System.exit(1);

    } 

    // Make the database connection

    try {

      System.out.println("Getting connection to Harvester tables");

      conn = DriverManager.getConnection(url, user, password);

      // If a SQLWarning object is available, print its warning(s).

      // There may be multiple warnings chained.

      warn = conn.getWarnings();

      if (warn != null) {

        while (warn != null) {

          System.out.println("SQLState: " + warn.getSQLState());

          System.out.println("Message:  " + warn.getMessage());

          System.out.println("Vendor: " + warn.getErrorCode());

          System.out.println("");

          warn = warn.getNextWarning();

        }

      }

    }

    catch (SQLException e) {

      System.out.println("Database access failed " + e);

      System.exit(1);

    }

    if (connectToMetacat()) {      

      try {

        System.out.println("Connecting to Metacat: " + metacatURL);

        metacat = MetacatFactory.createMetacatConnection(metacatURL);

      } 

      catch (MetacatInaccessibleException e) {

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

      } 

      catch (Exception e) {

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

      }

    }

    else {

      System.out.println("Not connecting to Metacat");

    }

  }

  /**

   * Writes one or more log entries to the HARVEST_LOG table.

   */

  private void writeHarvestLog() {

  }

}

/*

 * HarvestDocument.java

 *

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

 */

package edu.ucsb.nceas.metacat.harvesterClient;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.io.StringReader;

import java.net.MalformedURLException;

import java.net.URL;

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

import edu.ucsb.nceas.utilities.IOUtil;

/**

 * HarvestDocument manages operations and data for a single document to be

 * harvested.

 * 

 * @author  costa

 */

public class HarvestDocument {

  private String documentName;  

  private String documentType;

  private String documentURL;

  private Harvester harvester;

  private HarvestSiteSchedule harvestSiteSchedule;

  private int identifier;

  private int revision;

  private String scope;

  /**

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

   * that was read from a single <document> element in site document list.

   * 

   * @param harvester            the parent Harvester object

   * @param harvestSiteSchedule  the parent HarvestSiteSchedule object

   * @param scope                the value of the <scope> element

   * @param identifier           the value of the <identifier> element

   * @param revision             the value of the <revision> element

   * @param documentType         the value of the <documentType> element

   * @param documentURL          the value of the <documentURL> element

   */

  public HarvestDocument(

                          Harvester harvester,

                          HarvestSiteSchedule harvestSiteSchedule,

                          String scope,

                          int identifier,

                          int revision,

                          String documentType,

                          String documentURL

                        ) {

    this.harvester = harvester;

    this.harvestSiteSchedule = harvestSiteSchedule;

    this.documentType = documentType;

    this.documentURL = documentURL;

    this.scope = scope;

    this.identifier = identifier;

    this.revision = revision;

    this.documentName = scope + "." + identifier;

  }

  /**

   * Retrieve the document from the site using its <documentURL> value.

   * 

   * @return   A StringReader containing the document string.

   */

  private StringReader getSiteDocument() {

    String documentString;

    InputStream inputStream;

    InputStreamReader inputStreamReader;

    StringReader stringReader = null;

    URL url;

    try {

      url = new URL(documentURL);

      inputStream = url.openStream();

      inputStreamReader = new InputStreamReader(inputStream);

      documentString = IOUtil.getAsString(inputStreamReader, true);

      stringReader = new StringReader(documentString);

      System.out.println("  Successfully read document: " + documentURL);

    }

    catch (MalformedURLException e) {

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

    }

    catch (IOException e) {

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

    }

    return stringReader;

  }

  /**

   * Harvest the document from the site. Unless Metacat already has the

   * document, retrieve the document from the site and put (insert or

   * update) it to Metacat. If Metacat already has the document, determine

   * the highest revision stored in Metacat so that this can be reported

   * back to the user.

   */

  public void harvestDocument() {

    int highestRevision;

    String metacatReturnString;

    StringReader stringReader;

    /* If metacat already has this document, determine the highest revision in

     * metacat and report it to the user; else, insert or delete the document 

     * into metacat.

     */

    if (metacatHasDocument()) {

      System.out.println("  metacat has document");

      highestRevision = metacatHighestRevision();

      System.out.println("  metacatHighestRevision: " + highestRevision);

    }

    else {

      stringReader = getSiteDocument();

      if (stringReader != null) {

        if (parseDocument()) {

          metacatReturnString = putMetacatDocument(stringReader);

          System.out.println("  " + metacatReturnString);

        }

        else {

          System.out.println("Error parsing document.");

        }

      }

      else {

        System.out.print("  Error reading document at URL: ");

        System.out.println(documentURL);

      }

    }

  }

  /**

   * Boolean to determine whether Metacat already has this document.

   * 

   * @return  true if Metacat has the document, otherwise false

   */

  private boolean metacatHasDocument() {

    boolean     hasDocument = false;

    return hasDocument;

  }

  /**

   * Determines the highest revision that Metacat has for this document.

   * 

   * @return  int representing the highest revision for this document in Metacat

   */

  private int metacatHighestRevision() {

    int         highestRevision = 0;

    return highestRevision;

  }

  /**

   * Parse the document to determine whether it is valid EML prior to inserting

   * or updating it to Metacat. This is QA/QC measure. Currently unimplemented.

   * 

   * @return  true if the document is valid EML, otherwise false

   */

  private boolean parseDocument () {

    boolean success = true;

    return success;

  }

  /**

   * Print the data fields and values in this HarvestDocument object.

   */

  void printOutput() 

  {

    System.out.println("");

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

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

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

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

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

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

  }

  /**

   * Insert or update this document to Metacat. If revision equals 1, do an

   * insert; otherwise, do an update.

   * 

   * @return  the Metacat return string from the insert or update operation

   */

  private String putMetacatDocument(StringReader stringReader) {

    String docid = scope + "." + identifier + "." + revision;

    Metacat metacat = harvester.metacat;

    String metacatReturnString = "";

    if (harvester.connectToMetacat()) {

      try {

        if (revision == 1) {

          System.out.println("  Inserting document to metacat: " + docid);

          metacatReturnString = metacat.insert(docid, stringReader, null);

        }

        else {

          System.out.println("  Updating document to metacat: " + docid);

          metacatReturnString = metacat.update(docid, stringReader, null);

        }

      }

      catch (MetacatInaccessibleException e) {

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

      }

      catch (InsufficientKarmaException e) {

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

      }

      catch (MetacatException e) {

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

      }

      catch (IOException e) {

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

      }

    }

    else {

      metacatReturnString = "Not putting document to metacat";

    }

    return metacatReturnString;

  }

}

/*

 * HarvestLog.java

 *

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

 */

package edu.ucsb.nceas.metacat.harvesterClient;

/**

 * Manages log entries to be inserted to the HARVEST_LOG table.

 *

 * @author  costa

 */

public class HarvestLog {

  private Object harvestDate;

  private String harvestOperationCode;

  private String message;

  private int siteScheduleID;

  private String status;

  /** 

    * Creates a new instance of HarvestLog.

    */

  public HarvestLog() {

  }

  /**

   * Retrieves the value of the EXPLANATION field of the HARVEST_OPERATION

   * table based on the value of the HARVEST_OPERATION_CODE field. 

   * Not yet implemented.

   * 

   * @param harvestOperationCode  string value of the harvest operation code

   * @return           the explanation for this harvest operation, a String

   */

  public String dbGetExplanation(String harvestOperationCode) {

    String explanation = "";

    return explanation;

  }

  /**

   * Retrieves the value of the HARVEST_OPERATION_CODE_LEVEL field of the

   * HARVEST_OPERATION table based on the value of the HARVEST_OPERATION_CODE 

   * field. Not yet implemented.

   * 

   * @param harvestOperationCode  string value of the harvest operation code

   * @return          the code level value, an int

   */

  public int dbGetHarvestOperationCodeLevel(String harvestOperationCode) {

    int codeLevel = 0;

    return codeLevel;

  }

  /**

   * Inserts a new entry into the HARVEST_LOG table, based on the contents of

   * this HarvestLog object. Not yet implemented.

   */

  public void dbInsertHarvestLogEntry() {

  }

}

/*

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

      }

    }

  }

}