/src/edu/ucsb/nceas/metacat/client/MetacatClient.java - Annotate - Metacat - Ecoinformatics Redmine

metacat/src/edu/ucsb/nceas/metacat/client/MetacatClient.java @ 6941

-            jones
+/**
  *  '$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;
-            leinfelder
+import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.FileOutputStream;
-            jones
+import java.io.InputStream;
-            jones
+import java.io.InputStreamReader;
-            jones
+import java.io.StringReader;
-            jones
+import java.io.IOException;
-            jones
+import java.io.StringWriter;
-            jones
+import java.io.Reader;
-            leinfelder
+import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Enumeration;
 import java.util.List;
-            jones
+import java.util.Properties;
-            berkley
+import java.util.Vector;
-            barteau
+import javax.servlet.http.HttpServletRequest;
             jones
-            leinfelder
+import org.apache.commons.io.IOUtils;
 import org.apache.http.HttpResponse;
 import org.apache.http.HttpVersion;
 import org.apache.http.NameValuePair;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.entity.mime.HttpMultipartMode;
 import org.apache.http.entity.mime.MultipartEntity;
 import org.apache.http.entity.mime.content.FileBody;
 import org.apache.http.entity.mime.content.InputStreamBody;
 import org.apache.http.entity.mime.content.StringBody;
 import org.apache.http.impl.client.DefaultHttpClient;
 import org.apache.http.message.BasicNameValuePair;
 import org.apache.http.params.CoreProtocolPNames;
 import org.apache.http.util.EntityUtils;
-            jones
+import org.w3c.dom.Node;
-            berkley
+import org.w3c.dom.NodeList;
             jones
-            jones
+import edu.ucsb.nceas.utilities.IOUtil;
-            jones
+import edu.ucsb.nceas.utilities.XMLUtilities;
-            sgarg
+import java.io.File;
             jones
             leinfelder
-            jones
+/**
-            sgarg
+ *  This interface provides methods for initializing and logging in to a
  *  Metacat server, and then querying, reading, transforming, inserting,
-            jones
+ *  updating and deleting documents from that server.
  */
