/ - Diff - Metacat - Ecoinformatics Redmine

             StringBuffer self = new StringBuffer();
             StringBuffer queryString = new StringBuffer();
             queryString.append("SELECT xml_documents.docid, docname, doctype, date_created, date_updated, xml_documents.rev ");
             queryString.append("SELECT xml_documents.docid, identifier.guid, docname, doctype, date_created, date_updated, xml_documents.rev ");
             queryString.append("FROM xml_documents, identifier ");
             queryString.append("WHERE xml_documents.docid = identifier.docid AND xml_documents.rev = identifier.rev AND");

     import org.dataone.service.types.v1.Permission;
     import org.dataone.service.types.v1.Subject;
     import org.dataone.service.types.v1.SystemMetadata;
     import org.dataone.service.types.v1_1.QueryEngineDescription;
     import org.dataone.service.types.v1_1.QueryEngineList;
     import org.dataone.service.util.Constants;
     import org.dataone.service.util.DateTimeMarshaller;
     import org.dataone.service.util.ExceptionHandler;
-...
      * @author leinfelder
+     *
      */
     public class MNResourceHandler extends D1ResourceHandler{
     public class MNResourceHandler extends D1ResourceHandler {
         // MN-specific API Resources
         protected static final String RESOURCE_MONITOR = "monitor";
-...
                             getReplica(extra);
                             status = true;
+                        }
                     } else if (resource.startsWith(RESOURCE_QUERY)) {
     	                logMetacat.debug("Using resource " + RESOURCE_QUERY);
     	                // after the command
     	                extra = parseTrailing(resource, RESOURCE_QUERY);
     	                logMetacat.debug("query extra: " + extra);
     	                String engine = null;
     	                String query = null;
     	                if (extra != null) {
     		                // get the engine
     		                int engineIndex = extra.length();
     		                if (extra.indexOf("/") > -1) {
     		                	engineIndex = extra.indexOf("/");
+    		                }
     		                engine = extra.substring(0, engineIndex);
     		                logMetacat.debug("query engine: " + engine);
     		                // get the query if it is there
     		                query = extra.substring(engineIndex, extra.length());
     		                if (query != null && query.length() == 0) {
     		                	query = null;
     		                } else {
     		                	if (query.startsWith("/")) {
     		                		query = query.substring(1);
+    		                    }
+    		                }
     		                logMetacat.debug("query: " + query);
+    	                }
     	                logMetacat.debug("verb:" + httpVerb);
     	                if (httpVerb == GET) {
     	                    doQuery(engine, query);
     	                    status = true;
+    	                }
+                    }
                     if (!status) {
-...
+        }
         private void doQuery(String engine, String query) {
     		OutputStream out = null;
         	try {
         		// NOTE: we set the session explicitly for the MNode instance since these methods do not provide a parameter
     	    	if (engine == null) {
     	    		// just looking for list of engines
     	    		MNodeService mnode = MNodeService.getInstance(request);
         			mnode.setSession(session);
     	    		QueryEngineList qel = mnode.listQueryEngines();
     	    		response.setContentType("text/xml");
     	            response.setStatus(200);
     	            out = response.getOutputStream();
     	            TypeMarshaller.marshalTypeToOutputStream(qel, out);
     	            return;
     	    	} else {
     	    		if (query != null) {
     	    			MNodeService mnode = MNodeService.getInstance(request);
     	    			mnode.setSession(session);
     	    			InputStream stream = mnode.query(engine, query);
     	    			//response.setContentType("application/octet-stream");
     	    			response.setContentType("text/xml");
     	                response.setStatus(200);
     	                out = response.getOutputStream();
     	                // write the results to the output stream
     	                IOUtils.copyLarge(stream, out);
     	                return;
     	    		} else {
     	    			MNodeService mnode = MNodeService.getInstance(request);
     	    			mnode.setSession(session);
     	    			QueryEngineDescription qed = mnode.getQueryEngineDescription(engine);
     	    			response.setContentType("text/xml");
     		            response.setStatus(200);
     		            out = response.getOutputStream();
     		            TypeMarshaller.marshalTypeToOutputStream(qed, out);
     		            return;
+    	    		}
+    	    	}
         	} catch (BaseException be) {
             	// report Exceptions as clearly as possible
     			try {
     				out = response.getOutputStream();
     			} catch (IOException e) {
     				logMetacat.error("Could not get output stream from response", e);
+    			}
                 serializeException(be, out);
             } catch (Exception e) {
                 // report Exceptions as clearly and generically as possible
                 logMetacat.error(e.getClass() + ": " + e.getMessage(), e);
     			try {
     				out = response.getOutputStream();
     			} catch (IOException ioe) {
     				logMetacat.error("Could not get output stream from response", ioe);
+    			}
     			ServiceFailure se = new ServiceFailure("0000", e.getMessage());
                 serializeException(se, out);
+            }
+        }
         /**
          * Handles notification of system metadata changes for the given identifier
+         *
-...
+        }
         /**
          * Implements REST version of DataONE CRUD API --> get
          * @param pid ID of data object to be read

         protected static final String RESOURCE_META = "meta";
         protected static final String RESOURCE_LOG = "log";
         protected static final String RESOURCE_QUERY = "query";
         protected static final String RESOURCE_IS_AUTHORIZED = "isAuthorized";
         protected static final String RESOURCE_ACCESS_RULES = "accessRules";

                 response.setContentType("text/xml");
+            }
             createResultDocument(xmlquery, qspec, out, user, groups, useXMLIndex,
               pagesize, pagestart, sessionid, qformat);
               pagesize, pagestart, sessionid, qformat, false);
           }//if
           else
+          {
-...
             Writer nonout = null;
             StringBuffer xml = createResultDocument(xmlquery, qspec, nonout, user,
                                                     groups, useXMLIndex, pagesize,
                                                     pagestart, sessionid, qformat);
                                                     pagestart, sessionid, qformat, false);
             //transfer the xml to html
             try
-...
+      }
       /**
        * Transforms a hashtable of documents to an xml or html result and sent
        * the content to outputstream. Keep going untill hastable is empty. stop it.
-...
                                                   String user, String[] groups,
                                                   boolean useXMLIndex)
+        {
         	return createResultDocument(xmlquery,qspec,out, user,groups, useXMLIndex, 0, 0,"", qformat);
         	return createResultDocument(xmlquery,qspec,out, user,groups, useXMLIndex, 0, 0,"", qformat, false);
+        }
         /**
+         *
          * @param xmlquery
          * @param user
          * @param groups
          * @param useXMLIndex
          * @return
          * @throws IOException
          * @throws PropertyNotFoundException
          */
     	public String performPathquery(String xmlquery, String user,
     			String[] groups) throws PropertyNotFoundException, IOException {
     		// get the XML query and convert it to query specification
     		xmlquery = transformQuery(xmlquery);
     		QuerySpecification qspec = new QuerySpecification(xmlquery, parserName, PropertyService.getProperty("document.accNumSeparator"));
     		// force it to output the results to the string buffer, not outputstream
     		Writer nonout = null;
     		boolean useXMLIndex = (new Boolean(PropertyService.getProperty("database.usexmlindex"))).booleanValue();
     		StringBuffer xml = createResultDocument(xmlquery, qspec, nonout, user, groups, useXMLIndex, 0, 0, "", qformat, true);
     		return xml.toString();
+    	}
       /*
        * Transforms a hashtable of documents to an xml or html result and sent
        * the content to outputstream. Keep going untill hastable is empty. stop it.
-...
                                                 String user, String[] groups,
                                                 boolean useXMLIndex, int pagesize,
                                                 int pagestart, String sessionid,
                                                 String qformat)
                                                 String qformat, boolean includeGuid)
+      {
         DBConnection dbconn = null;
         int serialNumber = -1;
-...
             	logMetacat.debug("DBQuery.createResultDocument - Not in map query");
             	resultContent = findResultDoclist(qspec, out, user, groups,
                         dbconn, useXMLIndex, pagesize, pagestart,
                         sessionid, givenDocids, qformat);
                         sessionid, givenDocids, qformat, includeGuid);
+            }
             else
+            {
-...
             		givenDocids = (Vector)docidOverride.elementAt(i);
             		StringBuffer subset = findResultDoclist(qspec, out, user, groups,
                             dbconn, useXMLIndex, pagesize, pagestart,
                             sessionid, givenDocids, qformat);
                             sessionid, givenDocids, qformat, includeGuid);
             		resultContent.append(subset);
+            	}
+            }
-...
                                           String user, String[]groups,
                                           DBConnection dbconn, boolean useXMLIndex,
                                           int pagesize, int pagestart, String sessionid,
                                           Vector givenDocids, String qformat)
                                           Vector givenDocids, String qformat, boolean includeGuid)
                                           throws Exception
+        {
         	// keep track of the values we add as prepared statement question marks (?)
-...
           ResultDocumentSet docListResult = new ResultDocumentSet();
           PreparedStatement pstmt = null;
           String docid = null;
           String guid = null;
           String docname = null;
           String doctype = null;
           String createDate = null;
-...
         	  // include the docids, either exclusively, or in conjuction with the query
         	  if (operator == null) {
         		  query = "SELECT xml_documents.docid, docname, doctype, date_created, date_updated, xml_documents.rev " +
         		  query = "SELECT xml_documents.docid, identifier.guid, docname, doctype, date_created, date_updated, xml_documents.rev " +
         		  		"FROM xml_documents, identifier " +
         		  		"WHERE xml_documents.docid = identifier.docid AND xml_documents.rev = identifier.rev AND ";
                   query = query + docidCondition.toString();
-...
+          {
             logMetacat.debug("DBQuery.findResultDoclist - getting result: " + currentIndex);
             docid = rs.getString(1).trim();
             logMetacat.debug("DBQuery.findResultDoclist -  processing: " + docid);
             docname = rs.getString(2);
             doctype = rs.getString(3);
             logMetacat.debug("DBQuery.findResultDoclist - processing: " + doctype);
             createDate = rs.getString(4);
             updateDate = rs.getString(5);
             rev = rs.getInt(6);
             logMetacat.debug("DBQuery.findResultDoclist -  docid: " + docid);
             guid = rs.getString(2).trim();
             logMetacat.debug("DBQuery.findResultDoclist -  guid: " + guid);
             docname = rs.getString(3);
             doctype = rs.getString(4);
             logMetacat.debug("DBQuery.findResultDoclist - doctype: " + doctype);
             createDate = rs.getString(5);
             updateDate = rs.getString(6);
             rev = rs.getInt(7);
              Vector returndocVec = qspec.getReturnDocList();
            if (returndocVec.size() == 0 || returndocVec.contains(doctype))
-...
                                 + PropertyService.getProperty("document.accNumSeparator");
                completeDocid += rev;
                document.append("<docid>").append(completeDocid).append("</docid>");
                if (includeGuid) {
             	   document.append("<guid>").append(guid).append("</guid>");
+               }
                if (docname != null)
+               {
                    document.append("<docname>" + docname + "</docname>");

     package edu.ucsb.nceas.metacat.dataone;
     import java.io.ByteArrayInputStream;
     import java.io.IOException;
     import java.io.InputStream;
     import java.math.BigInteger;
     import java.security.NoSuchAlgorithmException;
     import java.sql.SQLException;
     import java.util.ArrayList;
     import java.util.Calendar;
     import java.util.Date;
     import java.util.List;
     import java.util.Set;
     import java.util.Timer;
     import javax.servlet.http.HttpServletRequest;
-...
     import org.dataone.service.mn.tier2.v1.MNAuthorization;
     import org.dataone.service.mn.tier3.v1.MNStorage;
     import org.dataone.service.mn.tier4.v1.MNReplication;
     import org.dataone.service.mn.v1.MNQuery;
     import org.dataone.service.types.v1.Checksum;
     import org.dataone.service.types.v1.DescribeResponse;
     import org.dataone.service.types.v1.Event;
     import org.dataone.service.types.v1.Group;
     import org.dataone.service.types.v1.Identifier;
     import org.dataone.service.types.v1.Log;
     import org.dataone.service.types.v1.LogEntry;
-...
     import org.dataone.service.types.v1.Subject;
     import org.dataone.service.types.v1.Synchronization;
     import org.dataone.service.types.v1.SystemMetadata;
     import org.dataone.service.types.v1.util.AuthUtils;
     import org.dataone.service.types.v1.util.ChecksumUtil;
     import org.dataone.service.types.v1_1.QueryEngineDescription;
     import org.dataone.service.types.v1_1.QueryEngineList;
     import org.dataone.service.util.Constants;
     import edu.ucsb.nceas.metacat.DocumentImpl;
     import edu.ucsb.nceas.metacat.DBQuery;
     import edu.ucsb.nceas.metacat.EventLog;
     import edu.ucsb.nceas.metacat.IdentifierManager;
     import edu.ucsb.nceas.metacat.McdbDocNotFoundException;
     import edu.ucsb.nceas.metacat.MetaCatServlet;
     import edu.ucsb.nceas.metacat.MetacatHandler;
     import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;
     import edu.ucsb.nceas.metacat.dataone.hazelcast.HazelcastService;
     import edu.ucsb.nceas.metacat.properties.PropertyService;
     import edu.ucsb.nceas.metacat.util.SystemUtil;
-...
+     *
      */
     public class MNodeService extends D1NodeService
         implements MNAuthorization, MNCore, MNRead, MNReplication, MNStorage {
         implements MNAuthorization, MNCore, MNRead, MNReplication, MNStorage, MNQuery {
         /* the logger instance */
         private Logger logMetacat = null;
-...
     		return update(null, pid, object, newPid, sysmeta);
+    	}
     	@Override
     	public QueryEngineDescription getQueryEngineDescription(String engine)
     			throws InvalidToken, ServiceFailure, NotAuthorized, NotImplemented,
     			NotFound {
     		// TODO: implement
     		throw new NotImplemented("", "Metacat has not implemented this method");
+    	}
     	@Override
     	public QueryEngineList listQueryEngines() throws InvalidToken,
     			ServiceFailure, NotAuthorized, NotImplemented {
     		QueryEngineList qel = new QueryEngineList();
     		// support pathquery initially
     		qel.addQueryEngine("pathquery");
     		// TODO: implement solr-based query
     		//qel.addQueryEngine("solr");
     		return qel;
+    	}
     	@Override
     	public InputStream query(String engine, String query) throws InvalidToken,
     			ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented,
     			NotFound {
     		if (engine.equals("pathquery")) {
     			try {
     				DBQuery queryobj = new DBQuery();
     				String user = Constants.SUBJECT_PUBLIC;
     				String[] groups= null;
     				if (session != null) {
     					user = session.getSubject().getValue();
     					Set<Subject> subjects = AuthUtils.authorizedClientSubjects(session);
     					if (subjects != null) {
     						List<String> groupList = new ArrayList<String>();
     						for (Subject subject: subjects) {
     							groupList.add(subject.getValue());
+    						}
     						groups = groupList.toArray(new String[0]);
+    					}
+    				}
     				String results = queryobj.performPathquery(query, user, groups);
     				return new ByteArrayInputStream(results.getBytes(MetaCatServlet.DEFAULT_ENCODING));
     			} catch (Exception e) {
+    			}
+    		}
     		return null;
+    	}
+    }

       /* parameters set in the incoming request */
       private Hashtable<String, String[]> params;
       /**
        * out-of-band session object to be used when not passed in as a method parameter
        */
       protected Session session;
       /**
        * Constructor - used to set the metacatUrl from a subclass extending D1NodeService
-...
       public D1NodeService(HttpServletRequest request) {
     		this.request = request;
+    	}
       /**
        * retrieve the out-of-band session
        * @return
        */
       	public Session getSession() {
     		return session;
+    	}
       	/**
       	 * Set the out-of-band session
       	 * @param session
       	 */
     	public void setSession(Session session) {
     		this.session = session;
+    	}
       /**
        * This method provides a lighter weight mechanism than
        * getSystemMetadata() for a client to determine basic
        * properties of the referenced object.

Project

General

Profile

Metacat

Revision 7417

Added by ben leinfelder about 12 years ago