Metacat

import org.apache.commons.fileupload.FileUploadException;

    /**

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

     *        

     * @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();

    }

     * return a tmp file with a given name

     * @param name

     * @return

     */

    private static File getTempFile(String name)

    {

        File tmpDir = getTempDirectory();

        File f = new File(tmpDir, name);

        return f;

    }

    /**

     * return a temp file with a default name

     * @return

     */

    private static File getTempFile()

    {

        return getTempFile(new Date().getTime() + ".tmp");

    }

    /**

    protected void putObject(String pid, String action) {

        try {

            // Read the incoming data from its Mime Multipart encoding

            logMetacat.debug("Disassembling MIME multipart form");

            InputStream object = null;

            InputStream sysmeta = null;

            Map<String, List<String>> multipartparams;

            try {

                // handle MMP inputs

                File tmpDir = getTempDirectory();

                System.out.println("temp dir: " + tmpDir.getAbsolutePath());

                MultipartRequestResolver mrr = 

                	new MultipartRequestResolver(tmpDir.getAbsolutePath(), 1000000000, 0);

                MultipartRequest mr = mrr.resolveMultipart(request);

                System.out.println("resolved multipart request");

                Map<String, File> files = mr.getMultipartFiles();

                if (files == null) {

                    throw new ServiceFailure("1202", "create/update must have multipart files with names 'object' and 'sysmeta'");

                }

                System.out.println("got multipart files");

                if (files.keySet() == null) {

                    System.out.println("No file keys in MMP request.");

                    throw new ServiceFailure("1202", "No file keys found in MMP.  " +

                            "create/update must have multipart files with names 'object' and 'sysmeta'");

                }

				// for logging purposes, dump out the key-value pairs that constitute the request

				// 3 types exist: request params, multipart params, and multipart files

                Iterator it = files.keySet().iterator();

                System.out.println("iterating through files");

                while (it.hasNext()) {

                    String key = (String)it.next();

                    System.out.println("files key: " + key);

                    System.out.println("files value: " + files.get(key));

                }

                multipartparams = mr.getMultipartParameters();

                it = multipartparams.keySet().iterator();

                System.out.println("iterating through multipartparams");

                while (it.hasNext()) {

                    String key = (String)it.next();

                    System.out.println("multipartparams key: " + key);

                    System.out.println("multipartparams value: " + multipartparams.get(key));

                }

                it = params.keySet().iterator();

                System.out.println("iterating through params");

                while (it.hasNext()) {

                    String key = (String)it.next();

                    System.out.println("param key: " + key);

                    System.out.println("param value: " + params.get(key));

                }

                System.out.println("done iterating the request...");

                File smFile = files.get("sysmeta");

				if (smFile == null) {

				    throw new InvalidRequest("1102", "Missing the required file-part 'sysmeta' from the multipart request.");

				}

                System.out.println("smFile: " + smFile.getAbsolutePath());

                sysmeta = new FileInputStream(smFile);

                File objFile = files.get("object");

				if (objFile == null) {

				    throw new InvalidRequest("1102", "Missing the required file-part 'object' from the multipart request.");

				}

                System.out.println("objectfile: " + objFile.getAbsolutePath());

                object = new FileInputStream(objFile);

            }

            catch (FileUploadException fue)

            {

                throw new ServiceFailure("1202", "Could not upload MMP files: " + fue.getMessage());

            }

            catch (IOException ioe)

            {

                throw new ServiceFailure("1202", 

                        "IOException when processing Mime Multipart: " + ioe.getMessage());

            }

            catch (Exception e)

            {

                throw new ServiceFailure("1202", "Error handling MMP upload: " + e.getClass() + ": " + e.getMessage());

            }

            // handle inserts

            if (action.equals(FUNCTION_NAME_INSERT)) { 

                logMetacat.debug("Commence creation...");

                SystemMetadata smd = (SystemMetadata) deserializeServiceType(SystemMetadata.class, sysmeta);

                Identifier id = new Identifier();

                id.setValue(pid);

                System.out.println("creating object with pid " + pid);

                Identifier rId = MNodeService.getInstance().create(session, id, object, smd);

                serializeServiceType(Identifier.class, rId, out);

            } else if (action.equals(FUNCTION_NAME_UPDATE)) { 

                // check that the newPid parameter was provided

                if (multipartparams.get("newPid") == null) {

                    throw new InvalidRequest("1202", "'newPid' must be contained in the request parameters.");

                }

                String newPidString = multipartparams.get("newPid").get(0);

                Identifier newPid = new Identifier();

                Identifier obsoletedPid = new Identifier();

                obsoletedPid.setValue(pid);

                logMetacat.debug("Commence update...");

                //get the systemmetadata object

                SystemMetadata smd = (SystemMetadata) deserializeServiceType(SystemMetadata.class, sysmeta);

                Identifier rId = MNodeService.getInstance().update(session, newPid, object, obsoletedPid, smd);

                serializeServiceType(Identifier.class, rId, out);

            } else {

                throw new InvalidRequest("1000", "Operation must be create or update.");

            }

            //clean up the MMP files

            //parts.get("systemmetadata").delete();

            //parts.get("object").delete();

        } catch (NotAuthorized e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InvalidToken e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (ServiceFailure e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (NotFound e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (IdentifierNotUnique e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (UnsupportedType e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InsufficientResources e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InvalidSystemMetadata e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (NotImplemented e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (InvalidRequest e) {

            response.setStatus(500);

            serializeException(e, out);

        } catch (JiBXException e) {

            response.setStatus(500);

            e.printStackTrace(System.out);

            InvalidSystemMetadata ism = new InvalidSystemMetadata("1080", e.getMessage());

            serializeException(ism, out);

        }