source: OAIProvider/trunk/src/main/java/eu/clarin/oai/provider/impl/VerbContextImpl.java @ 1911

package eu.clarin.oai.provider.impl;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPOutputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.stream.XMLStreamException;

import eu.clarin.oai.provider.Repository;
import eu.clarin.oai.provider.ext.Argument;
import eu.clarin.oai.provider.ext.OAIErrorCode;
import eu.clarin.oai.provider.ext.OAIOutputStream;
import eu.clarin.oai.provider.ext.RepositoryAdapter;
import eu.clarin.oai.provider.ext.VerbContext;

final class VerbContextImpl implements VerbContext {
    private static final int ENCODING_NONE    = 0x00;
    private static final int ENCODING_IDENITY = 0x01;
    private static final int ENCODING_DEFLATE = 0x02;
    private static final int ENCODING_GZIP    = 0x03;
    private static final String HEADER_ACCEPT_ENCODING = "Accept-Encoding";
    private static final String HEADER_CONTENT_ENCODING = "Content-Encoding";
    private static final String ENC_NAME_GZIP = "gzip";
    private static final String ENC_NAME_DEFLATE = "deflate";
    private static final String ENC_NAME_IDENTITY = "identity";
    private static final String ENC_NAME_WILDCARD = "*";

    private final static class ErrorImpl implements Error {
        private OAIErrorCode code;
        private String message;

        public ErrorImpl(OAIErrorCode code, String message) {
            super();
            this.code = code;
            this.message = message;
        }

        @Override
        public OAIErrorCode getCode() {
            return code;
        }

        @Override
        public String getMessage() {
            return message;
        }
    } // class ErrorImpl

    private final HttpServletRequest request;
    private final HttpServletResponse response;
    private final RepositoryAdapter repository;
    private String verb;
    private Map<String, Object> arguments;
    private List<Error> errors;

    VerbContextImpl(HttpServletRequest request, HttpServletResponse response,
            RepositoryAdapter repository) {
        this.request = request;
        this.response = response;
        this.repository = repository;
    }

    public String getParameter(String name) {
        String value = request.getParameter(name);
        if (value != null) {
            value = value.trim();
            if (!value.isEmpty()) {
                return value;
            }
        }
        return null;
    }

    public boolean isRepeatedParameter(String name) {
        String[] params = request.getParameterValues(name);
        if (params != null) {
            return params.length > 1;
        }
        return false;
    }

    public Set<String> getParameterNames() {
        Set<String> names = new HashSet<String>();
        for (Iterator<?> i = request.getParameterMap().keySet().iterator();
             i.hasNext();) {
            String s = (String) i.next();
            if (s.equalsIgnoreCase("verb")) {
                continue;
            }
            names.add(s);
        }
        return names;
    }

    public void setVerb(String verb) {
        this.verb = verb;
    }

    public void setArgument(Argument arg, Object value) {
        if (arguments == null) {
            arguments = new HashMap<String, Object>();
        }
        arguments.put(arg.getName(), value);
    }

    @Override
    public String getVerb() {
        return verb;
    }

    @Override
    public RepositoryAdapter getRepository() {
        return repository;
    }

    @Override
    public boolean hasArgument(String name) {
        boolean result = false;
        if (arguments != null) {
            result = arguments.containsKey(name);
        }
        return result;
    }

    @Override
    public Object getArgument(String name) {
        Object value = null;
        if (arguments != null) {
            value = arguments.get(name);
        }
        return value;
    }

    @Override
    public Map<String, String> getUnparsedArguments() {
        if (arguments == null) {
            return Collections.emptyMap();
        }
        Map<String, String> result =
            new HashMap<String, String>(arguments.size());
        for (String name : arguments.keySet()) {
            result.put(name, getParameter(name));
        }
        return result;
    }

    @Override
    public void addError(OAIErrorCode code, String message) {
        if (errors == null) {
            errors = new ArrayList<Error>();
        }
        errors.add(new ErrorImpl(code, message));
    }

    @Override
    public String getContextPath() {
        return request.getContextPath();
    }

    @Override
    public String getRequestURI() {
        return request.getRequestURL().toString();
    }

    @Override
    public boolean hasErrors() {
        return (errors != null);
    }

    @Override
    public List<Error> getErrors() {
        if (errors != null) {
            return errors;
        }
        return Collections.emptyList();
    }

