/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 6282

Added by ben leinfelder over 13 years ago

route all /d1/cn/* traffic through the CNRestServlet/Handler -- inspect the pathInfo when deciding what action to take and also strip off any extra parts (like pid).
include query() method pass-through to CNodeService

     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/*</url-pattern>
     	</servlet-mapping>
     	<!-- CNCore-->
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/object/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/formats/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/log/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/reserve/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/meta/*</url-pattern>
     	</servlet-mapping>
     	<!-- CNRead-->
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/resolve/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/assertRelation/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/checksum/*</url-pattern>
     	</servlet-mapping>
     	<!-- CNAuthorization -->
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/owner/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/isAuthorized/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/accessRules/*</url-pattern>
     	</servlet-mapping>
     	<!-- CNReplication -->
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/notify/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/meta/replication/*</url-pattern>
     	</servlet-mapping>
     	<servlet-mapping>
     		<servlet-name>CNRestServlet</servlet-name>
     		<url-pattern>/d1/cn/meta/policy/*</url-pattern>
     	</servlet-mapping>
     	<!-- MN REST services -->
     	<servlet-mapping>

     import java.io.IOException;
     import java.io.InputStream;
     import java.io.OutputStream;
     import java.io.PrintWriter;
     import java.io.UnsupportedEncodingException;
     import java.util.Date;
     import java.util.Map;
-...
     import org.dataone.service.types.ObjectFormatList;
     import org.dataone.service.types.ObjectLocationList;
     import org.dataone.service.types.Permission;
     import org.dataone.service.types.QueryType;
     import org.dataone.service.types.Subject;
     import org.dataone.service.types.SystemMetadata;
     import org.jibx.runtime.JiBXException;
-...
         	super.handle(httpVerb);
             try {
                 //substring off the "d1/cn/" part of the url
             	String resourcePrefix = RESOURCE_BASE_URL + "/cn/";
                 String resource = request.getServletPath();
                 resource = resource.substring(resource.indexOf(resourcePrefix) + resourcePrefix.length());
                 resource = resource.trim();
             	// get the resource
                 String resource = request.getPathInfo();
                 resource = resource.substring(resource.indexOf("/") + 1);
                 // get the rest
                 String extra = null;
                 if (resource.lastIndexOf("/") != -1) {
                     extra = resource.substring(resource.lastIndexOf("/") + 1);
+                }
                 logMetacat.debug("handling verb " + httpVerb + " request with resource '" + resource + "'");
                 boolean status = false;
                 if (resource != null) {
                     if (resource.equals(RESOURCE_ACCESS_RULES) && httpVerb == PUT) {
                     if (resource.startsWith(RESOURCE_ACCESS_RULES) && httpVerb == PUT) {
                         logMetacat.debug("Setting access policy");
                         setAccess();
                         status = true;
                         logMetacat.debug("done setting access");
                     } else if (resource.equals(RESOURCE_META)) {
                     } else if (resource.startsWith(RESOURCE_META)) {
                         logMetacat.debug("Using resource: " + RESOURCE_META);
                         String objectId = request.getPathInfo();
                         if (objectId != null && objectId.length() > 1) {
                             objectId = request.getPathInfo().substring(1);
+                        }
                         // get
                         if (httpVerb == GET) {
                             getSystemMetadataObject(objectId);
                             getSystemMetadataObject(extra);
                             status = true;
+                        }
                         // post to register system metadata
                         if (httpVerb == POST) {
                         	registerSystemMetadata(objectId);
                         	registerSystemMetadata(extra);
                         	status = true;
+                        }
                     } else if (resource.equals(RESOURCE_RESERVE)) {
                     } else if (resource.startsWith(RESOURCE_RESERVE)) {
                         // reserve the ID (in params)
                         if (httpVerb == POST) {
                         	reserve();
                         	status = true;
+                        }
                     } else if (resource.equals(RESOURCE_ASSERT_RELATION)) {
                     	String objectId = request.getPathInfo();
                         if (objectId != null && objectId.length() > 1) {
                             objectId = request.getPathInfo().substring(1);
+                        }
                     } else if (resource.startsWith(RESOURCE_ASSERT_RELATION)) {
                         // reserve the ID (in params)
                         if (httpVerb == GET) {
                         	assertRelation(objectId);
                         	assertRelation(extra);
                         	status = true;
+                        }
                     } else if (resource.equals(RESOURCE_RESOLVE)) {
                     	String objectId = request.getPathInfo();
                         if (objectId != null && objectId.length() > 1) {
                             objectId = request.getPathInfo().substring(1);
+                        }
                     } else if (resource.startsWith(RESOURCE_RESOLVE)) {
                         // resolve the object location
                         if (httpVerb == GET) {
                         	resolve(objectId);
                         	resolve(extra);
                         	status = true;
+                        }
                     } else if (resource.equals(RESOURCE_OWNER)) {
                     	String objectId = request.getPathInfo();
                         if (objectId != null && objectId.length() > 1) {
                             objectId = request.getPathInfo().substring(1);
+                        }
                     } else if (resource.startsWith(RESOURCE_OWNER)) {
                         // set the owner
                         if (httpVerb == PUT) {
                         	owner(objectId);
                         	owner(extra);
                         	status = true;
+                        }
                     } else if (resource.equals(RESOURCE_OWNER)) {
                     	String objectId = request.getPathInfo();
                         if (objectId != null && objectId.length() > 1) {
                             objectId = request.getPathInfo().substring(1);
+                        }
                     } else if (resource.startsWith(RESOURCE_OWNER)) {
                         // set the owner
                         if (httpVerb == PUT) {
                         	owner(objectId);
                         	owner(extra);
                         	status = true;
+                        }
                     } else if (resource.equals(RESOURCE_IS_AUTHORIZED)) {
                     	String objectId = request.getPathInfo();
                         if (objectId != null && objectId.length() > 1) {
                             objectId = request.getPathInfo().substring(1);
+                        }
                     } else if (resource.startsWith(RESOURCE_IS_AUTHORIZED)) {
                         // authorized?
                         if (httpVerb == GET) {
                         	isAuthorized(objectId);
                         	isAuthorized(extra);
                         	status = true;
+                        }
                     } else if (resource.equals(RESOURCE_OBJECTS)) {
                     } else if (resource.startsWith(RESOURCE_OBJECTS)) {
                         logMetacat.debug("Using resource 'object'");
                         logMetacat.debug("D1 Rest: Starting resource processing...");
                         String objectId = request.getPathInfo();
                         if (objectId != null && objectId.length() > 1) {
                             objectId = request.getPathInfo().substring(1);
+                        }
                         else {
                             objectId = null;
+                        }
                         logMetacat.debug("objectId: " + objectId);
                         logMetacat.debug("objectId: " + extra);
                         logMetacat.debug("verb:" + httpVerb);
                         if (httpVerb == GET) {
                             getObject(objectId);
                         	if (extra != null) {
                         		getObject(extra);
                         	} else {
                         		query();
+                        	}
                             status = true;
                         } else if (httpVerb == POST) {
                             putObject(objectId, FUNCTION_NAME_INSERT);
                             putObject(extra, FUNCTION_NAME_INSERT);
                             status = true;
+                        }
                     } else if (resource.equals(RESOURCE_FORMATS)) {
                     } else if (resource.startsWith(RESOURCE_FORMATS)) {
                       logMetacat.debug("Using resource: " + RESOURCE_FORMATS);
                       // check for a format identifier
                       String fmtid = request.getPathInfo();
                       if (fmtid != null && fmtid.length() > 1 ) {
                       	fmtid = request.getPathInfo().substring(1);
                       } else {
                       	fmtid = null;
+                      }
                       // handle each verb
                       if (httpVerb == GET) {
                       	if (fmtid == null) {
                       	if (extra == null) {
                       		// list the formats collection
                       		listFormats();
                       	} else {
                       		// get the specified format
                       		getFormat(fmtid);
                       		getFormat(extra);
+                      	}
                       	status = true;
+                      }
                     } else if (resource.equals(RESOURCE_LOG)) {
                     } else if (resource.startsWith(RESOURCE_LOG)) {
                         logMetacat.debug("Using resource: " + RESOURCE_LOG);
                         //handle log events
                         if (httpVerb == GET) {
-...
                             status = true;
+                        }
                     } else if (resource.equals(RESOURCE_CHECKSUM)) {
                     } else if (resource.startsWith(RESOURCE_CHECKSUM)) {
                         logMetacat.debug("Using resource: " + RESOURCE_CHECKSUM);
                         //handle checksum requests
                         if (httpVerb == GET) {
                             String guid = request.getPathInfo();
                             if (guid != null && guid.length() > 1) {
                                 guid = request.getPathInfo().substring(1); //trim the slash
+                            }
                             checksum(guid);
                             checksum(extra);
                             status = true;
+                        }
+                    }
-...
+        }
         /**
          * Earthgrid API > Query Service > Query Function : translates ecogrid query document to metacat query
          * then calls DBQuery > createResultDocument function and then again translate resultset to ecogrid resultset
+         *
          * NOTE:
          *      This is the only method that uses EcoGrid classes for its implementation.
          *      It does so because it takes an EcoGrid Query as input, and outputs an
          *      EcoGrid ResultSet document.  These documents are parsed by the auto-generated
          *      EcoGrid classes from axis, and so we link to them here rather than re-inventing them.
          *      This creates a circular dependency, because the Metacat classes are needed
          *      to build the EcoGrid implementation, and the EcoGrid jars are needed to build this query()
          *      method.  This circularity could be resolved by moving the EcoGrid classes
          *      to Metacat directly.  As we transition away from EcoGrid SOAP methods in
          *      favor of these REST interfaces, this circular dependency can be eliminated.
+         *
          *	Pass to the CN search service
+         *
          * @throws NotImplemented
          * @throws InvalidRequest
          * @throws NotAuthorized
          * @throws ServiceFailure
          * @throws InvalidToken
          * @throws Exception
          */
         private void query() throws Exception {
             /*  This block commented out because of the EcoGrid circular dependency.
              *  For now, query will not be supported until the circularity can be
              *  resolved, probably by moving the ecogrid query syntax transformers
              *  directly into the Metacat codebase.  MBJ 2010-02-03
             try {
                 EcogridQueryParser parser = new EcogridQueryParser(request
                         .getReader());
                 parser.parseXML();
                 QueryType queryType = parser.getEcogridQuery();
                 EcogridJavaToMetacatJavaQueryTransformer queryTransformer =
                     new EcogridJavaToMetacatJavaQueryTransformer();
                 QuerySpecification metacatQuery = queryTransformer
                         .transform(queryType);
                 DBQuery metacat = new DBQuery();
                 boolean useXMLIndex = (new Boolean(PropertyService
                         .getProperty("database.usexmlindex"))).booleanValue();
                 String xmlquery = "query"; // we don't care the query in resultset,
                 // the query can be anything
                 PrintWriter out = null; // we don't want metacat result, so set out null
                 // parameter: queryspecification, user, group, usingIndexOrNot
                 StringBuffer result = metacat.createResultDocument(xmlquery,
                         metacatQuery, out, username, groupNames, useXMLIndex);
                 // create result set transfer
                 String saxparser = PropertyService.getProperty("xml.saxparser");
                 MetacatResultsetParser metacatResultsetParser = new MetacatResultsetParser(
                         new StringReader(result.toString()), saxparser, queryType
                                 .getNamespace().get_value());
                 ResultsetType records = metacatResultsetParser.getEcogridResult();
                 System.out
                         .println(EcogridResultsetTransformer.toXMLString(records));
                 response.setContentType("text/xml");
                 out = response.getWriter();
                 out.print(EcogridResultsetTransformer.toXMLString(records));
             } catch (Exception e) {
                 e.printStackTrace();
             }*/
             response.setContentType("text/xml");
             response.setStatus(501);
             PrintWriter out = response.getWriter();
             out.print("<error>Query operation not yet supported by Metacat.</error>");
             out.close();
         private void query() throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest, NotImplemented {
         	String query = null;
     		QueryType queryType = null;
     		try {
     			query = params.get("query")[0];
     		} catch (Exception e) {
     			logMetacat.warn("query not specified");
+    		}
     		try {
     			String qt = params.get("queryType")[0];
     			queryType = QueryType.valueOf(qt);
     		} catch (Exception e) {
     			logMetacat.warn("queryType not specified");
+    		}
         	// expecting to throw NotImplemented
     		CNodeService.getInstance().search(session, queryType, query);
+        }
+    }

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 6282

Added by ben leinfelder over 13 years ago