Merge pull request #78 from cvogt/chris

Chris

7 files changed, 105 insertions, 82 deletions

diff --git a/stage1/ClassLoaderCache.scala b/stage1/ClassLoaderCache.scala
new file mode 100644
index 0000000..18a0d0e
--- /dev/null
+++ b/stage1/ClassLoaderCache.scala
@@ -0,0 +1,25 @@
+package cbt
+
+import java.net._
+
+private[cbt] object ClassLoaderCache{
+  private val cache = NailgunLauncher.classLoaderCache
+  def get( classpath: ClassPath )(implicit logger: Logger): ClassLoader
+    = cache.synchronized{
+    val lib = new Stage1Lib(logger)
+    val key = classpath.strings.sorted.mkString(":")
+    if( cache.containsKey(key) ){
+      logger.resolver("CACHE HIT: "++key)
+      cache.get(key)
+    } else {
+      logger.resolver("CACHE MISS: "++key)
+      val cl = new cbt.URLClassLoader( classpath, ClassLoader.getSystemClassLoader )
+      cache.put( key, cl )
+      cl
+    }
+  }
+  def remove( classpath: ClassPath ) = {
+    val key = classpath.strings.sorted.mkString(":")
+    cache.remove( key )
+  }
+}
diff --git a/stage1/MultiClassLoader.scala b/stage1/MultiClassLoader.scala
new file mode 100644
index 0000000..de9bd32
--- /dev/null
+++ b/stage1/MultiClassLoader.scala
@@ -0,0 +1,24 @@
+/*
+package cbt
+import java.net._
+import scala.util.Try
+
+import scala.collection.immutable.Seq
+
+
+class MultiClassLoader(parents: Seq[ClassLoader]) extends ClassLoader {
+  override def loadClass(name: String) = {
+    //System.err.println("LOADING CLASS "++name);
+    val c = parents.toStream.map{
+      parent =>
+      Try{
+        parent.loadClass(name)
+      }.map(Option[Class[_]](_)).recover{
+        case _:ClassNotFoundException => None
+      }.get
+    }.find(_.isDefined).flatten
+    c.getOrElse( ClassLoader.getSystemClassLoader.loadClass(name) )
+  }
+  override def toString = "MultiClassLoader(" ++ parents.mkString(",") ++ ")"
+}
+*/
diff --git a/stage1/Stage1.scala b/stage1/Stage1.scala
index 1aa3f09..7702678 100644
--- a/stage1/Stage1.scala
+++ b/stage1/Stage1.scala
@@ -67,14 +67,16 @@ abstract class Stage1Base{
 
     logger.stage1("before conditionally running zinc to recompile CBT")
     if( src.exists(newerThan(_, changeIndicator)) ) {
-      val stage1Classpath = CbtDependency(logger).dependencyClasspath
+      val stage1Classpath = CbtDependency()(logger).dependencyClasspath
       logger.stage1("cbt.lib has changed. Recompiling with cp: " ++ stage1Classpath.string)
       zinc( true, src, stage2Target, stage1Classpath )( zincVersion = "0.3.9", scalaVersion = constants.scalaVersion )
     }
     logger.stage1(s"[$now] calling CbtDependency.classLoader")
 
     logger.stage1(s"[$now] Run Stage2")
-    val ExitCode(exitCode) = runMain( mainClass, cwd +: args.drop(1).toVector, CbtDependency(logger).classLoader )
+    val ExitCode(exitCode) = /*trapExitCode*/{ // this 
+      runMain( mainClass, cwd +: args.drop(1).toVector, CbtDependency()(logger).classLoader )
+    }
     logger.stage1(s"[$now] Stage1 end")
     System.exit(exitCode)
   }
diff --git a/stage1/Stage1Lib.scala b/stage1/Stage1Lib.scala
index 1ad3030..67ae049 100644
--- a/stage1/Stage1Lib.scala
+++ b/stage1/Stage1Lib.scala
@@ -190,6 +190,11 @@ class Stage1Lib( val logger: Logger ) extends BaseLib{
   }
 
   def trapExitCode( code: => Unit ): ExitCode = {
+    /*
+    Doesn't seem to work reliably. Seems like the Security manager is not always
+    reset properly. Maybe some non-thread-safety issue or some Nailgun interaction.
+
+
     val old: Option[SecurityManager] = Option(System.getSecurityManager())
     try{
       val securityManager = new SecurityManager{
@@ -217,6 +222,9 @@ class Stage1Lib( val logger: Logger ) extends BaseLib{
     } finally {
       System.setSecurityManager(old.getOrElse(null))
     }
+    */
+    code
+    ExitCode.Success
   }
 }
 
