Package it.eng.spago.dispatching.httpchannel

Source Code of it.eng.spago.dispatching.httpchannel.AdapterHTTP

/**
* SpagoBI - The Business Intelligence Free Platform
*
* Copyright (C) 2004 - 2008 Engineering Ingegneria Informatica S.p.A.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*
**/
package it.eng.spago.dispatching.httpchannel;

import it.eng.spago.base.Constants;
import it.eng.spago.base.RequestContainer;
import it.eng.spago.base.ResponseContainer;
import it.eng.spago.base.ResponseContainerAccess;
import it.eng.spago.base.SessionContainer;
import it.eng.spago.base.SourceBean;
import it.eng.spago.base.SourceBeanException;
import it.eng.spago.configuration.ConfigSingleton;
import it.eng.spago.dispatching.coordinator.CoordinatorIFace;
import it.eng.spago.dispatching.coordinator.DispatcherManager;
import it.eng.spago.dispatching.httpchannel.upload.IUploadHandler;
import it.eng.spago.dispatching.httpchannel.upload.UploadFactory;
import it.eng.spago.dispatching.service.DefaultRequestContext;
import it.eng.spago.dispatching.service.RequestContextIFace;
import it.eng.spago.dispatching.service.ServiceIFace;
import it.eng.spago.error.EMFErrorHandler;
import it.eng.spago.error.EMFErrorSeverity;
import it.eng.spago.error.EMFInternalError;
import it.eng.spago.error.SessionExpiredException;
import it.eng.spago.event.EventNotifierFactory;
import it.eng.spago.event.IEventNotifier;
import it.eng.spago.event.ServiceEndEvent;
import it.eng.spago.event.ServiceStartEvent;
import it.eng.spago.exception.EMFExceptionHandler;
import it.eng.spago.navigation.LightNavigationManager;
import it.eng.spago.navigation.Navigator;
import it.eng.spago.presentation.Publisher;
import it.eng.spago.presentation.PublisherConfiguration;
import it.eng.spago.presentation.rendering.RenderIFace;
import it.eng.spago.presentation.rendering.RenderManager;
import it.eng.spago.tracing.TracerSingleton;
import it.eng.spago.util.Serializer;

import java.io.IOException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.servlet.ServletRequestContext;

import com.jamonapi.Monitor;
import com.jamonapi.MonitorFactory;

// TODO: Auto-generated Javadoc
/**
* The Class AdapterHTTP.
*/
public class AdapterHTTP extends HttpServlet {

    /** The Constant serialVersionUID. */
    private static final long serialVersionUID = 1L;

    /** The Constant NEW_SESSION. */
    public static final String NEW_SESSION = "NEW_SESSION";

    /** The Constant HTTP_CONTENT_TYPE. */
    public static final String HTTP_CONTENT_TYPE = "text/html";

    /** The Constant WAP_CONTENT_TYPE. */
    public static final String WAP_CONTENT_TYPE = "text/vnd.wap.wml";

    /** The Constant XML_CONTENT_TYPE. */
    public static final String XML_CONTENT_TYPE = "text/xml";

    /** The Constant HTTP_REQUEST_AUTH_TYPE. */
    public static final String HTTP_REQUEST_AUTH_TYPE = "HTTP_REQUEST_AUTH_TYPE";

    /** The Constant HTTP_REQUEST_CHARACTER_ENCODING. */
    public static final String HTTP_REQUEST_CHARACTER_ENCODING = "HTTP_REQUEST_CHARACTER_ENCODING";

    /** The Constant HTTP_REQUEST_CONTENT_LENGTH. */
    public static final String HTTP_REQUEST_CONTENT_LENGTH = "HTTP_REQUEST_CONTENT_LENGTH";

    /** The Constant HTTP_REQUEST_CONTENT_TYPE. */
    public static final String HTTP_REQUEST_CONTENT_TYPE = "HTTP_REQUEST_CONTENT_TYPE";

    /** The Constant HTTP_REQUEST_CONTEXT_PATH. */
    public static final String HTTP_REQUEST_CONTEXT_PATH = "HTTP_REQUEST_CONTEXT_PATH";

