/ - Diff - Metacat - Ecoinformatics Redmine

     import java.util.*;
     import java.io.*;
     import java.security.MessageDigest;
     import edu.ucsb.nceas.MCTestCase;
     import edu.ucsb.nceas.metacat.client.MetacatAuthException;
     import edu.ucsb.nceas.metacat.client.MetacatException;
-...
     import junit.framework.Test;
     import junit.framework.TestSuite;
     import org.dataone.service.types.*;
     import edu.ucsb.nceas.metacat.properties.PropertyService;
     import edu.ucsb.nceas.metacat.client.rest.MetacatRestClient;
     import edu.ucsb.nceas.metacat.service.SessionService;
     import edu.ucsb.nceas.metacat.util.SessionData;
     /**
      * A JUnit test for testing the dataone CrudService class
      */
-...
+    	{
     		TestSuite suite = new TestSuite();
     		suite.addTest(new CrudServiceTest("initialize"));
     		suite.addTest(new CrudServiceTest("testSingletonAccessor"));
     		suite.addTest(new CrudServiceTest("testCreate"));
     		//suite.addTest(new CrudServiceTest(""));
     		//suite.addTest(new CrudServiceTest(""));
     		//suite.addTest(new CrudServiceTest(""));
     		//suite.addTest(new CrudServiceTest(""));
     		//suite.addTest(new CrudServiceTest(""));
     		return suite;
+    	}
     	/**
     	 * create(AuthToken token, Identifier guid, InputStream object, SystemMetadata sysmeta)
          *   throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType,
          *       InsufficientResources, InvalidSystemMetadata, NotImplemented
     	 */
     	public void testCreate()
+    	{
     	    try
+    	    {
                 CrudService cs = CrudService.getInstance();
                 //login and get a sessionid
                 System.out.println("creating MetacatRestClient with url " + cs.getContextUrl());
                 MetacatRestClient restClient = new MetacatRestClient(cs.getContextUrl());
                 String username = PropertyService.getProperty("test.mcUser");
     			String password = PropertyService.getProperty("test.mcPassword");
     			System.out.println("logging in with username: " + username + " and password " + password + " to context " + cs.getContextUrl());
     			String response = restClient.login(username, password);
     			//System.out.println("response to login: " + response);
     			String sessionid = restClient.getSessionId();
     			SessionService sessionService = SessionService.getInstance();
     			sessionService.registerSession(new SessionData(sessionid, username, new String[0], password, "CrudServiceLogin"));
     			System.out.println("sessionid: " + sessionid);
     			AuthToken token = new AuthToken(sessionid);
                 String s = "<?xml version=\"1.0\"?><test></test>\n";
                 //create the system metadata then run the create method
                 StringBufferInputStream sbis = new StringBufferInputStream(s);
                 String docid = generateDocumentId();
                 String smdocid = generateDocumentId();
                 Identifier id = new Identifier();
                 id.setValue(docid);
                 SystemMetadata sm = new SystemMetadata();
                 //set the id
                 sm.setIdentifier(id);
                 System.out.println("sm id is " + id);
                 sm.setObjectFormat(ObjectFormat.convert("eml://ecoinformatics.org/eml-2.1.0"));
                 System.out.println("sm objectformat: " + sm.getObjectFormat());
                 //create the checksum
                 String checksumS = checksum(s);
                 ChecksumAlgorithm ca = ChecksumAlgorithm.convert("MD5");
                 Checksum checksum = new Checksum();
                 checksum.setValue(checksumS);
                 checksum.setAlgorithm(ca);
                 sm.setChecksum(checksum);
                 System.out.println("sm checksum is " + checksumS);
                 //set the size
                 sm.setSize(s.getBytes().length);
                 System.out.println("sm size: " + s.getBytes().length);
                 //submitter
                 Principal p = new Principal();
                 p.setValue("joe");
                 sm.setSubmitter(p);
                 sm.setRightsHolder(p);
                 sm.setDateUploaded(new Date());
                 sm.setDateSysMetadataModified(new Date());
                 NodeReference nr = new NodeReference();
                 nr.setValue("metacat");
                 sm.setOriginMemberNode(nr);
                 sm.setAuthoritativeMemberNode(nr);
                 cs.create(token, id, sbis, sm);
+            }
             catch(Exception e)
+            {
                 e.printStackTrace();
                 fail("Error in testCreate: " + e.getMessage());
+            }
+    	}
     	/**
     	 * getInstance()
     	 */
     	public void testSingletonAccessor()
