Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *

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

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Date;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Timer;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.dataone.service.exceptions.InsufficientResources;

import org.dataone.service.exceptions.InvalidRequest;

import org.dataone.service.exceptions.InvalidSystemMetadata;

import org.dataone.service.exceptions.InvalidToken;

import org.dataone.service.exceptions.NotAuthorized;

import org.dataone.service.exceptions.NotFound;

import org.dataone.service.exceptions.NotImplemented;

import org.dataone.service.exceptions.ServiceFailure;

import org.dataone.service.exceptions.UnsupportedType;

import org.dataone.service.mn.MemberNodeCrud;

import org.dataone.service.types.AuthToken;

import org.dataone.service.types.Checksum;

import org.dataone.service.types.DescribeResponse;

import org.dataone.service.types.SystemMetadata;

import org.jibx.runtime.IBindingFactory;

import org.jibx.runtime.IMarshallingContext;

import org.jibx.runtime.JiBXException;

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

import edu.ucsb.nceas.metacat.DocumentImpl;

import edu.ucsb.nceas.metacat.EventLog;

import edu.ucsb.nceas.metacat.McdbDocNotFoundException;

import edu.ucsb.nceas.metacat.McdbException;

import edu.ucsb.nceas.metacat.MetacatHandler;

import edu.ucsb.nceas.metacat.client.InsufficientKarmaException;

import edu.ucsb.nceas.metacat.replication.ForceReplicationHandler;

import edu.ucsb.nceas.utilities.ParseLSIDException;

import edu.ucsb.nceas.utilities.PropertyNotFoundException;

/**

 *

 * Implements DataONE MemberNode CRUD API for Metacat.

 *

 * @author Matthew Jones

 */

public class CrudService implements MemberNodeCrud {

    private ServletContext servletContext;

    private HttpServletRequest request;

    private HttpServletResponse response;

//    private Logger logMetacat;

    private MetacatHandler handler;

//    private String username;

//    private String password;

//    private String sessionId;

//    private String[] groupNames;

    private Hashtable<String, String[]> params;

    /**

     * 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) {

        this.servletContext = servletContext;

        this.request = request;

        this.response = response;

        handler = new MetacatHandler(this.servletContext, new Timer());

        initParams();

//        loadSessionData();

    }

    /**

     *  copies request parameters to a Hashtable which is given as argument to

     *  native MetacatHandler functions

     */

    private void initParams() {

        String name = null;

        String[] value = null;

        params = new Hashtable<String, String[]>();

        Enumeration paramlist = request.getParameterNames();

        while (paramlist.hasMoreElements()) {

            name = (String) paramlist.nextElement();

            value = request.getParameterValues(name);

            params.put(name, value);

        }

    }

    /**

     *

     * Load user details of metacat session from the request

     *

     */

//    private void loadSessionData() {

//        SessionData sessionData = RequestUtil.getSessionData(request);

//

//        // TODO: validate the session before allowing these values to be set

//        username = sessionData.getUserName();

//        password = sessionData.getPassword();

//        groupNames = sessionData.getGroupNames();

//        sessionId = sessionData.getId();

//

//        if (username == null) {

//            username = "public";

//        }

//    }

    /*

     * Look up the information on the session using the token provided in

     * the AuthToken.  The Session should have all relevant user information.

     * If the session has expired or is invalid, the 'public' session will

     * be returned, giving the user anonymous access.

     */

    private static SessionData getSessionData(AuthToken token) {

        SessionData sessionData = null;

        if (token != null) {

            sessionId = token.getToken();

        }

        // if the session id is registered in SessionService, get the

        // SessionData for it. Otherwise, use the public session.

        if (SessionService.isSessionRegistered(sessionId)) {

            sessionData = SessionService.getRegisteredSession(sessionId);

        } else {

            sessionData = SessionService.getPublicSession();

        }

        return sessionData;

    }

            ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType,

            InsufficientResources, InvalidSystemMetadata, NotImplemented {

        logMetacat.debug("Starting CrudService.create()...");

        SessionData sessionData = getSessionData(token);

        String username = sessionData.getUserName();

        String[] groups = sessionData.getGroupNames();

        // verify that guid == SystemMetadata.getIdentifier()

            throw new InvalidSystemMetadata(1180,

                "GUID in method call does not match GUID in system metadata.");

        }

        logMetacat.debug("Checking if identifier exists...");

        // Check that the identifier does not already exist

        IdentifierManager im = IdentifierManager.getInstance();

