Node.js Workshop - Sela SDP 2015

© Copyright SELA software & Education Labs Ltd. | 14-18 Baruch Hirsch St Bnei Brak, 51202 Israel | www.selagroup.com
SELA DEVELOPER PRACTICE
MAY 31 – JUNE 4, 2015
Nir Noy
Consultant, Web, Sela
@noynir
Node.js

Agenda
Introduction - What is Node.js.
File system.
Building servers.
Building APIs using modules, events and
packages.
Express Web framework.

Introduction – What is Node.js ?

What is Node.js
A JavaScript runtime that is designed for
asynchronous IO operations
Very lightweight and fast
Being used by a growing number of companies:

The Node.js ecosystem
Node.js has a rapidly growing ecosystem:
Web frameworks:
Express
Socket.io
Database support
Sql Databases
NoSql Databases
Hosting and Cloud environments
IIS, Azure
Heroku
Joyent

Synchronous server operations
// GET api/countries
public string Get()
{
var client = WebRequest.Create("http://.../");
var response = client.GetResponse();
var stream = response.GetResponseStream();
var reader = new StreamReader(stream);
return reader.ReadToEnd();
}
Blocking I/O operation

The Cost of I/O
I/O Operations are expensive.
I/O Source CPU Cycles
L1 – Cache 3
L2 – Cache 14
RAM 250
Disk 41,000,000
Network 240,000,000

Handling I/O
Waiting for I/O operations to complete is one of
the most common performance bottlenecks.
There are several common solutions to handle
it:
Synchronous
Pros: simple.
Cons: blocking, can hold up other requests.
Fork a new process
Pros: efficient, not holding up other requests.
Cons: does not scale, ~100 connections=~100 processes .

Handling I/O
Threads:
Pros:
efficient, not holding up other requests but more
lightweight then executing another process
Cons:
memory-expensive - ~1MB per thread, complicated, need
to worry about controlling access and shared resources.
Traditional web-servers (IIS, Apache) today use
an optimized thread-per-connection model that
uses thread pools.

Handling I/O in Node.js
Node.js runs your code on a single thread.
All I/O operations are asynchronous and Non-
Blocking
Internally threads and processes are used but not
explicitly exposed to your code.
When an I/O operation completes, an event is
triggered and the result is passed to a callback
function.

Why Node.js
Lightweight and efficient
using non-blocking I/O keeps memory consumption
stable by reducing the number of threads.
Less context switching overhead.
Concurrency
using non-blocking I/O keeps the main thread
responsive and allowing it support tens of thousands
of concurrent connections.
One Language
allows reuse of resources between the client and
server.

Node.js Event loop
I/O operations are evented and external events
are handled by Node’s Event loop.
Javascript functions are passed to a queue and
invoked when the return value from their
current I/O calls is available.
I/O Callbacks are invoked synchronously by the
order they returned.

Node.js Event loop
Server
Async
Workers
DDB, FS,
Network,
etc…
Request
Response
Request
Response

Node.js Usage
Running CPU intensive tasks (e.g. long running
loops) on Node.js’s main thread should be
avoided as it will block handling other requests
to the server.
Running CPU intensive tasks can be scaled out
to multiple node processes.
Node.js can run a managed cluster of multiple
processes to scale out an entire application.

The Node.js process
Unlike client-side JavaScript Node.js does not
run inside a browser window.
There are no window or document global
objects
The Node process provides the runtime for
node programs

Node.js process architecture
Node.exe
V8
CommonJS – Module loader
JavaScript Application
libuv
OS
Core Javascript modules for file
system, network, http, etc…
Responsible for loading modules
and manage dependencies.
Using CommonJS’s module
definition.
Multi-platform library written in C
that handles all async I/O
operations.
Google’s Javascript Engine.
Compiles the Javascript code to
native machine code.

The process global object
The process global object provides an API for
interacting with the process
Access command-line arguments
Get the execution path, current platform, node.js
version
Environment variables
Accessing standard input/output

Demo
Running Node from the command line

File System
Node.js provides the fs module for file system
operations:
Readingwriting files
Getting file metadata
Reading directories
Creating a file watcher
Most fs functions have synchronous APIs

Reading Directories
var fs = require('fs');
// this method reads the content of a directory
fs.readdir(process.argv[2], function(err,files){
files.forEach(function(file){
//Do something with file…
});
});

Demo
Inspecting directory’s content using the
fs module

Reading files
The fs module prvides different methods for
reading file content:
readFileSync reading the whole file synchronously
readFile reading the whole file asynchronously
createReadStream provides a stream based API for
reading files

//Async
fs.readFile(process.argv[2],'utf-8', function (err, data) {
if (err) throw err;
console.log(data)
});
//Read file sync
var f = fs.readFileSync(process.argv[2],'utf-8');
console.log(f);
Reading Files

Demo
Different ways to read files

Streams
Just like other frameworks Node.js use streams
as an abstraction for reading/writing data.
Just like most IO in Node.js, streams provide an
event base API using the on method
close, open
data
error
When using streams, data is read in chunks and
doesn’t block the main thread for the entire
time the data is buffered into memory.