    /** The Constant HTTP_REQUEST_METHOD. */
    public static final String HTTP_REQUEST_METHOD = "HTTP_REQUEST_METHOD";

    /** The Constant HTTP_REQUEST_PATH_INFO. */
    public static final String HTTP_REQUEST_PATH_INFO = "HTTP_REQUEST_PATH_INFO";

    /** The Constant HTTP_REQUEST_PATH_TRANSLATED. */
    public static final String HTTP_REQUEST_PATH_TRANSLATED = "HTTP_REQUEST_PATH_TRANSLATED";

    /** The Constant HTTP_REQUEST_PROTOCOL. */
    public static final String HTTP_REQUEST_PROTOCOL = "HTTP_REQUEST_PROTOCOL";

    /** The Constant HTTP_REQUEST_QUERY_STRING. */
    public static final String HTTP_REQUEST_QUERY_STRING = "HTTP_REQUEST_QUERY_STRING";

    /** The Constant HTTP_REQUEST_REMOTE_ADDR. */
    public static final String HTTP_REQUEST_REMOTE_ADDR = "HTTP_REQUEST_REMOTE_ADDR";

    /** The Constant HTTP_REQUEST_REMOTE_HOST. */
    public static final String HTTP_REQUEST_REMOTE_HOST = "HTTP_REQUEST_REMOTE_HOST";

    /** The Constant HTTP_REQUEST_REMOTE_USER. */
    public static final String HTTP_REQUEST_REMOTE_USER = "HTTP_REQUEST_REMOTE_USER";

    /** The Constant HTTP_REQUEST_REQUESTED_SESSION_ID. */
    public static final String HTTP_REQUEST_REQUESTED_SESSION_ID = "HTTP_REQUEST_REQUESTED_SESSION_ID";

    /** The Constant HTTP_REQUEST_REQUEST_URI. */
    public static final String HTTP_REQUEST_REQUEST_URI = "HTTP_REQUEST_REQUEST_URI";

    /** The Constant HTTP_REQUEST_SCHEME. */
    public static final String HTTP_REQUEST_SCHEME = "HTTP_REQUEST_SCHEME";

    /** The Constant HTTP_REQUEST_SERVER_NAME. */
    public static final String HTTP_REQUEST_SERVER_NAME = "HTTP_REQUEST_SERVER_NAME";

    /** The Constant HTTP_REQUEST_SERVER_PORT. */
    public static final String HTTP_REQUEST_SERVER_PORT = "HTTP_REQUEST_SERVER_PORT";

    /** The Constant HTTP_REQUEST_SERVLET_PATH. */
    public static final String HTTP_REQUEST_SERVLET_PATH = "HTTP_REQUEST_SERVLET_PATH";

    /** The Constant HTTP_REQUEST_USER_PRINCIPAL. */
    public static final String HTTP_REQUEST_USER_PRINCIPAL = "HTTP_REQUEST_USER_PRINCIPAL";

    /** The Constant HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_COOKIE. */
    public static final String HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_COOKIE = "HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_COOKIE";

    /** The Constant HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_URL. */
    public static final String HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_URL = "HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_URL";

    /** The Constant HTTP_REQUEST_REQUESTED_SESSION_ID_VALID. */
    public static final String HTTP_REQUEST_REQUESTED_SESSION_ID_VALID = "HTTP_REQUEST_REQUESTED_SESSION_ID_VALID";

    /** The Constant HTTP_REQUEST_SECURE. */
    public static final String HTTP_REQUEST_SECURE = "HTTP_REQUEST_SECURE";

    /** The Constant HTTP_ACCEPT_HEADER. */
    public static final String HTTP_ACCEPT_HEADER = "ACCEPT";

    /** The Constant WAP_MIME_TYPE. */
    public static final String WAP_MIME_TYPE = "vnd.wap";

    /** The Constant HTTP_SESSION_ID. */
    public static final String HTTP_SESSION_ID = "HTTP_SESSION_ID";
   
    /** The Constant HTTP_REQUESTED_WITH. */
    public static final String HTTP_REQUESTED_WITH = "x-requested-with";
       
