removed loopextension trait and setting up release plugins

Author: Richard Whaling

build.sbt

@@ -1,11 +1,39 @@
+
+homepage := Some(url("https://github.com/scala-native/scala-native-loop"))
+licenses := Seq("Apache 2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0"))
+publishMavenStyle := true
+publishArtifact in Test := false
+pomIncludeRepository := { _ => false }
+publishTo in ThisBuild := {
+  val nexus = "https://oss.sonatype.org/"
+  if (isSnapshot.value)
+    Some("snapshots" at nexus + "content/repositories/snapshots")
+  else
+    Some("releases"  at nexus + "service/local/staging/deploy/maven2")
+}
+scmInfo := Some(
+  ScmInfo(
+    url("https://github.com/scala-native/scala-native-loop"),
+    "scm:git:git@github.com:scala-native/scala-native-loop.git"
+  )
+)
+developers := List(
+  Developer("rwhaling", "Richard Whaling", "richard@whaling.dev", url("http://whaling.dev"))
+)
+
 lazy val commonSettings = Seq(
   organization := "dev.whaling",
-  version := "0.1-SNAPSHOT",
-  scalaVersion := "2.11.12"
+  version := "0.1.1-SNAPSHOT",
+  scalaVersion := "2.11.12",
+  skip in publish := true,
+  skip in publishLocal := true
 )
 
 lazy val core = (project in file("core"))
+                .settings(name := "native-loop-core")
                 .settings(commonSettings:_*)
+                .settings(skip in publish := false)
+                .settings(skip in publishLocal := false)
                 .enablePlugins(ScalaNativePlugin)
 
 lazy val pipe = (project in file("pipe"))
@@ -23,6 +51,14 @@ lazy val server = (project in file("server"))
                  .enablePlugins(ScalaNativePlugin)
                  .dependsOn(core)
 
+lazy val scalaJsCompat = (project in file("scalajs-compat"))
+                .settings(name := "native-loop-js-compat")
+                .settings(commonSettings:_*)
+                .settings(skip in publish := false)
+                .settings(skip in publishLocal := false)
+                .enablePlugins(ScalaNativePlugin)
+                .dependsOn(core)
+
 lazy val serverExample = (project in file("examples/server"))
              	 	 .settings(commonSettings:_*)
                  .enablePlugins(ScalaNativePlugin)

client/curl.scala

@@ -10,7 +10,7 @@ import scala.scalanative.runtime.Intrinsics
 
 case class ResponseState(var code:Int = 200,var headers:mutable.Map[String,String] = mutable.Map(),var body:String = "")
 