-            barteau
+public class MetacatClient implements Metacat {
-            jones
+    /** The URL string for the metacat server */
     private String metacatUrl;
             barteau
-            jones
+    /** The session identifier for the session */
     private String sessionId;
             barteau
-            leinfelder
+    /** The default character encoding, can be changed by client */
     private String encoding = "UTF-8";
-            leinfelder
+    public static void main(String[] args) {
     	try {
-            leinfelder
+    		Metacat mc =
     			MetacatFactory.createMetacatConnection(args[0]);
             leinfelder
-            leinfelder
+    		InputStream r = mc.read(args[1]);
     		FileOutputStream fos = new FileOutputStream(args[2]);
     		BufferedOutputStream bfos = new BufferedOutputStream(fos);
             leinfelder
             int c = r.read();
             while(c != -1)
+            {
               bfos.write(c);
               c = r.read();
+            }
             bfos.flush();
             bfos.close();
             fos.flush();
             fos.close();
     	} catch (Exception e) {
     		e.printStackTrace();
+    	}
+    }
-            barteau
+    /**
-            jones
+     * Constructor to create a new instance. Protected because instances
      * should only be created by the factory MetacatFactory.
      */
-            barteau
+    protected MetacatClient() {
-            jones
+        this.metacatUrl = null;
         this.sessionId = null;
             jones
             barteau
-            jones
+    /**
      *  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
-            jones
+     *  @return the response string from metacat in XML format
-            jones
+     *  @throws MetacatAuthException when the username/password could
      *                    not be authenticated
      */
-            sgarg
+    public String login(String username, String password)
-            barteau
+    throws MetacatAuthException, MetacatInaccessibleException {
-            jones
+        Properties prop = new Properties();
         prop.put("action", "login");
         prop.put("qformat", "xml");
         prop.put("username", username);
         prop.put("password", password);
-            daigle
+//        if (this.sessionId != null) {
 //        	prop.put("sessionid", sessionId);
 //        }
             barteau
-            jones
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        if (response.indexOf("<login>") == -1) {
-            jones
+            setSessionId("");
-            jones
+            throw new MetacatAuthException(response);
-            jones
+        } else {
-            jones
+            int start = response.indexOf("<sessionId>") + 11;
-            jones
+            int end = response.indexOf("</sessionId>");
             if ((start != -1) && (end != -1)) {
-            jones
+                setSessionId(response.substring(start,end));
             jones
             jones
-            jones
+        return response;
             jones
             sgarg
     /**
      *  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
      */
-            barteau
+    public String getloggedinuserinfo() throws MetacatInaccessibleException {
-            sgarg
+        Properties prop = new Properties();
         prop.put("action", "getloggedinuserinfo");
         prop.put("qformat", "xml");
             barteau
-            sgarg
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            sgarg
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            sgarg
+        return response;
+    }
             barteau
-            jones
+    /**
-            jones
+     *  Method used to log out a metacat server. The Metacat server will end
      *  the session when this call is invoked.
             tao
-            jones
+     *  @return the response string from metacat in XML format
-            tao
+     *  @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      */
-            barteau
+    public String logout() throws MetacatInaccessibleException, MetacatException {
-            tao
+        Properties prop = new Properties();
         prop.put("action", "logout");
-            sgarg
+        prop.put("qformat", "xml");
-            daigle
+        if (this.sessionId != null) {
         	prop.put("sessionid", sessionId);
+        }
             barteau
-            tao
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            tao
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            tao
+        if (response.indexOf("<logout>") == -1) {
             throw new MetacatException(response);
+        }
-            jones
+        setSessionId("");
-            jones
+        return response;
             tao
             barteau
-            tao
+    /**
-            daigle
+     *  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 validateSession(String sessionId)
     		throws MetacatAuthException, MetacatInaccessibleException {
         Properties prop = new Properties();
         prop.put("action", "validatesession");
         prop.put("sessionid", sessionId);
         String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            daigle
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
         if (response.indexOf("<validateSession><status>") == -1) {
             setSessionId("");
             throw new MetacatAuthException(response);
+        }
         return response;
+    }
             leinfelder
 	/**
-            daigle
+     *  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 isAuthorized(String resourceLsid, String permission, String sessionId)
     		throws MetacatAuthException, MetacatInaccessibleException {
         Properties prop = new Properties();
         prop.put("action", "isauthorized");
         prop.put("resourceLsid", resourceLsid);
         prop.put("permission", permission);
         prop.put("sessionId", sessionId);
         String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            daigle
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
         if (response.indexOf("<resourceAuthorization>") == -1) {
         	System.out.println("invalid response: " + response);
             throw new MetacatAuthException(response);
+        }
         return response;
+    }
     /**
-            jones
+     * Read an XML document from the metacat server session, accessed by docid,
      * and returned as a Reader.
+     *
      * @param docid the identifier of the document to be read
      * @return a Reader for accessing the document
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
-            jones
+     */
-            leinfelder
+    public InputStream read(String docid) throws InsufficientKarmaException,
-            barteau
+            MetacatInaccessibleException, MetacatException, DocumentNotFoundException {
-            leinfelder
+    	Reader r = null;
             barteau
-            jones
+        Properties prop = new Properties();
         prop.put("action", "read");
         prop.put("qformat", "xml");
         prop.put("docid", docid);
         InputStream response = null;
         try {
-            leinfelder
+            response = sendParameters(prop);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
-            leinfelder
+        BufferedInputStream bis = new BufferedInputStream(response);
         r = new InputStreamReader(bis);
-            jones
+        try {
-            leinfelder
+        	bis.mark(512);
-            jones
+            char[] characters = new char[512];
-            leinfelder
+            int len = r.read(characters, 0, 512);
-            jones
+            StringWriter sw = new StringWriter();
             sw.write(characters, 0, len);
             String message = sw.toString();
             sw.close();
-            leinfelder
+            bis.reset();
-            jones
+            if (message.indexOf("<error>") != -1) {
                 if (message.indexOf("does not have permission") != -1) {
                     throw new InsufficientKarmaException(message);
-            berkley
+                } else if(message.indexOf("does not exist") != -1) {
                     throw new DocumentNotFoundException(message);
-            jones
+                } else {
                     throw new MetacatException(message);
+                }
+            }
         } catch (IOException ioe) {
             throw new MetacatException(
-            sgarg
+                    "MetacatClient: Error converting Reader to String."
-            jones
+                    + ioe.getMessage());
+        }
-            leinfelder
+        return bis;
             jones
             barteau
-            jones
+    /**
-            barteau
+     * Read inline data from the metacat server session, accessed by
      * 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
      */
-            leinfelder
+    public InputStream readInlineData(String inlinedataid)
-            barteau
+    throws InsufficientKarmaException,
             MetacatInaccessibleException, MetacatException {
-            leinfelder
+        Reader r = null;
             barteau
         Properties prop = new Properties();
         prop.put("action", "readinlinedata");
         prop.put("inlinedataid", inlinedataid);
         InputStream response = null;
         try {
-            leinfelder
+            response = sendParameters(prop);
-            barteau
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
-            leinfelder
+        BufferedInputStream bis = new BufferedInputStream(response);
         r = new InputStreamReader(bis);
-            barteau
+        try {
-            leinfelder
+        	bis.mark(512);
-            barteau
+            char[] characters = new char[512];
-            leinfelder
+            int len = r.read(characters, 0, 512);
-            barteau
+            StringWriter sw = new StringWriter();
             sw.write(characters, 0, len);
             String message = sw.toString();
             sw.close();
-            leinfelder
+            bis.reset();
-            barteau
+            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());
+        }
-            leinfelder
+        return bis;
             barteau
-            sgarg
+    /**
-            sgarg
+     * Query the metacat document store with the given metacat-compatible
-            tao
+     * query document and default qformat xml, and return the result set as a Reader.
             jones
      * @param xmlQuery a Reader for accessing the XML version of the query
      * @return a Reader for accessing the result set
      */
-            tao
+    public Reader query(Reader xmlQuery) throws MetacatInaccessibleException,
-            barteau
+            IOException {
-            tao
+        String qformat = "xml";
         return query(xmlQuery, qformat);
+    }
     /**
      * Query the metacat document store with the given metacat-compatible
      * query document and qformat, and return the result set as a Reader.
+     *
      * @param xmlQuery a Reader for accessing the XML version of the query
      * @param qformat the format of return doc. It can be xml, knb, lter and etal.
      * @return a Reader for accessing the result set
      */
     public Reader query(Reader xmlQuery, String qformat) throws MetacatInaccessibleException,
             IOException {
-            tao
+        Reader reader = null;
         String query = null;
-            jones
+        try {
-            barteau
+            query = IOUtil.getAsString(xmlQuery, true);
-            jones
+        } catch (IOException ioE) {
-            barteau
+            throw ioE;
             tao
             barteau
-            tao
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "squery");
-            tao
+        prop.put("qformat", qformat);
-            tao
+        prop.put("query", query);
             barteau
-            tao
+        InputStream response = null;
         try {
-            leinfelder
+            response = sendParameters(prop);
-            tao
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
         reader = new InputStreamReader(response);
         return reader;
             jones
             barteau
-            jones
+    /**
      * 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
-            sgarg
+     * @param schema a Reader for accessing the DTD or XML Schema for
-            jones
+     *               the document
-            jones
+     * @return the metacat response message
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @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
-            jones
+     */
-            jones
+    public String insert(String docid, Reader xmlDocument, Reader schema)
-            daigle
+    	throws InsufficientKarmaException, MetacatException, IOException,
-            barteau
+            MetacatInaccessibleException {
             daigle
-            jones
+        String doctext = null;
         String schematext = null;
         try {
-            barteau
+            doctext = IOUtil.getAsString(xmlDocument, true);
             if (schema != null) {
                 schematext = IOUtil.getAsString(schema, true);
+            }
-            jones
+        } catch (IOException ioE) {
-            barteau
+            throw ioE;
             jones
             barteau
-            jones
+        //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);
+        }
             daigle
-            leinfelder
+//        if (sessionId != null) {
 //            prop.put("sessionid", sessionId);
 //        }
             barteau
-            jones
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        // 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);
+            }
+        }
             barteau
-            jones
+        return response;
             jones
             barteau
-            jones
+    /**
      * 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
-            sgarg
+     * @param schema a Reader for accessing the DTD or XML Schema for
-            jones
+     *               the document
-            jones
+     * @return the metacat response message
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @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
-            jones
+     */
-            jones
+    public String update(String docid, Reader xmlDocument, Reader schema)
-            barteau
+    throws InsufficientKarmaException, MetacatException, IOException,
             MetacatInaccessibleException {
-            jones
+        String doctext = null;
         String schematext = null;
         try {
-            barteau
+            doctext = IOUtil.getAsString(xmlDocument, true);
             if (schema != null) {
                 schematext = IOUtil.getAsString(schema, true);
+            }
-            jones
+        } catch (IOException ioE) {
-            barteau
+            throw ioE;
             jones
             barteau
-            jones
+        //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);
+        }
             barteau
-            jones
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        // 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);
+            }
+        }
             barteau
-            jones
+        return response;
             jones
             barteau
-            jones
+    /**
-            jones
+     * Upload a data document into the repository. Data files are stored on
      * metacat and may be in any format (binary or text), but they are all
      * treated as if they were binary.  Data files are not searched by the
      * query() methods because they are not loaded into the XML store because
      * they are not XML documents.  The File parameter is used to determine a
      * name for the uploaded document.
             barteau
-            jones
+     * @param docid the identifier to be used for the document
      * @param file the File to be uploaded
      * @param document a InputStream containing the data to be uploaded
-            barteau
+     * @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 {
-            leinfelder
+    	HttpClient httpclient = new DefaultHttpClient();
         httpclient.getParams().setParameter(
         		CoreProtocolPNames.PROTOCOL_VERSION,
         	    HttpVersion.HTTP_1_1);
     	httpclient.getParams().setParameter(
     			CoreProtocolPNames.HTTP_CONTENT_CHARSET,
     			encoding);
     	HttpPost post = new HttpPost(metacatUrl);
     	MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
     	// For File parameters
     	entity.addPart("datafile", new FileBody(file));
-            barteau
+        //set up properties
-            leinfelder
+        Properties prop = new Properties();
         prop.put("action", "upload");
         prop.put("docid", docid);
             barteau
-            leinfelder
+        // For usual String parameters
         Enumeration<Object> keys = prop.keys();
         while (keys.hasMoreElements()) {
         	String key = (String) keys.nextElement();
         	String value = prop.getProperty(key);
         	entity.addPart(key, new StringBody(value, Charset.forName(encoding)));
+        }
             barteau
-            leinfelder
+        post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
         post.setEntity(entity);
-            barteau
+        String response = null;
         try {
-            leinfelder
+        	response = EntityUtils.toString(httpclient.execute(post).getEntity(), encoding);
         	httpclient.getConnectionManager().shutdown();
-            barteau
+        } catch (Exception e) {
-            sgarg
+            throw new MetacatInaccessibleException(e.getMessage());
             barteau
         // Check for an error condition
         if (response.indexOf("<error>") != -1) {
-            sgarg
+            if (response.indexOf("does not have permission") != -1) {
-            barteau
+                throw new InsufficientKarmaException(response);
-            sgarg
+            } else {
-            barteau
+                throw new MetacatException(response);
             sgarg
             barteau
         return response;
+    }
     /**
-            jones
+     * Upload a data document into the repository. Data files are stored on
      * metacat and may be in any format (binary or text), but they are all
      * treated as if they were binary.  Data files are not searched by the
      * query() methods because they are not loaded into the XML store because
      * they are not XML documents. The name for the document is set explicitly
      * using the filename parameter.
             barteau
-            jones
+     * @param docid the identifier to be used for the document
      * @param filename the name to be used in the MIME description of the uploaded file
      * @param document a InputStream containing the data to be uploaded
-            barteau
+     * @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 {
-            leinfelder
+    	HttpClient httpclient = new DefaultHttpClient();
         httpclient.getParams().setParameter(
         		CoreProtocolPNames.PROTOCOL_VERSION,
         	    HttpVersion.HTTP_1_1);
     	httpclient.getParams().setParameter(
     			CoreProtocolPNames.HTTP_CONTENT_CHARSET,
     			encoding);
     	HttpPost post = new HttpPost(metacatUrl);
     	MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
     	// For File parameters
-            leinfelder
+    	InputStreamBody content = null;
     	if (size < 0) {
         	content = new InputStreamBody(fileData, filename);
     	} else {
     		content = new InputStreamKnownSizeBody(fileData, filename, size);
+    	}
-            leinfelder
+    	entity.addPart("datafile", content);
-            barteau
+        //set up properties
-            leinfelder
+        Properties prop = new Properties();
         prop.put("action", "upload");
         prop.put("docid", docid);
             barteau
-            leinfelder
+        // For usual String parameters
         Enumeration<Object> keys = prop.keys();
         while (keys.hasMoreElements()) {
         	String key = (String) keys.nextElement();
         	String value = prop.getProperty(key);
         	entity.addPart(key, new StringBody(value, Charset.forName(encoding)));
+        }
         post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
         post.setEntity(entity);
-            barteau
+        String response = null;
         try {
-            leinfelder
+        	response = EntityUtils.toString(httpclient.execute(post).getEntity(), encoding);
         	httpclient.getConnectionManager().shutdown();
-            barteau
+        } catch (Exception e) {
-            sgarg
+            throw new MetacatInaccessibleException(e.getMessage());
             barteau
         // Check for an error condition
         if (response.indexOf("<error>") != -1) {
-            sgarg
+            if (response.indexOf("does not have permission") != -1) {
-            barteau
+                throw new InsufficientKarmaException(response);
-            sgarg
+            } else {
-            barteau
+                throw new MetacatException(response);
             sgarg
             barteau
         return response;
+    }
-            sgarg
+    /**
-            jones
+     * Delete an XML document in the repository.
+     *
      * @param docid the docid to delete
-            jones
+     * @return the metacat response message
-            sgarg
+     * @throws InsufficientKarmaException when the user has insufficent rights
-            jones
+     *                                    for the operation
-            jones
+     * @throws MetacatInaccessibleException when the metacat server can not be
      *                                    reached or does not respond
      * @throws MetacatException when the metacat server generates another error
-            jones
+     */
-            jones
+    public String delete(String docid)
-            barteau
+    throws InsufficientKarmaException, MetacatException,
             MetacatInaccessibleException {
-            jones
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "delete");
         prop.put("docid", docid);
             barteau
-            jones
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            jones
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            jones
+        // 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);
+            }
+        }
-            harris
+        return response;
+    }
             barteau
-            daigle
+    /**
      * get the access control info for a given document id.
+     *
      * @param _docid the docid of the document for which the access should be applied.
+     *
      * @return the metacat access xml
      */
     public String getAccessControl(String docid)
     	throws InsufficientKarmaException, MetacatException,MetacatInaccessibleException {
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "getaccesscontrol");
         prop.put("docid", docid);
         String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            daigle
+        } 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;
+    }
             barteau
-            harris
+    /**
      * set the access on an XML document in the repository.
+     *
-            harris
+     * @param _docid the docid of the document for which the access should be applied.
             harris
      * @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
      */
-            daigle
+    public String setAccess(String docid, String principal, String
             permission, String permType, String permOrder )
-            barteau
+            throws InsufficientKarmaException, MetacatException,
             MetacatInaccessibleException {
-            harris
+        //set up properties
         Properties prop = new Properties();
         prop.put("action", "setaccess");
-            daigle
+        prop.put("docid", docid);
         prop.put("principal", principal);
         prop.put("permission", permission);
         prop.put("permType", permType);
         prop.put("permOrder", permOrder);
             barteau
-            harris
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            harris
+        } catch (Exception e) {
             throw new MetacatInaccessibleException(e.getMessage());
+        }
             barteau
-            harris
+        // 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);
+            }
+        }
-            jones
+        return response;
             jones
             barteau
-            jones
+    /**
-            daigle
+	 * Set access for a given doc id. The access is represented in an access
 	 * block of xml. All existing access will be replaced with the access
 	 * provided in the access block.
+	 *
 	 * @param docid
 	 *            the doc id for the doc we want to update
 	 * @param accessBlock
 	 *            the xml access block. This is the same structure as that
 	 *            returned by the getdocumentinfo action in metacat.
 	 * @return a string holding the response xml
 	 */
     public String setAccess(String docid, String accessBlock)
             throws InsufficientKarmaException, MetacatException, MetacatInaccessibleException {
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "setaccess");
         prop.put("docid", docid);
         prop.put("accessBlock", accessBlock);
         String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            daigle
+        } 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;
+    }
     /**
-            jones
+     * 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
      */
