AnnotCometServlet.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: AnnotCometServlet.java
 * Description: Servlet for communication with clients (annotation editors)
 */

/**
 * @file AnnotCometServlet.java
 *
 * @brief Servlet for communication with clients (annotation editors)
 */

/**
 * @package cz.vutbr.fit.knot.annotations.comet
 * 
 * @brief Classes related to communication with client, session handling etc.
 */
package cz.vutbr.fit.knot.annotations.comet;

import com.sun.grizzly.comet.CometContext;
import com.sun.grizzly.comet.CometEngine;
import com.sun.grizzly.comet.CometEvent;
import com.sun.grizzly.comet.CometHandler;
import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet for communication with clients (annotation editors)
 *
 * @brief Servlet for communication with clients (annotation editors)
 * @author idytrych
 */
public class AnnotCometServlet extends HttpServlet {

  /** Context path of servlet */
  private String contextPath = null;

  /**
   * Comet handler (handles comet request until timed out or sent data)
   * 
   * This class allow Java components part of an HTTP request to be polled by
   * the Grizzly Asynchronous Request Mechanism. It will be notified when
   * another CometHandler notify them using CometContext.notify. With Servlet,
   * it is recommended to attach the HTTPServletResponse and use this object
   * to push back bytes to the client.
   *
   * @brief Comet handler
   */
  public class AnnotHandler implements CometHandler<HttpServletResponse> {

    /** Servlet response object */
    private HttpServletResponse response;
    /** Client session in which this handler was created */
    private ArrayList<EditorSession> edSessionList = new ArrayList<EditorSession>();
    /** Was message already prepared? */
    private Boolean messagePrepared = false;
    
    /**
     * Event handler
     * Process notify events created in POST requests
     *
     * @param event Event
     * @throws java.io.IOException
     */
    @Override
    public void onEvent(CometEvent event) throws IOException {
      synchronized (messagePrepared) {
        if (messagePrepared) {
          return;
        }
        messagePrepared = true;
        if (CometEvent.NOTIFY == event.getType()) {
          PrintWriter writer = response.getWriter();
          // Flier flier = (Flier) event.attachment();  // gets flier with informations
          // get messages for client
          String responseString = null;
          EditorSession sessionWithMes = null;
          synchronized (edSessionList) {
            sessionWithMes = edSessionList.get(0);
            for (int i = 0; i < edSessionList.size(); i++) {
              if (edSessionList.get(i).hasMessagesTSVC()) {
                sessionWithMes = edSessionList.get(i);
                responseString = sessionWithMes.getAndCleanMessages();
                edSessionList.remove(i);
                edSessionList.add(sessionWithMes);
                break;
              }
            }
          }

          // Recieve protocol version
          int version = sessionWithMes.getNamespacesLOD();

          String sessAtt = " sessionID=\"" + sessionWithMes.getSessionId() + "\"";
          if (sessionWithMes.getProtocolLOD() < Constants.PROTOCOL_LOD_V2) {
            sessAtt = "";
          }

          StringBuilder sb = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\" ?><messages ");

          //Attach namespaces
          for (int i = 0; i < Constants.nameSpaces[version].length; i++) {
            sb.append(Constants.nameSpaces[version][i]);
          }

          if (responseString != null && !responseString.isEmpty()) {
            sb.append(sessAtt).append(">").append(responseString).append("</messages>");
          } else {
            sb.append(sessAtt).append("><ok/></messages>");
          }

          // send to client
          synchronized (contextPath) {
            writer.write(sb.toString());
            writer.flush();
          }

          event.getCometContext().resumeCometHandler(this);
        }
      }
    }  // onEvent()

    /**
     * This method is called when connection is suspended by addCometHandler()
     * 
     * @param event Event
     */
    @Override
    public void onInitialize(CometEvent event) throws IOException {
      synchronized (edSessionList) {
        Iterator<EditorSession> edSessIt = edSessionList.iterator();
        while(edSessIt.hasNext()){
            EditorSession es = edSessIt.next();
            es.setCometHandler(this);
            es.setCometContext(contextPath);
        }
      }
    }

