Server Side Javascript

Event Driven Non-Blocking I/O

Single thread/single event loop

Application registers handlers

Events trigger handlers

Everything runs on the event loop

vertx run Server.groovy

vertx run Server.groovy -instances 32 

vertx runmod server-mod -instances 32 

def eb = vertx.eventBus()

eb.registerHandler("test.address") { message ->  println "I received a message ${message.body}"}

eb.publish("test.address", "hello world") 

eb.send("test.address", "hello world") 

eb.send("test.address", "Some message") { message ->
  println "I received a reply ${message.body}"}

eb.registerHandler("test.address") { message ->
  println "I received a message ${message.body}"    // Do some work here    message.reply("Some reply")}

• String
  
• Primitives
  
• Boxed Primitives
  
• Boolean
  
• java.util.map - representing JSON
• org.vertx.java.core.JsonObject
• org.vertx.java.core.Buffer

def server = vertx.createHttpServer()
server.requestHandler { req ->  if (req.uri == "/")     req.response.sendFile("index.html")  if (req.uri.endsWith("vertxbus.js"))    req.response.sendFile("vertxbus.js")}.listen(8080)
def sockJSServer = vertx.createSockJSServer(server)sockJSServer.bridge( { prefix: "/eventBus"} )
server.listen(8080)

<script src="http://cdn.sockjs.org/sockjs-0.2.1.min.js"></script><script src="vertxbus.js"></script>
<script>var eb = new vertx.EventBus('http://localhost:8080/eventBus')
eb.onopen = function() {  eb.registerHandler('msgs.echo', function(message) {    alert('Echoing msg: ' + JSON.stringify(message))  });}

def server = vertx.createHttpServer()

server.websocketHandler{ ws ->
  println "A websocket has connected!"
}.listen(8080, "localhost")

def server = vertx.createHttpServer()

server.websocketHandler{ ws ->
  if (ws.path == "/services/echo") {
    Pump.createPump(ws, ws).start()
  } else {
    ws.reject()
  }
}.listen(8080, "localhost")

def client = vertx.createHttpClient()

client.connectWebsocket("http://localhost:8080/some-uri") { ws ->
  // Connected!
}

<script>
  var socket = new WebSocket("ws://localhost:8080/services/echo");
  socket.onmessage = function(event) {

    alert("Received data from websocket: " + event.data);
  }
  socket.onopen = function(event) {

    alert("Web Socket opened");
    socket.send("Hello World");
  };
  socket.onclose = function(event) {
    alert("Web Socket closed");
  };
</script>

• Strings
  
• Boxed Primitives
  
• byte[]
  
• org.vertx.java.core.buffer.Buffer
  
• org.vertx.java.core.shareddata.Shareable
  

def map = vertx.sharedData.getMap('demo.mymap')map["some-key"] = 123

def map = vertx.sharedData.getMap('demo.mymap')// Retrieve value 123 from the mapdef value = map."some-key"

def set = vertx.sharedData.getSet('demo.myset')set << "some-value"

def set = vertx.sharedData.getSet('demo.myset')// Set will now contain some-valueset.contains("some-value")

• MUST not block the event loop
• Some work is natually blocking
  
• Intensive data crunching
• 3rd-party blocking API's (e.g. JDBC, etc...)
• Node.js is not good for this type of work
  

public class FibWorker extends Verticle {  @Override  public void start() {    def eb = vertx.eventBus()    eb.registerHandler("fib.request") { message ->      def result = fib(message.body.intValue())      def resultMessage = { nbr: message.body,                            result: result }      eb.send("fib.response", resultMessage)    }  }
  def fib(n) { n < 2 ? 1 : fib(n-1) + fib(n-2) }}

public class WorkerExample extends Verticle {  @Override  public void start() {    def eb = vertx.eventBus()    eb.registerHandler("fib.response") { msg ->      println "Fib:${msg.body.nbr}=${msg.body.result}"    }
    container.deployWorkerVerticle("worker.FibWorker")       { msg ->      eb.send("fib.request", 20)    }  }}

• TCP/SSL servers and clients
  
• HTTP/HTTPS servers and clients
  
• WebSockets servers and clients
  
• Accessing the distributed event bus
  
• Periodic and one-off timers
  
• Buffers
  
• Flow control
  
• Accessing files on the file system
  
• Shared map and sets
  
• Logging
  
• Accessing configuration
  
• Writing SockJS servers
  
• Deploying and undeploying verticles
  

vertx.createHttpServer(someHttpServerConfig).requestHandler { request ->  def responseString = "ERROR"
  try {
    // Do some stuff with the request    	
    responseString = "OK"
  } catch (Exception e) {      responseString = "ERROR (${e.getClass().name})"  } finally {    request.response.end("${responseString}")
  }
}.listen(someHttpServerConfig.port)

http://slid.es/rappleg/vert-x