Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2000 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author$'

 *     '$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.client;

import java.io.IOException;

import java.net.URL;

import java.util.Properties;

import edu.ucsb.nceas.utilities.HttpMessage;

 *  Metacat server, and then querying, reading, transforming, inserting,

 */

public class MetacatClient implements Metacat

{

    /** The URL string for the metacat server */

    private String metacatUrl;

    private String sessionId;

     * Constructor to create a new instance. Protected because instances

     * should only be created by the factory MetacatFactory.

     */

    protected MetacatClient()

    {

        this.sessionId = null;

    /**

     *  Method used to log in to a metacat server. Implementations will need

     *  to cache a cookie value to make the session persistent.  Each time a

     *  call is made to one of the other methods (e.g., read), the cookie will

     *  need to be passed back to the metacat server along with the request.

     *

     *  @param username   the username of the user, like an LDAP DN

     *  @param password   the password for that user for authentication

     *                    not be authenticated

     */

    {

        prop.put("action", "login");

        prop.put("qformat", "xml");

        prop.put("username", username);

        prop.put("password", password);

        String response = null;

        try {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        if (response.indexOf("<login>") == -1) {

            if ((start != -1) && (end != -1)) {

    /**

     *  the session when this call is invoked.

     *                                    reached or does not respond

     */

        Properties prop = new Properties();

        prop.put("action", "logout");

        try {

            throw new MetacatInaccessibleException(e.getMessage());

        }

            throw new MetacatException(response);

        }

     * and returned as a Reader.

     *

     * @param docid the identifier of the document to be read

     * @return a Reader for accessing the document

     *                                    reached or does not respond

     * @throws MetacatException when the metacat server generates another error

        MetacatInaccessibleException, MetacatException

        Properties prop = new Properties();

        prop.put("action", "read");

        prop.put("qformat", "xml");

        prop.put("docid", docid);

        InputStream response = null;

        try {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        try {

            char[] characters = new char[512];

            int len = pbr.read(characters, 0, 512);

            StringWriter sw = new StringWriter();

            sw.write(characters, 0, len);

            String message = sw.toString();

            sw.close();

            pbr.unread(characters, 0, len);

            if (message.indexOf("<error>") != -1) {

                if (message.indexOf("does not have permission") != -1) {

                    throw new InsufficientKarmaException(message);

                } else {

                    throw new MetacatException(message);

                }

            }

        } catch (IOException ioe) {

            throw new MetacatException(

        }

        return pbr;

        * inlinedataid and returned as a Reader.

        *

        * @param inlinedataid the identifier of the data to be read

        * @return a Reader for accessing the document

        * @throws InsufficientKarmaException when the user has insufficent rights

        *                                    for the operation

        * @throws MetacatInaccessibleException when the metacat server can not be

        *                                    reached or does not respond

        * @throws MetacatException when the metacat server generates another error

        */

       public Reader readInlineData(String inlinedataid)

           throws InsufficientKarmaException,

           MetacatInaccessibleException, MetacatException

       {

           PushbackReader pbr = null;

           Properties prop = new Properties();

           prop.put("action", "readinlinedata");

           prop.put("inlinedataid", inlinedataid);

           InputStream response = null;

           try {

               throw new MetacatInaccessibleException(e.getMessage());

           }

           pbr = new PushbackReader(new InputStreamReader(response), 512);

           try {

               char[] characters = new char[512];

               int len = pbr.read(characters, 0, 512);

               StringWriter sw = new StringWriter();

               sw.write(characters, 0, len);

               String message = sw.toString();

               sw.close();

               pbr.unread(characters, 0, len);

               if (message.indexOf("<error>") != -1) {

                   if (message.indexOf("does not have permission") != -1) {

                       throw new InsufficientKarmaException(message);

                   } else {

                       throw new MetacatException(message);

                   }

               }

           } catch (IOException ioe) {

               throw new MetacatException(

                       "MetacatClient: Error converting Reader to String."

                       + ioe.getMessage());

           }

           return pbr;

       }

    /**

     *

     * @param xmlQuery a Reader for accessing the XML version of the query

     * @return a Reader for accessing the result set

     */

                                                IOException

        String query = null;

          query = IOUtil.getAsString(xmlQuery, true);

        } catch (IOException ioE) {

        }

        //set up properties

        Properties prop = new Properties();

        prop.put("action", "squery");

        prop.put("qformat", "xml");

        prop.put("query", query);

        try {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        reader = new InputStreamReader(response);

        return reader;

    /**

     * Insert an XML document into the repository.

     *

     * @param docid the docid to insert the document

     * @param xmlDocument a Reader for accessing the XML document to be inserted

     *                                    reached or does not respond

     * @throws MetacatException when the metacat server generates another error

     * @throws IOException when there is an error reading the xml document

        throws InsufficientKarmaException, MetacatException, IOException,

        MetacatInaccessibleException

        String doctext = null;

        String schematext = null;

        try {

          doctext = IOUtil.getAsString(xmlDocument, true);

          if (schema != null) {

              schematext = IOUtil.getAsString(schema, true);

          }

        } catch (IOException ioE) {

          throw ioE;

        }

        //set up properties

        Properties prop = new Properties();

        prop.put("action", "insert");

        prop.put("docid", docid);

        prop.put("doctext", doctext);

        if (schematext != null) {

            prop.put("dtdtext", schematext);

        }

        try {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        // Check for an error condition

        if (response.indexOf("<error>") != -1) {

            if (response.indexOf("does not have permission") != -1) {

                throw new InsufficientKarmaException(response);

            } else {

                throw new MetacatException(response);

            }

        }

        return response;

    /**

     * Update an XML document in the repository.

     *

     * @param docid the docid to update

     * @param xmlDocument a Reader for accessing the XML text to be updated

     *                                    reached or does not respond

     * @throws MetacatException when the metacat server generates another error

     * @throws IOException when there is an error reading the xml document

        throws InsufficientKarmaException, MetacatException, IOException,

        MetacatInaccessibleException

        String doctext = null;

        String schematext = null;

        try {

          doctext = IOUtil.getAsString(xmlDocument, true);

          if (schema != null) {

              schematext = IOUtil.getAsString(schema, true);

          }

        } catch (IOException ioE) {

          throw ioE;

        }

        //set up properties

        Properties prop = new Properties();

        prop.put("action", "update");

        prop.put("docid", docid);

        prop.put("doctext", doctext);

        if (schematext != null) {

            prop.put("dtdtext", schematext);

        }

        try {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        // Check for an error condition

        if (response.indexOf("<error>") != -1) {

            if (response.indexOf("does not have permission") != -1) {

                throw new InsufficientKarmaException(response);

            } else {

                throw new MetacatException(response);

            }

        }

        return response;

    /**

       *

       * @param docid the docid to insert the document

       * @param document a Reader for accessing the document to be uploaded

       * @return the metacat response message

       * @throws InsufficientKarmaException when the user has insufficent rights

       *                                    for the operation

       * @throws MetacatInaccessibleException when the metacat server can not be

       *                                    reached or does not respond

       * @throws MetacatException when the metacat server generates another error

       * @throws IOException when there is an error reading the xml document

       */

      public String upload(String docid, File file)

          throws InsufficientKarmaException, MetacatException, IOException,

          MetacatInaccessibleException

      {

          URL url = new URL(metacatUrl.trim());

          HttpMessage msg = new HttpMessage(url);

          //set up properties

          Properties arg = new Properties();

          arg.put("action", "upload");

          arg.put("docid", docid);

          Properties filenames = new Properties();

          String filename = file.getAbsolutePath();

          filenames.put("datafile", filename);

          String response = null;

          try {

            throw new MetacatInaccessibleException(e.getMessage());

          }

          // Check for an error condition

          if (response.indexOf("<error>") != -1) {

            if (response.indexOf("does not have permission") != -1) {

              throw new InsufficientKarmaException(response);

            } else {

              throw new MetacatException(response);

            }

          }

      }

          *

          * @param docid the docid to insert the document

          * @param document a Reader for accessing the document to be uploaded

          * @return the metacat response message

          * @throws InsufficientKarmaException when the user has insufficent rights

          *                                    for the operation

          * @throws MetacatInaccessibleException when the metacat server can not be

          *                                    reached or does not respond

          * @throws MetacatException when the metacat server generates another error

          * @throws IOException when there is an error reading the xml document

          */

      public String upload(String docid, String filename, InputStream fileData,

                           int size)

          throws InsufficientKarmaException, MetacatException, IOException,

          MetacatInaccessibleException {

          URL url = new URL(metacatUrl.trim());

          HttpMessage msg = new HttpMessage(url);

          //set up properties

          Properties arg = new Properties();

          arg.put("action", "upload");

          arg.put("docid", docid);

          Properties filenames = new Properties();

          filenames.put("datafile", filename);

          String response = null;

          try {

            response = sendDataForString(arg, filenames, fileData, size);

          } catch (Exception e) {

            throw new MetacatInaccessibleException(e.getMessage());

          }

          // Check for an error condition

          if (response.indexOf("<error>") != -1) {

            if (response.indexOf("does not have permission") != -1) {

              throw new InsufficientKarmaException(response);

            } else {

              throw new MetacatException(response);

            }

          }

          return response;

    /**

     *

     * @param docid the docid to delete

     *                                    reached or does not respond

     * @throws MetacatException when the metacat server generates another error

        throws InsufficientKarmaException, MetacatException,

        MetacatInaccessibleException

        Properties prop = new Properties();

        prop.put("action", "delete");

        prop.put("docid", docid);

        try {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        // Check for an error condition

        if (response.indexOf("<error>") != -1) {

            if (response.indexOf("does not have permission") != -1) {

                throw new InsufficientKarmaException(response);

            } else {

                throw new MetacatException(response);

            }

        }

    }

    /**

     * set the access on an XML document in the repository.

     *

     * @param _principal the document's principal

     *

     * @param _permission the access permission to be applied to the docid

     *  {e.g. read,write,all}

     *

     * @param _permType the permission type to be applied to the document

     *  {e.g. allow or deny}

     *

     * @param _permOrder the order that the document's permissions should be

     *  processed {e.g. denyFirst or allowFirst}

     *

     *

     * @return the metacat response message

     *

     * @throws InsufficientKarmaException when the user has insufficent rights

     *                                    for the operation

     * @throws MetacatInaccessibleException when the metacat server can not be

     *                                    reached or does not respond

     * @throws MetacatException when the metacat server generates another error

     */

    public String setAccess(String _docid, String _principal, String

                            _permission, String _permType,

                            String _permOrder )

        throws InsufficientKarmaException, MetacatException,

        MetacatInaccessibleException

    {

        //set up properties

        Properties prop = new Properties();

        prop.put("action", "setaccess");

        prop.put("docid", _docid);

        prop.put("principal", _principal);

        prop.put("permission", _permission);

        prop.put("permType", _permType);

        prop.put("permOrder", _permOrder);

        String response = null;

        try {

            response = sendDataForString(prop, null, null, 0);

        } catch (Exception e) {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        // Check for an error condition

        if (response.indexOf("<error>") != -1) {

            if (response.indexOf("does not have permission") != -1) {

                throw new InsufficientKarmaException(response);

            } else {

                throw new MetacatException(response);

            }

        }

    /**

     * When the MetacatFactory creates an instance it needs to set the

     * MetacatUrl to which connections should be made.

     *

     * @param metacatUrl the URL for the metacat server

     */

    public void setMetacatUrl(String metacatUrl)

    {

     * Get the session identifier for this session.  This is only valid if

     * the login methods has been called successfully for this Metacat object

     * beforehand.

     *

     * @returns the sessionId as a String, or null if the session is invalid

     */

    public String getSessionId()

    {

        return this.sessionId;

    }

     * previously established with a call to login.  To continue to use the

     * metacat access methods (e.g., read, query, insert, etc.).

     *

     * @param String the sessionId from a previously established session

     */

    public void setSessionId(String sessionId)

    {

        this.sessionId = sessionId;

    }

    /**

     * The method will return the lasted revision in metacat server

     * for a given document id. If some error happent, this method will throw

     * a exception.

     * @param docId String  the given docid you want to use. the docid it self

     *                      can have or haven't revision number

     * @throws MetacatException

     */

     public int getNewestDocRevision(String docId) throws MetacatException

     {

       int rev = 0;

       //set up properties

       Properties prop = new Properties();

       prop.put("action", "getrevisionanddoctype");

       prop.put("docid", docId);

       String response = null;

        try

        {

            response = sendDataForString(prop, null, null, 0);

            String revStr = parserRevisionResponse(response);

            Integer revObj = new Integer(revStr);

            rev = revObj.intValue();

            // Check for an error condition

           if (response.indexOf("<error>") != -1)

           {

              throw new MetacatException(response);

           }

        catch (Exception e)

        {

            throw new MetacatException(e.getMessage());

        }

        return rev;

     }

     * PRIVATE METHODS

     ************************************************************************/

     * Send a request to metacat.

     *

     * @param prop the properties to be URL encoded and sent

     *                  in case of upload, otherwise null

     * @param fileData  the inputStream for the file data to be sent to Metacat

     *                  in case of upload, otherwise null

     * @param size      the size of the data being sent to Metacat

     *                  in case of upload, otherwise 0

                                                  InputStream fileData,

                                                  int size)

    {

        InputStream returnStream = null;

        URL url = new URL(metacatUrl);

        HttpMessage msg = new HttpMessage(url);

            returnStream = msg.sendPostData(args);

        } else if (fileData == null){

            returnStream = msg.sendPostData(args, filename);

        } else if (size > 0) {

            returnStream = msg.sendPostData(args, filename, fileData, size);

                                       "the input stream being passed");

    }

    /**

     * Send a request to Metacat

     *

     * @param filename  the properties to be sent to Metacat

     *                  in case of upload, otherwise null

     * @param fileData  the inputStream for the file data to be sent to Metacat

     *                  in case of upload, otherwise null

     * @param size      the size of the data being sent to Metacat

     *                  in case of upload, otherwise 0

     */

                                              InputStream fileData,

                                              int size)

    {

        /*

            Note:  The reason that there are three try statements all executing

            the same code is that there is a problem with the initial connection

            sure that a connection is made because it gives each connection a

            THIS IS A TOTAL HACK.  THIS NEEDS TO BE LOOKED INTO AFTER THE BETA1

            RELEASE OF MORPHO!!!  cwb (7/24/01)

          */

        try {

            try {

                try {

                    System.err.println(