    /**
     * This method is called when connection timed out or if client closes 
     * connnection.
     * If timed out, ok message is sent. If client closes connection, ok message 
     * is sent too (but possibly discarded).
     * 
     * @param event Event
     */
    @Override
    public void onInterrupt(CometEvent event) throws IOException {
      synchronized (messagePrepared) {
        if (messagePrepared) {
          return;
        }
        messagePrepared = true;
        EditorSession sess = this.getFirstSessionAndRotate();
        int version = sess.getNamespacesLOD();
        synchronized (edSessionList) {
          StringBuilder sb = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\" ?><messages ");

          String sessAtt = " sessionID=\"" + sess.getSessionId() + "\"";
          if (sess.getProtocolLOD() < Constants.PROTOCOL_LOD_V2) {
            sessAtt = "";
          }

          for (int i = 0; i < Constants.nameSpaces[version].length; i++) {
            sb.append(Constants.nameSpaces[version][i]);
          }
          sb.append(sessAtt).append("><ok/></messages>");

          PrintWriter writer = response.getWriter();
          writer.write(sb.toString());
          writer.flush();
        }
        event.getCometContext().resumeCometHandler(this);
        removeThisFromContext();
      }
    }  // onInterrupt()

    /**
     * This method is called when connection is resumed and terminated
     * 
     * @param event Event
     */
    @Override
    public void onTerminate(CometEvent event) throws IOException {
      removeThisFromContext();
    }

    /**
     * Attaches an attachment to this class
     * 
     * @param attachment
     */
    @Override
    public void attach(HttpServletResponse attachment) {
      this.response = attachment;
    }

    /**
     * Removes this hadler from comet context
     */
    private void removeThisFromContext() throws IOException {
      response.getWriter().close();
      CometContext context =
              CometEngine.getEngine().getCometContext(contextPath);
      context.removeCometHandler(this);
    }

    /**
     * Gets client session list in which this handler was created
     * 
     * @return Returns client session list in which this handler was created
     */
    public ArrayList<EditorSession> getEdSessionList() {
      return edSessionList;
    }

    /**
     * Sets client session list in which this handler was created
     *
     * @param edSessionList Client session list in which this handler was created
     */
    public void setEdSessionList(ArrayList<EditorSession> edSessionList) {
      this.edSessionList = edSessionList;
    }
    
    /**
     * Gets the latest used session in list in which this handler was created
     * 
     * @return Returns latest used client session in which this handler was created
     */
    public EditorSession getFirstSessionAndRotate(){
      EditorSession first = null;
      synchronized (edSessionList) {
        first = edSessionList.get(0);
        edSessionList.remove(0);
        edSessionList.add(first);
      }
      return first;
    }
    
    /**
     * Adds session to the session list
     * 
     * @param session session for add
     */
    public void addSessionInSessionList(EditorSession session){
      synchronized (edSessionList) {
        this.edSessionList.add(session);
      }
    }
  }  // private class AnnotHandler

  /**
   * Initializes servlet (sets path, timeout etc.)
   *
   * @param config Configuration info
   */
  @Override
  public void init(ServletConfig config) throws ServletException {

    super.init(config);
    ServletContext context = config.getServletContext();
    contextPath = context.getContextPath() + Constants.COMET_CONTEXT_PATH;

    CometEngine engine = CometEngine.getEngine();
    CometContext cometContext = engine.register(contextPath);
    cometContext.setExpirationDelay(Constants.COMET_TIMEOUT_SEC * 1000); // in milliseconds
  }

  /**
   * Handles the HTTP <code>GET</code> method.
   * This method is dedicated for comet requests. Session id is sent as URI
   * parameter "session".
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
//    request.setCharacterEncoding("UTF-8");
    response.setContentType("text/xml;charset=UTF-8");

    // get session id and convert to Long
    String sessionStr = request.getParameter("session");
    if(sessionStr == null || sessionStr.isEmpty()){
     sessionStr = request.getParameter("sessionID"); 
    }
    
    Long sessionId = null;
    try {
      sessionId = Long.decode(sessionStr);
    } catch (NumberFormatException numberFormatException) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        Logger.getLogger(AnnotCometServlet.class.getName()).log(Level.ALL, "Bad session id: " + sessionStr);
      }
      sessionId = null;
    } catch (Exception e) {
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL_ERRORS) {
        Logger.getLogger(AnnotCometServlet.class.getName()).log(Level.ALL, "Bad session id", e);
      }
      sessionId = null;
    }

    EditorSession session = null;
    if (sessionId != null) {
      session = AppBean.getSession(sessionId);  // find session
    }
    if (session == null) {  // if session not exists
      if (Constants.LOG_LEVEL >= Constants.LOG_LEVEL_ALL) {
        Logger.getLogger(AnnotCometServlet.class.getName()).log(Level.ALL, "Session not found");
      }
      PrintWriter writer = response.getWriter();
      // send error message
      String err = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
              + "<messages>\n"
              + RequestInfo.createErrorMsg(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED)
              + "</messages>";
      writer.write(err);
      writer.flush();
      return;
    }

    AppBean.getSessionsCleaner().setSessionConfirm(session.getSessionId());
    
    String resStr = session.getAndCleanMessages();  // get messages for client
    if (!resStr.isEmpty()) {  // if there are messages to send
      // create response XML with messages
      int version = session.getNamespacesLOD();
      StringBuilder sb = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\" ?><messages ");

      String sessAtt = " sessionID=\"" + session.getSessionId() + "\"";
      if (session.getProtocolLOD() < Constants.PROTOCOL_LOD_V2) {
        sessAtt = "";
      }
      
      for(int i = 0; i < Constants.nameSpaces[version].length; i++){
        sb.append(Constants.nameSpaces[version][i]);
      }

      sb.append(sessAtt).append(">").append(resStr).append("</messages>");
      
      // send to client
      PrintWriter resWriter = response.getWriter();
      resWriter.write(sb.toString());
      resWriter.flush();
      return;
    }  // if there are messages to send
    
    // create comet handler
    AnnotHandler handler = new AnnotHandler();
    handler.addSessionInSessionList(session);
    handler.attach(response);

    // sleep and wait to data
    CometEngine engine = CometEngine.getEngine();
    CometContext context = engine.getCometContext(contextPath);
    context.addCometHandler(handler);
  }  // doGet()

  /**
   * Handles the HTTP <code>POST</code> method.
   * If only one message (session) is sent, this is comet request, else this
   * is AJAX request.
   *
   * @param request servlet request
   * @param response servlet response
   * @throws ServletException if a servlet-specific error occurs
   * @throws IOException if an I/O error occurs
   */
  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
