Introduction to Nodejs

gabriele lana
gabriele.lana@cleancode.it
twitter: @gabrielelana

why
node.js?

“Node's goal is to
provide an easy
way to build
scalable network
programs”

http://nodejs.org/#about

what is
node.js?
• asynchronous i/o framework
• core in c++ on top of v8
• rest of it in javascript
• swiss army knife for network
related stuffs
• can handle thousands of
concurrent connections with
minimal overhead (cpu/memory)
on a single process

multiple thread
synchronous I/0

you can
“always”
scale with
multiple
machines but
it costs
you $$$

CPU BOUND
TASKS?

but...
what is HE
doing?

CPU BOUND
TASKS?

...OR I/o
but... BOUND
what is HE TASKS?
doing?

synchronous I/0

function productsInCart(request, response) {
var db = new Db()
var user = new User(request)
if (user.isAuthorized("cart/products")) {
response.write(
JSON.stringify(
db.productsInCart(user.cartId())
)
)
} else {
response.unauthorized()
}
}

single thread
asynchronous I/0

single thread
asynchronous I/0

I am
“callback”
call me
if you
need me...

hello_world_server.js
Event Emitter

var http = require("http")

var server = http.createServer(function(request, response) {
response.writeHead(200, {
"Content-Type": "plain/text"
})
response.write("Hello Worldn")
response.end()
})

server.listen(8080)

console.log("> SERVER STARTED")

Event Emitter

coder@apollo:~/Work/src/node/examples$ node hello_world_server.js
> SERVER STARTED
#1
coder@apollo:~$ curl "http://localhost:8080/"
Hello World
#2

Event Emitter

var server = require("http").createServer()

server.on("request", function(request, response) {
console.log("> REQUEST STARTED")
request.on("end", function() {
console.log("> REQUEST CLOSED")
response.writeHead(200, {
"Content-Type": "plain/text"
})
response.end("Hello Worldn")
server.close()
})
response.on("close", function() {
console.log("> RESPONSE CLOSED")
})
})

Event Emitter

...

server.on("close", function() {
console.log("> SERVER CLOSED")
})

server.on("listening", function() {
console.log("> SERVER STARTED")
})

server.listen(8080)

Event Emitter

coder@apollo:~/Work/src/node/examples$ node hello_world_server.js
> SERVER STARTED #1
coder@apollo:~$ curl "http://localhost:8080/"
Hello World #2
#1
> REQUEST STARTED
> REQUEST CLOSED
> SERVER CLOSED

data streamS
var chunks = [],
output = fs.createWriteStream("./output")
proxy_stream.js

request.on("data", function(chunk) {
chunks = forEachLine(chunks.concat(chunk), function(line) {
output.write(parseInt(line, 10) * 2)
output.write("n")
})
})

request.on("end", function() {
response.writeHead(200, { "Content-Type": "plain/text" })
response.end("OKn")
output.end()
server.close()
})
})

data streamS

coder@apollo:~/Work/src/node/examples$ node stream_doubler.js
#1
coder@apollo:~$ curl "http://localhost:8080/" --data $'1n2n3n'
OK #2
coder@apollo:~/Work/src/node/examples$ cat output
2
4
6 #1

why
javascript?

• Friendly callbacks
• ubiquitous (well known)
• no I/o primitives
• one language to rule them all

web applications
before: a web
mind shift #1 server with some
application logic

application
Web server

application

application

application

web applications
after: an application
mind shift #1 accessible over
http
web server

application

web applications
after: an application
mind shift #1 that can
communicate and
collaborate with
the world
web server

application

web applications
before: stateful
mind shift #2 • no easy to scale
• no easy to reuse

v
M
c

web applications
before: stateful

v
M
c

conversation application
state state

web applications
before: stateful

v
M
c

tightly coupled

web applications
after: stateless
mind shift #2 • easy to scale
• easy to reuse

v
http
M
c

web applications
after: stateless
mind shift #2 • easy to scale
• easy to reuse

v
http
M
c

conversation application
state state

web applications
after: stateless
mind shift #2
http

web server
M
http

statefull
connection

• easy to scale M
• easy to reuse

the fork
long_running_job.sh be with you

#!/bin/bash

for count in `seq 1 100`; do
echo $count
sleep 0.1
done

the fork
long_running_server.js be with you
var spawn = require("child_process").spawn,
server = require("http").createServer()

var job = spawn("./long_running_job.sh")

job.stdout.on("data", function(tick) {
response.write(tick)
})

job.on("exit", function() {
response.end()
})
})

the fork
be with you
coder@apollo:~$ ab -c 1 -n 1 "http://localhost:8080/"
...
Concurrency Level: 1
Time taken for tests: 10.531 seconds
...

...
...

the fork
be with you
...
...

...
...

...
...

enter comet

w
at
ch
watch M spawn
ch
at
w

watch
w

w
t a

at
ch

ch

INSTALL NPM
(node packet manager)

coder@apollo:~/Work/src/node/examples$ curl http://npmjs.org/install.sh | sh
...
npm ok
It worked

coder@apollo:~/Work/src/node/examples$ npm search | wc -l
1918