diff --git a/stage1/URLClassLoader.scala b/stage1/URLClassLoader.scala
new file mode 100644
index 0000000..870f186
--- /dev/null
+++ b/stage1/URLClassLoader.scala
@@ -0,0 +1,22 @@
+package cbt
+
+import java.net._
+
+case class URLClassLoader(classPath: ClassPath, parent: ClassLoader)
+  extends java.net.URLClassLoader(
+    classPath.strings.map(
+      path => new URL("file:"++path)
+    ).toArray,
+    parent
+  ){
+  override def toString = (
+    scala.Console.BLUE ++ "cbt.URLClassLoader" ++ scala.Console.RESET
+      ++ "(\n  " ++ getURLs.map(_.toString).sorted.mkString(",\n  ")
+      ++ (
+        if(getParent() != ClassLoader.getSystemClassLoader())
+          ",\n" ++ getParent().toString.split("\n").map("  "++_).mkString("\n")
+        else ""
+      )
+      ++ "\n)"
+  )
+}
diff --git a/stage1/classloader.scala b/stage1/classloader.scala
deleted file mode 100644
index 50e33a2..0000000
--- a/stage1/classloader.scala
+++ /dev/null
@@ -1,64 +0,0 @@
-package cbt
-import java.io._
-import java.net._
-import java.nio.file._
-import scala.util.Try
-
-import scala.collection.immutable.Seq
-
-object ClassLoaderCache{
-  private val cache = NailgunLauncher.classLoaderCache
-  def get( classpath: ClassPath )(implicit logger: Logger): ClassLoader
-    = cache.synchronized{
-    val lib = new Stage1Lib(logger)
-    val key = classpath.strings.sorted.mkString(":")
-    if( cache.containsKey(key) ){
-      logger.resolver("CACHE HIT: "++key)
-      cache.get(key)
-    } else {
-      logger.resolver("CACHE MISS: "++key)
-      val cl = new cbt.URLClassLoader( classpath, ClassLoader.getSystemClassLoader )
-      cache.put( key, cl )
-      cl
-    }
-  }
-  def remove( classpath: ClassPath ) = {
-    val key = classpath.strings.sorted.mkString(":")
-    cache.remove( key )
-  }
-}
-/*
-class MultiClassLoader(parents: Seq[ClassLoader]) extends ClassLoader {
-  override def loadClass(name: String) = {
-    //System.err.println("LOADING CLASS "++name);
-    val c = parents.toStream.map{
-      parent =>
-      Try{
-        parent.loadClass(name)
-      }.map(Option[Class[_]](_)).recover{
-        case _:ClassNotFoundException => None
-      }.get
-    }.find(_.isDefined).flatten
-    c.getOrElse( ClassLoader.getSystemClassLoader.loadClass(name) )
-  }
-  override def toString = "MultiClassLoader(" ++ parents.mkString(",") ++ ")"
-}
-*/
-case class URLClassLoader(classPath: ClassPath, parent: ClassLoader)
-  extends java.net.URLClassLoader(
-    classPath.strings.map(
-      path => new URL("file:"++path)
-    ).toArray,
-    parent
-  ){
-  override def toString = (
-    scala.Console.BLUE ++ "cbt.URLClassLoader" ++ scala.Console.RESET
-      ++ "(\n  " ++ getURLs.map(_.toString).sorted.mkString(",\n  ")
-      ++ (
-        if(getParent() != ClassLoader.getSystemClassLoader())
-          ",\n" ++ getParent().toString.split("\n").map("  "++_).mkString("\n")
-        else ""
-      )
-      ++ "\n)"
-  )
-}
diff --git a/stage1/resolver.scala b/stage1/resolver.scala
index fae5e9d..30f03e2 100644
--- a/stage1/resolver.scala
+++ b/stage1/resolver.scala
@@ -32,12 +32,13 @@ abstract class Dependency{
   def exportedJars: Seq[File]
   def jars: Seq[File] = exportedJars ++ dependencyJars
 
+  def canBeCached = false
   def cacheDependencyClassLoader = true
 
   private object cacheClassLoaderBasicBuild extends Cache[URLClassLoader]
   def classLoader: URLClassLoader = cacheClassLoaderBasicBuild{
     val transitiveClassPath = transitiveDependencies.map{
-      case d: MavenDependency => Left(d)
+      case d if d.canBeCached => Left(d)
       case d => Right(d)
     }
     val buildClassPath = ClassPath.flatten(
@@ -95,35 +96,39 @@ abstract class Dependency{
 }
 
 // TODO: all this hard codes the scala version, needs more flexibility
-class ScalaCompiler(logger: Logger) extends MavenDependency("org.scala-lang","scala-compiler",constants.scalaVersion)(logger)
-class ScalaLibrary(logger: Logger) extends MavenDependency("org.scala-lang","scala-library",constants.scalaVersion)(logger)
-class ScalaReflect(logger: Logger) extends MavenDependency("org.scala-lang","scala-reflect",constants.scalaVersion)(logger)
+class ScalaCompilerDependency(version: String)(implicit logger: Logger) extends MavenDependency("org.scala-lang","scala-compiler",version)
+class ScalaLibraryDependency (version: String)(implicit logger: Logger) extends MavenDependency("org.scala-lang","scala-library",version)
+class ScalaReflectDependency (version: String)(implicit logger: Logger) extends MavenDependency("org.scala-lang","scala-reflect",version)
 
-case class ScalaDependencies(logger: Logger) extends Dependency{
+case class ScalaDependencies(version: String)(implicit val logger: Logger) extends Dependency{ sd =>
+  final val updated = false
+  override def canBeCached = true
   def exportedClasspath = ClassPath(Seq())
   def exportedJars = Seq[File]()  
-  def dependencies = Seq( new ScalaCompiler(logger), new ScalaLibrary(logger), new ScalaReflect(logger) )
-  final val updated = false
+  def dependencies = Seq(
+    new ScalaCompilerDependency(version)(logger),
+    new ScalaLibraryDependency(version)(logger),
+    new ScalaReflectDependency(version)(logger)
+  )
 }
 
-/*
-case class BinaryDependency( path: File, dependencies: Seq[Dependency] ) extends Dependency{
+case class BinaryDependency( path: File, dependencies: Seq[Dependency] )(implicit val logger: Logger) extends Dependency{
+  def updated = false
   def exportedClasspath = ClassPath(Seq(path))
-  def exportedJars = Seq[File]()
+  def exportedJars = Seq[File](path)
 }
-*/
 
-case class Stage1Dependency(logger: Logger) extends Dependency{
+case class Stage1Dependency()(implicit val logger: Logger) extends Dependency{
   def exportedClasspath = ClassPath( Seq(nailgunTarget, stage1Target) )
   def exportedJars = Seq[File]()  
-  def dependencies = ScalaDependencies(logger: Logger).dependencies
+  def dependencies = ScalaDependencies(constants.scalaVersion).dependencies
   def updated = false // FIXME: think this through, might allow simplifications and/or optimizations
 }
-case class CbtDependency(logger: Logger) extends Dependency{
+case class CbtDependency()(implicit val logger: Logger) extends Dependency{
   def exportedClasspath = ClassPath( Seq( stage2Target ) )
   def exportedJars = Seq[File]()  
   override def dependencies = Seq(
-    Stage1Dependency(logger),
+    Stage1Dependency()(logger),
     MavenDependency("net.incongru.watchservice","barbary-watchservice","1.0")(logger),
     MavenDependency("com.lihaoyi","ammonite-repl_2.11.7","0.5.5")(logger),
     MavenDependency("org.scala-lang.modules","scala-xml_2.11","1.0.5")(logger)
@@ -136,10 +141,11 @@ final case class Classifier(name: String) extends ClassifierBase
 case object javadoc extends ClassifierBase
 case object sources extends ClassifierBase
 
-case class MavenDependency( groupId: String, artifactId: String, version: String, sources: Boolean = false )(val logger: Logger)
+case class MavenDependency( groupId: String, artifactId: String, version: String, sources: Boolean = false )(implicit val logger: Logger)
   extends ArtifactInfo{
 
   def updated = false
+  override def canBeCached = true
 
   private val groupPath = groupId.split("\\.").mkString("/")
   def basePath = s"/$groupPath/$artifactId/$version/$artifactId-$version"++(if(sources) "-sources" else "")