Streams (cont.)
var strm = fs.createReadStream(process.argv[2]);
strm.setEncoding('utf8');
strm.on('data', function(data) {
console.log('read from strm');
});
strm.on('end', function(){
console.log('ended strm')
})

The pipe method allows you to connect a
readable stream as the destination of a
writeable stream
var fs = require("fs");
// Read File
fs.createReadStream("input/people.json")
// Write File
.pipe(fs.createWriteStream("output/people.json"));
Stream.pipe

Building HTTP servers
Node.js was originally designed as a platform
for building web servers.
Most Web applications are I/O Bound
~90% of a request’s processing time is spent on
waiting for I/O to complete.
Node.js async I/O mechanism provides node
with high concurrency and a low memory
footprint.

Building HTTP servers (cont.)
Node.js is designed to be scaled out to multiple
processes and machines which makes it ideal
for cloud hosting.
The http module provides basic functionality
for handling HTTP (client and server)
Additional frameworks like Express and Restify
provide higher level abstractions (like MVC)

var http = require('http');
http.createServer(function(req,res){
var response = 'Hello World';
res.writeHead(200,
{
'Content-Type': 'text/plain',
'Content-Length': response.length
});
res.write(response);
res.end();
}).listen(3000);
Node Http Server

The http.Server class
The http.createServer() method is used to
create a server.
It returns an instance of the http.Server object.
The http.Server provides a set of events
request – fires on every incoming request.
Connection -fires on every new tcp connection.
Upgrade - fires on every incoming upgrade request.

Demo
Handling the ‘connection’ event

Receiving data
HTTP allows server applications to receive data:
Using the request URI
Message body
Use the url and querystring modules for
parsing URLs and query strings.
Message body can contain any format
Being a JavaScript runtime, Node.js process JSON
natively
Other formats are supported through npm packages.

