source: trunk/java-client/org/nzdl/gsdl/util/NzdlIORs.java@ 2141

/*
 *    NzdlIORs.java
 *    Copyright (C) 2001 New Zealand Digital Library Project
 *
 *    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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

// the package we're in
package org.nzdl.gsdl.util;

// long live GNU ...
import gnu.getopt.Getopt;
import gnu.getopt.LongOpt;

// java libraries we're using
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.Serializable;
import java.net.URL;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Vector;

// local libraries
import org.nzdl.gsdl.service.NzdlCollectionInfo; 
import org.nzdl.gsdl.service.NzdlQuery;
import org.nzdl.gsdl.service.NzdlRequest;
import org.nzdl.gsdl.service.NzdlResponse;
import org.nzdl.gsdl.service.NzdlResultSet;
import org.nzdl.gsdl.service.NzdlService;
import org.nzdl.gsdl.service.NzdlServiceClient;

/**
 * Class NzdlIORs
 *
 * A repositry for IORs of various NZDL servers we've seen.
 *
 * @author stuart yeates ([email protected])
 * @author Brett Sheeran ([email protected])
 * @author Dave Nichols ([email protected])
 * @author Gordon Paynter ([email protected])
 * @version $Revision: 2141 $
 * @see org.nzdl.gsdl.SimpleServer
 * @see org.nzdl.gsdl.service.NzdlCollectionInfo
 * @see org.nzdl.gsdl.service.NzdlQuery
 * @see org.nzdl.gsdl.service.NzdlRequest
 * @see org.nzdl.gsdl.service.NzdlResponse
 * @see org.nzdl.gsdl.service.NzdlResultSet
 * @see org.nzdl.gsdl.service.NzdlService
 * @see org.nzdl.gsdl.service.NzdlServiceClient
 * @see gnu.getopt.Getopt
 * @see gnu.getopt.LongOpt
 * @see <a href="http://www.nzdl.org/">The New Zealand Digital Library Project</a>
 * @see <a href="http://www.nzdl.org/fast-cgi-bin/library?&a=p&p=gsdl">Greenstone Digital Library Software</a>
 */

public class NzdlIORs implements Cloneable, Serializable {

  /** The collection of CORBA IORs we know about */
  protected static Properties knownIORs = null;
  /** The name of the properties file */
  static String propertiesFileName = "knownIORs.properties";
  /** The name of the file we look for IOR's in */
  public static String IORFileName = "/tmp/localcorba.objid";

  /** default places wit look for IORs ... */
  static String[] urlsCompiledIn = 
  { 
    "http://nikau.cs.waikato.ac.nz/~say1/gsdl/cgi-bin/getior", 
    "http://www.nzdl.org/cgi-bin/getior"
  };



  /**
   * Get the first known-good IOR
   * @see java.lang.String
   * @return the string containing the IOR
   */
  public static String getFirstValid()  {
    checkLoaded();
    synchronized (knownIORs) {
      
      Enumeration e = knownIORs.keys();
      while (e.hasMoreElements()) {
    String IOR = (String) e.nextElement();
    if (attemptToInitialise(null, null, IOR) != null) {
      return IOR;
    }
      }
      return null;
    }
  }

  /**
   * Check that the class has been correctly initialised
   */
  static protected void checkLoaded()  {
    // if we're already initialised we can bail now and
    // save synchronization overhead ...
    if (knownIORs != null)
      return;
    
    Properties blarg = new Properties();
    
    // take a lock on blarg. currently it's local, but 
    // won't be soon...
    synchronized (blarg) {

      try {
    synchronized (Class.forName("org.nzdl.gsdl.util.NzdlIORs")) {
      if (knownIORs != null)
        return;
      knownIORs = blarg;
    }
      } catch (ClassNotFoundException exception) {
    System.err.println("Exception locking class:" + exception);
      }
      
      
      try {
      File file = new File(propertiesFileName);
    if (file.exists()) {
      knownIORs.load(new FileInputStream(file));
    } 
      } catch (IOException exception) {
    System.err.println("Exception reading properties file:" + exception);
      }
    }
    getIORfromFile(IORFileName);
  }

  /**
   * Save the IORs back to the underlying file
   * @see java.io.File
   */
  static protected void checkSave()  {
    synchronized (knownIORs) {
      if (knownIORs == null)
    throw new Error("saving null property list");
      
      File file = new File(propertiesFileName);
      try {
    knownIORs.store(new FileOutputStream(file),
            "NZDL IOR's see: org.nzdl.gsdl.util.NzdlIORs");
      } catch (IOException i) {
    System.err.println("Error reading properties file:" + i);
      }
    }
  }
  /**
   * Find a valid IOR to initialise from.
   * @param _args the command line arguments
   * @param _URL a URL to look for an IOR in
   * @param _filename a local filename to look for an IOR in
   * @param _IOR a string to look for an IOR in
   * @see org.omg.CORBA.ORB
   */
  public static NzdlServiceClient findIOR(String [] _args,
                      String _URL,
                      String _filename,
                      String _IOR)  {
    
    // read our prevously seed IORs ...
    String IOR = null;
    NzdlServiceClient client = null;
      
    // try a URL from the command line
    if ( _URL != null) {
      IOR = NzdlIORs.getIORfromURL(_URL);
      client = attemptToInitialise(_args, null, IOR);
    }
    
    // try an IOR from the command line
    if (_IOR != null && client == null) {
      IOR = NzdlIORs.registerIOR(_IOR);
      client = attemptToInitialise(_args, null, IOR);
    }
    
    // try an IOR from a file (the filename may have been 
    // given from teh commandline
    if (client == null) {
      IOR = NzdlIORs.getIORfromFile(_filename);
      client = attemptToInitialise(_args, null, IOR);
    }
    
    // try the compiled-in URLs
    if (client == null) {
      for (int i=0;( i<urlsCompiledIn.length && client == null );i++) {
    IOR = NzdlIORs.getIORfromURL(urlsCompiledIn[i]);
    client = attemptToInitialise(_args, null,IOR);
      }
    }
    
    // the knownIORs is the last resort
    if (client == null) {
      IOR = NzdlIORs.getFirstValid();
      client = attemptToInitialise(_args, null, IOR);
    }
    return client;
  }