    @Override
    public OAIOutputStream getOutputStream() throws IOException,
            XMLStreamException {
        int bestEnc = ENCODING_NONE;
        float bestQvalue = 0.0f;
        boolean identityPresent = false;

        @SuppressWarnings("unchecked")
        Enumeration<String> headers =
            request.getHeaders(HEADER_ACCEPT_ENCODING);
        if (headers.hasMoreElements()) {
            while (headers.hasMoreElements()) {
                StringTokenizer tok =
                    new StringTokenizer(headers.nextElement(), ",");
                while (tok.hasMoreTokens()) {
                    String item = tok.nextToken();
    
                    String enc = null;
                    float qvalue = -1.0f;
    
                    int pos = item.indexOf(';');
                    if (pos != -1) {
                        enc = item.substring(0, pos).trim();
                        int pos2 = item.indexOf('=', pos + 1);
                        if (pos2 != -1) {
                            String tmp = item.substring(pos2 + 1).trim();
                            try {
                                float value = Float.parseFloat(tmp);
                                if (value >= 0.0f && value <= 1.0f) {
                                    qvalue = value;
                                }
                            } catch (NumberFormatException e) {
                                /* IGNORE */
                            }
                        }
                    } else {
                        enc = item.trim();
                        qvalue = 1.0f;
                    }

                    // check, if encoding/qvalue pair is well-formed
                    if (checkEncoding(enc) && (qvalue >= 0.0f)) {
                        // special handling for identity encoding flag
                        if (ENC_NAME_IDENTITY.equalsIgnoreCase(enc) &&
                                (qvalue > 0.0f)) {
                            identityPresent = true;
                        }
    
                        // rate current best encoding versus parsed encoding
                        if (qvalue > bestQvalue) {
                            if (ENC_NAME_IDENTITY.equalsIgnoreCase(enc) ||
                                    ENC_NAME_WILDCARD.equals(enc)) {
                                bestEnc = ENCODING_IDENITY;
                            } else if (ENC_NAME_DEFLATE.equalsIgnoreCase(enc)
                                    && repository.supportsCompressionMethod(
                                            Repository.COMPRESSION_DEFLATE)) {
                                bestEnc = ENCODING_DEFLATE;
                            } else if (ENC_NAME_GZIP.equalsIgnoreCase(enc)
                                    && repository.supportsCompressionMethod(
                                            Repository.COMPRESSION_GZIP)) {
                                bestEnc = ENCODING_GZIP;
                            } else {
                                /* skip unsupported encoding */
                                continue;
                            }
                            bestQvalue = qvalue;
                        }
                    }
                } // while (tokens)
            } // while (headers)

            /*
             * OAI Specification mandates that identity encoding is included
             * in Accept-Encoding header with a non-zero qvalue.
             * (see Section 3.1.3)
             */
            if (!identityPresent) {
                /*
                 * XXX: if we where being pedantic, we would signal an error
                 * here. However, for now, we just assume, that identity
                 * encoding can be understood by any harvester.
                 */
                // throw new OAIException("Accept-Encoding header must " +
                // "include \"identity\" encoding with non-zero " +
                // "qvalue (see OAI Specification section 3.1.3)");
                if (bestEnc == ENCODING_NONE) {
                    bestEnc = ENCODING_IDENITY;
                }
            }
        } else {
            /* no accept header, use identity encoding */
            bestEnc = ENCODING_IDENITY;
        }

        response.setStatus(HttpServletResponse.SC_OK);
        response.setContentType("text/xml");
        response.setCharacterEncoding("utf-8");

        OutputStream out = null;
        switch (bestEnc) {
        default:
            /* FALL-TROUGH */
        case ENCODING_IDENITY:
            out = response.getOutputStream();
            break;
        case ENCODING_DEFLATE:
            response.addHeader(HEADER_CONTENT_ENCODING, ENC_NAME_DEFLATE);
            out = new DeflaterOutputStream(response.getOutputStream(),
                    new Deflater(Deflater.DEFAULT_COMPRESSION, true));
            break;
        case ENCODING_GZIP:
            response.addHeader(HEADER_CONTENT_ENCODING, ENC_NAME_GZIP);
            out = new GZIPOutputStream(response.getOutputStream(),
                    response.getBufferSize());
            break;
        }
        return new OAIOutputStreamImpl(this, out);
    }

    private boolean checkEncoding(String encoding) {
        if (ENC_NAME_WILDCARD.equals(encoding)) {
            return true;
        }
        for (int i = 0; i < encoding.length(); i++) {
            if (!Character.isLetter(encoding.charAt(i))) {
                return false;
            }
        }
        return true;
    }

} // class VerbContextImpl