Add option -port to fsc

Option "port" limits compile server lookup and start to given port.
Normally fsc will start a compile server in a random port if no server
is yet running. This can be problematic with firewalls and/or remote
compile servers. Option "port" should not be confused with option
"server" which looks for a compile server in given host and port and
fails if such server is not found.

Automatic tests for command line user interface do not exist at all.
Thus, adding a test for one new option would require designing a whole
new testing method.

5 files changed, 54 insertions, 27 deletions

diff --git a/src/compiler/scala/tools/nsc/CompileClient.scala b/src/compiler/scala/tools/nsc/CompileClient.scala
index 3017d8c9cc..f259504473 100644
--- a/src/compiler/scala/tools/nsc/CompileClient.scala
+++ b/src/compiler/scala/tools/nsc/CompileClient.scala
@@ -43,8 +43,8 @@ class StandardCompileClient extends HasCompileSocket with CompileOutputCommon {
     info(vmArgs.mkString("[VM arguments: ", " ", "]"))
 
     val socket =
-      if (settings.server.value == "") compileSocket.getOrCreateSocket(vmArgs mkString " ", !shutdown)
-      else Some(compileSocket.getSocket(settings.server.value))
+      if (settings.server.value == "") compileSocket.getOrCreateSocket(vmArgs mkString " ", !shutdown, settings.port.value)
+      else compileSocket.getSocket(settings.server.value)
 
     socket match {
       case Some(sock) => compileOnServer(sock, fscArgs)
diff --git a/src/compiler/scala/tools/nsc/CompileServer.scala b/src/compiler/scala/tools/nsc/CompileServer.scala
index 029e1c4629..aa02957a6c 100644
--- a/src/compiler/scala/tools/nsc/CompileServer.scala
+++ b/src/compiler/scala/tools/nsc/CompileServer.scala
@@ -6,6 +6,7 @@
 package scala.tools.nsc
 
 import java.io.PrintStream
+import io.Directory
 import scala.tools.nsc.reporters.{Reporter, ConsoleReporter}
 import scala.reflect.internal.util.{FakePos, Position}
 import scala.tools.util.SocketServer
@@ -19,7 +20,7 @@ import settings.FscSettings
  *  @author Martin Odersky
  *  @version 1.0
  */
-class StandardCompileServer extends SocketServer {
+class StandardCompileServer(fixPort: Int = 0) extends SocketServer(fixPort) {
   lazy val compileSocket: CompileSocket = CompileSocket
 
   private var compiler: Global = null
@@ -166,12 +167,12 @@ class StandardCompileServer extends SocketServer {
 }
 
 
-object CompileServer extends StandardCompileServer {
+object CompileServer {
   /** A directory holding redirected output */
-  private lazy val redirectDir = (compileSocket.tmpDir / "output-redirects").createDirectory()
+  //private lazy val redirectDir = (compileSocket.tmpDir / "output-redirects").createDirectory()
 
-  private def createRedirect(filename: String) =
-    new PrintStream((redirectDir / filename).createFile().bufferedOutput())
+  private def createRedirect(dir: Directory, filename: String) =
+    new PrintStream((dir / filename).createFile().bufferedOutput())
 
   def main(args: Array[String]) =
     execute(() => (), args)
@@ -187,21 +188,33 @@ object CompileServer extends StandardCompileServer {
    */
   def execute(startupCallback : () => Unit, args: Array[String]) {
     val debug = args contains "-v"
+    var port = 0
 
+    val i = args.indexOf("-p")
+    if (i >= 0 && args.length > i + 1) {
+    	scala.util.control.Exception.ignoring(classOf[NumberFormatException]) {
+    		port = args(i + 1).toInt 
+    	}
+    }
+    
+    // Create instance rather than extend to pass a port parameter.
+    val server = new StandardCompileServer(port)
+    val redirectDir = (server.compileSocket.tmpDir / "output-redirects").createDirectory()
+    
     if (debug) {
-      echo("Starting CompileServer on port " + port)
-      echo("Redirect dir is " + redirectDir)
+      server.echo("Starting CompileServer on port " + server.port)
+      server.echo("Redirect dir is " + redirectDir)
     }
 
-    Console.withErr(createRedirect("scala-compile-server-err.log")) {
-      Console.withOut(createRedirect("scala-compile-server-out.log")) {
-        Console.err.println("...starting server on socket "+port+"...")
+    Console.withErr(createRedirect(redirectDir, "scala-compile-server-err.log")) {
+      Console.withOut(createRedirect(redirectDir, "scala-compile-server-out.log")) {
+        Console.err.println("...starting server on socket "+server.port+"...")
         Console.err.flush()
-        compileSocket setPort port
+        server.compileSocket setPort server.port
         startupCallback()
-        run()
+        server.run()
 
-        compileSocket deletePort port
+        server.compileSocket deletePort server.port
       }
     }
   }
diff --git a/src/compiler/scala/tools/nsc/CompileSocket.scala b/src/compiler/scala/tools/nsc/CompileSocket.scala
index c693fbe8e2..27a14141fa 100644
--- a/src/compiler/scala/tools/nsc/CompileSocket.scala
+++ b/src/compiler/scala/tools/nsc/CompileSocket.scala
@@ -46,6 +46,9 @@ trait HasCompileSocket {
 class CompileSocket extends CompileOutputCommon {
   protected lazy val compileClient: StandardCompileClient = CompileClient
   def verbose = compileClient.verbose
+  
+  /* Fixes the port where to start the server, 0 yields some free port */
+  var fixPort = 0
 
   /** The prefix of the port identification file, which is followed
    *  by the port number.
@@ -64,7 +67,7 @@ class CompileSocket extends CompileOutputCommon {
 
   /** The class name of the scala compile server */
   protected val serverClass     = "scala.tools.nsc.CompileServer"
-  protected def serverClassArgs = if (verbose) List("-v") else Nil  // debug
+  protected def serverClassArgs = (if (verbose) List("-v") else Nil) ::: (if (fixPort > 0) List("-p", fixPort.toString) else Nil) 
 
   /** A temporary directory to use */
   val tmpDir = {
@@ -104,9 +107,14 @@ class CompileSocket extends CompileOutputCommon {
   def portFile(port: Int) = portsDir / File(port.toString)
 
   /** Poll for a server port number; return -1 if none exists yet */
-  private def pollPort(): Int = portsDir.list.toList match {
+  private def pollPort(): Int = if (fixPort > 0) {
+  	if (portsDir.list.toList.exists(_.name == fixPort.toString)) fixPort else -1
+  } else portsDir.list.toList match {
     case Nil      => -1
-    case x :: xs  => try x.name.toInt finally xs foreach (_.delete())
+    case x :: xs  => try x.name.toInt catch {
+    	case e: Exception => x.delete()
+    	throw e
+    }
   }
 
   /** Get the port number to which a scala compile server is connected;
@@ -152,7 +160,8 @@ class CompileSocket extends CompileOutputCommon {
     * create a new daemon if necessary.  Returns None if the connection
     * cannot be established.
     */
-  def getOrCreateSocket(vmArgs: String, create: Boolean = true): Option[Socket] = {
+  def getOrCreateSocket(vmArgs: String, create: Boolean = true, fixedPort: Int = 0): Option[Socket] = {
+    fixPort = fixedPort
     val maxMillis = 10L * 1000   // try for 10 seconds
     val retryDelay = 50L
     val maxAttempts = (maxMillis / retryDelay).toInt
@@ -186,14 +195,17 @@ class CompileSocket extends CompileOutputCommon {
     try   { Some(x.toInt) }
     catch { case _: NumberFormatException => None }
 
-  def getSocket(serverAdr: String): Socket = (
-    for ((name, portStr) <- splitWhere(serverAdr, _ == ':', doDropIndex = true) ; port <- parseInt(portStr)) yield
+  def getSocket(serverAdr: String): Option[Socket] = (
+    for ((name, portStr) <- splitWhere(serverAdr, _ == ':', doDropIndex = true) ; port <- parseInt(portStr)) yield    	
       getSocket(name, port)
   ) getOrElse fatal("Malformed server address: %s; exiting" format serverAdr)
 
-  def getSocket(hostName: String, port: Int): Socket =
-    Socket(hostName, port).opt getOrElse fatal("Unable to establish connection to server %s:%d; exiting".format(hostName, port))
-
+  def getSocket(hostName: String, port: Int): Option[Socket] = {
+    val sock = Socket(hostName, port).opt
+    if (sock.isEmpty) warn("Unable to establish connection to server %s:%d".format(hostName, port))
+    sock
+  }
+  
   def getPassword(port: Int): String = {
     val ff  = portFile(port)
     val f   = ff.bufferedReader()
diff --git a/src/compiler/scala/tools/nsc/settings/FscSettings.scala b/src/compiler/scala/tools/nsc/settings/FscSettings.scala
index 8c2b510bfd..fffbb4333f 100644
--- a/src/compiler/scala/tools/nsc/settings/FscSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/FscSettings.scala
@@ -22,13 +22,15 @@ class FscSettings(error: String => Unit) extends Settings(error) {
   val reset        = BooleanSetting("-reset",    "Reset compile server caches")
   val shutdown     = BooleanSetting("-shutdown", "Shutdown compile server")
   val server       = StringSetting ("-server",   "hostname:portnumber", "Specify compile server socket", "")
+  val port         = IntSetting    ("-port",     "Search and start compile server in given port only",
+  		                                      0, Some((0, Int.MaxValue)), (_: String) => None)
   val preferIPv4   = BooleanSetting("-ipv4",     "Use IPv4 rather than IPv6 for the server socket")
   val idleMins     = IntSetting    ("-max-idle", "Set idle timeout in minutes for fsc (use 0 for no timeout)",
                                               30, Some((0, Int.MaxValue)), (_: String) => None)
 
   // For improved help output, separating fsc options from the others.
   def fscSpecific = Set[Settings#Setting](
-    currentDir, reset, shutdown, server, preferIPv4, idleMins
+    currentDir, reset, shutdown, server, port, preferIPv4, idleMins
   )
   val isFscSpecific: String => Boolean = fscSpecific map (_.name)
 
diff --git a/src/compiler/scala/tools/util/SocketServer.scala b/src/compiler/scala/tools/util/SocketServer.scala
index 1d39a59cf4..7858bf0658 100644
--- a/src/compiler/scala/tools/util/SocketServer.scala
+++ b/src/compiler/scala/tools/util/SocketServer.scala
@@ -28,12 +28,12 @@ trait CompileOutputCommon {
  *  @author  Martin Odersky
  *  @version 1.0
  */
-abstract class SocketServer extends CompileOutputCommon {
+abstract class SocketServer(fixPort: Int = 0) extends CompileOutputCommon {
   def shutdown: Boolean
   def session(): Unit
   def timeout(): Unit = ()  // called after a timeout is detected for subclasses to cleanup
   // a hook for subclasses
-  protected def createServerSocket(): ServerSocket = new ServerSocket(0)
+  protected def createServerSocket(): ServerSocket = new ServerSocket(fixPort)
 
   var in: BufferedReader = _
   var out: PrintWriter   = _