//设置package包名称以及导入依赖的类
#set( $symbol_pound = '#' )
#set( $symbol_dollar = '$' )
#set( $symbol_escape = '\' )
package ${package}

import javax.servlet.ServletContext

import nl.knaw.dans.lib.logging.DebugEnhancedLogging
import org.eclipse.jetty.ajp.Ajp13SocketConnector
import org.eclipse.jetty.server.Server
import org.eclipse.jetty.servlet.ServletContextHandler
import org.scalatra._
import org.scalatra.servlet.ScalatraListener

import scala.util.Try

class ${javaName}Service(serverPort: Int, app: ${javaName}App) extends DebugEnhancedLogging {
  import logger._

  private val server = new Server(serverPort)
  private val context = new ServletContextHandler(ServletContextHandler.NO_SESSIONS)
  context.addEventListener(new ScalatraListener() {
    override def probeForCycleClass(classLoader: ClassLoader): (String, LifeCycle) = {
      ("anonymous", new LifeCycle {
        override def init(context: ServletContext): Unit = {
          context.mount(new ${javaName}Servlet(app), "/")
        }
      })
    }
  })
  server.setHandler(context)
  info(s"HTTP port is ${symbol_dollar}{serverPort}")

  def start(): Try[Unit] = Try {
    info("Starting service...")
    server.start()
  }

  def stop(): Try[Unit] = Try {
    info("Stopping service...")
    server.stop()
  }

  def destroy(): Try[Unit] = Try {
    server.destroy()
    app.close()
  }
} 

//设置package包名称以及导入依赖的类
import javax.servlet.ServletContext

import akka.actor.{ActorSystem, Props}
import com.innoq.integration.{InterceptionController, InterceptionHandler, Launcher, MockController}
import org.scalatra.LifeCycle

class ScalatraBootstrap extends LifeCycle {
  override def init(context: ServletContext) {
    val actorSystem = ActorSystem("test-server")

    val interceptionHandler = actorSystem.actorOf(Props[InterceptionHandler])

    try {
      context.mount(new InterceptionController(actorSystem, interceptionHandler), "/interceptions/*")
      context.mount(new MockController(actorSystem, interceptionHandler), "/mocks/*")
    } catch {
      case e: Throwable =>
        Launcher.stopServer()
        throw e
    }
  }
} 

//设置package包名称以及导入依赖的类
import javax.servlet.ServletContext

import gitbucket.core.plugin.PluginRegistry
import gitbucket.core.service.SystemSettingsService.SystemSettings
import gitbucket.html5media.{Html5VideoRenderer, Html5AudioRenderer, PDFRenderer}
import io.github.gitbucket.solidbase.model.Version

class Plugin extends gitbucket.core.plugin.Plugin {
  override val pluginId: String = "html5media"
  override val pluginName: String = "HTML5 media Plugin"
  override val description: String = "Provides HTML5 video/audio player and PDF viewer for GitBucket."
  override val versions: List[Version] = List(
    new Version("1.0.0"),
    new Version("1.0.1")
  )

  override def initialize(registry: PluginRegistry, context: ServletContext, settings: SystemSettings): Unit = {
    val html5v = new Html5VideoRenderer()
    val html5a = new Html5AudioRenderer()
    val pdf = new PDFRenderer()
    registry.addRenderer("mp4", html5v)
    registry.addRenderer("webm", html5v)
    registry.addRenderer("ogv", html5v)
    registry.addRenderer("mp3", html5a)
    registry.addRenderer("aac", html5a)
    registry.addRenderer("ogg", html5a)
    registry.addRenderer("flac", html5a)
    registry.addRenderer("wav", html5a)
    registry.addRenderer("pdf", pdf)
    super.initialize(registry, context, settings)
  }
} 

//设置package包名称以及导入依赖的类
package com.pagerduty.scheduler.admin.http.standalone

import javax.servlet.ServletContext

import com.pagerduty.scheduler.Scheduler
import com.pagerduty.scheduler.admin.AdminService
import com.pagerduty.scheduler.admin.http.{AdminServlet, Settings}
import org.scalatra.LifeCycle