+    	{
     	    CrudService cs = CrudService.getInstance();
     	    assertNotNull(cs);
+    	}
     	/**
     	 * Run an initial test that always passes to check that the test harness is
     	 * working.
     	 */
-...
     		assertTrue(1 == 1);
+    	}
     	/**
     	 * produce an md5 checksum for item
     	 */
     	private String checksum(String item)
     	  throws Exception
+    	{
             StringBufferInputStream fis =  new StringBufferInputStream(item);
             byte[] buffer = new byte[1024];
             MessageDigest complete = MessageDigest.getInstance("MD5");
             int numRead;
             do
+            {
               numRead = fis.read(buffer);
               if (numRead > 0)
+              {
                 complete.update(buffer, 0, numRead);
+              }
             } while (numRead != -1);
             return getHex(complete.digest());
+    	}
     	/**
     	 * convert a byte array to a hex string
     	 */
     	private static String getHex( byte [] raw )
+    	{
     	    final String HEXES = "0123456789ABCDEF";
             if ( raw == null ) {
               return null;
+            }
             final StringBuilder hex = new StringBuilder( 2 * raw.length );
             for ( final byte b : raw ) {
               hex.append(HEXES.charAt((b & 0xF0) >> 4))
                  .append(HEXES.charAt((b & 0x0F)));
+            }
             return hex.toString();
+        }
+    }

