jove.notebook.components.Session.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jove-notebook_2.11 Show documentation
jove-notebook
The newest version!
package jove.notebook.components

import jove.{ Kernel => NBKernel }
import jove.notebook.Protocol
import jove.helpers.Kernels
import jove._
import scalaz._, Scalaz._

sealed trait NotebookSession {
  def kernelId: String
}

object NotebookSession {
  case class EmbeddedNotebookSession(
    kernelId: String,
    kernel: NBKernel,
    interpreter: Interpreter                        
  ) extends NotebookSession

  case class RemoteNotebookSession(
    kernelId: String,
    kernel: NBKernel,
    socket: MessageSocket
  ) extends NotebookSession
}


class Session(kernelComponent: Kernels) {

  private val _sessionsLock = new AnyRef
  private var _sessions = Map.empty[String, NotebookSession]
  private var _dummySessions = Map.empty[String, Protocol.Session]

  private def _newSession(kernelId: String, id: String) =
    for {
      kk <- kernelComponent.kernel(kernelId).map(kernelId.->) toRightDisjunction new Exception("Kernel not found")
      (kernelId, kernel) = kk
      session <- {
        kernel match {
          case k: InterpreterKernel =>
            k.interpreter(Some(getClass.getClassLoader)).map(NotebookSession.EmbeddedNotebookSession(kernelId, kernel, _))
          case k: SocketKernel =>
            k.socket(Some(getClass.getClassLoader)).map(NotebookSession.RemoteNotebookSession(kernelId, kernel, _))
        }
      }
    } yield {
      _sessions += id -> session

      session
    }

  def session(id: String, create: Boolean = false): Option[NotebookSession] =
    _sessions.get(id)

  def sessionOrNew(kernelId: String, id: String): Throwable \/ NotebookSession = _sessionsLock.synchronized {
    _sessions.get(id).map(\/-(_)) getOrElse _newSession(kernelId, id)
  }

  def sessions: List[String] = _sessions.keys.toList

  def dummySessions: Map[String, Protocol.Session] = _sessionsLock.synchronized(_dummySessions)
  def addDummySession(id: String, session: Protocol.Session): Unit = _sessionsLock.synchronized {
    _dummySessions += id -> session
  }
  def deleteDummySession(id: String): Unit = _sessionsLock.synchronized {
    _dummySessions -= id
  }
}