/ - Diff - Metacat - Ecoinformatics Redmine

           suite.addTest(new MetacatClientTest("getNewestDocRevision"));  // (also tries to insert)
           suite.addTest(new MetacatClientTest("upload"));
           suite.addTest(new MetacatClientTest("upload_stream"));
           suite.addTest(new MetacatClientTest("upload_stream_chunked"));
           suite.addTest(new MetacatClientTest("invalidRead"));
           suite.addTest(new MetacatClientTest("read"));
           suite.addTest(new MetacatClientTest("query"));
-...
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test the upload() function by passing an InputStream
          */
         public void upload_stream_chunked()
+        {
             debug("\nStarting upload_stream_chunked test...");
             try {
                 newdocid = generateDocumentId();
                 String identifier = newdocid + ".1";
                 m.login(username, password);
                 File testFile = new File(onlinetestdatafile);
                 String response = m.upload(identifier, "onlineDataFile1",
                                            new FileInputStream(testFile), -1);
                 assertTrue(response.indexOf("<success>") != -1);
                 assertTrue(response.indexOf(identifier) != -1);
                 identifier = newdocid + ".2";
                 response = m.upload(identifier, "onlineDataFile1",
                         new FileInputStream(testFile), -1);
                assertTrue(response.indexOf("<success>") != -1);
                assertTrue(response.indexOf(identifier) != -1);
                debug("upload_stream_chunked(): response=" + response);
             } catch (MetacatAuthException mae) {
                 fail("Authorization failed:\n" + mae.getMessage());
             } catch (MetacatInaccessibleException mie) {
               mie.printStackTrace();
                 fail("Metacat Inaccessible:\n" + mie.getMessage());
             } catch (InsufficientKarmaException ike) {
                 assertTrue(1 == 1);
                 fail("Insufficient karma:\n" + ike.getMessage());
             } catch (MetacatException me) {
                 fail("Metacat Error:\n" + me.getMessage());
             } catch (Exception e) {
                 fail("General exception:\n" + e.getMessage());
+            }
+        }
         /**
          * Test the invalidUpdate() function. A user try to update a document
          * which it doesn't have permission

     import javax.servlet.http.HttpServletResponse;
     import javax.servlet.http.HttpSession;
     import org.apache.commons.fileupload.FileItem;
     import org.apache.commons.fileupload.disk.DiskFileItemFactory;
     import org.apache.commons.fileupload.servlet.ServletFileUpload;
     import org.apache.commons.io.IOUtils;
     import org.apache.commons.io.input.XmlStreamReader;
     import org.apache.log4j.Logger;
-...
     import au.com.bytecode.opencsv.CSVWriter;
     import com.oreilly.servlet.multipart.FilePart;
     import com.oreilly.servlet.multipart.MultipartParser;
     import com.oreilly.servlet.multipart.ParamPart;
     import com.oreilly.servlet.multipart.Part;
     import edu.ucsb.nceas.metacat.accesscontrol.AccessControlException;
     import edu.ucsb.nceas.metacat.accesscontrol.AccessControlForSingleFile;
     import edu.ucsb.nceas.utilities.access.AccessControlInterface;
-...
     import edu.ucsb.nceas.metacat.database.DBConnection;
     import edu.ucsb.nceas.metacat.database.DBConnectionPool;
     import edu.ucsb.nceas.metacat.dataone.D1NodeService;
     import edu.ucsb.nceas.metacat.dataone.MNodeService;
     import edu.ucsb.nceas.metacat.dataone.SyncAccessPolicy;
     import edu.ucsb.nceas.metacat.dataone.SystemMetadataFactory;
     import edu.ucsb.nceas.metacat.dataone.hazelcast.HazelcastService;
-...
             Hashtable<String,String[]> params = new Hashtable<String,String[]>();
             Hashtable<String,String> fileList = new Hashtable<String,String>();
             int sizeLimit = 1000;
             String tmpDir = "/tmp";
             try {
                 sizeLimit =
                     (new Integer(PropertyService.getProperty("replication.datafilesizelimit"))).intValue();
-...
                 		         pnfe.getMessage());
                 pnfe.printStackTrace(System.out);
+            }
             try {
                 tmpDir = PropertyService.getProperty("application.tempDir");
             } catch (PropertyNotFoundException pnfe) {
                 logMetacat.error("MetacatHandler.handleMultipartForm - " +
                 		         "Could not determine temp dir, using default. " +
                 		         pnfe.getMessage());
                 pnfe.printStackTrace(System.out);
+            }
             logMetacat.debug("MetacatHandler.handleMultipartForm - " +
             		         "The size limit of uploaded data files is: " +
             		         sizeLimit);
             try {
                 MultipartParser mp = new MultipartParser(request,
                         sizeLimit * 1024 * 1024);
                 Part part;
                 while ((part = mp.readNextPart()) != null) {
                     String name = part.getName();
                     if (part.isParam()) {
             	boolean isMultipart = ServletFileUpload.isMultipartContent(request);
             	// Create a factory for disk-based file items
             	DiskFileItemFactory factory = new DiskFileItemFactory();
             	// Configure a repository (to ensure a secure temp location is used)
             	File repository = new File(tmpDir);
             	factory.setRepository(repository);
             	// Create a new file upload handler
             	ServletFileUpload upload = new ServletFileUpload(factory);
             	// Parse the request
             	List<FileItem> items = upload.parseRequest(request);
             	Iterator<FileItem> iter = items.iterator();
             	while (iter.hasNext()) {
             		FileItem item = iter.next();
             		String name = item.getFieldName();
             	    if (item.isFormField()) {
                         // it's a parameter part
                         ParamPart paramPart = (ParamPart) part;
                         String[] values = new String[1];
                         values[0] = paramPart.getStringValue();
                         values[0] = item.getString();
                         params.put(name, values);
                         if (name.equals("action")) {
                             action = values[0];
+                        }
                     } else if (part.isFile()) {
                     } else {
                         // it's a file part
                         FilePart filePart = (FilePart) part;
                         String fileName = filePart.getFileName();
                         // the filePart will be clobbered on the next loop, save to disk
                         tempFile = MetacatUtil.writeTempUploadFile(filePart, fileName);
                         String fileName = item.getName();
                         // write to disk
                         tempFile = MetacatUtil.writeTempUploadFile(item, fileName);
                         fileList.put(name, tempFile.getAbsolutePath());
                         fileList.put("filename", fileName);
                         fileList.put("name", tempFile.getAbsolutePath());
                     } else {
                         logMetacat.info("MetacatHandler.handleMultipartForm - " +
                         		        "Upload name '" + name + "' was empty.");
+                    }
+                }
             } catch (IOException ioe) {
             } catch (Exception ioe) {
                 try {
                     out = response.getWriter();
                 } catch (IOException ioe2) {

     import java.io.FileInputStream;
     import java.io.FileOutputStream;
     import java.io.IOException;
     import java.io.InputStream;
     import java.io.PrintWriter;
     import java.net.MalformedURLException;
     import java.util.Hashtable;
     import java.util.Vector;
     import org.apache.commons.fileupload.FileItem;
     import org.apache.commons.io.IOUtils;
     import org.apache.log4j.Logger;
     import com.oreilly.servlet.multipart.FilePart;
-...
     	 *            the name of the file to be written to disk
     	 * @return tempFilePath a String containing location of temporary file
     	 */
         public static File writeTempUploadFile (FilePart filePart, String fileName) throws IOException {
         public static File writeTempUploadFile (FileItem fi, String fileName) throws Exception {
             File tempFile = null;
             String tempDirPath = null;
             try {
-...
     		//tempFile = new File(tempDirPath, fileName);
     		tempFile = File.createTempFile("upload", ".tmp", tempDir);
     		fileSize = filePart.writeTo(tempFile);
     		fi.write(tempFile);
     		fileSize = fi.getSize();
     		if (fileSize == 0) {
     			logMetacat.warn("Uploaded file '" + fileName + "'is empty!");

     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;
-...
         	MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
         	// For File parameters
         	InputStreamBody content = null;
         	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);
+        	}

Project

General

Profile

Metacat

Revision 8748

Added by ben leinfelder over 10 years ago