Metacat

/**

 *  '$RCSfile$'

 *  Copyright: 2010 Regents of the University of California and the

 *              National Center for Ecological Analysis and Synthesis

 *  Purpose: To test the Access Controls in metacat by JUnit

 *

 *   '$Author: berkley $'

 *     '$Date: 2010-05-03 14:26:08 -0700 (Fri, 14 Aug 2009) $'

 * '$Revision: 5027 $'

 *

 * 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.restservice;

import java.util.*;

import java.io.*;

import edu.ucsb.nceas.MCTestCase;

import edu.ucsb.nceas.metacat.dataone.CrudServiceTest;

import junit.framework.Test;

import junit.framework.TestSuite;

import org.apache.commons.io.IOUtils;

/**

 * @author berkley

 * class to test ResourceHandler

 */

public class ResourceHandlerTest extends MCTestCase

{

    public ResourceHandlerTest(String name)

    {

        super(name);

    }

    /**

     * Create a suite of tests to be run together

     */

    public static Test suite() 

    {

        TestSuite suite = new TestSuite();

        suite.addTest(new ResourceHandlerTest("testProcessMMP"));

        return suite;

    }

    public void testProcessMMP()

    {

        try

        {

            File f = new File("test/testMimeInput.txt");

            FileInputStream fis = new FileInputStream(f);

            ResourceHandler rh = new ResourceHandler(null, null, null);

            //Hashtable h = rh.processMMP(fis);

            InputStream is = rh.processMMP(fis);

            String s = IOUtils.toString(is);

            System.out.println("Final Stream: " + s);

        }

        catch(Exception e)

        {

            fail("Unexpected error in testProcessMMP: " + e.getMessage());

        }

    }

}

