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.net.URL;

import java.util.Properties;

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

    /**

     *  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

     *  @return the response string from metacat in XML format

     *  @throws MetacatAuthException when the username/password could

     *                    not be authenticated

     */

    public String getloggedinuserinfo() throws MetacatInaccessibleException

    {

        Properties prop = new Properties();

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

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

        try {

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

        } catch (Exception e) {

            throw new MetacatInaccessibleException(e.getMessage());

        }

        return response;

    }

     *  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

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

        }

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

                    throw new DocumentNotFoundException(message);

                    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;

    }

    /**

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

     * an exception.

     *                      can have or haven't revision number

     * @throws MetacatException

     */

     public int getNewestDocRevision(String docId) throws MetacatException

     {

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

     }

    /**

     * Return the highest document id for a given scope.  This is used by

     * clients to make it easier to determine the next free identifier in a

     * sequence for a given scope.

     * @param scope String  the scope to use for looking up the latest id

     * @throws MetacatException when an error occurs

     */

    public String getLastDocid(String scope) throws MetacatException {

        String lastIdentifier = "";

        //set up properties

        Properties prop = new Properties();

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

        prop.put("scope", scope);

        String response = null;

        try {

            // Check for an error condition

               throw new MetacatException(response);

            } else {

                Reader responseReader = new StringReader(response);

                Node root =

                    XMLUtilities.getXMLReaderAsDOMTreeRootNode(responseReader);

                Node docidNode =

                    XMLUtilities.getNodeWithXPath(root, "/lastDocid/docid");

        } catch (Exception e) {

        }

    }

     * 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