Theory
પાંચ લીટીમાં જીવતો server
એક જમાનામાં web servers આખા માળખા જેવા લાગતા: server ના ઓરડામાં ગંભીર માણસો દ્વારા install થતી કોઈ વસ્તુ.
આજે તમે એવો એક server 5 લીટીમાં લખશો, node app.js વડે ચલાવશો, અને તમારા પોતાના browser માં એવા સરનામે જઈને જોશો જે તમારી machine ની બહાર ક્યારેય જતું જ નથી. FestConnect નું back end, એટલે કે એ ખોખું જે Unit 4 એ ફક્ત દોરી બતાવ્યું હતું, પહેલી વાર ચાલુ થાય છે.
આ વાનગી માટે 3 ઘટકો જોઈએ: http module, એક callback function, અને એક port.
Theory
ઘટકો, નામ સાથે
- http module: HTTP બોલવા માટે Node સાથે જ અંદરથી એક library આવે છે;
require('http')એને load કરે છે (modules ને એમનો આખો પાઠ હવે પછી મળે છે) - createServer(callback): server બનાવે છે; callback એ તમારો કાઉન્ટર પરનો કારકુન છે: એ દરેક આવતી request માટે એક વાર ચાલે છે
- req અને res: callback ના 2 arguments:
reqકહે છે કે મુલાકાતીએ શું માગ્યું (એનું URL, method, headers); અનેresએ જવાબ છે જેને તમે ઘડીને મોકલો છો - listen(port): નંબરવાળા દરવાજે દુકાન ખોલે છે:
server.listen(8080)
Practical
app.js: FestConnect નો પહેલો server
const http = require('http'); // 1: http module ને load કરો
const server = http.createServer(function (req, res) {
// આ function દરેક request દીઠ એક વાર ચાલે છે
res.writeHead(200, { 'Content-Type': 'text/html' });
res.write('<h1>FestConnect Live</h1>');
res.write('<p>Seats left for Garba Night: 40</p>');
res.end(); // પૂરું કરો અને જવાબ મોકલો
});
server.listen(8080); // 8080 નંબરનો દરવાજો ખોલો
console.log('Server running at http://localhost:8080');
This example runs in Gri-Learn on the web, where you can edit it and see the output.
Follow along
File થી પહેલી મુલાકાત સુધી
- ઉપરના listing ને app.js નામે સાચવો કોઈ પણ folder માં; સાદું લખાણ; નામ એ રૂઢિ છે, કાયદો નહીં.
- ચલાવો: node app.js Command prompt console.log વાળી લીટી છાપે છે અને પછી... કશું જ નહીં. એ સ્તબ્ધતાનો અર્થ એ કે server જીવતો છે અને રાહ જુએ છે. Ctrl+C એને અટકાવે છે.
- Browser માં http://localhost:8080 ખોલો localhost એટલે આ જ machine; 8080 એટલે તમે ખોલેલો દરવાજો. શીર્ષક દેખાય છે: તમે જાતે પીરસેલું તમારું પહેલું page.
- થોડી વાર refresh કરો દરેક refresh એ નવી request છે; તમારો callback દર વખતે ફરી ચાલે છે.
Theory
req અને res: એક જ વાતચીતના બે છેડા
દરેક request તમારા callback ને 2 objects સાથે જગાડે છે:
req (એટલે કે માગણી): મુલાકાતીએ જે કંઈ મોકલ્યું તે બધું; અત્યારે સૌથી ઉપયોગી છે req.url, એટલે કે એણે માગેલો રસ્તો ("/", "/schedule", "/?event=garba": પાઠ 24 એને વાંચે છે).
res (એટલે કે જવાબ): તમારો ઉત્તર, જે 3 પગલે ઘડાય છે: writeHead (પહેલાં status અને headers), write (શરીરનું content, જે વારંવાર લખી શકાય), અને end (મહોર મારીને મોકલી દેવું: એના વગર browser કાયમ રાહ જોયા કરે છે).
ધ્યાન આપો કે Unit 4 માં તમે કોને મળી ચૂક્યા છો: તમારો AJAX નો code બરાબર આ જ objects ની સામેની બાજુ હતો: xhr એ જે મોકલ્યું એ req બન્યું; અને res જે મોકલે છે એ responseText બને છે.
Quiz
http.createServer(function (req, res) {...}) માં એ function ખરેખર ક્યારે ચાલે છે?
- એક જ વાર, જ્યારે node app.js server ચાલુ કરે છે
- દરેક આવતી request માટે એક વાર: દરેક મુલાકાત અને દરેક refresh એને ફરી ચલાવે છે
- સતત, loop માં, જ્યાં સુધી server ચાલુ હોય
- ફક્ત ત્યારે જ્યારે ક્યાંક res.end() બોલાવાય
Show the answer
દરેક આવતી request માટે એક વાર: દરેક મુલાકાત અને દરેક refresh એને ફરી ચલાવે છે
Callback એ કાઉન્ટર પરનો કારકુન છે: એ ત્યાં સુધી ઊંઘે છે જ્યાં સુધી કોઈ request ન આવે, પછી એને પતાવે છે, અને ફરી ઊંઘી જાય છે: 10 મુલાકાતી એટલે 10 વાર એ ચાલ્યો, અને ઉપરનાં પગલાંમાં દરેક refresh એ એને ફરી ચલાવ્યો હતો. વિકલ્પ A તો listen() ની એક વારની ભૂમિકા વર્ણવે છે, એટલે કે દરવાજો ખોલવાની ક્ષણ, જે જુદી છે. વિકલ્પ C એ એક જ thread ને બાળી નાખે જેને event loop સાચવે છે: Node તમારો code ફક્ત events ના જવાબમાં જ ચલાવે છે. વિકલ્પ D કારણ અને પરિણામ ઊલટાવે છે: res.end() એ તો દરેક વારના ચાલવામાં જવાબ પૂરો કરવાની રીત છે, એને ચાલુ કરાવનારું કારણ નહીં.
Think first
એ ચકરડું જે કદી અટકતું નથી
એક સહાધ્યાયીના server માં writeHead અને write તો છે, પણ એ res.end() લખવાનું ભૂલી ગયો. એ localhost:8080 ખોલે છે. Tap કરતાં પહેલાં કહો: એનું browser બરાબર શું કરશે, અને HTTP ના જવાબો કઈ રીતે ચાલે છે એમાંથી આ ભૂલ કઈ રીતે નીકળે છે?
Show the answer
એનું tab કાયમ ફર્યા કરે છે: content કદાચ દેખાય પણ ખરું (write એ એને ટુકડે ટુકડે મોકલી દીધું), પણ browser રાહ જોતું જ રહે છે, કારણ કે એને કોઈએ કહ્યું જ નથી કે જવાબ પૂરો થઈ ગયો છે. res.end() એ જ સંકેત છે: HTTP ના જવાબો સ્પષ્ટપણે પૂરા ન કરાય ત્યાં સુધી ખુલ્લા પ્રવાહ જ રહે છે, અને એ રચનાને લીધે જ મોટાં pages ટુકડે ટુકડે વહી શકે છે (ગયા પાઠમાં જોયેલું Node નું ભરાવો ન કરવાનું લક્ષણ).
ન કોઈ ભૂલ, ન કોઈ crash: ફક્ત કાયમ load થયા કરતું tab, અને એટલે જ ભુલાઈ ગયેલો end() એ Node ની સૌથી ઓળખાઈ જતી શરૂઆતની ભૂલોમાંની એક છે. જવાબનો દરેક રસ્તો end() સુધી પહોંચવો જ જોઈએ.
Watch out
ગોઠવણમાં આવતા અંતરાય
Port પહેલેથી વપરાયેલો: listen વખતે EADDRINUSE આવે એટલે બીજું કોઈ program (ઘણી વાર બીજા બારામાં ભુલાઈ ગયેલો તમારો જ server) 8080 પર બેઠું છે: એને બંધ કરો અથવા 8081 પસંદ કરો.
ફેરફારની કશી અસર થતી નથી: Node એ તમારી file શરૂઆતમાં જ load કરી લીધી હતી; ફેરફારો માટે એને ફરી ચાલુ કરવો પડે (Ctrl+C, અને પછી ફરી node app.js).
localhost ફક્ત તમારું જ છે: સહાધ્યાયીઓ તમારા localhost:8080 પર આવી શકતા નથી; એ તમારી machine ની બહાર ક્યારેય જતું નથી: deployment એ પછીના કોઈ અભ્યાસક્રમની વાત છે.
Theory
Unit 4 થી શરૂ થયેલું વર્તુળ પૂરું થાય છે
Listing ના HTML ની જગ્યાએ JSON ની string અને Content-Type તરીકે application/json મૂકી દો, એટલે આ જ server તમારાં AJAX pages જે xhr.open("GET", ...) બોલાવે છે એનો બરાબર જવાબ આપી શકે છે: હવે તારના બંને છેડા તમારા હાથમાં છે, અને એ પણ એક જ ભાષામાં. બે સુધારા બાકી છે: code ને modules માં ગોઠવવો (હવે પછી), અને મુલાકાતીએ ખરેખર શું માગ્યું એ query string માંથી વાંચવું (એ પછી): અને ત્યાર બાદ FestConnect નો server ખરું કામ કરવા લાગશે.
Summary
Key takeaways
- ઘટકો: http module (require('http')), callback સાથેનું createServer, req અને res, તથા listen(port).
- Callback દરેક આવતી request માટે એક વાર ચાલે છે: એટલે કે event loop મુલાકાતીઓને પીરસે છે.
- req એટલે એમણે શું માગ્યું (req.url); res એટલે તમારો જવાબ: પહેલાં writeHead, પછી write, પછી end.
- res.end() મહોર મારીને મોકલી દે છે; એ ભૂલી જાઓ તો browser કાયમ ફર્યા કરે છે.
- server.listen(8080) દરવાજો ખોલે છે; http://localhost:8080 ખોલો (આ જ machine, એ જ port).
- Code માં ફેરફાર કરો તો server ફરી ચાલુ કરવો પડે; port ટકરાય એટલે એ દરવાજો બીજા server એ પકડી રાખ્યો છે.
- યાદ રાખવાની કડી: require, create, listen; અને પછી head, body, end.