-            barteau
+    public void setMetacatUrl(String metacatUrl) {
-            jones
+        this.metacatUrl = metacatUrl;
             jones
             barteau
-            jones
+    /**
      * 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
      */
-            barteau
+    public String getSessionId() {
-            jones
+        return this.sessionId;
+    }
             barteau
-            jones
+    /**
-            sgarg
+     * Set the session identifier for this session.  This identifier was
      * previously established with a call to login.  To continue to use the
-            jones
+     * same session, set the session id before making a call to one of the
      * metacat access methods (e.g., read, query, insert, etc.).
+     *
      * @param String the sessionId from a previously established session
      */
-            barteau
+    public void setSessionId(String sessionId) {
-            jones
+        this.sessionId = sessionId;
+    }
             tao
     /**
-            barteau
+     * The method will return the latest revision in metacat server
-            jones
+     * for a given document id. If some error happens, this method will throw
-            barteau
+     * an exception.
-            tao
+     * @param docId String  the given docid you want to use. the docid it self
      *                      can have or haven't revision number
      * @throws MetacatException
      */
-            barteau
+    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 {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            barteau
+            //parseRevisionResponse will return null if there is an
             //error that it can't handle
             String revStr = parserRevisionResponse(response);
             Integer revObj = new Integer(revStr);
             rev = revObj.intValue();
             // Check for an error condition
             if (response.indexOf("<error>") != -1 && revStr == null) {
                 throw new MetacatException(response);
+            }
         } catch (Exception e) {
             throw new MetacatException(e.getMessage());
+        }
         return rev;
+    }
-            jones
+    /**
      * 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
-            barteau
+     * sequence for a given scope.
-            jones
+     * @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);
             barteau
-            jones
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            tao
+            // Check for an error condition
-            jones
+            if (response.indexOf("<error>") != -1) {
-            barteau
+                throw new MetacatException(response);
-            jones
+            } else {
                 Reader responseReader = new StringReader(response);
-            barteau
+                Node root =
                         XMLUtilities.getXMLReaderAsDOMTreeRootNode(responseReader);
                 Node docidNode =
                         XMLUtilities.getNodeWithXPath(root, "/lastDocid/docid");
-            jones
+                lastIdentifier = docidNode.getFirstChild().getNodeValue();
             jones
         } catch (Exception e) {
-            tao
+            throw new MetacatException(e.getMessage());
+        }
-            jones
+        return lastIdentifier;
+    }
             berkley
     /**
      * return a list of all docids that match a given scope.  if scope is null
      * return all docids registered in the system
      * @param scope String  the scope to use to limit the docid query
      * @throws MetacatException when an error occurs
      */
     public Vector getAllDocids(String scope) throws MetacatException {
         Vector resultVec = new Vector();
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "getalldocids");
-            barteau
+        if(scope != null) {
             prop.put("scope", scope);
             berkley
             barteau
-            berkley
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            berkley
+            // Check for an error condition
             if (response.indexOf("<error>") != -1) {
-            barteau
+                throw new MetacatException(response);
-            berkley
+            } else {
                 Reader responseReader = new StringReader(response);
-            barteau
+                Node root =
                         XMLUtilities.getXMLReaderAsDOMTreeRootNode(responseReader);
-            berkley
+                NodeList nlist = root.getChildNodes();
-            barteau
+                for(int i=0; i<nlist.getLength(); i++) {
                     Node n = nlist.item(i);
                     if(n.getNodeName().equals("docid")) {
                         //add the content to the return vector
                         String nodeVal = n.getFirstChild().getNodeValue();
                         resultVec.addElement(nodeVal);
+                    }
             berkley
+            }
         } catch (Exception e) {
             throw new MetacatException(e.getMessage());
+        }
         return resultVec;
+    }
             berkley
     /**
      * return true of the given docid is registered, false if not
      * @param scope String  the scope to use to limit the docid query
      * @throws MetacatException when an error occurs
      */
     public boolean isRegistered(String docid) throws MetacatException {
         Vector resultVec = new Vector();
         //set up properties
         Properties prop = new Properties();
         prop.put("action", "isregistered");
-            barteau
+        if(docid == null) {
             throw new MetacatException("<error>Cannot check if a null docid " +
                     "is registered.</error>");
             berkley
         prop.put("docid", docid);
             barteau
-            berkley
+        String response = null;
         try {
-            leinfelder
+        	InputStream result = sendParameters(prop);
             response = IOUtils.toString(result, encoding);
-            berkley
+            // Check for an error condition
             if (response.indexOf("<error>") != -1) {
-            barteau
+                throw new MetacatException(response);
-            berkley
+            } else {
-            leinfelder
+                if (response.indexOf("true") != -1) {
-            barteau
+                    return true;
             berkley
                 return false;
+            }
         } catch (Exception e) {
             throw new MetacatException(e.getMessage());
+        }
+    }
             barteau
-            barteau
+    /**
      * Send a request to Metacat.  An alternative to the sentData method.
      * Allows for sending multiple parameters with the same name,
      * different names, or any combo.  Send properties where the entry
      * key contains the "param value",
      * and the entry value contains the "param name".
      * Constraint: param values must be unique.
+     *
      * @return InputStream as returned by Metacat
      * @param args Properties of the parameters to be sent to Metacat, where,
      *      key = param value
      *      value = param name
      * @throws java.lang.Exception thrown
      */
-            leinfelder
+    synchronized public InputStream sendParameters(Properties prop) throws Exception {
         InputStream result = null;
-            jones
+        try {
-            leinfelder
+        	HttpClient httpclient = new DefaultHttpClient();
             httpclient.getParams().setParameter(
             		CoreProtocolPNames.PROTOCOL_VERSION,
             	    HttpVersion.HTTP_1_1);
         	httpclient.getParams().setParameter(
         			CoreProtocolPNames.HTTP_CONTENT_CHARSET,
         			encoding);
             HttpPost post = new HttpPost(metacatUrl);
             //set the params
             List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
             Enumeration<Object> keys = prop.keys();
             while (keys.hasMoreElements()) {
             	String key = (String) keys.nextElement();
             	String value = prop.getProperty(key);
             	NameValuePair nvp = new BasicNameValuePair(key, value);
             	nameValuePairs.add(nvp);
             jones
-            leinfelder
+            post.setEntity(new UrlEncodedFormEntity(nameValuePairs, encoding));
             post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
             HttpResponse httpResponse = httpclient.execute(post);
             result = httpResponse.getEntity().getContent();
             //httpclient.getConnectionManager().shutdown();
-            jones
+        } catch (Exception e) {
-            leinfelder
+            throw new MetacatInaccessibleException(e.getMessage());
             jones
-            leinfelder
+        return result;
             jones
             tao
     /*
      * "getversionanddoctype" action will return a string from metacat server.
      * The string format is "revision;doctype"(This is bad idea, we should use xml)
      * This method will get revision string from the response string
      */
-            barteau
+    private String parserRevisionResponse(String response) throws Exception {
         String revision = null;
         if (response != null) {
             if(response.indexOf("<error>") != -1) {
                 if(response.indexOf("There is not record") != -1) {
                     return "0";
                 } else {
                     return null;
+                }
             } else {
                 int firstSemiCol = response.indexOf(";");
                 revision = response.substring(0, firstSemiCol);
+            }
             berkley
-            barteau
+        return revision;
+    }
     /**
      * JSP API: This is a convenience method to reduce the amount of code in a Metacat Client
      * JSP.  It handles creating/reusing an instance of a MetacatClient.
      * @param request Since this is intended to be used by a JSP, it is passed the
      * available "request" variable (the HttpServletRequest).
      * @throws edu.ucsb.nceas.metacat.client.MetacatInaccessibleException Received by MetacatFactory.
      * @return MetacatClient instance.
      */
-            barteau
+    public static MetacatClient getMetacatClient(HttpServletRequest request) throws MetacatInaccessibleException {
-            barteau
+        MetacatClient                       result;
         String                              metacatPath = "http://%1$s%2$s/metacat";
         String                              host, context;
         javax.servlet.http.HttpSession      session;
         session = request.getSession();
         result = (MetacatClient) session.getAttribute("MetacatClient");
         if (result == null) {
             host = request.getHeader("host");
             context = request.getContextPath();
-            barteau
+            metacatPath = metacatPath.replaceFirst("%1$s", host);
             metacatPath = metacatPath.replaceFirst("%2$s", context);
-            barteau
+            result = (MetacatClient) MetacatFactory.createMetacatConnection(metacatPath);
             session.setAttribute("MetacatClient", result);
+        }
         return(result);
+    }
             leinfelder
 	public String getEncoding() {
 		return encoding;
+	}
 	public void setEncoding(String encoding) {
 		this.encoding = encoding;
+	}
             barteau
             jones
             leinfelder
 class InputStreamKnownSizeBody extends InputStreamBody {
 	private int length;
 	public InputStreamKnownSizeBody(
 			final InputStream in,
 			final String filename,
 			final int length) {
 		super(in, filename);
 		this.length = length;
+	}
 	@Override
 	public long getContentLength() {
 		return this.length;
+	}
+}

Project

General

Profile

Metacat