pekko/kernel/src/main/scala/jersey/AkkaServlet.scala

/**
 * Copyright (C) 2009 Scalable Solutions.
 */

package se.scalablesolutions.akka.kernel.jersey

import kernel.Kernel
import config.ConfiguratorRepository
import util.Logging

import com.sun.jersey.api.core.{DefaultResourceConfig, ResourceConfig}
import com.sun.jersey.spi.container.servlet.ServletContainer
import com.sun.jersey.spi.container.WebApplication

import javax.servlet.{ServletConfig}
import javax.servlet.http.{HttpServletRequest,HttpServletResponse}

import org.atmosphere.cpr.{AtmosphereServlet,AtmosphereServletProcessor,AtmosphereEvent}
import org.atmosphere.cpr.AtmosphereServlet.{AtmosphereHandlerWrapper}
import org.atmosphere.container.GrizzlyCometSupport
import org.atmosphere.handler.ReflectorServletProcessor
import org.atmosphere.core.{JerseyBroadcaster}

import java.util.{HashSet, HashMap}
import java.net.{URL,URLClassLoader}
import java.io.{InputStream}

import scala.collection.jcl.Conversions._


class AkkaServlet extends ServletContainer with AtmosphereServletProcessor with Logging {

  override def initiate(rc: ResourceConfig, wa: WebApplication) = {
    //  super.initiate(rc, wa)
    //  log.info("Initializing akka servlet")
    Kernel.boot // will boot if not already booted by 'main'
    val configurators = ConfiguratorRepository.getConfiguratorsFor(getServletContext)
    val set = new HashSet[Class[_]]
    for {
      conf <- configurators
      clazz <- conf.getComponentInterfaces
    } set.add(clazz)

    wa.initiate(
      new DefaultResourceConfig(set),
      new ActorComponentProviderFactory(configurators))
  }

    override def onMessage(event : AtmosphereEvent[HttpServletRequest,HttpServletResponse]) : AtmosphereEvent[_,_] =
    {
        var isUsingStream = false
        try {
            event.getResponse.getWriter
        } catch {
            case e: IllegalStateException => isUsingStream = true
        }

        if (isUsingStream){
            event.getResponse.getOutputStream.write(event.getMessage.toString.getBytes);
            event.getResponse.getOutputStream.flush
        } else {
            event.getResponse.getWriter.write(event.getMessage.toString)
            event.getResponse.getWriter.flush
        }

        event
    }

    override def onEvent(event : AtmosphereEvent[HttpServletRequest,HttpServletResponse]) : AtmosphereEvent[_,_] =
    {
        event.getRequest.setAttribute(classOf[org.atmosphere.cpr.AtmosphereEvent[_,_]].getName, event)
        event.getRequest.setAttribute(classOf[AkkaServlet].getName, this)

        service(event.getRequest, event.getResponse)

        event
    }
}

class AkkaCometServlet extends org.atmosphere.cpr.AtmosphereServlet with Logging
  {
      override def init(sconf : ServletConfig) = {

        val cfg = new AtmosphereConfig

        atmosphereHandlers.put("", new AtmosphereHandlerWrapper(new AkkaServlet,new JerseyBroadcaster()))

        super.setCometSupport(new GrizzlyCometSupport(cfg))
        getCometSupport.init(sconf)

        //Would call super.initAtmosphereServletProcessor(sconf) if they'd let me, but they don't so I roll my own
        for(e <- atmosphereHandlers.entrySet){
            val h = e.getValue.atmosphereHandler
            if(h.isInstanceOf[AtmosphereServletProcessor])
                    (h.asInstanceOf[AtmosphereServletProcessor]).init(sconf)
        }

      }

      override def loadAtmosphereDotXml(is : InputStream, urlc :URLClassLoader) = () //Hide it
  }