class ScalatraBootstrap extends LifeCycle {
  override def init(context: ServletContext) {
    val adminService = context.getAttribute(AdminHttpServer.AdminServiceAttributeKey)
    val settings = context.getAttribute(AdminHttpServer.SettingsAttributeKey)

    (adminService, settings) match {
      case (service: AdminService, settings: Settings) =>
        context mount (new AdminServlet(service), s"/${settings.apiNamespace}/*")
      case _ =>
        throw new RuntimeException("Couldn't start Admin HTTP server without dependencies!")
    }

  }
} 

//设置package包名称以及导入依赖的类
package com.github.twinra.lendmanager.rest

import javax.servlet.ServletContext

import com.github.twinra.lendmanager.dao.LendingRepository
import com.github.twinra.lendmanager.repo.{ItemRepository, PersonRepository}
import org.scalatra.LifeCycle
import scalikejdbc.config.DBs

class ScalatraBootstrap extends LifeCycle {
  override def init(context: ServletContext) {
    DBs.setup()
    implicit val itemsRepo = new ItemRepository {
      init()
    }
    implicit val peopleRepo = new PersonRepository {
      init()
    }
    implicit val lendingsRepo = new LendingRepository {
      init()
    }

    context.mount(new PeopleServlet, "/people/*")
    context.mount(new ItemsServlet, "/items/*")
    context.mount(new LendingsServlet, "/lendings/*")
  }

  override def destroy(context: ServletContext): Unit = DBs.closeAll()
} 

//设置package包名称以及导入依赖的类
package jp.seraphr.fileupload.main

import javax.servlet.ServletContext

import jp.seraphr.fileupload.FileUploadApi
import jp.seraphr.fileupload.model.UploadSettings
import org.scalatra.{ LifeCycle, ScalatraServlet }
import upickle.Api


class ScalatraBootstrap extends LifeCycle {
  class FileUploadServlet extends ScalatraServlet with FileUploadApi {
    override protected val settings: UploadSettings = UploadSettings("fileparam")
    override val jsonApi: Api = upickle.default
  }

  override def init(context: ServletContext): Unit = {
    val tServlet = new FileUploadServlet
    context.mount(tServlet, "/fileupload")
  }
} 

//设置package包名称以及导入依赖的类
import javax.servlet.ServletContext

import com.typesafe.scalalogging.LazyLogging
import org.scalatra.{LifeCycle}

import io.aigar.controller.{AdminController, GameController, LeaderboardController}
import io.aigar.game.GameThread
import io.aigar.model.PlayerRepository
import io.aigar.score.ScoreThread

object ScalatraBootstrap {
  final val PasswordLength = 28
}

class ScalatraBootstrap extends LifeCycle
                        with LazyLogging {
  logger.info("Bootstrapping application.")
  var playerRepository: PlayerRepository = null
  var game: GameThread = null
  var scoreThread: ScoreThread = null
  final val adminPassword = (new scala.util.Random(new java.security.SecureRandom())).alphanumeric.take(ScalatraBootstrap.PasswordLength).mkString
  final val path = "/api/1"

  override def init(context: ServletContext): Unit = {
    appInit()

    logger.info("****************************")
    logger.info("***Administrator password***")
    logger.info(adminPassword)
    logger.info("****************************")

    context.mount(new AdminController(adminPassword, game, playerRepository), s"$path/admin
  def appInit(players: Option[PlayerRepository] = None): Unit = {
    playerRepository = players.getOrElse(new PlayerRepository(None))
    scoreThread = new ScoreThread(playerRepository)
    game = new GameThread(scoreThread)

    launchThreads
  }

  private def closeDbConnection: Unit = {
    playerRepository.closeConnection
  }

  override def destroy(context: ServletContext): Unit = {
    super.destroy(context)
    closeDbConnection

    scoreThread.running = false
    game.running = false
  }

  def launchThreads: Unit = {
    new Thread(scoreThread).start
    new Thread(game).start
  }
}