test/edu/ucsb/nceas/metacattest/restservice/MetacatRestClientTest.java
84	84	*/
85	85	public void setUp()
86	86	{
	87	System.out.println("contextUrl: " + contextUrl);
87	88	m = new MetacatRestClient(contextUrl);
88	89	}
89	90

                     initParams();
                     Timer timer = new Timer();
                     handler = new MetacatHandler(servletContext, timer);
                     handler = new MetacatHandler(timer);
                     if (resource.equals(RESOURCE_SESSION) && httpVerb == POST
                             && params.get(FUNCTION_KEYWORD) != null) {
-...
          */
         private void getObject(String guid) {
           //hack...fix this
             CrudService cs = new CrudService(servletContext, request, response);
             //CrudService cs = new CrudService(servletContext, request, response);
             CrudService cs = CrudService.getInstance();
             cs.setParamsFromRequest(request);
             AuthToken token = null;
             OutputStream out = null;
             try {
-...
          * @param guid ID of data object to be read
          */
         private void getSystemMetadataObject(String guid) {
             CrudService cs = new CrudService(servletContext, request, response);
             //CrudService cs = new CrudService(servletContext, request, response);
             CrudService cs = CrudService.getInstance();
             cs.setParamsFromRequest(request);
             AuthToken token = null;
             OutputStream out = null;
             try {
-...
                         IUnmarshallingContext uctx = bfact.createUnmarshallingContext();
                         SystemMetadata m = (SystemMetadata) uctx.unmarshalDocument(sysmeta, null);
                         CrudService cs = new CrudService(servletContext, request, response);
                         //CrudService cs = new CrudService(servletContext, request, response);
                         CrudService cs = CrudService.getInstance();
                         cs.setParamsFromRequest(request);
                         Identifier id = new Identifier();
                         id.setValue(guid);
                         cs.create(token, id, object, m);

     			SessionService.unRegisterAllSessions();
     	         //Initialize Metacat Handler
                 handler = new MetacatHandler(getServletContext(), timer);
                 handler = new MetacatHandler(timer);
     			handler.set_sitemapScheduled(false);

                         // write to xml_node complete. start the indexing thread.
                         addDocidToIndexingQueue(docid, rev);
                    } catch (Exception e) {
                        e.printStackTrace();
                 	   logMetacat.error("DocumentImpl.write - Problem with parsing: " + e.getMessage());
                         conn.rollback();
                         conn.setAutoCommit(true);
-...
                         Vector<XMLSchema> schemaList = XMLSchemaService.findSchemasInXML((StringReader)xml);
                         boolean allSchemasRegistered =
                         	XMLSchemaService.areAllSchemasRegistered(schemaList);
                         System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!are all schemas registered: " + allSchemasRegistered);
                         if (XMLSchemaService.useFullSchemaValidation() && !allSchemasRegistered) {
                             System.out.println("setting full schema validation");
                         	parser.setFeature(FULLSCHEMAVALIDATIONFEATURE, true);
+                        }
                         // From DB to find the register external schema location
                         String externalSchemaLocation = null;
                         externalSchemaLocation = XMLSchemaService.getNameSpaceAndLocationString();
                         System.out.println("external schema location: " + externalSchemaLocation);
                         logMetacat.debug("DocumentImpl.initalizeParser - Generic external schema location: " + externalSchemaLocation);
                         // Set external schemalocation.
                         if (externalSchemaLocation != null
                                 && !(externalSchemaLocation.trim()).equals("")) {
                         System.out.println("setting external schema location to " + externalSchemaLocation);
                             parser.setProperty(EXTERNALSCHEMALOCATIONPROPERTY,
                                     externalSchemaLocation);
+                        }

     import javax.servlet.http.HttpServletRequest;
     import javax.servlet.http.HttpServletResponse;
     import javax.servlet.http.HttpSession;
     import javax.activation.MimetypesFileTypeMap;
     import org.apache.log4j.Logger;
     import org.ecoinformatics.eml.EMLParser;
-...
         private static final String ERROR = "<error>";
         private static final String ERRORCLOSE = "</error>";
         private ServletContext servletContext;
     	private Timer timer;
         public MetacatHandler(ServletContext servletContext, Timer timer) {
         	this.servletContext = servletContext;
         public MetacatHandler(Timer timer) {
         	this.timer = timer;
+        }
-...
                     if (response != null) {
                         // MIME type
                         String contentType = servletContext.getMimeType(filename);
                         //String contentType = servletContext.getMimeType(filename);
                         String contentType = (new MimetypesFileTypeMap()).getContentType(filename);
                         if (contentType == null) {
                             ContentTypeProvider provider = new ContentTypeProvider(
                                     docid);
-...
         private void readFromURLConnection(HttpServletResponse response,
                 String docid) throws IOException, MalformedURLException {
             ServletOutputStream out = response.getOutputStream();
             String contentType = servletContext.getMimeType(docid); //MIME type
             //String contentType = servletContext.getMimeType(docid); //MIME type
             String contentType = (new MimetypesFileTypeMap()).getContentType(docid);
             if (contentType == null) {
                 if (docid.endsWith(".xml")) {
                     contentType = "text/xml";
-...
          * Handle the database putdocument request and write an XML document to the
          * database connection
          */
         public void handleInsertOrUpdateAction(String ipAddress,
         public String handleInsertOrUpdateAction(String ipAddress,
                 HttpServletResponse response, PrintWriter out, Hashtable<String, String[]> params,
                 String user, String[] groups) {
             Logger logMetacat = Logger.getLogger(MetaCatServlet.class);
-...
+            }
             if(params.get("docid") == null){
                 out.println("<?xml version=\"1.0\"?>");
                 out.println("<error>");
                 out.println("Docid not specified");
                 out.println("</error>");
                 logMetacat.error("MetaCatServlet.handleInsertOrUpdateAction - Docid not specified");
                 return;
                 String msg = "<?xml version=\"1.0\"?>" +
                     "<error>" +
                     "Docid not specified" +
                     "</error>";
                 if(out != null)
+                {
                     out.println(msg);
                     logMetacat.error("MetaCatServlet.handleInsertOrUpdateAction - Docid not specified");
+                }
                 return msg;
+            }
             try {
                 if (!AuthUtil.canInsertOrUpdate(user, groups)) {
                     out.println("<?xml version=\"1.0\"?>");
                     out.println("<error>");
                     out.println("User '" + user + "' not allowed to insert and update");
                     out.println("</error>");
                     String msg = "<?xml version=\"1.0\"?>" +
                     "<error>" +
                     "User '" + user + "' not allowed to insert and update" +
                     "</error>";
                     if(out != null)
+                    {
                       out.println(msg);
+                    }
                     logMetacat.error("MetaCatServlet.handleInsertOrUpdateAction - User '" + user + "' not allowed to insert and update");
                     return;
                     return msg;
+                }
             } catch (MetacatUtilException ue) {
                 logMetacat.error("MetaCatServlet.handleInsertOrUpdateAction - Could not determine if user could insert or update: "
-...
+                }
                 if(doctext == null){
                     out.println("<?xml version=\"1.0\"?>");
                     out.println("<error>");
                     out.println("Document text not submitted");
                     out.println("</error>");
                     String msg = "<?xml version=\"1.0\"?>" +
                     "<error>" +
                     "Document text not submitted." +
                     "</error>";
                     if(out != null)
+                    {
                       out.println(msg);
+                    }
                     // TODO: this should really throw an exception
                     return;
                     return msg;
+                }
                 logMetacat.debug("MetaCatServlet.handleInsertOrUpdateAction - the xml document in metacat servlet (before parsing):\n" + doctext[0]);
-...
+            }
             if (qformat == null || qformat.equals("xml")) {
                 response.setContentType("text/xml");
                 out.println(output);
                 if(response != null)
+                {
                   response.setContentType("text/xml");
                   out.println(output);
+                }
                 return output;
             } else {
                 try {
                     DBTransform trans = new DBTransform();
-...
                     e.printStackTrace(System.out);
+                }
+            }
             return null;
+        }
         /**

          */
     	public String login(String username, String password)
     	throws MetacatAuthException, MetacatInaccessibleException {
     		String urlParams = FUNCTION_KEYWORD+"="+FUNCTION_NAME_LOGIN;
     		System.out.println("in login");
     	    String urlParams = FUNCTION_KEYWORD+"="+FUNCTION_NAME_LOGIN;
     		String postData = "username="+username+"&password="+password;
     		String response = null;
     		try {
     			response = sendData(RESOURCE_SESSION, POST, urlParams, postData, "application/x-www-form-urlencoded", null, null);
-...
     		HttpURLConnection connection = null ;
     		String restURL = contextRootUrl+resource;
     		System.out.println("restURL: " + restURL);
     		if (urlParamaters != null) {
     			if (restURL.indexOf("?") == -1)

      */
     public class CrudService implements MemberNodeCrud {
         private ServletContext servletContext;
         /*private ServletContext servletContext;
         private HttpServletRequest request;
         private HttpServletResponse response;
         private HttpServletResponse response;*/
         private static CrudService crudService = null;
         private MetacatHandler handler;
         private Hashtable<String, String[]> params;
         Logger logMetacat = null;
         private String metacatUrl;
         /**
          * singleton accessor
          */
         public static CrudService getInstance()
+        {
           if(crudService == null)
+          {
             crudService = new CrudService();
+          }
           return crudService;
+        }
         /**
          * Initializes new instance by setting servlet context,request and response.
          * TODO: remove dependency on Servlet infrastructure
          * TODO: Make this a real service, and make it a Singleton
          */
         public CrudService(ServletContext servletContext,
                 HttpServletRequest request, HttpServletResponse response) {
         public CrudService() {
         //change crud service into a singleton.  dont pass servlet data structures here
             this.servletContext = servletContext;
             logMetacat = Logger.getLogger(CrudService.class);
             try
+            {
                 String server = PropertyService.getProperty("server.name");
                 String port = PropertyService.getProperty("server.httpPort");
                 String context = PropertyService.getProperty("application.context");
                 metacatUrl = "http://" + server + ":" + port + "/" + context;
                 logMetacat.debug("Initializing CrudService with url " + metacatUrl);
+            }
             catch(Exception e)
+            {
                 logMetacat.error("Could not find servlet url in CrudService: " + e.getMessage());
                 e.printStackTrace();
                 throw new RuntimeException("Error getting servlet url in CrudService: " + e.getMessage());
+            }
             /*this.servletContext = servletContext;
             this.request = request;
             this.response = response;
             logMetacat = Logger.getLogger(CrudService.class);
             this.response = response;*/
             params = new Hashtable<String, String[]>();
             handler = new MetacatHandler(this.servletContext, new Timer());
             initParams();
     //        loadSessionData();
             handler = new MetacatHandler(new Timer());
+        }
         /**
          *  copies request parameters to a Hashtable which is given as argument to
          *  native MetacatHandler functions
          * return the context url CrudService is using.
          */
         private void initParams() {
             String name = null;
             String[] value = null;
             params = new Hashtable<String, String[]>();
         public String getContextUrl()
+        {
             return metacatUrl;
+        }
         /**
          * set the params for this service from an HttpServletRequest param list
          */
         public void setParamsFromRequest(HttpServletRequest request)
+        {
             Enumeration paramlist = request.getParameterNames();
             while (paramlist.hasMoreElements()) {
                 name = (String) paramlist.nextElement();
                 value = request.getParameterValues(name);
                 String name = (String) paramlist.nextElement();
                 String[] value = (String[])request.getParameterValues(name);
                 params.put(name, value);
+            }
+        }
         /**
          * set the parameter values needed for this request
          */
         public void setParameter(String name, String[] value)
+        {
             params.put(name, value);
+        }
         public Identifier create(AuthToken token, Identifier guid,
                 InputStream object, SystemMetadata sysmeta) throws InvalidToken,
                 ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType,
                 InsufficientResources, InvalidSystemMetadata, NotImplemented {
             logMetacat.debug("Starting CrudService.create()...");
             System.out.println("sysmeta object format: " + sysmeta.getObjectFormat());
             // authenticate & get user info
             SessionData sessionData = getSessionData(token);
-...
                     public String produce(final OutputStream dataSink) throws Exception {
                         try {
                             handler.readFromMetacat(request.getRemoteAddr(), null,
                             handler.readFromMetacat(/*request.getRemoteAddr()*/metacatUrl, null,
                                     dataSink, localId, "xml",
                                     sessionData.getUserName(),
                                     sessionData.getGroupNames(), true, params);
-...
                     @Override
                     public String produce(final OutputStream dataSink) throws Exception {
                         try {
                             handler.readFromMetacat(request.getRemoteAddr(), null,
                             handler.readFromMetacat(/*request.getRemoteAddr()*/metacatUrl, null,
                                     dataSink, localId, "xml",
                                     sessionData.getUserName(),
                                     sessionData.getGroupNames(), true, params);
-...
          */
         private boolean isScienceMetadata(SystemMetadata sysmeta) {
             boolean scimeta = false;
             System.out.println("sysmeta: " + sysmeta.toString());
             System.out.println("sysmeta format: " + sysmeta.getObjectFormat());
             switch (sysmeta.getObjectFormat()) {
                 case EML_2_1_0: scimeta = true; break;
                 case EML_2_0_1: scimeta = true; break;
-...
+                        }
                         logMetacat.debug("Logging the creation event.");
                         EventLog.getInstance().log(request.getRemoteAddr(),
                         EventLog.getInstance().log(/*request.getRemoteAddr()*/metacatUrl,
                                 username, localId, "create");
                         // Schedule replication for this data file
-...
             // TODO: refactor handleInsertOrUpdateAction() to not output XML directly
             // onto output stream, or alternatively, capture that and parse it to
             // generate the right exceptions
             ByteArrayOutputStream output = new ByteArrayOutputStream();
             PrintWriter pw = new PrintWriter(output);
             handler.handleInsertOrUpdateAction(request.getRemoteAddr(), response,
                     pw, params, sessionData.getUserName(),
                     sessionData.getGroupNames());
             String outputS = new String(output.toByteArray());
             logMetacat.debug("CrudService.insertDocument - Metacat returned: " + outputS);
             //ByteArrayOutputStream output = new ByteArrayOutputStream();
             //PrintWriter pw = new PrintWriter(output);
             String result = handler.handleInsertOrUpdateAction(/*request.getRemoteAddr()*/metacatUrl, null,
                                 null, params, sessionData.getUserName(), sessionData.getGroupNames());
             //String outputS = new String(output.toByteArray());
             logMetacat.debug("CrudService.insertDocument - Metacat returned: " + result);
     //        if (!(outputS.indexOf("<success>") > 0 && outputS.indexOf(localId) > 0)) {
     //            throw new ServiceFailure(1190, outputS);
     //        }

Project

General

Profile

Metacat

Revision 5337

Added by berkley about 14 years ago