Metacat

/**

 *  '$RCSfile$'

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

 *              National Center for Ecological Analysis and Synthesis

 *

 *   '$Author: Serhan AKIN $'

 *     '$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.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.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.IdentifierType;

import org.dataone.service.types.LogRecordSet;

import org.dataone.service.types.SystemMetadata;

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

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

    /**

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

        String 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 IdentifierType create(AuthToken token, IdentifierType guid, 

            InputStream object, SystemMetadata sysmeta) throws InvalidToken, 

            ServiceFailure, NotAuthorized, IdentifierNotUnique, UnsupportedType, 

            InsufficientResources, InvalidSystemMetadata, NotImplemented {

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

    }

    public IdentifierType delete(AuthToken token, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            NotImplemented {

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

    }

    public DescribeResponse describe(AuthToken token, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            NotImplemented {

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

    }

    public InputStream get(AuthToken token, IdentifierType 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.getIdentifier());

            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, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            InvalidRequest, NotImplemented {

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

    }

    public Checksum getChecksum(AuthToken token, IdentifierType 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, IdentifierType guid)

            throws InvalidToken, ServiceFailure, NotAuthorized, NotFound, 

            InvalidRequest, NotImplemented {

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

    }

    public IdentifierType update(AuthToken token, IdentifierType guid, 

            InputStream object, IdentifierType obsoletedGuid, SystemMetadata sysmeta) 

            throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

            UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata, 

            NotImplemented {

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

    }

}