/* __ *\
** ________ ___ / / ___ __ ____ Scala.js sbt plugin **
** / __/ __// _ | / / / _ | __ / // __/ (c) 2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \ http://scala-js.org/ **
** /____/\___/_/ |_/____/_/ | |__/ /____/ **
** |/____/ **
\* */
package scala.scalajs.sbtplugin.env.nodejs
import scala.scalajs.sbtplugin.env._
import scala.scalajs.sbtplugin.JSUtils.toJSstr
import scala.scalajs.tools.io._
import scala.scalajs.tools.classpath._
import scala.scalajs.tools.env._
import scala.scalajs.tools.jsdep._
import scala.scalajs.tools.logging._
import scala.scalajs.sbtplugin.JSUtils._
import java.io.{ Console => _, _ }
import java.net._
import scala.io.Source
class NodeJSEnv(
nodejsPath: String = "node",
addArgs: Seq[String] = Seq.empty,
addEnv: Map[String, String] = Map.empty
) extends ExternalJSEnv(addArgs, addEnv) with ComJSEnv {
protected def vmName: String = "node.js"
protected def executable: String = nodejsPath
override def jsRunner(classpath: CompleteClasspath, code: VirtualJSFile,
logger: Logger, console: JSConsole): JSRunner = {
new NodeRunner(classpath, code, logger, console)
}
override def asyncRunner(classpath: CompleteClasspath, code: VirtualJSFile,
logger: Logger, console: JSConsole): AsyncJSRunner = {
new AsyncNodeRunner(classpath, code, logger, console)
}
override def comRunner(classpath: CompleteClasspath, code: VirtualJSFile,
logger: Logger, console: JSConsole): ComJSRunner = {
new ComNodeRunner(classpath, code, logger, console)
}
protected class NodeRunner(classpath: CompleteClasspath,
code: VirtualJSFile, logger: Logger, console: JSConsole
) extends ExtRunner(classpath, code, logger, console)
with AbstractNodeRunner
protected class AsyncNodeRunner(classpath: CompleteClasspath,
code: VirtualJSFile, logger: Logger, console: JSConsole
) extends AsyncExtRunner(classpath, code, logger, console)
with AbstractNodeRunner
protected class ComNodeRunner(classpath: CompleteClasspath,
code: VirtualJSFile, logger: Logger, console: JSConsole
) extends AsyncNodeRunner(classpath, code, logger, console)
with ComJSRunner {
/** Retry-timeout to wait for the JS VM to connect */
private final val acceptTimeout = 1000
private[this] val serverSocket =
new ServerSocket(0, 0, InetAddress.getByName(null)) // Loopback address
private[this] var comSocket: Socket = _
private[this] var jvm2js: DataOutputStream = _
private[this] var js2jvm: DataInputStream = _
private def comSetup = new MemVirtualJSFile("comSetup.js").withContent(
s"""
(function() {
// The socket for communication
var socket = null;
// The callback where received messages go
var recvCallback = null;
// Buffers received data
var inBuffer = new Buffer(0);
function onData(data) {
inBuffer = Buffer.concat([inBuffer, data]);
tryReadMsg();
}
function tryReadMsg() {
if (inBuffer.length < 4) return;
var msgLen = inBuffer.readInt32BE(0);
var byteLen = 4 + msgLen * 2;
if (inBuffer.length < byteLen) return;
var res = "";
for (var i = 0; i < msgLen; ++i)
res += String.fromCharCode(inBuffer.readInt16BE(4 + i * 2));
inBuffer = inBuffer.slice(byteLen);
recvCallback(res);
}
global.scalajsCom = {
init: function(recvCB) {
if (socket !== null) throw new Error("Com already open");
var net = require('net');
recvCallback = recvCB;
socket = net.connect(${serverSocket.getLocalPort});
socket.on('data', onData);
},
send: function(msg) {
if (socket === null) throw new Error("Com not open");
var len = msg.length;
var buf = new Buffer(4 + len * 2);
buf.writeInt32BE(len, 0);
for (var i = 0; i < len; ++i)
buf.writeInt16BE(msg.charCodeAt(i), 4 + i * 2);
socket.write(buf);
},
close: function() {
if (socket === null) throw new Error("Com not open");
socket.end();
}
}
}).call(this);
"""
)
def send(msg: String): Unit = {
if (awaitConnection()) {
jvm2js.writeInt(msg.length)
jvm2js.writeChars(msg)
jvm2js.flush()
}
}
def receive(): String = {
if (!awaitConnection())
throw new ComJSEnv.ComClosedException
try {
val len = js2jvm.readInt()
val carr = Array.fill(len)(js2jvm.readChar())
String.valueOf(carr)
} catch {
case e: EOFException =>
throw new ComJSEnv.ComClosedException
}
}
def close(): Unit = {
serverSocket.close()
if (jvm2js != null)
jvm2js.close()
if (js2jvm != null)
js2jvm.close()
if (comSocket != null)
comSocket.close()
}
override def stop(): Unit = {
close()
super.stop()
}
/** Waits until the JS VM has established a connection or terminates
* @return true if the connection was established
*/
private def awaitConnection(): Boolean = {
serverSocket.setSoTimeout(acceptTimeout)
while (comSocket == null && isRunning) {
try {
comSocket = serverSocket.accept()
jvm2js = new DataOutputStream(
new BufferedOutputStream(comSocket.getOutputStream()))
js2jvm = new DataInputStream(
new BufferedInputStream(comSocket.getInputStream()))
} catch {
case to: SocketTimeoutException =>
}
}
comSocket != null
}
override protected def initFiles(): Seq[VirtualJSFile] =
super.initFiles :+ comSetup
override protected def finalize(): Unit = close()
}
protected trait AbstractNodeRunner extends AbstractExtRunner {
protected[this] val libCache = new VirtualFileMaterializer(true)
/** File(s) to automatically install source-map-support.
* Is used by [[initFiles]], override to change/disable.
*/
protected def installSourceMap(): Seq[VirtualJSFile] = Seq(
new MemVirtualJSFile("sourceMapSupport.js").withContent(
"""
try {
require('source-map-support').install();
} catch (e) {}
"""
)
)
/** File(s) to hack console.log to prevent if from changing `%%` to `%`.
* Is used by [[initFiles]], override to change/disable.
*/
protected def fixPercentConsole(): Seq[VirtualJSFile] = Seq(
new MemVirtualJSFile("nodeConsoleHack.js").withContent(
"""
// Hack console log to duplicate double % signs
(function() {
var oldLog = console.log;
var newLog = function() {
var args = arguments;
if (args.length >= 1 && args[0] !== void 0 && args[0] !== null) {
args[0] = args[0].toString().replace(/%/g, "%%");
}
oldLog.apply(console, args);
};
console.log = newLog;
})();
"""
)
)
/** File(s) to define `__ScalaJSEnv`. Defines `exitFunction`.
* Is used by [[initFiles]], override to change/disable.
*/
protected def runtimeEnv(): Seq[VirtualJSFile] = Seq(
new MemVirtualJSFile("scalaJSEnvInfo.js").withContent(
"""
__ScalaJSEnv = {
exitFunction: function(status) { process.exit(status); }
};
"""
)
)
/** Concatenates results from [[installSourceMap]], [[fixPercentConsole]] and
* [[runtimeEnv]] (in this order).
*/
override protected def initFiles(): Seq[VirtualJSFile] =
installSourceMap() ++ fixPercentConsole() ++ runtimeEnv()
/** Libraries are loaded via require in Node.js */
override protected def getLibJSFiles(): Seq[VirtualJSFile] = {
initFiles() ++
classpath.jsLibs.map(requireLibrary) :+
classpath.scalaJSCode
}
/** Rewrites a library virtual file to a require statement if possible */
protected def requireLibrary(dep: ResolvedJSDependency): VirtualJSFile = {
dep.info.commonJSName.fold(dep.lib) { varname =>
val fname = dep.lib.name
libCache.materialize(dep.lib)
new MemVirtualJSFile(s"require-$fname").withContent(
s"""$varname = require(${toJSstr(fname)});"""
)
}
}
// Send code to Stdin
override protected def sendVMStdin(out: OutputStream): Unit = {
sendJS(getJSFiles(), out)
}
/** write a single JS file to a writer using an include fct if appropriate
* uses `require` if the file exists on the filesystem
*/
override protected def writeJSFile(file: VirtualJSFile,
writer: Writer): Unit = {
file match {
case file: FileVirtualJSFile =>
val fname = toJSstr(file.file.getAbsolutePath)
writer.write(s"require($fname);\n")
case _ =>
super.writeJSFile(file, writer)
}
}
// Node.js specific (system) environment
override protected def getVMEnv(): Map[String, String] = {
val baseNodePath = sys.env.get("NODE_PATH").filter(_.nonEmpty)
val nodePath = libCache.cacheDir.getAbsolutePath +
baseNodePath.fold("")(p => File.pathSeparator + p)
sys.env ++ Seq(
"NODE_MODULE_CONTEXTS" -> "0",
"NODE_PATH" -> nodePath
) ++ additionalEnv
}
}
}
