server/directmemory-server/src/main/java/org/apache/directmemory/server/services/DirectMemoryServlet.java

package org.apache.directmemory.server.services;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.commons.lang.StringUtils;
import org.apache.directmemory.DirectMemory;
import org.apache.directmemory.cache.CacheService;
import org.apache.directmemory.memory.Pointer;
import org.apache.directmemory.server.commons.DirectMemoryException;
import org.apache.directmemory.server.commons.DirectMemoryHttpConstants;
import org.apache.directmemory.server.commons.DirectMemoryRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.core.MediaType;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import static java.lang.Integer.getInteger;
import static org.apache.directmemory.DirectMemory.DEFAULT_CONCURRENCY_LEVEL;
import static org.apache.directmemory.DirectMemory.DEFAULT_INITIAL_CAPACITY;

/**
 * TODO add some listener plugin mechanism to store figures/statistics on cache access
 *
 * @author Olivier Lamy
 */
public class DirectMemoryServlet
    extends HttpServlet
{

    private Logger log = LoggerFactory.getLogger( getClass() );

    private CacheService<Object, Object> cacheService;

    private Map<String, ContentTypeHandler> contentTypeHandlers;


    @Override
    public void init( ServletConfig config )
        throws ServletException
    {
        super.init( config );
        // TODO some configuration for cacheService.init( .... ); different from sysproperties
        //int numberOfBuffers, int size, int initialCapacity, int concurrencyLevel

        cacheService = new DirectMemory<Object, Object>().setNumberOfBuffers(
            getInteger( "directMemory.numberOfBuffers", 10 ) ).setSize(
            getInteger( "directMemory.size", 1000 ) ).setInitialCapacity(
            getInteger( "directMemory.initialCapacity", DEFAULT_INITIAL_CAPACITY ) ).setConcurrencyLevel(
            getInteger( "directMemory.concurrencyLevel", DEFAULT_CONCURRENCY_LEVEL ) ).newCacheService();

        //

        contentTypeHandlers = new HashMap<String, ContentTypeHandler>( 2 );
        contentTypeHandlers.put( MediaType.APPLICATION_JSON, new JsonContentTypeHandler() );
        contentTypeHandlers.put( DirectMemoryHttpConstants.JAVA_SERIALIZED_OBJECT_CONTENT_TYPE_HEADER,
                                 new JavaSerializedContentTypeHandler() );
        contentTypeHandlers.put( MediaType.TEXT_PLAIN, new TextPlainContentTypeHandler() );
        log.info( "DirectMemoryServlet initialized" );

    }

    @Override
    public void destroy()
    {
        super.destroy();
    }

    @Override
    protected void doPost( HttpServletRequest req, HttpServletResponse resp )
        throws ServletException, IOException
    {
        this.doPut( req, resp );
    }

    @Override
    protected void doPut( HttpServletRequest req, HttpServletResponse resp )
        throws ServletException, IOException
    {
        //TODO check request content to send HttpServletResponse.SC_BAD_REQUEST
        // if missing parameter in json request

        String path = req.getPathInfo();
        String servletPath = req.getServletPath();
        String key = retrieveKeyFromPath( path );

        DirectMemoryRequest request = null;

        ContentTypeHandler contentTypeHandler = findPutCacheContentTypeHandler( req, resp );

        if ( contentTypeHandler == null )
        {
            String contentType = req.getContentType();
            log.error( "No content type handler for content type {}", contentType );
            resp.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                            "Content-Type '" + contentType + "' not supported" );
            return;
        }
        try
        {
            request = contentTypeHandler.handlePut( req, resp );
        }
        catch ( DirectMemoryException e )
        {
            resp.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage() );
            return;
        }

        //if exists free first ?
        //if ( cacheService.retrieveByteArray( key ) == null )
        byte[] bytes = request.getCacheContent();
        Pointer p = cacheService.putByteArray( key, bytes, request.getExpiresIn() );
        if ( p == null )
        {
            resp.sendError( HttpServletResponse.SC_NO_CONTENT, "Content not put in cache for key: " + key );
            return;
        }
        log.debug( "put content for key {} size {}", key, bytes.length );
        resp.addHeader( DirectMemoryHttpConstants.EXPIRES_SERIALIZE_SIZE, Integer.toString( bytes.length ) );
    }

    protected ContentTypeHandler findPutCacheContentTypeHandler( HttpServletRequest req, HttpServletResponse response )
    {

        String contentType = req.getContentType();
        if ( StringUtils.startsWith( contentType, MediaType.APPLICATION_JSON ) )
        {
            // 	application/json
            return contentTypeHandlers.get( MediaType.APPLICATION_JSON );
        }
        else if ( StringUtils.startsWith( contentType, MediaType.TEXT_PLAIN ) )
        {
            // text/plain
            return contentTypeHandlers.get( MediaType.TEXT_PLAIN );
        }
        return contentTypeHandlers.get( contentType );
    }

    @Override
    protected void doDelete( HttpServletRequest req, HttpServletResponse resp )
        throws ServletException, IOException
    {
        String path = req.getPathInfo();
        String servletPath = req.getServletPath();
        String key = retrieveKeyFromPath( path );

        Pointer pointer = cacheService.getPointer( key );
        if ( pointer == null )
        {
            resp.sendError( HttpServletResponse.SC_NO_CONTENT, "No content for key: " + key );
            return;
        }
        cacheService.free( pointer );
        log.debug( "free content of key: {}", key );
    }

    @Override
    protected void doGet( HttpServletRequest req, HttpServletResponse resp )
        throws ServletException, IOException
    {
        // url format = /cache/key so get the key from path
        String path = req.getPathInfo();
        String servletPath = req.getServletPath();
        String key = retrieveKeyFromPath( path );

        if ( StringUtils.isEmpty( key ) )
        {
            resp.sendError( HttpServletResponse.SC_BAD_REQUEST, "key missing in path" );
            return;
        }

        String acceptContentType = req.getHeader( "Accept" );

        if ( StringUtils.isEmpty( acceptContentType ) )
        {
            resp.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                            "you must specify Accept with Content-Type you want in the response" );
            return;
        }

        ContentTypeHandler contentTypeHandler = findGetCacheContentTypeHandler( req, resp );

        if ( contentTypeHandler == null )
        {
            String contentType = req.getContentType();
            log.error( "No content type handler for content type {}", acceptContentType );
            resp.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                            "Content-Type: " + acceptContentType + " not supported" );
            return;
        }

        byte[] bytes = cacheService.retrieveByteArray( key );

        log.debug( "return content size {} for key {}", ( bytes == null ? "null" : bytes.length ), key );

        if ( bytes == null || bytes.length == 0 )
        {
            resp.sendError( HttpServletResponse.SC_NO_CONTENT, "No content for key: " + key );
            return;
        }

        try
        {
            byte[] respBytes =
                contentTypeHandler.handleGet( new DirectMemoryRequest().setKey( key ), bytes, resp, req );
            resp.getOutputStream().write( respBytes );
        }
        catch ( DirectMemoryException e )
        {
            resp.sendError( HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage() );
        }


    }

    protected ContentTypeHandler findGetCacheContentTypeHandler( HttpServletRequest req, HttpServletResponse response )
    {

        String acceptContentType = req.getHeader( "Accept" );
        if ( StringUtils.contains( acceptContentType, MediaType.APPLICATION_JSON ) )
        {
            // 	application/json
            return contentTypeHandlers.get( MediaType.APPLICATION_JSON );
        }
        else if ( StringUtils.startsWith( acceptContentType, MediaType.TEXT_PLAIN ) )
        {
            return contentTypeHandlers.get( MediaType.TEXT_PLAIN );
        }
        return contentTypeHandlers.get( acceptContentType );
    }

    /**
     * protected for unit test reason
     *
     * @param path
     * @return
     */

    protected String retrieveKeyFromPath( String path )
    {
        if ( StringUtils.endsWith( path, "/" ) )
        {
            return StringUtils.substringAfterLast( StringUtils.substringBeforeLast( path, "/" ), "/" );
        }
        return StringUtils.substringAfterLast( path, "/" );
    }
}