Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: $'

 *     '$Date: 2009-06-13 15:28:13 +0300  $'

 *

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

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.sql.SQLException;

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.commons.io.IOUtils;

import org.apache.log4j.Logger;

import org.dataone.service.exceptions.IdentifierNotUnique;

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.Identifier;

import org.dataone.service.types.LogRecordSet;

import org.dataone.service.types.SystemMetadata;

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

import edu.ucsb.nceas.metacat.AccessionNumberException;

import edu.ucsb.nceas.metacat.DocumentImpl;

import edu.ucsb.nceas.metacat.EventLog;

import edu.ucsb.nceas.metacat.IdentifierManager;

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.properties.PropertyService;

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

import edu.ucsb.nceas.metacat.service.SessionService;

import edu.ucsb.nceas.metacat.util.SessionData;

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;

    Logger logMetacat = null;

    /**

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

        logMetacat = Logger.getLogger(CrudService.class);

        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;

        String sessionId = "PUBLIC";

        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;

    }

    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()...");

        // TODO: authenticate & get user info

        String username = "GARBAGETOBEREPLACED";

        String[] groups = null;

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

        logMetacat.debug("Comparing guid|sysmeta_guid: " + guid.getValue() + "|" + sysmeta.getIdentifier().getValue());

//        if (!guid.getIdentifier().equals(sysmeta.getIdentifier().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();

        if (im.identifierExists(guid.getValue())) {

            throw new IdentifierNotUnique(1120, 

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

        }

        // generate guid/localId pair for object

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

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

        // TODO: generate guid/localId pair for sysmeta

        // TODO: update system metadata fields

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

        // TODO: Check if we are handling metadata or data

        // TODO: CASE METADATA:

        // Setup and call handleInsertOrUpdate()

        // TODO: DEFAULT CASE: DATA

        try {

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

            if (DocumentImpl.getDataFileLockGrant(localId)) {

                // Save the data file to disk using "localId" as the name

                try {

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

                    File dataDirectory = new File(datafilepath);

                    dataDirectory.mkdirs();

                    File newFile = writeStreamToFile(dataDirectory, localId, object);

                    // TODO: Check that the file size matches SystemMetadata

                    //                        long size = newFile.length();

                    //                        if (size == 0) {

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

                    //                        }

                    //register the file in the database (which generates an exception

                    // 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());

                }

            }

        } catch (Exception e) {

            // 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());

        }

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

        return guid;

    }

    public Identifier delete(AuthToken token, Identifier guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            NotImplemented {

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

    }

    public DescribeResponse describe(AuthToken token, Identifier guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            NotImplemented {

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

    }

    public InputStream get(AuthToken token, Identifier guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            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 String localId = im.getLocalId(guid.getValue());

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

        }

/*    

 *      Alternative approach that uses Piped streams, but requires thread handling

 *      which makes exception handling difficult (because exceptions fall off the

 *      calling thread, terminating the thread.

 *      

        // Look up the localId for this global identifier

        IdentifierManager im = IdentifierManager.getInstance();

        try {

            final String localId = im.getLocalId(guid.getIdentifier());

            // Now use that localId to read the object and return it

            params.put("docid", new String[] { localId });        

            final PipedInputStream in = new PipedInputStream();

            new Thread(

                    new Runnable() {

                        public void run() {

                            try {

                                PipedOutputStream out = new PipedOutputStream(in);

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

                                        out, localId, "xml",

                                        username, groupNames, 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().");

                            }

                        }

                    }

            ).start();

            return in;

        } catch (McdbDocNotFoundException e) {

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

        }        

*/

    }

    public Checksum getChecksum(AuthToken token, Identifier guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            InvalidRequest, NotImplemented {

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

    }

    public Checksum getChecksum(AuthToken token, Identifier guid, 

            String checksumAlgorithm) throws InvalidToken, ServiceFailure, 

            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.");

    }

    public SystemMetadata getSystemMetadata(AuthToken token, Identifier guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            InvalidRequest, NotImplemented {

        // Look up ID of system metadata based on guid

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

        // Read system metadata from disk and create SystemMetadata object

            // Follows same implementation plan as get()

        // return it

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

    }

    public Identifier update(AuthToken token, Identifier guid, 

            InputStream object, Identifier obsoletedGuid, SystemMetadata sysmeta) 

            throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

            UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata, 

            NotImplemented {

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

    }

    private File writeStreamToFile(File dir, String fileName, InputStream data) 

        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;

    }   

}