coder@apollo:~/Work/src/node/examples$ npm install connect socket.io underscore
coder@apollo:~/Work/src/node/examples$ npm list
!"# connect@1.4.1
$ !"" mime@1.2.2
$ %"" qs@0.1.0
%"" socket.io@0.6.17
%"" underscore@1.1.6

server/
routing
progress_server.js

var server = connect(
connect.favicon(),
connect.logger({"buffer": true}),
connect.router(function(resource) {
resource.post("/spawn", function(request, response) {
...
})
}),
connect.static(path.join(__dirname, "public"), {"cache": true})
)

server/
routing
progress_server.js

var job = spawn(path.join(__dirname, "bin", "job.sh")),
id = ++counter

response.writeHead(202, {"Content-Type": "plain/text"})
response.end("OKn")

job.stdout.on("data", function(output) {
var progress = parseInt(output.toString(), 10)
_(connections).each(function(connection) {
connection.send({"id": id, "progress": progress})
})
})
})

server/
socket.io
progress_server.js

io.listen(server).on("connection", function(client) {

connections[client.sessionId] = client

client.on("disconnect", function() {
delete connections[client.sessionId]
})

})

server/
simulation
progress_server.js

server.listen(port, host, function() {
var spawnJobsInterval = setInterval(function() {
http.request({
"port": port, "host": host, "method": "POST", "path": "/spawn"
}).end()
}, Math.floor(Math.random()*2000)+500)

server.on("close", function() {
clearInterval(spawnJobsInterval)
process.exit()
})
})

process.on("SIGINT", function() {
server.close()
})

interface/html
<html>
<head>
<title>Node.js - Long Running Jobs</title>
<link href="css/style.css" rel="stylesheet" />
<script type="text/javascript" src="/socket.io/socket.io.js"></script>
<script type="text/javascript" src="js/jquery-1.6.0.js"></script>
<script type="text/javascript" src="js/progress.js"></script>
index.html

</head>
<body>
<div id="template">
<div class="progress-container">
<span class="progress-text">JOB/? - ?%</span>
<div class="progress-bar"></div>
</div>
</div>
<div id="container"> </div>
</body>
<script>
...
</script>
</html>

interface/
socket.io
<html>
...
<script>
$(function() {
var socket = new io.Socket()
index.html

socket.on("connect", function() { })
socket.on("disconnect", function() { })
socket.on("message", function(job) {
$("#template").progressBar(job.id, job.progress)
})

socket.connect()
})
</script>
</html>

interface/
progress bar
$.fn.progressBar = function(id, progress) {
var $template = $(this)
$("#job-" + id)
.otherwise(function() {
return $template.children().clone()
progress.js

.attr("id", "job-" + id)
.find(".progress-text").text("JOB/" + id + " - 0%").end()
.appendTo("#container")
})
.find(".progress-text").text("JOB/" + id + " - " + progress + "%").end()
.find(".progress-bar").css("width", progress + "%").end()
.tap(function() {
if (progress === 100) {
$(this)
.find(".progress-bar").css("background-color", "red").end()
.after(500, function() {
$(this).fadeOut("slow", function() {
$(this).remove()
})
})
}

interface/
progress bar
$.fn.otherwise = function(ifNotFound) {
if (this.length === 0) {
return ifNotFound()
}
progress.js

return this
}

$.fn.after = function(milliseconds, doSomething) {
var self = this
setTimeout(function() {
doSomething.apply(self)
}, milliseconds)
return this
}

$.fn.tap = function() {
var fn = Array.prototype.shift.apply(arguments)
fn.apply(this, arguments)
return this
}

we can do it
with a little
more “style”

server/
event emitter
var Job = (function() {
var EventEmitter = require("events").EventEmitter,
progress_server.js

spawn = require("child_process").spawn,
inherits = require("util").inherits

function Job(id) {
EventEmitter.call(this)
this.id = id
}

inherits(Job, EventEmitter)

Job.prototype.run = function() {
return _(this).tap(function(job) {
spawn(path.join(__dirname, "bin", "job.sh"))
.stdout.on("data", function(output) {
job.emit("progress", job.id, parseInt(output.toString(), 10))
})
})
}
return Job
})()

server/
event emitter
progress_server.js

new Job(++counter)
.on("progress", function(id, progress) {
_(connections).each(function(connection) {
connection.send({"id": id, "progress": progress})
})
})
.run()

response.writeHead(202, { "Content-Type": "plain/text" })
response.end("OKn")
})

node.js is
awesome
but when
should i
use it?

when to use it?

• chat/messaging
• real-time applications
• intelligent proxies
• high concurrency applications
• communication hubs
• coordinators

please tell
me something
bad about
node.js

some warnings
• release stable 0.4.7 (young)
• lots of stuffs to look at
• lots of half backed stuffs
• retro compatibility???
• bad at handling static contents
• Bad at handling binary contents
• hard to find organized and
authoritative informations

gabriele lana
gabriele.lana@cleancode.it
twitter: @gabrielelana

http://joind.in/3359

Introduction to Nodejs

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Introduction to Nodejs (20)

More from Gabriele Lana (20)

Recently uploaded (20)

Introduction to Nodejs