    /** The Constant XMLHTTPREQUEST. */
    public static final String XMLHTTPREQUEST = "XMLHttpRequest";

    /** The Constant SERIALIZE_SESSION_ATTRIBUTE. */
    private static final String SERIALIZE_SESSION_ATTRIBUTE = "COMMON.SERIALIZE_SESSION";

    // Atributo della configurazione che indica se serializzare il contenuto
    // della sessione
    /** The serialize session. */
    private boolean serializeSession = false;

   
    /**
     * Handle query string field.
     *
     * @param request the request
     * @param serviceReq the service req
     * @param queryStringFieldName the query string field name
     *
     * @throws SourceBeanException the source bean exception
     */
    private void handleQueryStringField(HttpServletRequest request,SourceBean serviceReq,String queryStringFieldName) throws SourceBeanException {
     
      String queryString = queryStringFieldName.substring(queryStringFieldName.indexOf("{")+1, queryStringFieldName.indexOf("}"));
     
      StringTokenizer st = new StringTokenizer(queryString, "&", false);
     
      String parameterToken = null;
      String parameterName = null;
      String parameterValue = null;
      while (st.hasMoreTokens()){
        parameterToken = st.nextToken();
        parameterName = parameterToken.substring(0, parameterToken.indexOf("="));
        parameterValue = parameterToken.substring(parameterToken.indexOf("=")+1);
        if (serviceReq.containsAttribute(parameterName)){
          serviceReq.updAttribute(parameterName, parameterValue);
        } else {
          serviceReq.setAttribute(parameterName, parameterValue);
        }
      }
     
    }
   
