/**
* '$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.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.Vector;
import javax.servlet.http.HttpServletRequest;
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.AbstractContentBody;
import org.apache.http.entity.mime.content.ByteArrayBody;
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;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import edu.ucsb.nceas.utilities.IOUtil;
import edu.ucsb.nceas.utilities.XMLUtilities;
import java.io.File;
/**
* This interface provides methods for initializing and logging in to a
* Metacat server, and then querying, reading, transforming, inserting,
* updating and deleting documents from that server.
*/
public class MetacatClient implements Metacat {
/** The URL string for the metacat server */
private String metacatUrl;
/** The session identifier for the session */
private String sessionId;
/** The default character encoding, can be changed by client */
private String encoding = "UTF-8";
public static void main(String[] args) {
try {
Metacat mc =
MetacatFactory.createMetacatConnection(args[0]);
InputStream r = mc.read(args[1]);
FileOutputStream fos = new FileOutputStream(args[2]);
BufferedOutputStream bfos = new BufferedOutputStream(fos);
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();
}
}
/**
* Constructor to create a new instance. Protected because instances
* should only be created by the factory MetacatFactory.
*/
protected MetacatClient() {
this.metacatUrl = null;
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
* @return the response string from metacat in XML format
* @throws MetacatAuthException when the username/password could
* not be authenticated
*/
public String login(String username, String password)
throws MetacatAuthException, MetacatInaccessibleException {
Properties prop = new Properties();
prop.put("action", "login");
prop.put("qformat", "xml");
prop.put("username", username);
prop.put("password", password);
// if (this.sessionId != null) {
// prop.put("sessionid", sessionId);
// }
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
if (response.indexOf("<login>") == -1) {
setSessionId("");
throw new MetacatAuthException(response);
} else {
int start = response.indexOf("<sessionId>") + 11;
int end = response.indexOf("</sessionId>");
if ((start != -1) && (end != -1)) {
setSessionId(response.substring(start,end));
}
}
return response;
}
/**
* 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");
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
return response;
}
/**
* Method used to log out a metacat server. The Metacat server will end
* the session when this call is invoked.
*
* @return the response string from metacat in XML format
* @throws MetacatInaccessibleException when the metacat server can not be
* reached or does not respond
*/
public String logout() throws MetacatInaccessibleException, MetacatException {
Properties prop = new Properties();
prop.put("action", "logout");
prop.put("qformat", "xml");
if (this.sessionId != null) {
prop.put("sessionid", sessionId);
}
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
if (response.indexOf("<logout>") == -1) {
throw new MetacatException(response);
}
setSessionId("");
return response;
}
/**
* 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 {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
if (response.indexOf("<validateSession><status>") == -1) {
setSessionId("");
throw new MetacatAuthException(response);
}
return response;
}
/**
* 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 {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} 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;
}
/**
* 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
* @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 InputStream read(String docid) throws InsufficientKarmaException,
MetacatInaccessibleException, MetacatException, DocumentNotFoundException {
Reader r = null;
Properties prop = new Properties();
prop.put("action", "read");
prop.put("qformat", "xml");
prop.put("docid", docid);
InputStream response = null;
try {
response = sendParameters(prop);
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
BufferedInputStream bis = new BufferedInputStream(response);
r = new InputStreamReader(bis);
try {
bis.mark(512);
char[] characters = new char[512];
int len = r.read(characters, 0, 512);
StringWriter sw = new StringWriter();
sw.write(characters, 0, len);
String message = sw.toString();
sw.close();
bis.reset();
if (message.indexOf("<error>") != -1) {
if (message.indexOf("does not have permission") != -1) {
throw new InsufficientKarmaException(message);
} else if(message.indexOf("does not exist") != -1) {
throw new DocumentNotFoundException(message);
} else {
throw new MetacatException(message);
}
}
} catch (IOException ioe) {
throw new MetacatException(
"MetacatClient: Error converting Reader to String."
+ ioe.getMessage());
}
return bis;
}
/**
* 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
*/
public InputStream readInlineData(String inlinedataid)
throws InsufficientKarmaException,
MetacatInaccessibleException, MetacatException {
Reader r = null;
Properties prop = new Properties();
prop.put("action", "readinlinedata");
prop.put("inlinedataid", inlinedataid);
InputStream response = null;
try {
response = sendParameters(prop);
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
BufferedInputStream bis = new BufferedInputStream(response);
r = new InputStreamReader(bis);
try {
bis.mark(512);
char[] characters = new char[512];
int len = r.read(characters, 0, 512);
StringWriter sw = new StringWriter();
sw.write(characters, 0, len);
String message = sw.toString();
sw.close();
bis.reset();
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 bis;
}
/**
* Query the metacat document store with the given metacat-compatible
* query document and default qformat xml, and return the result set as a Reader.
*
* @param xmlQuery a Reader for accessing the XML version of the query
* @return a Reader for accessing the result set
*/
public Reader query(Reader xmlQuery) throws MetacatInaccessibleException,
IOException {
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 {
Reader reader = null;
String query = null;
try {
query = IOUtil.getAsString(xmlQuery, true);
} catch (IOException ioE) {
throw ioE;
}
//set up properties
Properties prop = new Properties();
prop.put("action", "squery");
prop.put("qformat", qformat);
prop.put("query", query);
InputStream response = null;
try {
response = sendParameters(prop);
} catch (Exception e) {
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
* @param schema a Reader for accessing the DTD or XML Schema for
* the document
* @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 insert(String docid, Reader xmlDocument, Reader schema)
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);
}
// if (sessionId != null) {
// prop.put("sessionid", sessionId);
// }
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} 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;
}
/**
* 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
* @param schema a Reader for accessing the DTD or XML Schema for
* the document
* @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 update(String docid, Reader xmlDocument, Reader schema)
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);
}
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} 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;
}
/**
* 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.
*
* @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
* @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 {
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));
//set up properties
Properties prop = new Properties();
prop.put("action", "upload");
prop.put("docid", docid);
// 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);
String response = null;
try {
response = EntityUtils.toString(httpclient.execute(post).getEntity(), encoding);
httpclient.getConnectionManager().shutdown();
} 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;
}
/**
* 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.
*
* @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
* @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 {
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
AbstractContentBody content = null;
if (size < 0) {
content = new InputStreamBody(fileData, filename);
//content = new ByteArrayBody(IOUtils.toByteArray(fileData), filename);
} else {
content = new InputStreamKnownSizeBody(fileData, filename, size);
}
entity.addPart("datafile", content);
//set up properties
Properties prop = new Properties();
prop.put("action", "upload");
prop.put("docid", docid);
// 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);
String response = null;
try {
response = EntityUtils.toString(httpclient.execute(post).getEntity(), encoding);
httpclient.getConnectionManager().shutdown();
} 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;
}
/**
* Delete an XML document in the repository.
*
* @param docid the docid to delete
* @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 delete(String docid)
throws InsufficientKarmaException, MetacatException,
MetacatInaccessibleException {
//set up properties
Properties prop = new Properties();
prop.put("action", "delete");
prop.put("docid", docid);
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} 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;
}
/**
* 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 {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} 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;
}
/**
* set the access on an XML document in the repository.
*
* @param _docid the docid of the document for which the access should be applied.
*
* @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 {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} 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;
}
/**
* 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 {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
} 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;
}
/**
* 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) {
this.metacatUrl = 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;
}
/**
* Set the session identifier for this session. This identifier was
* previously established with a call to login. To continue to use the
* 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
*/
public void setSessionId(String sessionId) {
this.sessionId = sessionId;
}
/**
* The method will return the latest revision in metacat server
* for a given document id. If some error happens, this method will throw
* an 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 {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
//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;
}
/**
* 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 {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
// Check for an error condition
if (response.indexOf("<error>") != -1) {
throw new MetacatException(response);
} else {
Reader responseReader = new StringReader(response);
Node root =
XMLUtilities.getXMLReaderAsDOMTreeRootNode(responseReader);
Node docidNode =
XMLUtilities.getNodeWithXPath(root, "/lastDocid/docid");
lastIdentifier = docidNode.getFirstChild().getNodeValue();
}
} catch (Exception e) {
throw new MetacatException(e.getMessage());
}
return lastIdentifier;
}
/**
* 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");
if(scope != null) {
prop.put("scope", scope);
}
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
// Check for an error condition
if (response.indexOf("<error>") != -1) {
throw new MetacatException(response);
} else {
Reader responseReader = new StringReader(response);
Node root =
XMLUtilities.getXMLReaderAsDOMTreeRootNode(responseReader);
NodeList nlist = root.getChildNodes();
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);
}
}
}
} catch (Exception e) {
throw new MetacatException(e.getMessage());
}
return resultVec;
}
/**
* 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");
if(docid == null) {
throw new MetacatException("<error>Cannot check if a null docid " +
"is registered.</error>");
}
prop.put("docid", docid);
String response = null;
try {
InputStream result = sendParameters(prop);
response = IOUtils.toString(result, encoding);
// Check for an error condition
if (response.indexOf("<error>") != -1) {
throw new MetacatException(response);
} else {
if (response.indexOf("true") != -1) {
return true;
}
return false;
}
} catch (Exception e) {
throw new MetacatException(e.getMessage());
}
}
/**
* 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 key",
* and the entry value contains the "param value".
* Constraint: no multi-valued parameters are supported
*
* @return InputStream as returned by Metacat
* @param args Properties of the parameters to be sent to Metacat, where,
* key = param key
* value = param value
* @throws java.lang.Exception thrown
*/
synchronized public InputStream sendParameters(Properties prop) throws Exception {
InputStream result = null;
try {
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);
}
post.setEntity(new UrlEncodedFormEntity(nameValuePairs, encoding));
post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
HttpResponse httpResponse = httpclient.execute(post);
result = httpResponse.getEntity().getContent();
//httpclient.getConnectionManager().shutdown();
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
return result;
}
/**
* Send a request to Metacat.
* NOTE: 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
*/
synchronized public InputStream sendParametersInverted(Properties prop) throws Exception {
InputStream result = null;
try {
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()) {
// NOTE: using the value as the key for multi-valued parameters
String key = (String) keys.nextElement();
String value = prop.getProperty(key);
NameValuePair nvp = new BasicNameValuePair(value, key);
nameValuePairs.add(nvp);
}
post.setEntity(new UrlEncodedFormEntity(nameValuePairs, encoding));
post.setHeader("Cookie", "JSESSIONID="+ this.sessionId);
HttpResponse httpResponse = httpclient.execute(post);
result = httpResponse.getEntity().getContent();
//httpclient.getConnectionManager().shutdown();
} catch (Exception e) {
throw new MetacatInaccessibleException(e.getMessage());
}
return result;
}
/*
* "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
*/
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);
}
}
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.
*/
public static MetacatClient getMetacatClient(HttpServletRequest request) throws MetacatInaccessibleException {
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();
metacatPath = metacatPath.replaceFirst("%1$s", host);
metacatPath = metacatPath.replaceFirst("%2$s", context);
result = (MetacatClient) MetacatFactory.createMetacatConnection(metacatPath);
session.setAttribute("MetacatClient", result);
}
return(result);
}
public String getEncoding() {
return encoding;
}
public void setEncoding(String encoding) {
this.encoding = encoding;
}
}
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;
}
}