Vert.X mini-talk

orb@nostacktrace.com

Vert.x
A polyglot
asynchronous
application platform
Norman Richards

for the JVM


Do you need Async?
Conan, What is
best in life?

To crush their servers,
Norman Richards

s! them smoking before you,
and to hear the lamentations
of their admins!
http://www.mikeperham.com/
Conan, the C10K Barbarian

Ok, so of course that means ...
Norman Richards

http://bit.ly/ACrwel


Some Async options

Node.js (JavaScript)
Twisted (Python)
Tornado (Python)
EventMachine (Ruby)
Vert.x (Java)
Vert.x (Javascript)
Vert.x (Python)
Norman Richards

Vert.x (Ruby)
Vert.x (Groovy)


Key advantages of vert.x

Runs on the JVM (Java 7+)

Choose the best language

Hybrid evented/threaded model
Norman Richards


Evented IO

One thread handles all requests

Everything is an event handler

Never block the thread

Do work quickly + register callbacks
Norman Richards

Any kind of service - not just HTTP


simple Example

import org.vertx.java.core.Handler;
import org.vertx.java.core.http.HttpServerRequest;
import org.vertx.java.platform.Verticle;

public class ServerExample extends Verticle {

  public void start() {
    vertx.createHttpServer().requestHandler(new Handler<HttpServerRequest>() {
      public void handle(HttpServerRequest req) {
        req.response.headers().put("Content-Type", "text/html; charset=UTF-8");
        req.response.end("<html><body><h1>Hello from vert.x!</h1></body></html>");
      }
Norman Richards

    }).listen(8080);
  }
}


slightly bigger Example
server.requestHandler(new Handler<HttpServerRequest>() {
public void handle(HttpServerRequest request) {

final Buffer body = new Buffer(0);

request.dataHandler(new Handler<Buffer>() {
public void handle(Buffer buffer) {
body.appendBuffer(buffer);
}
});

request.endHandler(new SimpleHandler() {
public void handle() {
// The entire body has now been received
Norman Richards

log.info("The total body received was " + body.length() + " bytes");
}
});

}
}).listen(8080, "localhost");


the verticle

the unit of management/deployment
Event Loop

classloader isolated
Event Handler

Event Handler
one thread / one event loop
Event Handler

Event Handler
only one handler running at a time
Norman Richards

VERTICLE
no multi-threaded worries


One VERTICLE PER CPU

Shared Connection Load Balancer

Event Loop Event Loop Event Loop Event Loop

Event Handler Event Handler Event Handler Event Handler


Norman Richards


VERTICLE VERTICLE VERTICLE VERTICLE


One VERTICLE PER CPU PER HOST





Norman Richards


host1 host2


SHARED STATE

Event Loop Event Loop

Event Handler Event Handler per-instance “session”
Event Handler Event Handler

Event Handler Event Handler map or set interface
Event Handler Event Handler

only immutable values
Norman Richards

VERTICLE VERTICLE

Shared State


SHARED MAPs

ConcurrentMap<String, Integer> map =
vertx.sharedData().getMap("app.interesting-data");

map.put("some-key", 123);
map.putIfAbsent("some-key", 123);
map.replace("some-key", 123, 124);
map.get("some-key");
map.remove("some-key");
Norman Richards


SHARED SETS

Set<String> set = vertx.sharedData().getSet("app.active-users");

set.add("alfred");
set.contains("alfred");
set.contains("remove");
Norman Richards


distributed event bus






Norman Richards

Shared State Shared State

Event Bus


The event bus

ad-hoc addressing

pubsub or p2p messaging

not persistent

JSON-based messaging
Norman Richards


The event bus
Handler<Message<String>> myHandler = new Handler<Message<String>>() {
public void handle(Message<String> message) {
System.out.println("I received a message " + message.body);

// do work

message.reply("This is a reply");
}
};

eb.registerHandler("test.address", myHandler);

eb.send("test.address", "This is a message", new Handler<Message<String>>() {
Norman Richards

public void handle(Message<String> message) {
System.out.println("I received a reply " + message.body);
}
});


... in groovy

def myHandler = { message ->
println "I received a message ${message.body}"

// do work

message.reply "This is a reply"
}

eb.registerHandler("test.address", myHandler)

Norman Richards

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


... in ruby

Vertx::EventBus.registerHandler('test.address') do |message|
puts("I received a message #{message.body}")

# do work

message.reply('This is a reply')
end

Vertx::EventBus.send('test.address', 'This is a message') do |message|
puts("I received a reply #{message.body}")
Norman Richards

end


... in python

def handler(message):
print "I received a message %s" % message.body

# do work

message.reply('This is a reply')

EventBus.registerHandler('test.address', handler)

def reply_handler(message):
Norman Richards

print "I received a reply %s" % message.body

EventBus.send('test.address', 'This is a message', reply_handler)


... in javscript

var myHandler = function(message, replier) {
log.info('I received a message ' + message);

// Now reply to it

replier('This is a reply');
}

eb.registerHandler('test.address', myHandler);

eb.send('test.address', 'This is a message', function(reply) {
Norman Richards

log.info('I received a reply ' + reply);
});


... in clojure !!!

(defhandle my-handle [message]
(println "I received a mesage" (:body message))

;; do work

(reply message "This is a reply"))

(register-handler event-bus "test.address" my-handle)

(send event-bus "test.address"
"This is a message"
Norman Richards

(handle [response]
(println "I received a reply" (:body response))))


WHAT about things that block?

blocking IO

CPU-intensive operations

legacy Java libraries
Norman Richards


WORKER VERTICLES

Event Loop Event Handler Event Handler Event Handler

Event Handler Event Handler Event Handler
Event Handler

Event Handler Event Handler Event Handler
Event Handler

Event Handler

WORKER WORKER WORKER

VERTICLE Worker Thread Pool
Norman Richards


more vert.x things

timers
streams / pumps / buffers
module system
SockJS / websockets
eventbus bridge
Norman Richards

outgoing network clients

Norman Richards orb@nostacktrace.com

http://vertx.io


Austin Clojure meetup
Next Meeting:
Monday, March 4. 7pm @ Capital Factory
Norman Richards

http://www.meetup.com/Austin-Clojure-Meetup/


http://lambdajam.com/


thank you

Vert.X mini-talk

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (14)

Similar to Vert.X mini-talk

Similar to Vert.X mini-talk (20)

Recently uploaded

Recently uploaded (20)

Vert.X mini-talk