    /**
     * Make the service name available in request also if the service was invoked with the
     * .action or .page URL
     *
     * @param requestContainer Current RequestContainer
     * @param serviceRequest Current request
     */
    private void handleServiceName(SourceBean serviceRequest, final RequestContainer requestContainer) {
      String path = ((String)requestContainer.getAttribute(HTTP_REQUEST_SERVLET_PATH)).toUpperCase();
      try {
            if (path.endsWith(Constants.ACTION_URL_PATTERN)) {
              serviceRequest.setAttribute(Constants.ACTION_NAME, path.substring(1, path.length() - Constants.ACTION_URL_PATTERN.length()));
            } else if (path.endsWith(Constants.PAGE_URL_PATTERN)) {
              serviceRequest.setAttribute(Constants.PAGE, path.substring(1, path.length() - Constants.PAGE_URL_PATTERN.length()));
            }
      } catch (SourceBeanException ex) {
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.WARNING,
                    "AdapterHTTP::handleServiceName: ", ex);
      }
    }
   
    /**
     * Handle suspend resume.
     *
     * @param serviceRequest the service request
     * @param requestContainer the request container
     *
     * @throws SourceBeanException the source bean exception
     */
    private void handleSuspendResume(SourceBean serviceRequest, RequestContainer requestContainer)
      throws SourceBeanException {
        String deleteSuspendResumeId = (String)serviceRequest.getAttribute("DELETE_SUSPEND_RESUME_ID");
        if ((deleteSuspendResumeId != null) && (deleteSuspendResumeId.trim().length() > 0)){
          TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.INFORMATION,
          "AdapterHTTP::service: DELETE_SUSPEND_RESUME_ID ["+deleteSuspendResumeId+"] FOUND IN SERVICE REQUEST : DELETE SUSPEND RESUME CONTAINERS");
          SessionContainer aPermanentContainer = requestContainer.getSessionContainer().getPermanentContainer();
          SourceBean suspendedResumeContainers = (SourceBean)aPermanentContainer.getAttribute(deleteSuspendResumeId);
          /*
          TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.INFORMATION,
          "AdapterHTTP::service: DELETE_SUSPEND_RESUME_ID Container to delete" + suspendedResumeContainers);
          */
          if (suspendedResumeContainers != null){
            aPermanentContainer.delAttribute(deleteSuspendResumeId);
          }
          /*
          suspendedResumeContainers = (SourceBean)aPermanentContainer.getAttribute(deleteSuspendResumeId);
          TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.INFORMATION,
          "AdapterHTTP::service: DELETE_SUSPEND_RESUME_ID Container to delete" + suspendedResumeContainers);
          */
       
        // Suspend Service Request
        String suspendResumeId = (String)serviceRequest.getAttribute("SUSPEND_RESUME_ID");
        if ((suspendResumeId != null) && (suspendResumeId.trim().length() > 0)){
          TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.INFORMATION,
          "AdapterHTTP::service: SUSPEND_RESUME_ID ["+suspendResumeId+"] FOUND IN SERVICE REQUEST SUSPEND CURRENT SERVICE REQUEST");
          SessionContainer aPermanentContainer = requestContainer.getSessionContainer().getPermanentContainer();
          SourceBean suspendedResumeContainers = (SourceBean)aPermanentContainer.getAttribute(suspendResumeId);
           
            if (suspendedResumeContainers == null) {
                TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.WARNING,
                        "AdapterHTTP::service: SUSPENDED-RESUME-CONTAINER NOT FOUND");
            } else if (suspendedResumeContainers.getAttribute(Constants.SERVICE_REQUEST) != null){
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.INFORMATION,
                "AdapterHTTP::service: SUSPENDED-RESUME-CONTAINER CONTAINS ALREADY A SERVICE REQUEST OVERWRITE IT");
            suspendedResumeContainers.updAttribute(serviceRequest);
          } else {
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.INFORMATION,
                "AdapterHTTP::service: SUSPENDED-RESUME-CONTAINER CONTAINS ALREADY A SERVICE REQUEST WRITE IT");
            suspendedResumeContainers.setAttribute(serviceRequest);
          }
        }
    }
   
    /**
     * Handle multipart form.
     *
     * @param request the request
     * @param requestContext the request context
     *
     * @throws Exception the exception
     */
    private void handleMultipartForm(HttpServletRequest request, RequestContextIFace requestContext)
      throws Exception{
      SourceBean serviceRequest = requestContext.getServiceRequest();
     
      // Create a factory for disk-based file items
      FileItemFactory factory = new DiskFileItemFactory();
     
        // Create a new file upload handler
      ServletFileUpload upload = new ServletFileUpload(factory);

        // Parse the request
        List fileItems = upload.parseRequest(request);
        Iterator iter = fileItems.iterator();
        while (iter.hasNext()) {
            FileItem item = (FileItem) iter.next();

            if (item.isFormField()) {
                String name = item.getFieldName();
                String value = item.getString();
                serviceRequest.setAttribute(name, value);
            } else {
                processFileField(item, requestContext);
            }
        }
    }
   
    /**
     * Handle simple form.
     *
     * @param request the request
     * @param requestContext the request context
     *
     * @throws SourceBeanException the source bean exception
     */
    private void handleSimpleForm(HttpServletRequest request, RequestContextIFace requestContext)
      throws SourceBeanException{
      SourceBean serviceRequest = requestContext.getServiceRequest();
        Enumeration names = request.getParameterNames();
        while (names.hasMoreElements()) {
            String parameterName = (String) names.nextElement();
           
            if (parameterName.startsWith("QUERY_STRING")){
              handleQueryStringField(request, serviceRequest, parameterName);
            }else{
              String[] parameterValues = request.getParameterValues(parameterName);
              if (parameterValues != null)
                for (int i = 0; i < parameterValues.length; i++)
                  serviceRequest.setAttribute(parameterName, parameterValues[i]);
            }
        } // while (names.hasMoreElements())
    }
   
    /* (non-Javadoc)
     * @see javax.servlet.http.HttpServlet#service(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
     */
    public void service(HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException {
        Monitor monitor = null;
      IEventNotifier eventNotifier = null;
      RequestContextIFace requestContext = null;

        try {
          SourceBean serviceRequest = null;
            EMFErrorHandler emfErrorHandler = null;
            EMFExceptionHandler exceptionHandler = new EMFExceptionHandler();
           
            // Retrieve LOOP responseContainer, if any
            ResponseContainer loopbackResponseContainer = ResponseContainer.getResponseContainer();
           
            RequestContainer requestContainer = new RequestContainer();
            RequestContainer.setRequestContainer(requestContainer);
           
            ResponseContainer responseContainer = new ResponseContainer();
            ResponseContainer.setResponseContainer(responseContainer);
           
            requestContext = new DefaultRequestContext(requestContainer,
                    responseContainer);
           
            // Retrieve HTTP session
            HttpSession session = request.getSession(true);

          eventNotifier = EventNotifierFactory.getEventNotifier();
          eventNotifier.notifyEvent(
                new ServiceStartEvent(session),
                requestContext);           
          // Trace only after calling listener, so the session id can be written on log files
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                      "AdapterHTTP::service: invocato");

            boolean loopback = (request.getAttribute(Constants.PUBLISHING_MODE_LOOPBACK) != null);
            if (loopback) {
                TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                "AdapterHTTP::service: loop-back rilevato");

                // remove from the request the loopback attribute
              request.removeAttribute(Constants.PUBLISHING_MODE_LOOPBACK);
           
                loopbackResponseContainer = ResponseContainerAccess.getResponseContainer(request);
                serviceRequest = loopbackResponseContainer.getLoopbackServiceRequest();
                if (serviceRequest == null) {
                    serviceRequest = new SourceBean(Constants.SERVICE_REQUEST);
                } else {
                    Object newServiceRequest = serviceRequest
                            .getAttribute(Constants.SERVICE_REQUEST);
                    if ((newServiceRequest != null) && (newServiceRequest instanceof SourceBean))
                        serviceRequest = (SourceBean) newServiceRequest;
                } // if (serviceRequest == null)
                requestContainer.setServiceRequest(serviceRequest);
               
                // The errors are kept in loop mode, so retrieve old error handler
                emfErrorHandler = loopbackResponseContainer.getErrorHandler();
               
                if (emfErrorHandler == null) {
                    emfErrorHandler = new EMFErrorHandler();
                }
            } // if (loopbackResponseContainer != null)
            else {
                monitor = MonitorFactory.start("controller.adapter.http");
                serviceRequest = new SourceBean(Constants.SERVICE_REQUEST);
                requestContainer.setServiceRequest(serviceRequest);

                // Get header parameter before parsing the request
                setHttpRequestData(request, requestContainer);
               
                // Check if the service was invoked with the .action or .page URL
                handleServiceName(serviceRequest, requestContainer);
               
                boolean isMultipart = ServletFileUpload.isMultipartContent(new ServletRequestContext(request));
                if (isMultipart) {
                  handleMultipartForm(request, requestContext);
                } else {
                  handleSimpleForm(request, requestContext);
                }

                emfErrorHandler = new EMFErrorHandler();
            } // if (loopbackResponseContainer != null) else

           
            //***************** NAVIGATION CONTROL *******************************************************
            serviceRequest = LightNavigationManager.controlLightNavigation(request, serviceRequest);
            requestContainer.setServiceRequest(serviceRequest);
            //********************************************************************************************
           
            Exception serviceException = null;
            CoordinatorIFace coordinator = null;
            try {
              responseContainer.setErrorHandler(emfErrorHandler);
             
              String channelType = Constants.HTTP_CHANNEL;
              String channelTypeParameter = (String) (serviceRequest
                      .getAttribute(Constants.CHANNEL_TYPE));
              String channelTypeHeader = (String) (requestContainer.getAttribute(HTTP_ACCEPT_HEADER));
              if (((channelTypeParameter != null) && channelTypeParameter
                      .equalsIgnoreCase(Constants.WAP_CHANNEL))
                      || ((channelTypeHeader != null) && (channelTypeHeader.indexOf(WAP_MIME_TYPE) != -1)))
                  channelType = Constants.WAP_CHANNEL;
              requestContainer.setChannelType(channelType);
              requestContainer.setInternalRequest(request);
              requestContainer.setInternalResponse(response);
              requestContainer.setAdapterConfig(getServletConfig());
              TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                      "AdapterHTTP::service: requestContainer", requestContainer);
              TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                      "AdapterHTTP::service: sessionContainer", requestContainer
                              .getSessionContainer());
 
              SourceBean serviceResponse = new SourceBean(Constants.SERVICE_RESPONSE);
              responseContainer.setServiceResponse(serviceResponse);

              checkSession(session, requestContext);
                Navigator.checkNavigation(requestContainer);
             
              // Refresh service request because Navigator services can changed it
              serviceRequest = requestContainer.getServiceRequest();
             
              // Suspend/Resume service
              handleSuspendResume(serviceRequest, requestContainer);
             
              coordinator = DispatcherManager.getCoordinator(requestContext);
              if (coordinator == null) {
                  TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.WARNING,
                          "AdapterHTTP::service: coordinator nullo !");
                  serviceException = new Exception("Coordinatore non trovato");
                  emfErrorHandler.addError(new EMFInternalError(EMFErrorSeverity.ERROR,
                          "Coordinatore non trovato !"));
              } // if (coordinator == null)
              else {
                  ((RequestContextIFace) coordinator).setRequestContext(requestContext);
                  responseContainer.setBusinessType(coordinator.getBusinessType());
                  responseContainer.setBusinessName(coordinator.getBusinessName());
                  responseContainer.setPublisherName(coordinator.getPublisherName());
                      coordinator.service(serviceRequest, serviceResponse);
                     
                    ((RequestContextIFace) coordinator).setRequestContext(null);
//                    requestContainer.setInternalRequest(null);
              } // if (coordinator == null) else

            } // try
            catch (Exception ex) {
              ServiceIFace service = (coordinator != null)? coordinator.getService() : null;
              exceptionHandler.handleException(ex, service, requestContext);
            } // catch (Exception ex)
           