-object Curl extends LoopExtension {
+object Curl {
   import LibCurl._
   import LibCurlConstants._
   import LibUV._
@@ -25,8 +25,6 @@ object Curl extends LoopExtension {
   val requestPromises = mutable.Map[Long,Promise[ResponseState]]()
   val requests = mutable.Map[Long,ResponseState]()
 
-  override def activeRequests = requests.size
-
   var initialized = false
 
   def init():Unit = {
@@ -42,7 +40,6 @@ object Curl extends LoopExtension {
       println(s"timerCB: $startTimerCB")
 
       check(uv_timer_init(loop,timerHandle),"uv_timer_init")
-      EventLoop.addExtension(this)
       initialized = true
       println("done")
     }

core/loop.scala

@@ -11,34 +11,18 @@ import scala.Option
 import LibUV.Buffer
 import LibUVConstants.check
 
-trait LoopExtension {
-  def activeRequests:Int
-}
-
 object EventLoop extends ExecutionContextExecutor {
   import LibUV._, LibUVConstants._
 
-
   val loop = uv_default_loop()
   private val taskQueue = ListBuffer[Runnable]()
-  private val extensions = ListBuffer[LoopExtension]()
-  var publishers = 0
+  val handle = stdlib.malloc(uv_handle_size(UV_PREPARE_T))
 
   private def initDispatcher(loop:LibUV.Loop):PrepareHandle = {
-    val handle = stdlib.malloc(uv_handle_size(UV_PREPARE_T))
     check(uv_prepare_init(loop, handle), "uv_prepare_init")
-    check(uv_prepare_start(handle, prepareCallback), "uv_prepare_start")
     return handle
   }
 
-  def addExtension(e:LoopExtension):Unit = {
-    extensions.append(e)
-  }
-
-  private def extensionsWorking():Boolean = {
-    extensions.exists( _.activeRequests > 0)
-  }
-
   val prepareCallback = new PrepareCB {
     def apply(handle:PrepareHandle) = {
       while (taskQueue.nonEmpty) {
@@ -49,27 +33,29 @@ object EventLoop extends ExecutionContextExecutor {
           case t: Throwable => reportFailure(t)
         }
       }
-      if (taskQueue.isEmpty && !extensionsWorking) {
-        println("stopping dispatcher")
+      if (taskQueue.isEmpty) {
         LibUV.uv_prepare_stop(handle)
       }
-
     }
   }
 
   private val dispatcher = initDispatcher(loop)
 
-  def execute(runnable: Runnable): Unit = taskQueue += runnable
+  private val bootstrapFuture = Future(run())(scalanative.runtime.ExecutionContext.global)
+
+  def execute(runnable: Runnable): Unit = {
+    taskQueue += runnable
+    check(uv_prepare_start(handle, prepareCallback), "uv_prepare_start")
+  }
+
   def reportFailure(t: Throwable): Unit = {
-    println(s"Future failed with Throwable $t:")
     t.printStackTrace()
   }
 
   def run(mode:Int = UV_RUN_DEFAULT):Unit = {
     var continue = 1
     while (continue != 0) {
         continue = uv_run(loop, mode)
-        println(s"uv_run returned $continue")
     }
   }
 }
@@ -192,12 +178,11 @@ object LibUVConstants {
 
   def check(v:Int, label:String):Int = {
       if (v == 0) {
-        println(s"$label returned $v")
         v
       } else {
         val error = fromCString(uv_err_name(v))
         val message = fromCString(uv_strerror(v))
-        println(s"$label returned $v: $error: $message")
+        println(s"ERROR: $label returned $v: $error: $message")
         v
       }
   }

core/timer.scala

@@ -10,20 +10,16 @@ import scala.Option
 import scala.concurrent.duration._
 import LibUV._, LibUVConstants._
 
-object Timer extends LoopExtension {
-  EventLoop.addExtension(this)
+object Timer {
 
   var serial = 0L
-  var timers = mutable.HashMap[Long,Promise[Unit]]()
-
-  override def activeRequests():Int = 
-    timers.size
+  var callbacks = mutable.HashMap[Long,() => Unit]()
 
   def delay(dur:Duration):Future[Unit] = {
     val promise = Promise[Unit]()
     serial += 1
     val timer_id = serial
-    timers(timer_id) = promise
+    callbacks(timer_id) = () => promise.success(())
     val millis = dur.toMillis
 
     val timer_handle = stdlib.malloc(uv_handle_size(UV_TIMER_T))
@@ -37,13 +33,46 @@ object Timer extends LoopExtension {
 
   val timerCB = new TimerCB { 
     def apply(handle:TimerHandle):Unit = {
-      println("callback fired!")
       val timer_data = handle.asInstanceOf[Ptr[Long]]
       val timer_id = !timer_data
-      val timer_promise = timers(timer_id)
-      timers.remove(timer_id)
-      println(s"completing promise ${timer_id}")
-      timer_promise.success(())
+      val callback = callbacks(timer_id)
+      callbacks.remove(timer_id)
+      callback()
+      stdlib.free(handle)
+    }
+  }
+
+  // low-level, intended for use in scala.js compat layer - leaks memory if 
+  // caller does not free() returned handle
+  def oneTime(dur:Double, callback: () => Unit):PrepareHandle = {
+    serial += 1
+    val timer_id = serial
+
+    val timer_handle = stdlib.malloc(uv_handle_size(UV_TIMER_T))
+    uv_timer_init(EventLoop.loop,timer_handle)
+    val timer_data = timer_handle.asInstanceOf[Ptr[Long]]
+    !timer_data = timer_id
+
+    callbacks(timer_id) = () => {
+      callback()
     }
+
+    uv_timer_start(timer_handle, timerCB, dur.toLong, 0)
+    timer_handle
+  }
+
+  // low-level, intended for use in scala.js compat layer - leaks memory if 
+  // caller does not free() returned handle
+  def repeat(dur:Double, callback: () => Unit):PrepareHandle = {
+    serial += 1
+    val timer_id = serial
+
+    callbacks(timer_id) = () => callback()
+    val timer_handle = stdlib.malloc(uv_handle_size(UV_TIMER_T))
+    uv_timer_init(EventLoop.loop,timer_handle)
+    val timer_data = timer_handle.asInstanceOf[Ptr[Long]]
+    !timer_data = timer_id
+    uv_timer_start(timer_handle, timerCB, dur.toLong, dur.toLong)
+    timer_handle
   }
 }

pipe/pipe.scala

@@ -34,28 +34,15 @@ case class Handle(serial:Long, handle:Ptr[Byte]) {
   }
 }
 
-object StreamIO extends LoopExtension {
+object StreamIO {
   import LibUV._, LibUVConstants._
   type ItemHandler = ((String,PipeHandle,Long) => Unit)
   type DoneHandler = ((PipeHandle,Long) => Unit)
   type Handlers = (ItemHandler, DoneHandler)
   var streams = mutable.HashMap[Long,Handlers]()
   var serial = 0L
 
-  override def activeRequests:Int = {
-    streams.size
-  }
-
-  var initialized = false
-
-  def checkInit() = if (!initialized) {
-    println("initializing PipeIO")
-    EventLoop.addExtension(this)
-    initialized = true
-  }
-
   def fromPipe(fd:Int):Handle = {
-    checkInit
     val id = serial
     serial += 1
     val handle = stdlib.malloc(uv_handle_size(UV_PIPE_T))
@@ -66,22 +53,8 @@ object StreamIO extends LoopExtension {
     Handle(id,handle)
   }
 
-  // def fromSocket(fd:Int):Handle = {
-  //   checkInit
-  //   val id = serial
-  //   serial += 1
-  //   val handle = stdlib.malloc(uv_handle_size(UV_TCP_T)).asInstanceOf[Ptr[Long]]
-  //   uv_tcp_init(EventLoop.loop,handle)
-  //   val socket_data = handle
-  //   !socket_data = serial
-  //   // getaddrinfo/uv_connect here
-  //   ???
-  //   // Handle(id,handle)
-  // }
-
   def stream(fd:Int)(itemHandler:ItemHandler,
                      doneHandler:DoneHandler):Handle = {
-    checkInit
     val pipeId = serial
     serial += 1
     val handle = stdlib.malloc(uv_handle_size(UV_PIPE_T))

project/plugins.sbt

@@ -1 +1,3 @@
-addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.4.0-SNAPSHOT")
+addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.4.0-M2")
+addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.1")
+addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "1.1")

server/server.scala

@@ -6,7 +6,7 @@ import scala.scalanative.libc.stdlib._
 import scala.scalanative.libc.string._
 import scala.concurrent._
 
-object Server extends LoopExtension {
+object Server {
   import LibUV._, LibUVConstants._
   import Parser._
 
@@ -17,8 +17,6 @@ object Server extends LoopExtension {
   val HTTP_RESPONSE = 1
   val HTTP_BOTH = 2
 
-  override def activeRequests = listeners.size
-
   type ConnectionState = CStruct3[Long,LibUV.TCPHandle,Ptr[HttpParser.Parser]]
   type RequestHandler = (RequestState, TCPHandle) => Unit
   type WriteState = (Promise[Unit],Ptr[Buffer])
@@ -61,7 +59,6 @@ object Server extends LoopExtension {
   }
 
   def init(port:Int)(handler:RequestHandler):Unit = {
-    EventLoop.addExtension(this)
     listeners(port) = handler
     val addr = malloc(64)
     check(uv_ip4_addr(c"0.0.0.0", 9999, addr),"uv_ip4_addr")