                "GUID is already in use by an existing object.");

        }

        // generate guid/localId pair for object

        logMetacat.debug("Generating a guid/localId mapping");

        boolean isScienceMetadata = isScienceMetadata(sysmeta);

            // TODO: CASE METADATA:

            // Setup and call handleInsertOrUpdate()

            // TODO: DEFAULT CASE: DATA (needs to be checked and completed)

            try {

                logMetacat.debug("Case DATA: starting to write to disk.");

                if (DocumentImpl.getDataFileLockGrant(localId)) {

                    try {

                        String datafilepath = PropertyService.getProperty("application.datafilepath");

                        dataDirectory.mkdirs();

                        //                        long size = newFile.length();

                        //                        if (size == 0) {

                        //                            throw new IOException("Uploaded file is 0 bytes!");

                        //                        }

                        // if the docid is not acceptable or other untoward things happen

                        try {

                            logMetacat.debug("Registering document...");

                            DocumentImpl.registerDocument(localId, "BIN", localId,

                                    username, groups);

                            logMetacat.debug("Registrtion step completed.");

                        } catch (SQLException e) {

                            //newFile.delete();

                            logMetacat.debug("SQLE: " + e.getMessage());

                            e.printStackTrace(System.out);

                            throw new ServiceFailure(1190, "Registration failed: " + e.getMessage());

                        } catch (AccessionNumberException e) {

                            //newFile.delete();

                            logMetacat.debug("ANE: " + e.getMessage());

                            e.printStackTrace(System.out);

                            throw new ServiceFailure(1190, "Registration failed: " + e.getMessage());

                        } catch (Exception e) {

                            //newFile.delete();

                            logMetacat.debug("Exception: " + e.getMessage());

                            e.printStackTrace(System.out);

                            throw new ServiceFailure(1190, "Registration failed: " + e.getMessage());

                        }

                        logMetacat.debug("Logging the creation event.");

                        EventLog.getInstance().log(request.getRemoteAddr(),

                                username, localId, "create");

                        // Force replication this data file

                        // To data file, "insert" and update is same

                        // The fourth parameter is null. Because it is notification

                        // server and this method is in MetaCatServerlet. It is

                        // original command, not get force replication info from

                        // another metacat

                        // TODO: note that GUID mapping is not being replicated

                        logMetacat.debug("Scheduling replication.");

                        ForceReplicationHandler frh = new ForceReplicationHandler(

                                localId, "insert", false, null);

                    } catch (PropertyNotFoundException e) {

                        throw new ServiceFailure(1190, "Could not lock file for writing:" + e.getMessage());

                }

                // Could not get a lock on the document, so we can not update the file now

                throw new ServiceFailure(1190, "Failed to lock file: " + e.getMessage());

            // Insert the system metadata into the object store

            insertSystemMetadata(sysmeta, sessionData);

        logMetacat.debug("Returning from CrudService.create()");

        return guid;

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

            NotImplemented {

        // Retrieve the session information from the AuthToken

        // If the session is expired, then the user is 'public'

        final SessionData sessionData = getSessionData(token);

        // Look up the localId for this global identifier

        IdentifierManager im = IdentifierManager.getInstance();

        try {

            final InputStreamFromOutputStream<String> objectStream =

                new InputStreamFromOutputStream<String>() {

                @Override

                public String produce(final OutputStream dataSink) throws Exception {

                    try {

                        handler.readFromMetacat(request.getRemoteAddr(), null,

                                dataSink, localId, "xml",

                                sessionData.getUserName(),

                                sessionData.getGroupNames(), true, params);

                    } catch (PropertyNotFoundException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (ClassNotFoundException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (IOException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (SQLException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (McdbException e) {

                        throw new ServiceFailure(1030, e.getMessage());

                    } catch (ParseLSIDException e) {

                        throw new NotFound(1020, e.getMessage());

                    } catch (InsufficientKarmaException e) {

                        throw new NotAuthorized(1000, "Not authorized for get().");

                    }

                    return "Completed";

                }

            };

            return objectStream;

        } catch (McdbDocNotFoundException e) {

            throw new NotFound(1020, e.getMessage());

        }

    }

            InvalidRequest, NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

            NotAuthorized, NotFound, InvalidRequest, NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

    public LogRecordSet getLogRecords(AuthToken token, Date fromDate, Date toDate)

            throws InvalidToken, ServiceFailure, NotAuthorized, InvalidRequest,

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

            InvalidRequest, NotImplemented {

            // TODO: Initially from document, later from entry in table?

            // TODO: Follows same implementation plan as get()

    }

            InputStream object, Identifier obsoletedGuid, SystemMetadata sysmeta)

            UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata,

            NotImplemented {

        throw new NotImplemented(1000, "This method not yet implemented.");

    }

        throws ServiceFailure {

//        logMetacat.debug("***********************************************");

//        logMetacat.debug("** FILE TEST FROM CS                         **");

//        logMetacat.debug("***********************************************");

        File newFile = new File(dir, fileName);

        logMetacat.debug("Filename for write is: " + newFile.getAbsolutePath());

        try {

            if (newFile.createNewFile()) {

//                logMetacat.debug("File doesn't yet exist, so write to it.");

//                logMetacat.debug("Creating file stream...");

                // write data stream to desired file

                OutputStream os = new FileOutputStream(newFile);

//                logMetacat.debug("Copying file stream...");

                long length = IOUtils.copyLarge(data, os);

                os.flush();

//                logMetacat.debug("Closing file stream...");

                os.close();

//                logMetacat.debug("Done with file stream...");

            } else {

                logMetacat.debug("File creation failed, or file already exists.");

                throw new ServiceFailure(1190, "File already exists: " + fileName);

            }

        } catch (FileNotFoundException e) {

            logMetacat.debug("FNF: " + e.getMessage());

            throw new ServiceFailure(1190, "File not found: " + fileName + " "

                    + e.getMessage());

        } catch (IOException e) {

            logMetacat.debug("IOE: " + e.getMessage());

            throw new ServiceFailure(1190, "File was not written: " + fileName

                    + " " + e.getMessage());

        }

//        logMetacat.debug("***********************************************");

//        logMetacat.debug("** END FILE TEST                             **");

//        logMetacat.debug("***********************************************");

        return newFile;

    /**

     * Determine if a given object should be treated as an XML science metadata

     * object.

     *

     * TODO: This test should be externalized in a configuration dictionary rather than being hardcoded.

     *

     * @param sysmeta the SystemMetadata describig the object

     * @return true if the object should be treated as science metadata

     */

    private boolean isScienceMetadata(SystemMetadata sysmeta) {

        boolean scimeta = false;

        switch (sysmeta.getObjectFormat()) {

            case EML_2_1_0: scimeta = true; break;

            case EML_2_0_1: scimeta = true; break;

            case EML_2_0_0: scimeta = true; break;

            case FGDC_STD_001_1_1999: scimeta = true; break;

            case FGDC_STD_001_1998: scimeta = true; break;

            case NCML_2_2: scimeta = true; break;

        }

        return scimeta;

    }

    private void insertSystemMetadata(SystemMetadata sysmeta, SessionData sessionData)

        throws ServiceFailure {

        logMetacat.debug("Starting to insert SystemMetadata...");

        IdentifierManager im = IdentifierManager.getInstance();

        // generate guid/localId pair for sysmeta

        String sysMetaGuid = DocumentUtil.generateDocumentId(1);

        sysmeta.setDateSysMetadataModified(new Date());

        String xml = new String(serializeSystemMetadata(sysmeta).toByteArray());

        insertDocument(xml, sysMetaGuid, sessionData);

    }

    private void insertDocument(String xml, String guid, SessionData sessionData)

        throws ServiceFailure {

        logMetacat.debug("Starting to insert xml document...");

        IdentifierManager im = IdentifierManager.getInstance();

        // generate guid/localId pair for sysmeta

        String localId = im.generateLocalId(guid, 1);

        logMetacat.debug("Metadata guid|localId: " + guid + "|" +

                localId);

        // TODO: insert system metadata to metacat (probably at end)

        // TODO: can't pass in the out PrintWriter, as we don't want to write

        // error info on this stream -- need to be able to return to process

        // the real object.  So, need to:

        // TODO: refactor handleInsertOrUpdateAction() to not output XML directly

        // onto output stream, or alternatively, capture that and parse it to

        // generate the right exceptions

        String[] action = new String[1];

        action[0] = "insert";

        params.put("action", action);

        String[] docid = new String[1];

        docid[0] = localId;

        params.put("docid", docid);

        String[] doctext = new String[1];

        doctext[0] = xml;

        logMetacat.debug(doctext[0]);

        params.put("doctext", doctext);

        ByteArrayOutputStream output = new ByteArrayOutputStream();

        PrintWriter pw = new PrintWriter(output);

        handler.handleInsertOrUpdateAction(request.getRemoteAddr(), response,

                pw, params, sessionData.getUserName(),

                sessionData.getGroupNames());

        logMetacat.debug(new String(output.toByteArray()));

        logMetacat.debug("Finsihed inserting xml document.");

    }

    private ByteArrayOutputStream serializeSystemMetadata(SystemMetadata sysmeta)

        throws ServiceFailure {

        IBindingFactory bfact;

        ByteArrayOutputStream sysmetaOut = null;

        try {

            bfact = BindingDirectory.getFactory(SystemMetadata.class);

            IMarshallingContext mctx = bfact.createMarshallingContext();

            sysmetaOut = new ByteArrayOutputStream();

            mctx.marshalDocument(sysmeta, "UTF-8", null, sysmetaOut);

        } catch (JiBXException e) {

            throw new ServiceFailure(1190, "Failed to serialize and insert SystemMetadata: " + e.getMessage());

        }

        return sysmetaOut;

    }