  /**
   * Connect to each of the ORB's described by the IORs and throw away
   * any that can't be connected to.
   * @see org.omg.CORBA.ORB
   */
 public static void validate()  {
    checkLoaded();
    synchronized (knownIORs) {

      Properties valid = new Properties();
      
      if (knownIORs != null)
    throw new Error("saving null property list");
    
      Enumeration e = knownIORs.keys();
      while (e.hasMoreElements()) {
    String IOR = (String) e.nextElement();
    if (attemptToInitialise(null, null, IOR) != null) {
      valid.put(IOR,"");
    }
      }
      try {
    synchronized (Class.forName("org.nzdl.gsdl.util.NzdlIORs")) {
      knownIORs = valid;
    }
      } catch (ClassNotFoundException exception) {
    System.err.println("Exception locking class:" + exception);
      }
      checkSave();
    }    
  }

  /**
   * Register a given IOR 
   * @see java.lang.String
   * @param str the IOR
   * @return the str
   */
 public static String registerIOR(String str)
  {
    checkLoaded();    
    if (str != null)
      synchronized (knownIORs) {
    knownIORs.put(str,"");
      }
    checkSave();
    return str;
  }

 
  /**
   * Retrieve an IOR from a URL
   * @see java.net.URL
   * @param str the url to retrieve
   * @return the IOR
   */
  public static String getIORfromURL(String str)
  {
    checkLoaded();
    String ior = null;
    
    try { 
      System.err.println("Looking for a URL at:" + str);
      URL url = new URL(str);
      InputStream his = url.openStream();
      DataInputStream dhis = new DataInputStream(his) ;
      ior = dhis.readLine();

      if (ior != null)
    synchronized (knownIORs) {
      knownIORs.put(ior,"");
    }      
      checkSave();
      return ior;
    } catch (Throwable throwable) {
      System.err.println("NzdlHosts::getIOR() unable to construct or read URL \"" +
             str + "\", \"" + ior + "\": " + throwable);
      return "";
    }
  }

  /**
   * Retrieve an IOR from a file
   * @see java.io.File
   * @param str the file to open
   * @return the IOR
   */
  public static String getIORfromFile(String file) {
    checkLoaded();
    String ior = null;
    if (file == null || file.equals(""))
      return "";
    file = file.trim();
    try  {
      BufferedReader input
    = new BufferedReader(new FileReader(file));
      ior = input.readLine();               
    } catch (java.io.IOException e) {
      System.err.println("Error reading IOR file:\n" + e);
    }
    if (ior != null)
      synchronized (knownIORs) {
    knownIORs.put(ior,"");
      }
    checkSave();
    return ior;
  }   // end of getIorKey

  /**
   * Write all IORs to a flat file (for reading from c++ etc).
   *
   * Not used for the properties files.
   *
   * @see java.util.Properties
   * @param file the file to write to
   */
  public static void  writeToFile(String file) {
    checkLoaded();
    if (file != null)
      synchronized (knownIORs) {
    String ior = null;
    file = file.trim();
    try  {
      BufferedWriter output
        = new BufferedWriter(new FileWriter(file));
      Enumeration e = knownIORs.keys();
      while (e.hasMoreElements()) {
        String IOR = (String) e.nextElement();
        output.write(IOR);
        output.newLine();
      } 
    } catch (java.io.IOException e) {
      System.err.println("Error reading IOR file:\n" + e);
    }
      }
  }   // end of getIorKey
  

  /**
   * Attempt to connect to the object pointed to by an IOR
   * @see org.omg.CORBA.ORB
   * @param _args the command line arguments
   * @param _props the system properties
   * @param _IOR the IOR string
   * @return the newly created NzdlServiceClient
   */
  static public NzdlServiceClient attemptToInitialise(String [] _args, 
                      Properties _props, 
                      String _IOR) {
    checkLoaded();
    NzdlServiceClient nzdl = null;
    try {
      nzdl = new NzdlServiceClient( _args, _props, _IOR);
    } catch (Throwable t) {
      System.err.println ("failed to initialise using:");
      System.err.println (_IOR);
      return null;
    }
    return nzdl;
  }
  
  /**
   * Write the System properties to a file called "System.properties" in
   * the current directory.
   */
  public static final void main( String [] args ) {
 
    try {
      File file = new File("System.properties");
      
      System.getProperties().store(new FileOutputStream(file),"");
    } catch (Exception exception) {
      System.err.println("Error locking class:" + exception);
    }
  } //main
} // class