//    request.setCharacterEncoding("UTF-8");
    response.setContentType("text/xml;charset=UTF-8");

    BufferedReader bufReader = request.getReader();

    // read XML with messages from client to String
    StringWriter writer = new StringWriter();
    int nextChar;
    while ((nextChar = bufReader.read()) != -1) {
      writer.write(nextChar);
    }
    String messagesStr = writer.toString();
    
    // process messages from client and create object with informations about request
    RequestInfo requestInfo = MessageProcessor.processXML(messagesStr);
    if (requestInfo == null) {  //  if request is bad
      PrintWriter resWriter = response.getWriter();
      // send error message to client
      String err = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
              + "<messages>\n"
              + RequestInfo.createErrorMsg(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_32_BAD_REQUEST)
              + "</messages>";
      resWriter.write(err);
      resWriter.flush();
      return;
    }
    
    // Gettion session
    EditorSession session = requestInfo.getSession(); 

    // If request is not complete - <session id=""> is missing
    if (session == null){
      PrintWriter resWriter = response.getWriter();
      // send error message to client
      String err = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n"
              + "<messages>\n"
              + RequestInfo.createErrorMsg(Constants.PROTOCOL_LOD_V1, Localisation.LANGUAGE_ENG, Localisation.ERROR_31_SESSION_EXPIRED)
              + "</messages>";
      resWriter.write(err);
      resWriter.flush();
      return;
    }
    
    // If only one message in this request is session, this is comet request 
    // through POST
    if (requestInfo.getCometSessionList() != null && !requestInfo.getCometSessionList().isEmpty() 
        && requestInfo.isSessionOnly()) {  // more sessions in one channel

      Iterator<EditorSession> edSessIt = requestInfo.getCometSessionList().iterator();
      while (edSessIt.hasNext()) {
        AppBean.getSessionsCleaner().setSessionConfirm(edSessIt.next().getSessionId());
      }

      String responseString = null;
      EditorSession sessionWithMes = null;
      ArrayList<EditorSession> edSessionList = requestInfo.getCometSessionList();
      
      synchronized (edSessionList) {
        sessionWithMes = edSessionList.get(0);
        for (int i = 0; i < edSessionList.size(); i++) {
          if (edSessionList.get(i).hasMessagesTSVC()) {
            sessionWithMes = edSessionList.get(i);
            responseString = sessionWithMes.getAndCleanMessages();
            edSessionList.remove(i);
            edSessionList.add(sessionWithMes);
            break;
          }
        }
      }
      
      if(responseString != null && !responseString.isEmpty()){
        StringBuilder sb = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\" ?><messages ");
        
        int version = sessionWithMes.getNamespacesLOD();
        

        String sessAtt = " sessionID=\"" + sessionWithMes.getSessionId() + "\"";
        if (sessionWithMes.getProtocolLOD() < Constants.PROTOCOL_LOD_V2) {
          sessAtt = "";
        }
        //Attach namespaces
        for(int i = 0; i < Constants.nameSpaces[version].length; i++){
          sb.append(Constants.nameSpaces[version][i]);
        }

        sb.append(sessAtt).append(">").append(responseString).append("</messages>");

        //Send to client
        PrintWriter resWriter = response.getWriter();
        resWriter.write(sb.toString());
        resWriter.flush();
        return;
      }

      // create comet handler
      AnnotHandler handler = new AnnotHandler();
      handler.setEdSessionList(edSessionList);
      handler.attach(response);

      // sleep and wait to data
      CometEngine engine = CometEngine.getEngine();
      CometContext context = engine.getCometContext(contextPath);
      context.addCometHandler(handler);
      return;

    } else if (requestInfo.getSession() != null && requestInfo.isSessionOnly()) {  // one session
      AppBean.getSessionsCleaner().setSessionConfirm(requestInfo.getSession().getSessionId());
      
      // get messages for client
      String resStr = requestInfo.getSession().getAndCleanMessages();
      if (!resStr.isEmpty()) {  // if there are messages to send
        // create response XML with messages
        int version = session.getNamespacesLOD();
        StringBuilder sb = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\" ?><messages ");
 
        String sessAtt = " sessionID=\"" + session.getSessionId() + "\"";
        if (session.getProtocolLOD() < Constants.PROTOCOL_LOD_V2) {
          sessAtt = "";
        }
        
        for(int i = 0; i < Constants.nameSpaces[version].length; i++){
          sb.append(Constants.nameSpaces[version][i]);
        }
        sb.append(sessAtt).append(">").append(resStr).append("</messages>");
        
        // send to client
        PrintWriter resWriter = response.getWriter();
        resWriter.write(sb.toString());
        resWriter.flush();
        return;
      }  // if there are messages to send
      
      // create comet handler
      AnnotHandler handler = new AnnotHandler();
      handler.addSessionInSessionList(requestInfo.getSession());
      handler.attach(response);

      // sleep and wait to data
      CometEngine engine = CometEngine.getEngine();
      CometContext context = engine.getCometContext(contextPath);
      context.addCometHandler(handler);
      return;
    }  // If only one message in this request is session, ...
    
    if (requestInfo.getSession() != null) {
      AppBean.getSessionsCleaner().setSessionConfirm(requestInfo.getSession().getSessionId());
    }

    if (requestInfo.getCometSessionList() != null && !requestInfo.getCometSessionList().isEmpty()){
        Iterator<EditorSession> edSessIt = requestInfo.getCometSessionList().iterator();
        
        while(edSessIt.hasNext()){
                AppBean.getSessionsCleaner().setSessionConfirm(edSessIt.next().getSessionId());
        }
    }

    // process data from request and create response messages
    // This is done by calling modules and adding other messages (warnings, errors, ...)
    String responseMessages = requestInfo.getReplyText();
    responseMessages = responseMessages + AppBean.getResponseCreator().createPostResponse(requestInfo);
    responseMessages = responseMessages + requestInfo.getWarnings();
    responseMessages = responseMessages + requestInfo.getErrors();
    if (responseMessages.isEmpty()) {  // if no other messages, send <ok/>
      responseMessages = "<ok/>";
    }

    // Create response XML with messages and send to client
    
    PrintWriter resWriter = response.getWriter();

    int version = session.getNamespacesLOD();
    StringBuilder sb = new StringBuilder("<?xml version=\"1.0\" encoding=\"utf-8\" ?><messages ");

    for(int i = 0; i < Constants.nameSpaces[version].length; i++){
      sb.append(Constants.nameSpaces[version][i]);
    }
    sb.append(">").append(responseMessages).append("</messages>");

    synchronized(contextPath){
        resWriter.write(sb.toString());
        resWriter.flush();
    }

    // if it's allowed, create responses for all other connected clients, 
    // store it to their sessions (it will be sent via comet) and notify
    // comet handlers
    if (requestInfo.getCanNotify() && requestInfo.getFlier() != null) {
      ResponseCreator rc = AppBean.getResponseCreator();
      synchronized(AppBean.getSessions()){
        Iterator<EditorSession> sesIt = AppBean.getSessions().iterator();
        while (sesIt.hasNext()) {
          EditorSession es = sesIt.next();
          es.addMessageTS(rc.createCometResponse(requestInfo.getFlier(), es));
        }
      }
    
      // notify comet handlers
      CometEngine engine = CometEngine.getEngine();
      CometContext<?> context = engine.getCometContext(contextPath);
      context.notify(requestInfo.getFlier());
    }
    
  }  // doPost()

  /**
   * Returns a short description of the servlet.
   *
   * @return a String containing servlet description
   */
  @Override
  public String getServletInfo() {
    return "Servlet for communication with annotation editors.";
  }
}  // class AnnotCometServlet