import com.gc.iotools.stream.is.InputStreamFromOutputStream;

    /*private Hashtable processMMP(InputStream is)

        System.out.println("mime: " + s);

    */

    protected InputStream processMMP(final InputStream is)

        Hashtable<String, InputStream> partsHash = new Hashtable<String, InputStream>();

        final InputStreamFromOutputStream<String> objectStream = 

            new InputStreamFromOutputStream<String>() 

        {

            @Override

            public String produce(final OutputStream dataSink) throws Exception 

            {

                System.out.println("producing data");

                String[] searchStrings = {"boundary=", "Content-Disposition: attachment; filename=systemmetadata",

                String boundary = "";

                String searchSegment = null;

                byte[] b = new byte[1024];

                int numread = is.read(b, 0, 1024);

                String s = new String(b, 0, numread);

                int ssi = 0;

                boolean doneWithCurrentArray = false;

                boolean searchForBoundary = false;

                int currentArrayIndex = 0;

                while(numread != -1)

                {

                    String searchString;

                    if(!searchForBoundary)

                    {

                        if(ssi == searchStrings.length)

                        {

                            break;

                        }

                        searchString = searchStrings[ssi];

                    }

                    else

                    {

                        searchString = boundary;

                    }

                    System.out.println("searchString: " + searchString);

                    System.out.println("done with array: " + doneWithCurrentArray);

                    System.out.println("searchForBoundary: " + searchForBoundary);

                    if(doneWithCurrentArray)

                    {

                        System.out.println("Getting new chunk");

                        numread = is.read(b, 0, 1024);

                        s = new String(b, 0, numread);

                    }

                    System.out.println("/////////////////current chunk (s): \n" + s + "\n////////////end current chunk");

                    int[] result = StreamUtil.lookForMatch(searchString, s);

                    System.out.println("got result from StreamUtil: " + result[0] + ", " + result[1]);

                    if(result[0] != -1 && result[1] == searchString.length())

                    { //we have the whole search string in this group of bytes

                        System.out.println("1");

                        if(searchForBoundary)

                        {

                            System.out.println("2");

                            //find the boundary, chop it off the end and inc ssi

                            String strToWrite = s.substring(0, s.indexOf(boundary, currentArrayIndex));

                            System.out.println("XXXX 1 writing string: " + strToWrite + "\nXXXX");

                            dataSink.write(strToWrite.getBytes());

                            doneWithCurrentArray = false; 

                            currentArrayIndex = s.indexOf(boundary, currentArrayIndex) + 1;

                            searchForBoundary = false;

                            ssi++;

                        }

                        else if(ssi == 0)

                        { //we're looking for the boundary marker

                            int searchStringIndex = s.indexOf(searchString);

                            if(s.indexOf("\"", searchStringIndex + searchString.length() + 1) == -1)

                            { //the end of the boundary is in the next byte array

                                boundary = s.substring(searchStringIndex + searchString.length() + 1, s.length());

                                doneWithCurrentArray = true;

                            }

                            else if(!boundary.startsWith("--"))

                            { //we can read the whole boundary from this byte array

                                boundary = s.substring(searchStringIndex + searchString.length() + 1, 

                                    s.indexOf("\"", searchStringIndex + searchString.length() + 1));

                                boundary = "--" + boundary;

                                ssi++;

                                doneWithCurrentArray = false;

                            }

                            else

                            { //we're now reading the 2nd byte array to get the rest of the boundary

                                searchString = "\"";

                                searchStringIndex = s.indexOf(searchString);

                                boundary += s.substring(0, searchStringIndex);

                                boundary = "--" + boundary;

                                ssi++;

                                doneWithCurrentArray = false;

                            }

                            System.out.println("boundary: " + boundary);

                        }

                        else if(ssi == 1 || ssi == 2)

                        { 

                            int searchStringIndex = s.indexOf(searchString);

                            //find the beginning of the system metadata or data object and 

                            //start writing it to the dataSink

                            int smBeginIndex = s.indexOf(searchString) + searchString.length() + 2;

                            searchForBoundary = true;

                            int boundaryIndex = s.indexOf(boundary, smBeginIndex);

                            int end = s.length();

                            if(boundaryIndex != -1)

                            {

                                end = boundaryIndex;

                                ssi++;

                                searchForBoundary = false;

                            }

                            currentArrayIndex = end + 1;

                            String strToWrite = s.substring(smBeginIndex, end);

                            System.out.println("XXXX 2 writing string: " + strToWrite + "\nXXXX");

                            dataSink.write(strToWrite.getBytes());

                            if(end == s.length())

                            {

                                System.out.println("DONE WITH ARRAY");

                                doneWithCurrentArray = true;

                                currentArrayIndex = 0;

                            }

                            else

                            {

                                System.out.println("NOT DONE WITH ARRAY");

                                doneWithCurrentArray = false;

                            }

                        }

                    }

                    else if(result[1] != searchString.length() && result[0] != 0)

                    {  //part of the search string is on the end of this byte group

                        doneWithCurrentArray = true;

                        searchForBoundary = false;

                        searchSegment = s.substring(result[0], s.length());

                        System.out.println("searchSegment1: " + searchSegment);

                    }

                    else if(result[1] != searchString.length() && result[0] == 0)

                    {  //we have the end of the searchString at the beginning of this byte group

                        if(searchSegment != null)

                        {

                            searchSegment += s.substring(0, result[1]);

                            System.out.println("searchSegment2: " + searchSegment);

                            searchForBoundary = true;

                            doneWithCurrentArray = true;

                            ssi++;

                            String strToWrite = s.substring(result[1] + 1, s.length());

                            System.out.println("XXXX 3 writing string: " + strToWrite + "\nXXXX");

                            dataSink.write(strToWrite.getBytes());

                        }

                    }

                    else

                    {

                        if(searchForBoundary)

                        {

                            //we're in between the start and end of a section 

                            //so just write this to the stream

                            System.out.println("XXXX 4 writing string: " + s + "\nXXXX");

                            dataSink.write(s.getBytes());

                        }

                    }

                }

                dataSink.flush();

                return "Completed";

            }

        };

        //return partsHash;

        return objectStream;

    }

            Hashtable parts/* = processMMP(request.getInputStream());*/ = new Hashtable();

        } catch (IOException e) {

        }*/ catch (JiBXException e) {