Preparatory work for timing out individual bots

scalatron · scalatron · commit 93699b162d22 · 2012-05-11T06:09:52.000+02:00
diff --git a/Scalatron/src/scalatron/botwar/BotWar.scala b/Scalatron/src/scalatron/botwar/BotWar.scala
@@ -9,6 +9,7 @@ import java.awt.event.{WindowEvent, WindowAdapter, KeyEvent, KeyListener}
 import scalatron.scalatron.api.Scalatron
 import scalatron.scalatron.impl.{TournamentRoundResult, TournamentState, Plugin, PluginCollection, Game}
 import akka.dispatch.ExecutionContext
+import akka.actor.ActorSystem
 
 
 /** BotWar: an implementation of the Scalatron Game trait.
@@ -32,7 +33,7 @@ case object BotWar extends Game
         secureMode: Boolean,
         verbose: Boolean
     )(
-        executionContextForTrustedCode: ExecutionContext,
+        actorSystem: ActorSystem,
         executionContextForUntrustedCode: ExecutionContext
     )
     {
@@ -74,6 +75,7 @@ case object BotWar extends Game
         val stepCallback = (state: SimState) => {
             tournamentState.updateMostRecentState(state)
 
+            val executionContextForTrustedCode = actorSystem.dispatcher
             renderer.draw(display.renderTarget, state.gameState)(executionContextForTrustedCode)
 
             // enforce maxFPS (max frames per second) by putting this thread to sleep if appropriate
@@ -113,7 +115,7 @@ case object BotWar extends Game
 
             // run game
             val runner = Simulation.Runner(factory, stepCallback, resultCallback)
-            runner(plugins, randomSeed)(executionContextForTrustedCode, executionContextForUntrustedCode)
+            runner(plugins, randomSeed)(actorSystem, executionContextForUntrustedCode)
 
             roundIndex += 1
 
@@ -132,7 +134,7 @@ case object BotWar extends Game
         secureMode: Boolean,
         verbose: Boolean
     )(
-        executionContextForTrustedCode: ExecutionContext,
+        actorSystem: ActorSystem,
         executionContextForUntrustedCode: ExecutionContext
     )
     {
@@ -186,7 +188,7 @@ case object BotWar extends Game
 
             // run game
             val runner = Simulation.Runner(factory, stepCallback, resultCallback)
-            runner(plugins, randomSeed)(executionContextForTrustedCode, executionContextForUntrustedCode)
+            runner(plugins, randomSeed)(actorSystem, executionContextForUntrustedCode)
 
             roundIndex += 1
 
diff --git a/Scalatron/src/scalatron/botwar/BotWarSimulation.scala b/Scalatron/src/scalatron/botwar/BotWarSimulation.scala
@@ -6,18 +6,19 @@ package scalatron.botwar
 import scala.util.Random
 import scalatron.scalatron.impl.{Plugin, TournamentRoundResult}
 import akka.dispatch.ExecutionContext
+import akka.actor.ActorSystem
 
 
 /** Implementations of generic Simulation traits for the BotWar game. */
 object BotWarSimulation
 {
     case class SimState(gameState: State) extends Simulation.State[SimState,TournamentRoundResult] {
-        def step(executionContextForUntrustedCode: ExecutionContext) = {
+        def step(actorSystem: ActorSystem, executionContextForUntrustedCode: ExecutionContext) = {
             // to make results reproducible, generate a freshly seeded randomizer for every cycle
             val rnd = new Random(gameState.time)
 
             // apply the game dynamics to the game state
-            Dynamics(gameState, rnd, executionContextForUntrustedCode) match {
+            Dynamics(gameState, rnd, actorSystem, executionContextForUntrustedCode) match {
                 case Left(updatedGameState) => Left(SimState(updatedGameState))
                 case Right(gameResult) => Right(gameResult)
             }
diff --git a/Scalatron/src/scalatron/botwar/Dynamics.scala b/Scalatron/src/scalatron/botwar/Dynamics.scala
@@ -5,23 +5,23 @@ package scalatron.botwar
 
 import scala.util.Random
 import scalatron.scalatron.impl.TournamentRoundResult
-import akka.util.Duration
 import akka.util.duration._
 import akka.dispatch._
 import java.util.concurrent.TimeoutException
+import akka.actor.ActorSystem
 
 
 /** Game dynamics. Function that, when applied to a game state, returns either a successor
   *  game state or a game result.
   */
-case object Dynamics extends ((State, Random, ExecutionContext) => Either[State,TournamentRoundResult])
+case object Dynamics extends ((State, Random, ActorSystem, ExecutionContext) => Either[State,TournamentRoundResult])
 {
-    def apply(state: State, rnd: Random, executionContextForUntrustedCode: ExecutionContext) = {
+    def apply(state: State, rnd: Random, actorSystem: ActorSystem, executionContextForUntrustedCode: ExecutionContext) = {
         // determine which bots are eligible to move in the nest step
         val eligibleBots = computeEligibleBots(state)
 
         // have each bot compute its command
-        val botCommandsAndTimes = computeBotCommands(state, eligibleBots)(executionContextForUntrustedCode) // was: actorSystem
+        val botCommandsAndTimes = computeBotCommands(state, eligibleBots, actorSystem)(executionContextForUntrustedCode) // was: actorSystem
 
         // store time taken with each bot
         var updatedBoard = state.board
@@ -100,11 +100,12 @@ case object Dynamics extends ((State, Random, ExecutionContext) => Either[State,
                 }
             })
 
+    type BotResponse = (Entity.Id,(Long,String,Iterable[Command]))
 
     // returns a collection of tuples: (id, (nanoSeconds, commandList))
-    def computeBotCommands(state: State, eligibleBots: Iterable[Bot])(implicit executionContextForUntrustedCode: ExecutionContext): Iterable[(Entity.Id,(Long,String,Iterable[Command]))] = {
-        // use Akka to work this out
-        val future = Future.traverse(eligibleBots)(bot => Future {
+    def computeBotCommands(state: State, eligibleBots: Iterable[Bot], actorSystem: ActorSystem)(implicit executionContextForUntrustedCode: ExecutionContext): Iterable[(Entity.Id,(Long,String,Iterable[Command]))] = {
+        // use Akka Futures to work this out
+        val outerFuture = Future.traverse(eligibleBots)(bot => Future {
             try {
                 val timeBefore = System.nanoTime
                 val (inputString,commands) = bot.respondTo(state)
@@ -121,9 +122,71 @@ case object Dynamics extends ((State, Random, ExecutionContext) => Either[State,
             }
         })
 
+
+        /*
+        // This is based on Viktor Klang's proposal, see https://groups.google.com/forum/?fromgroups#!topic/akka-user/5MY8lsYGbYM
+        val TimeoutSentinel : Option[BotResponse] = None
+        val timeout = Promise[Option[BotResponse]]()
+        val c = actorSystem.scheduler.scheduleOnce(1000 millis){ timeout.success(TimeoutSentinel) }
+        timeout onComplete { case _ => c.cancel() }
+
+        val outerFuture = Future.traverse(eligibleBots)(bot =>
+            Promise[Option[BotResponse]]()
+            .completeWith(Future {
+                try {
+                    val timeBefore = System.nanoTime
+                    val (inputString,commands) = bot.respondTo(state)
+                    val timeSpent = System.nanoTime - timeBefore
+                    if(commands.isEmpty) None else Some((bot.id,(timeSpent,inputString,commands)))
+                } catch {
+                    case t: NoClassDefFoundError =>
+                        // we fake a Log() command issued by the bot to report the error into the browser UI:
+                        Some((bot.id,(0L,"",Iterable[Command](Command.Disable("error: class not found: " + t.getMessage)))))
+
+                    case t: Throwable =>
+                        // we inject a Disable() command as-if-issued-by-the-bot to report the error into the browser UI:
+                        Some((bot.id,(0L,"",Iterable[Command](Command.Disable(t.getMessage)))))
+                }
+            })
+            .completeWith(timeout)
+        )
+        */
+        /*
+        // this is an attempt based on nested Futures. Does not seems to work at all: every call times out. ?!?
+        val TimeoutSentinel : Option[BotResponse] = None
+        val outerFuture = Future.traverse(eligibleBots)(bot =>
+            Future {
+                val innerFuture = Future {
+                    try {
+                        val timeBefore = System.nanoTime
+                        val (inputString,commands) = bot.respondTo(state)
+                        val timeSpent = System.nanoTime - timeBefore
+                        if(commands.isEmpty) None else Some((bot.id,(timeSpent,inputString,commands)))
+                    } catch {
+                        case t: NoClassDefFoundError =>
+                            // we fake a Log() command issued by the bot to report the error into the browser UI:
+                            Some((bot.id,(0L,"",Iterable[Command](Command.Disable("error: class not found: " + t.getMessage)))))
+
+                        case t: Throwable =>
+                            // we inject a Disable() command as-if-issued-by-the-bot to report the error into the browser UI:
+                            Some((bot.id,(0L,"",Iterable[Command](Command.Disable(t.getMessage)))))
+                    }
+                }
+                try {
+                    Await.result(innerFuture, 5000 millis)      // generous timeout - for now, we only want to capture infinite loops
+                } catch {
+                    case t: TimeoutException =>
+                        System.err.println("warning: timeout while invoking the control function of bot: " + bot.name)
+                        TimeoutSentinel
+                }
+            }
+        )
+        */
+
         // Note: an overall timeout across all bots is a temporary solution - we want timeouts PER BOT
         try {
-            val result = Await.result(future, 2000 millis)      // generous timeout - note that this is over ALL plug-ins
+            val result = Await.result(outerFuture, 10000 millis)      // generous timeout - note that this is over ALL plug-ins
+            // result.filter(TimeoutSentinel ==).foreach(r => println("bot timed out"))
             result.flatten
         } catch {
             case t: TimeoutException =>
diff --git a/Scalatron/src/scalatron/botwar/Simulation.scala b/Scalatron/src/scalatron/botwar/Simulation.scala
@@ -6,6 +6,7 @@ package scalatron.botwar
 import scalatron.scalatron.impl.Plugin
 import akka.util.Duration
 import akka.dispatch.{ExecutionContext, Future, Await}
+import akka.actor.ActorSystem
 
 
 /** Traits for generic simulations, of which a game like BotWar is an example.
@@ -22,7 +23,7 @@ object Simulation
       * @tparam R type of the result returned by the simulator (arbitrary)
       */
     trait State[S <: State[S, R], R] extends UntypedState {
-        def step(executionContextForUntrustedCode: ExecutionContext) : Either[S, R]
+        def step(actorSystem: ActorSystem, executionContextForUntrustedCode: ExecutionContext) : Either[S, R]
     }
 
 
@@ -46,15 +47,15 @@ object Simulation
     {
         /** @param plugins the collection of external plug-ins to bring into the simulation
           * @param randomSeed the random seed to use for initializing the simulation
-          * @param executionContextForTrustedCode execution context whose threads are trusted (e.g. actor system)
+          * @param actorSystem execution context whose threads are trusted (e.g. actor system)
           * @param executionContextForUntrustedCode execution context whose threads are untrusted (sandboxed by the security manager)
           * @return an optional simulation result (if the simulation was not prematurely aborted)
           */
         def apply(
             plugins: Iterable[Plugin.External],
             randomSeed: Int
         )(
-            executionContextForTrustedCode: ExecutionContext,
+            actorSystem: ActorSystem,
             executionContextForUntrustedCode: ExecutionContext
         ): Option[R] =
         {
@@ -68,7 +69,8 @@ object Simulation
                 // the callback will generally render the prior state to the screen.
 
                 // process state update, returns either next state or result
-                val stepFuture = Future( { currentState.step(executionContextForUntrustedCode) } )(executionContextForTrustedCode) // compute next state
+                val executionContextForTrustedCode = actorSystem.dispatcher
+                val stepFuture = Future( { currentState.step(actorSystem, executionContextForUntrustedCode) } )(executionContextForTrustedCode) // compute next state
 
                 // process callback (usually rendering) on prior state, returns true if to continue simulating, false if not
                 val callbackFuture = Future( {
diff --git a/Scalatron/src/scalatron/scalatron/impl/Game.scala b/Scalatron/src/scalatron/scalatron/impl/Game.scala
@@ -1,6 +1,7 @@
 package scalatron.scalatron.impl
 
 import akka.dispatch.ExecutionContext
+import akka.actor.ActorSystem
 
 /** This material is intended as a community resource and is licensed under the
   * Creative Commons Attribution 3.0 Unported License. Feel free to use, modify and share it.
@@ -23,7 +24,7 @@ trait Game {
       * @param tournamentState the tournament state object to update whenever a round ends
       * @param secureMode if true, certain bot processing restrictions apply
       * @param verbose if true, log to the console verbosely
-      * @param executionContextForTrustedCode execution context for trusted code (e.g. from Akka ActorSystem)
+      * @param actorSystem execution context for trusted code (e.g. from Akka ActorSystem)
       * @param executionContextForUntrustedCode execution context for untrusted code (e.g. for bot control functions)
       */
     def runVisually(
@@ -34,7 +35,7 @@ trait Game {
         secureMode: Boolean,
         verbose: Boolean
     )(
-        executionContextForTrustedCode: ExecutionContext,
+        actorSystem: ActorSystem,
         executionContextForUntrustedCode: ExecutionContext
     )
 
@@ -47,7 +48,7 @@ trait Game {
       * @param tournamentState the tournament state object to update whenever a round ends
       * @param secureMode if true, certain bot processing restrictions apply
       * @param verbose if true, log to the console verbosely
-      * @param executionContextForTrustedCode execution context for trusted code (e.g. from Akka ActorSystem)
+      * @param actorSystem execution context for trusted code (e.g. from Akka ActorSystem)
       * @param executionContextForUntrustedCode execution context for untrusted code (e.g. for bot control functions)
       */
     def runHeadless(
@@ -58,7 +59,7 @@ trait Game {
         secureMode: Boolean,
         verbose: Boolean
     )(
-        executionContextForTrustedCode: ExecutionContext,
+        actorSystem: ActorSystem,
         executionContextForUntrustedCode: ExecutionContext
     )
 
diff --git a/Scalatron/src/scalatron/scalatron/impl/ScalatronImpl.scala b/Scalatron/src/scalatron/scalatron/impl/ScalatronImpl.scala
@@ -239,9 +239,9 @@ case class ScalatronImpl(
         val headless = (argMap.get("-headless").getOrElse("no") == "yes")
         val executionContextForTrustedCode = actorSystem.dispatcher
         if(headless) {
-            game.runHeadless(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(executionContextForTrustedCode, executionContextForUntrustedCode)
+            game.runHeadless(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(actorSystem, executionContextForUntrustedCode)
         } else {
-            game.runVisually(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(executionContextForTrustedCode, executionContextForUntrustedCode)
+            game.runVisually(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(actorSystem, executionContextForUntrustedCode)
         }
     }
 
diff --git a/Scalatron/src/scalatron/scalatron/impl/ScalatronSandboxState.scala b/Scalatron/src/scalatron/scalatron/impl/ScalatronSandboxState.scala
@@ -14,10 +14,11 @@ case class ScalatronSandboxState(sandbox: ScalatronSandbox, simState: BotWarSimu
     def time = simState.gameState.time.toInt      // CBB: warn on truncation from Long to Int
 
     def step(count: Int): SandboxState = {
+        val actorSystem = sandbox.user.scalatron.actorSystem
         val executionContextForUntrustedCode = sandbox.user.scalatron.executionContextForUntrustedCode
         var updatedState = simState
         for( i <- 0 until count ) {
-            updatedState.step(executionContextForUntrustedCode) match {
+            updatedState.step(actorSystem, executionContextForUntrustedCode) match {
                 case Left(successorState) =>
                     updatedState = successorState
 

Original file line number	Diff line number	Diff line change
`@@ -239,9 +239,9 @@ case class ScalatronImpl(`
`239`	`239`	`val headless = (argMap.get("-headless").getOrElse("no") == "yes")`
`240`	`240`	`val executionContextForTrustedCode = actorSystem.dispatcher`
`241`	`241`	`if(headless) {`
`242`		`- game.runHeadless(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(executionContextForTrustedCode, executionContextForUntrustedCode)`
	`242`	`+ game.runHeadless(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(actorSystem, executionContextForUntrustedCode)`
`243`	`243`	`} else {`
`244`		`- game.runVisually(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(executionContextForTrustedCode, executionContextForUntrustedCode)`
	`244`	`+ game.runVisually(pluginBaseDirectoryPath, argMap, rounds, tournamentState, secureMode, verbose)(actorSystem, executionContextForUntrustedCode)`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`