var url = require('url') ;
http.createServer(function (req, res) {
var queryObject = url.parse(req.url,true).query;
console.log(queryObject);
res.writeHead(200);
res.end('Feel free to add query parameters to the end of the
url');
}).listen(8080);
Parsing URL and Querystring

Demo
Using the URL and QueryString APIs

Http streaming
// handling incoming HTTP requests
var handleRequests = function(req,res){
// creating an outgoing HTTP request
req = http.request(options, responseCallback =
function(response) {
var str = '';
response.on('data', function (chunk) {
str += chunk;
});
response.on('end', function(){
res.end(str);
});
});
req.end();
};

Chunked transfer encoding
HTTP 1.1 introduced Chunked transfer encoding
that allows messages to be sent in chunks.
The Content-Length header is removed and a
Transfer-Encoding:chunked header is added to
the response.
HTTP can send messages in chunks
Write data in small chunks keeping a small memory
footprint
Freeing node’s single thread to serve more requests

Building APIs using modules, events
and packages

CommonJS Modules
Node.js uses CommonJS modules for
structuring code.
Modules are defined in separate .js files
To consume a module use the require
function

Modules and Scopes
Modules provide a simple mechanism for
creating scopes in JavaScript
Members defined inside a module are not
accessible outside
To expose a member use the exports object
This allow CommonJS to simplify dependency
resolution

Demo
Defining and Using Modules

The Global object
Unlike browsers the top-level scope in Node.js
is the module not global
To expose objects globally (across modules)
you can add them to the global object

Demo
Exposing Objects Globally

Node Package Manager (NPM)
The Node Package Manager (NPM) provides a
management mechanism for modules:
Download and install
Version management
Deployment

Managing Dependencies
NPM packages are managed in a file called
package.json
package.json schema define fields like:
name, description
Version
Dependencies
Dependencies are being resolved during NPM
install

{
"name": "app",
"version": "0.0.0",
"private": true,
"scripts": {
"start": "node ./bin/www"
},
"dependencies": {
"body-parser": "~1.10.2",
"cookie-parser": "~1.3.3",
"debug": "~2.1.1",
"express": "~4.11.1",
"jade": "~1.9.1",
"lodash": "^3.3.1",
"morgan": "~1.5.1",
"serve-favicon": "~2.2.0"
}
}
A look at Package.json

Managing Dependencies
NPM packages are installed inside a folder
named node_modules
The folder is created inside the path where the
“npm install …” was executed.
When a npm module is required node will look
it up inside the node_modules folder of the
current path.
If the module is not found it is recursively searched
up the folder tree.

Demo
Modules Dependency Resolution

The EventEmitter
Most of Node.js's APIs are event based
The events module provides the event emitter
object for emitting events.
Events are fired through the emit method and
can be watched using the on method.

Introduction to Express
Node.js http module provides bare-bones HTTP
server functionality
Building a modern web application server
would require implementing many common
features such as:
Routing
Session Management
Cookies & Requests Parsers
Request Logging

Introduction to Express
Express is a web application framework inspired
by Sinatra.
Express middleware provides an expendable
Http pipeline on top of Node.js's httpServer
An Express application is essentially a series of
middleware calls
A middleware is simply a function with access to
the request object, response object and a
callback to next middleware in line.

Express is available through npm
$ npm install express --save
Express provides a generator tool to quickly
create an application skeleton.
$ npm install express-generator –g
//run
$ express -h
Express Installation

Routing is one of the pillars of Express
To create a route use the app.verb convention
// respond with "Hello World!" on the homepage
app.get('/', function (req, res) {
res.send('Hello World!');
})
// accept POST request on the homepage
app.post('/', function (req, res) {
res.send('Got a POST request');
})
// accept PUT request at /user
app.put('/user', function (req, res) {
res.send('Got a PUT request at /user');
})
Routing

Routers
An Express application might have a large
number of routes defined.
Maintaining All of them in a single file can be a pain.
Routers helps you keep your routes clean,
organized and modular.
Routers are defined in a separate node modules
and used as middlewares.

A router is an isolated instance of middlewares
and routes.
The router can have middleware and http VERB
routes added just like an application.
var router = express.Router([options]);
router.get('/events', function(req, res, next) {
// .. some logic here .. like any other middleware // ..
});
Routers (cont.)

Routing and Parameters
Express support parameters as part of the URI
Declare a parameter in the URI by using a “:” in
front of it
Access query-string parameters using req.query
Use regular expressions
To set a parameter as optional add a “?” suffix.

router.get('/user/:username',function(req,res){
//Do something
})
router.get("/page1/:id?",function(req,res){
req.params.id=req.params.id || 0;
res.send("query: "+ JSON.stringify(req.query));
});
Routes With Parameters

Demo
Passing Parameters to Routes

Express application settings can be set using
app.set() and retrieved using app.get()
You can also set middleware functions using
app.use().
// this middleware will be executed for every request to the
app
app.use(function (req, res, next) {
console.log('Time: %d', Date.now());
next();
})
Configuring Express

Views are template based UI mechanism
Express support many view-engines including:
Jade
JSHtml
EJS
View engines are defined by setting the ‘view-
engine’ variable
app.set('view engine', 'jade');
// view engine setup
app.set('views', path.join(__dirname, 'views'));
Views

Jade
Jade is Express default view-engine
It is based on Haml it provide a clean syntax for
generating HTML
Tab based
Full support for HTML

doctype
html
head
title My Page
body
div.jumbotron
h1#title This is my Page
p how do you like my styling?
Jade template

Jade fully support JavaScript using the script
element:
Linking to external JS files
Embedding in-line JavaScript
To setup static content serving in Express use
the built-in static middleware.
app.use(express.static(__dirname+'/public'));
// multiple static folders can be defined.
Mixing up JavaSript & Jade

Blocks
In most applications, some UI components are
used throughout the application
Blocks provide a way to provide a common
layout that is shared among views

doctype
html
head
title My Application
link(href='/css/bootstrap.min.css', rel="stylesheet")
link(href='/css/bootstrap-theme.min.css',
rel="stylesheet")
body
div.page-header
h1 This is my Application
div.container-fluid
block content
Jade Layout Template

extends layout
block content
div.container
p this is a container
div and some more text here
Jade Template Using Layout

Model
Express provides a mechanism to insert data-
models into views
The rendering of the complete artifact is up to
the view engine

extends layout
block content
div.container.bg-danger
h1 oops...,Server error
p #{error}
Rendering data in Jade

Functionality to Express apps are added via
third-party middleware installed through npm.
$ npm install cookie-parser
var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');
// load the cookie parsing middleware
app.use(cookieParser());
Express Middlewares

Common Express Middlewares
Express 4.0 Name
body-parser
compression
cookie-session
morgan
cookie-parser
express-session
static-favicon
response-time
errorhandler
method-override
connect-timeout
vhost
csurf

var express = require('express')
var bodyParser = require('body-parser')
var app = express()
// parse application/json
app.use(bodyParser.json())
app.use(function (req, res) {
res.setHeader('Content-Type', 'text/plain')
res.write('you posted:n')
res.end(JSON.stringify(req.body, null, 2))
})
The body-parser middleware

var express = require('express')
var session = require('express-session')
var app = express()
app.use(session({
secret: 'keyboard cat',
resave: false,
saveUninitialized: true
}));
app.use(function(req, res, next) {
var sess = req.session
if (sess.views) {
sess.views++
} else {
sess.views = 1
res.end('welcome to the session demo. refresh!')
}
})
Express-Session

Summary
Node.js is not just for building servers
It allows JavaScript to run outside of browsers
and perform asynchronous IO
It is asynchronous by nature
Node.js runs your code on a single thread.
Lightweight, fast and extremely cool.
nirn@sela.co.il | @noynir

Node.js Workshop - Sela SDP 2015

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Node.js Workshop - Sela SDP 2015 (20)

Recently uploaded (20)

Node.js Workshop - Sela SDP 2015

Editor's Notes