//            requestContainer.setInternalResponse(null);
//            requestContainer.setAdapterConfig(null);
            // nel caso in cui sia attiva la persistenza della sessione
            // forza la scrittura sul database
            synchronized (session) {
                session.setAttribute(Constants.REQUEST_CONTAINER, session.getAttribute(Constants.REQUEST_CONTAINER));
            } // synchronized (session)
           
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                    "AdapterHTTP::service: responseContainer", responseContainer);
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                    "AdapterHTTP::service: sessionContainer", requestContainer
                            .getSessionContainer());

            if (serializeSession) {
                TracerSingleton
                        .log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                                "AdapterHTTP::service: sessionContainer size ["
                                        + Serializer.serialize(requestContainer
                                                .getSessionContainer()).length + "]");
            }

            render(requestContext, serviceException);
        } // try
        catch (Exception ex) {
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.CRITICAL,
                    "AdapterHTTP::service: ", ex);
        } // catch (Excpetion ex) try
        finally {
            RequestContainer.delRequestContainer();
            ResponseContainer.delResponseContainer();
            if (monitor != null) {
                monitor.stop();
            }
           
            if (eventNotifier != null) {
              eventNotifier.notifyEvent(
                new ServiceEndEvent(null),
                requestContext);
            }
           
        } // finally
    } // public void service(HttpServletRequest request, HttpServletResponse
    // response) throws IOException, ServletException

    /**
     * Process file field.
     *
     * @param item the item
     * @param requestContext the request context
     *
     * @throws Exception the exception
     */
    private void processFileField(final FileItem item, RequestContextIFace requestContext)
            throws Exception {
        String uploadManagerName = (String)ConfigSingleton.getInstance().getAttribute("UPLOAD.UPLOAD-MANAGER.NAME");
        if (uploadManagerName == null) {
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.CRITICAL,
                    "AdapterHTTP::processFileField: metodo di upload non selezionato");
        }
       
        IUploadHandler uploadHandler = UploadFactory.getHandler(uploadManagerName);
        if (uploadHandler instanceof RequestContextIFace) {
            ((RequestContextIFace) uploadHandler).setRequestContext(requestContext);
        }
        uploadHandler.upload(item);
    }
   
    /**
     * Check session.
     *
     * @param session the session
     * @param requestContext the request context
     *
     * @throws SessionExpiredException the session expired exception
     */
    private void checkSession(HttpSession session, RequestContextIFace requestContext)
      throws SessionExpiredException {
     
      // start modifications by Zerbetto on 25-02-2008: NEW_SESSION parameter can force a new session
        boolean isRequestedSessionIdValid = true;
        boolean isRequiredNewSession = false;    // Zerbetto on 25-02-2008
        RequestContainer requestContainer = requestContext.getRequestContainer();
               
        if (session.isNew()) {
            isRequestedSessionIdValid = (requestContainer.getAttribute(HTTP_REQUEST_REQUESTED_SESSION_ID) == null);
          String newSessionRequestAttr = (String) requestContainer.getServiceRequest().getAttribute(NEW_SESSION); // Zerbetto on 25-02-2008
          isRequiredNewSession = newSessionRequestAttr != null && newSessionRequestAttr.equalsIgnoreCase("TRUE"); // Zerbetto on 25-02-2008
        } // if (session.isNew())
        synchronized (session) {
            RequestContainer parentRequestContainer = (RequestContainer) session
                    .getAttribute(Constants.REQUEST_CONTAINER);
            if (!Navigator.isNavigatorEnabled()) {
                if (parentRequestContainer == null)
                    requestContainer.setSessionContainer(new SessionContainer(true));
                else
                    requestContainer.setSessionContainer(parentRequestContainer
                            .getSessionContainer());
            }
            else {
                if (parentRequestContainer == null)
                    requestContainer.setSessionContainer(new SessionContainer(true));
                else {
                    requestContainer.setSessionContainer(new SessionContainer(false));
                    requestContainer.setParent(parentRequestContainer);
                } // if (parentRequestContainer == null) else
            } // if (!Navigator.isNavigatorEnabled())
            session.setAttribute(Constants.REQUEST_CONTAINER, requestContainer);
        } // synchronized (session)
        if (!isRequestedSessionIdValid) {
          if (!isRequiredNewSession) { // Zerbetto on 25-02-2008
              TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.WARNING,
                      "AdapterHTTP::service: sessione scaduta !");
              throw new SessionExpiredException(EMFErrorSeverity.ERROR, "Expired Session");
          } // Zerbetto on 25-02-2008
        } // if (!isRequestedSessionIdValid)
        // end modifications by Zerbetto on 25-02-2008: NEW_SESSION parameter can force a new session
    }

    /**
     * Render.
     *
     * @param requestContext the request context
     * @param serviceException the service exception
     *
     * @throws Exception the exception
     */
    private void render(RequestContextIFace requestContext, Exception serviceException)
            throws Exception {
        ResponseContainer responseContainer = requestContext.getResponseContainer();
      
        Boolean isHttpResponseFreezed = (Boolean) responseContainer
                .getAttribute(Constants.HTTP_RESPONSE_FREEZED);
        if ((isHttpResponseFreezed == null) || (!isHttpResponseFreezed.booleanValue())) {
         
          // Retrieve publisher configuration for current service
            PublisherConfiguration publisherConfig = Publisher.getPublisherConfiguration(requestContext,
                    serviceException);
           
            try {
              // Retrieve renderer according to publisher type and channel type
            RenderIFace renderer = RenderManager.getInstance().getRenderer(publisherConfig);

            // Store in session last used publisher name
              Publisher.setLastPublisherName(publisherConfig.getName());

              // Setup phase
              renderer.prepareRender(requestContext, publisherConfig, getServletContext());
             
              // Render phase
              renderer.render(requestContext, publisherConfig, getServletContext());
            } finally {
              // Allow better garbage collection
              publisherConfig.release();
            }

        } // if ((isHttpResponseFreezed == null) ||
        // (!isHttpResponseFreezed.getBoolean()))
        else
            TracerSingleton.log(Constants.NOME_MODULO, TracerSingleton.DEBUG,
                    "AdapterHTTP::service: http response congelata");
    }

    /**
     * Sets the http request data.
     *
     * @param request the request
     * @param requestContainer the request container
     */
    private void setHttpRequestData(HttpServletRequest request, RequestContainer requestContainer) {
        requestContainer.setAttribute(HTTP_REQUEST_AUTH_TYPE, request.getAuthType());
        requestContainer.setAttribute(HTTP_REQUEST_CHARACTER_ENCODING, request.getCharacterEncoding());
        requestContainer.setAttribute(HTTP_REQUEST_CONTENT_LENGTH, String.valueOf(request
                .getContentLength()));
        requestContainer.setAttribute(HTTP_REQUEST_CONTENT_TYPE, request.getContentType());
        requestContainer.setAttribute(HTTP_REQUEST_CONTEXT_PATH, request.getContextPath());
        requestContainer.setAttribute(HTTP_REQUEST_METHOD, request.getMethod());
        requestContainer.setAttribute(HTTP_REQUEST_PATH_INFO, request.getPathInfo());
        requestContainer.setAttribute(HTTP_REQUEST_PATH_TRANSLATED, request.getPathTranslated());
        requestContainer.setAttribute(HTTP_REQUEST_PROTOCOL, request.getProtocol());
        requestContainer.setAttribute(HTTP_REQUEST_QUERY_STRING, request.getQueryString());
        requestContainer.setAttribute(HTTP_REQUEST_REMOTE_ADDR, request.getRemoteAddr());
        requestContainer.setAttribute(HTTP_REQUEST_REMOTE_HOST, request.getRemoteHost());
        requestContainer.setAttribute(HTTP_REQUEST_REMOTE_USER, request.getRemoteUser());
        requestContainer.setAttribute(HTTP_REQUEST_REQUESTED_SESSION_ID, request
                .getRequestedSessionId());
        requestContainer.setAttribute(HTTP_REQUEST_REQUEST_URI, request.getRequestURI());
        requestContainer.setAttribute(HTTP_REQUEST_SCHEME, request.getScheme());
        requestContainer.setAttribute(HTTP_REQUEST_SERVER_NAME, request.getServerName());
        requestContainer.setAttribute(HTTP_REQUEST_SERVER_PORT, String.valueOf(request
                .getServerPort()));
        requestContainer.setAttribute(HTTP_REQUEST_SERVLET_PATH, request.getServletPath());
        if (request.getUserPrincipal() != null)
            requestContainer.setAttribute(HTTP_REQUEST_USER_PRINCIPAL, request.getUserPrincipal());
        requestContainer.setAttribute(HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_COOKIE, String
                .valueOf(request.isRequestedSessionIdFromCookie()));
        requestContainer.setAttribute(HTTP_REQUEST_REQUESTED_SESSION_ID_FROM_URL, String
                .valueOf(request.isRequestedSessionIdFromURL()));
        requestContainer.setAttribute(HTTP_REQUEST_REQUESTED_SESSION_ID_VALID, String
                .valueOf(request.isRequestedSessionIdValid()));
        requestContainer.setAttribute(HTTP_REQUEST_SECURE, String.valueOf(request.isSecure()));
        Enumeration headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = (String) headerNames.nextElement();
            String headerValue = request.getHeader(headerName);
            requestContainer.setAttribute(headerName, headerValue);
        } // while (headerNames.hasMoreElements())
        requestContainer.setAttribute(HTTP_SESSION_ID, request.getSession().getId());
        requestContainer.setAttribute(Constants.HTTP_IS_XML_REQUEST, "FALSE");
    } // private void setHttpRequestData(HttpServletRequest request,

    // RequestContainer requestContainer)

    /*
     * (non-Javadoc)
     *
     * @see javax.servlet.GenericServlet#init()
     */
    public void init() throws ServletException {
        super.init();

        String serializeSessionStr = (String) ConfigSingleton.getInstance().getAttribute(
                SERIALIZE_SESSION_ATTRIBUTE);
        if ((serializeSessionStr != null) && (serializeSessionStr.equalsIgnoreCase("TRUE"))) {
            serializeSession = true;
        }
    }

} // public class ActionServlet extends HttpServlet
TOP

Related Classes of it.eng.spago.dispatching.httpchannel.AdapterHTTP

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.