Sistemas y Tecnologías Web: Servidor

1
2
3
4
5
6
7
'use strict';
const http = require('http');
const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World!\n');
});
server.listen(60700, () => console.log('Server listening in port 60700'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'use strict';
const express = require('express');
const morgan = require('morgan');

const app = express();

app.use(morgan('dev'));

// In addition to get(), Express has put(), post(), and delete()
// methods to register handlers for HTTP PUT, POST, and DELETE requests,
// respectively
app.get('/hello/:name', (req, res) => {
  res.status(200).json({hello: req.params.name});
});

app.listen(60701, ()=> console.log("Listening on 60701"));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
var fs    = require('fs'),
    nconf = require('nconf');

// The order in which you attach the configuration sources determines their priority in the hierarchy.
// Setup nconf to use (in-order):
//   1. Command-line arguments
//   2. Environment variables
//   3. A file located at 'path/to/config.json'
//
nconf.argv() // Loads process.argv using yargs. If options is supplied it is passed along to yargs.
 .env('__')      // Loads process.env into the hierarchy
 .file({ file: './config.json' });

// See "node hello-nconf.js --conf='./config-2.json'"
nconf.get('conf') && nconf.file(nconf.get('conf'));

//
// Set a few variables on `nconf`.
//
nconf.set('database:host', '127.0.0.1');
nconf.set('database:port', 4000);

console.log('foo: ' + nconf.get('foo'));
console.log('NODE_ENV: ' + nconf.get('NODE_ENV'));

//
// Get the entire database object from nconf. This will output
// { host: '127.0.0.1', port: 5984 }
//
console.log('database: ' + JSON.stringify(nconf.get('database')));

// It is important to note that setting keys in the File engine will not be persisted
// to disk until a call to .save() is made
// Save the configuration object to disk
//
nconf.save(function (err) {
  fs.readFile('./config.json', function (err, data) {
    console.dir(JSON.parse(data.toString()))
  });
});

1
2
3
  nconf.argv()     // Loads process.argv using yargs. If options is supplied it is passed along to yargs.
   .env('__')      // Loads process.env into the hierarchy
   .file({ file: './config.json' });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'use strict';

const express = require('express');
const morgan = require('morgan');
const nconf = require('nconf');
                  // b4  web-services chapter-7
const pkg = require('../../../package.json');

nconf.argv().env('__');
nconf.defaults({conf: `${__dirname}/config.json`});
nconf.file(nconf.get('conf'));

const app = express();
app.use(morgan('dev'));

app.get('/api/version', (req, res) => {
  res.status(200).send(pkg.version);
});

require('./lib/search.js')(app, nconf.get('es'));
require('./lib/bundle.js')(app, nconf.get('es'));
app.listen(nconf.get('port'), () => console.log('Listening on port '+nconf.get('port')));

1
2
3
4
5
6
7
8
9
10
/**
 * Provides API endpoints for searching the books index.
 */
'use strict';
const request = require('request');
const rp = require('request-promise');

module.exports = (app, es) => {
  const url = `http://${es.host}:${es.port}/${es.books_index}/book/_search`;
};  

1
require('./lib/search.js')(app, nconf.get('es'));

1
2
3
4
5
6
7
8
9
10
app.get('/api/search/books/:field/:query', (req, res) => {
  const esReqBody = {
    size: 10, // limits the number of documents that will be sent back
    query: {  // describes what kind of objects we want to find
      match: {
        [req.params.field]: req.params.query
      }
    }
  };
  ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
app.get('/api/search/books/:field/:query', (req, res) => {
   ...
   const options = {url, json: true, body: esReqBody };

    request.get(options, (err, esRes, esResBody) => {
      if (err) {
        res.status(502).json({
          error: 'bad_gateway',
          reason: err.code
        });
      }
      if (esRes.statusCode !== 200) {
        res.status(esRes.statusCode).json(esResBody);
        return;
      }
      res.status(200).json(esResBody.hits.hits.map(({_source}) => _source));
    });
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/**
  * Provides API endpoints for searching the book index
*/
'use strict';
const request = require('request');
const rp = require('request-promise');

module.exports = (app, es) => {
  const url = `http://${es.host}:${es.port}/${es.books_index}/book/_search`;
  /**
   * Search for books matching a particular field value
   * Example: /api/search/books/authors/Twain
   */
  app.get('/api/search/books/:field/:query', (req, res) => {
    const esReqBody = {
      size: 10, // limits the number of documents that will be sent back
      query: {  // describes what kind of objects we want to find
        match: {
          [req.params.field]: req.params.query
        }
      }
    };
    const options = {url, json: true, body: esReqBody };

    request.get(options, (err, esRes, esResBody) => {
      if (err) {
        res.status(502).json({
          error: 'bad_gateway',
          reason: err.code
        });
      }
      if (esRes.statusCode !== 200) {
        res.status(esRes.statusCode).json(esResBody);
        return;
      }
      res.status(200).json(esResBody.hits.hits.map(({_source}) => _source));
    });
  });

  /**
   * Collect suggested terms for a given field based on a given query
   * Example: /api/suggest/authors/lipman
  */
  app.get('/api/suggest/:field/:query', (req, res) => {
    const esReqBody = {
      size: 0, // We don’t want any matching documents returned, just the suggestions
      suggest: {
        suggestions: { // Elasticsearch’s Suggest API allows you to request multiple
                       // kinds of suggestions in the same request,
                       // but here we’re submitting only one. 
          text: req.params.query,
          term: {
            field: req.params.field,
            suggest_mode: 'always'
          }
        }
      }
    };
    const options = { url, json: true, body: esReqBody };
    const promise = rp(options);
    /*
    // Version from section: "Using a Promise with request", pages 162-166
    const promise = new Promise((resolve, reject) => {
      request.get(options, (err, esRes, esResBody) => {
        if (err) {
          reject({error: err});
          return;
        }
        if (esRes.statusCode !== 200) {
          reject({error: esResBody});
          return;
        }
        resolve(esResBody);
      });
    });
    */
    promise
      .then(esResBody =>
        res.status(200).json(esResBody.suggest.suggestions)
      )
      .catch(
        ({error}) => res.status(error.status || 502).json(error)
      );
  });
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'use strict';

const express = require('express');
const morgan = require('morgan');
const nconf = require('nconf');
                  // b4  web-services chapter-7
const pkg = require('../../../package.json');

nconf.argv().env('__');
nconf.defaults({conf: `${__dirname}/config.json`});
nconf.file(nconf.get('conf'));

const app = express();
app.use(morgan('dev'));

app.get('/api/version', (req, res) => {
  res.status(200).send(pkg.version);
});

require('./lib/search.js')(app, nconf.get('es'));
require('./lib/bundle.js')(app, nconf.get('es'));
app.listen(nconf.get('port'), () => console.log('Listening on port '+nconf.get('port')));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let trimnl = (s) => s.replace(/\s+/g,"");
let request = trimnl(`
  {
  	"size": 0,
  	"suggest": {
  		"suggestions": {
  			"text": "lipman",
  			"term": {
  				"field": "authors",
  				"suggest_mode": "always"
  			}
  		}
  	}
  }
`);

gulp.task('c7-es-suggest', shell.task(
  `curl -s  -H 'Content-Type: application/json' -d '${request}' -X GET localhost:9200/books/book/_search | jq .suggest.suggestions`
));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
 * Collect suggested terms for a given field based on a given query
 * Example: /api/suggest/authors/lipman
*/
app.get('/api/suggest/:field/:query', (req, res) => {
  const esReqBody = {
    size: 0,
    suggest: {
      suggestions: {
        text: req.params.query,
        term: {
          field: req.params.field,
          suggest_mode: 'always'
        }
      }
    }
  };
  const options = { url, json: true, body: esReqBody };
  const promise = new Promise((resolve, reject) => {
    request.get(options, (err, esRes, esResBody) => {
      if (err) {
        reject({error: err});
        return;
      }
      if (esRes.statusCode !== 200) {
        reject({error: esResBody});
        return;
      }
      resolve(esResBody);
    });
  });
  promise
    .then(esResBody =>
      res.status(200).json(esResBody.suggest.suggestions)
    )
    .catch(
      ({error}) => res.status(error.status || 502).json(error)
    );
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
[~/local/src/CA/sol-nodejs-the-right-way/developing-restful-web-services-chapter-7/web-services/b4(master)]$ cat -n lib/search.js
     .........
     5	const request = require('request');
     6	const rp = require('request-promise');
     7
     8	module.exports = (app, es) => {
     9	  const url = `http://${es.host}:${es.port}/${es.books_index}/book/_search`;
    10	  /**
    11	   * Search for books matching a particular field value
    12	   * Example: /api/search/books/authors/Twain
    13	   */
    14	  app.get('/api/search/books/:field/:query', (req, res) => {
    ..........
    38	  });
    39
    40	  /**
    41	   * Collect suggested terms for a given field based on a given query
    42	   * Example: /api/suggest/authors/lipman
    43	  */
    44	  app.get('/api/suggest/:field/:query', (req, res) => {
    45	    const esReqBody = {
    46	      size: 0,
    47	      suggest: {
    48	        suggestions: {
    49	          text: req.params.query,
    50	          term: {
    51	            field: req.params.field,
    52	            suggest_mode: 'always'
    53	          }
    54	        }
    55	      }
    56	    };
    57	    const options = { url, json: true, body: esReqBody };
    58	    const promise = rp(options);
    59	    /*
    60	    // Version from section: "Using a Promise with request", pages 162-166
    61	    const promise = new Promise((resolve, reject) => {
    62	      request.get(options, (err, esRes, esResBody) => {
    63	        if (err) {
    64	          reject({error: err});
    65	          return;
    66	        }
    67	        if (esRes.statusCode !== 200) {
    68	          reject({error: esResBody});
    69	          return;
    70	        }
    71	        resolve(esResBody);
    72	      });
    73	    });
    74	    */
    75	    promise
    76	      .then(esResBody =>
    77	        res.status(200).json(esResBody.suggest.suggestions)
    78	      )
    79	      .catch(
    80	        ({error}) => res.status(error.status || 502).json(error)
    81	      );
    82	  });
    83	};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
​  {
​    ​"name"​: ​"light reading"​,
​    ​"books"​: [
       {
  ​      ​"id"​: ​"pg132"​,
  ​      ​"title"​: ​"The Art of War"​
  ​     },
       {
        ​"id"​: ​"pg2680"​,
  ​      ​"title"​: ​"Meditations"​,
  ​     },
       {
  ​      ​"id"​: ​"pg6456"​,
  ​      ​"title"​: ​"Public Opinion"​
  ​     }
     ]
​  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * Provide API endpoints for working with book bundles_index
 */
'use strict';

const rp = require('request-promise');
module.exports = (app, es) => {
  const url = `http://${es.host}:${es.port}/${es.bundles_index}/bundle`;

  /**
   * Create a new bundle with the specified names
   * Example: curl -X POST http://<host>:<port>/api/bundle?name=<name>
   */
   app.post('/api/bundle', (req, res) => {
      const bundle = {
        name: req.query.name || '',
        books: []

      };

      rp.post({url, body: bundle, json: true})
        .then(esResBody => res.status(201).json(esResBody))
        .catch(({error}) => res.status(error.status || 502).json(error));
   });
};

1
2
3
4
5
6
7
8
9
10
11
12
13
app.get('/api/bundle/:id', async (req, res) => {
  const options = {
    url: `${url}/${req.params.id}`,
    json: true
  };

  try {
    const esResBody = await rp(options);
    res.status(200).json(esResBody);
  } catch (esResErr) {
    res.status(esResErr.statusCode || 502).json(esResErr.error);
  }
});

1
2
3
4
5
6
7
8
9
10
// BAD IMPLEMENTATION! async Express handler without a try/catch block
app.get('/api/err-bundle/:id', async (req, res) => {
  const options = {
    url: `${url}/${req.params.id}`,
    json: true
  };

  const esResBody = await rp(options);
  res.status(200).json(esResBody);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * Set the :id bundle's name to the provide :name
 * curl -X PUT http://<host>:<port>/api/bundle/<id>/name/<name>
 */
 app.put('/api/bundle/:id/name/:name', async (req, res) => {
   const bundleUrl = `${url}/${req.params.id}`;

   try {
     const response = await rp.get({url: bundleUrl, json: true});
     const bundle = response._source;
     bundle.name = req.params.name;
     const esResBody = await rp.put({url: bundleUrl, body: bundle, json: true});
     res.status(200).json(esResBody);
   } catch(esResErr) {
     res.status(esResErr.statusCode || 502).json(esResErr.error);
   }
 });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
    /**
     * Put a book into a bundle by its id
     * curl -X PUT http://<host>:<port>/api/bundle/<id>/book/<pgid>
    */
    app.put('/api/bundle/:id/book/:pgid', async (req, res) => {
      debugger;
      const bundleUrl = `${url}/${req.params.id}`;
      const bookUrl = `http://${es.host}:${es.port}/${es.books_index}/book/${req.params.pgid}`;
      try {
        // Request the bundle and book in parallel
        const [bundleRes, bookRes] = await Promise.all([
          rp.get({url: bundleUrl, json: true}),
          rp.get({url: bookUrl, json: true})
        ]);
        // Extract bundle and book information from responses
        const { _source: bundle, _version: version } = bundleRes;
        const { _source: book } = bookRes;

        const idx = bundle.books.findIndex(book => book.id === req.params.pgid);
        if (idx === -1) {
          bundle.books.push({
            id: req.params.pgid,
            title: book.title
          });
        }

        // Save the updated bundle
        const esResBody = await rp.put({
          url: bundleUrl,
          qs: { version }, // qs stands for "query string". We pass the version number
          /* When ES receives the request it checks that its internal version number
          for this document  matches the qs param. If they don't match  it means the document
          changed somehow  and ES will send back a 409 conflict HTTP status code causing
          the await to throw an exception */
          body: bundle,
          json: true
        });

        res.status(200).json(esResBody);

      } catch(esResErr) {
        res.status(esResErr.statusCode || 502).json(esResErr.error);
      }
    });

1
2
3
4
5
6
7
8
9
10
11
12
/**
  * Delete a bundle entirely.
  * curl -X DELETE http://<host>:<port>/api/bundle/<id>
  */
 app.delete('/api/bundle/:id', async (req, res) => {
   const bundleUrl = `${url}/${req.params.id}`;
   try {
     ..
   } catch (esResErr) {
     res.status(esResErr.statusCode || 502).json(esResErr.error);
   }
 });

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
  * Remove a book from a bundle.
  * curl -X DELETE http://<host>:<port>/api/bundle/<id>/book/<pgid>
  */
 app.delete('/api/bundle/:id/book/:pgid', async (req, res) => {
   const bundleUrl = `${url}/${req.params.id}`;

   try {
     ...
   } catch (esResErr) {
     res.status(esResErr.statusCode || 502).json(esResErr.error);
   }
 });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
/********************* CHAPTER 7 *********************/

gulp.task("c7-http-server", shell.task(
    `node developing-restful-web-services-chapter-7/web-services/server.js`
));

gulp.task("c7-http-client", shell.task(
    `curl localhost:60700`
));

gulp.task("c7-express-server", shell.task(
    `node developing-restful-web-services-chapter-7/web-services/hello/server.js`
));

gulp.task("c7-express-client-verbose", shell.task(
    `curl -i localhost:60701/hello/ivan`
));

gulp.task("c7-express-client", shell.task(
    `curl -s localhost:60701/hello/ivan | jq`
));

// Server listening in port 60702
gulp.task("c7-b4-server", shell.task(
    `node developing-restful-web-services-chapter-7/web-services/b4/server.js`
));

gulp.task("c7-b4-server-debug", shell.task(
    `node --inspect-brk developing-restful-web-services-chapter-7/web-services/b4/server.js`
));

gulp.task("c7-b4-server-nodemon", shell.task(
    `nodemon developing-restful-web-services-chapter-7/web-services/b4/server.js`
));

gulp.task("c7-get-shakespeare", shell.task(
    `curl -s localhost:60702/api/search/books/authors/Shakespeare | jq .[].title`
));

gulp.task("c7-get-sawyer", shell.task(
    `curl -s localhost:60702/api/search/books/title/sawyer | jq .[].title`
));

gulp.task("c7-suggest", shell.task(
    //`curl -s localhost:60702/api/suggest/authors/twayn | jq '.[].options[].text'`
    `curl -s localhost:60702/api/suggest/authors/twayn | jq '.'`
));

gulp.task("c7-create-b4-index", shell.task(
    `commanding-databases-chapter-6/esclu/esclu create-index -i b4`
));

// Communicate directly to es to create the bundle
gulp.task("c7-es-create-a-bundle", shell.task(
    `curl -H 'Content-Type: application/json' -X POST localhost:9200/b4/bundle -d '{"name":"nutrition","books":[]}'`
    // CKPgeWcB2Cwi_q-mx5lC
));

gulp.task("c7-esclu-list", shell.task(` echo "
   ./esclu li
   ./esclu get _search  | jq .
   ./esclu get '_search' | jq '.hits.hits[]._source' | head -n 20
   ./esclu get '_search/?q=authors:Twain' | jq '.' | head -n 30
   ./esclu get '_search?q=authors:Twain&_source=title' | jq '.' | head -n 30
   ./esclu get '_search?q=authors:Twain&_source=title' | jq '.hits.hits[]._source.title'
   ./esclu q authors:Twain AND subjects:children
   ./esclu q | jq '.' | head -n 30
   ./esclu q -f title,authors | jq '.' | head -n 30
   ./esclu q -f title,authors | jq '.hits.hits[]._source' | head -n 30
   ./esclu q authors:Shakespeare AND subjects:Drama -f title | jq '.hits.hits[]._source.title'
   ./esclu get pg132 --index books --type book | jq '.'
   ./esclu get pg132 -i books -t book | jq '._source' > ../data/art_of_war.json
   ./esclu put ../data/art_of_war.json -i books -t book --id pg132 # Warning put
  "`
));

// Get the bundle created by the former task
gulp.task('c7-request-es-bundle-by-id', shell.task(
    `BUNDLE_ID=CKPgeWcB2Cwi_q-mx5lC && curl -s localhost:9200/b4/bundle/$BUNDLE_ID | jq .`
));

gulp.task('c7-create-a-bundle', shell.task(
    `curl -s -X POST localhost:60702/api/bundle/?name=light%20reading | jq .`
));

gulp.task('c7-bundle-id', shell.task(
    `BUNDLE_ID=zLkMWmcB1uX03maR3vEQ && echo $BUNDLE_ID`
));

gulp.task('c7-bundle-another-id', shell.task(
    `BUNDLE_ID=WpBEamcBVH6YJQy3-NQF && echo $BUNDLE_ID`
));

gulp.task('c7-request-bundle-by-id', shell.task(
    `BUNDLE_ID=zLkMWmcB1uX03maR3vEQ && curl -s localhost:9200/b4/bundle/$BUNDLE_ID | jq .`
));

gulp.task('c7-change-bundle-name', shell.task(
    `BUNDLE_ID=zLkMWmcB1uX03maR3vEQ && curl -s -X PUT localhost:60702/api/bundle/$BUNDLE_ID/name/lectura%20ligera | jq .`
));

const header = '"Content-Type: application/json"';
let trimnl = (s) => s.replace(/\s+/g, "");

/*
  We are adding now to the index named accounts
  a document of type person
  having the id 1;
  since the index does not exist yet, Elasticsearch will automatically create it.
*/
let request = trimnl(`
  {
        "size": 0,
        "suggest": {
                "suggestions": {
                        "text": "twayn",
                        "term": {
                                "field": "authors",
                                "suggest_mode": "always"
                        }
                }
        }
  }
`);

/*
console.log(request);
curl -X GET "localhost:9200/twitter/_search" -H 'Content-Type: application/json' -d'
{
    "query" : {
        "term" : { "user" : "kimchy" }
    }
}
'
*/


gulp.task('c7-es-suggest', shell.task(
    `curl -s  -H 'Content-Type: application/json' -d '${request}' -X GET localhost:9200/books/book/_search | jq .suggest.suggestions`
));

gulp.task('c7-change-bundle-name-foo', shell.task(
    `BUNDLE_ID=zLkMWmcB1uX03maR3vEQ && curl -s -X PUT localhost:60702/api/bundle/$BUNDLE_ID/name/foo | jq .`
));

gulp.task('c7-insert-book-into-bundle', shell.task(
    `BUNDLE_ID=zLkMWmcB1uX03maR3vEQ && curl -s -X PUT localhost:60702/api/bundle/$BUNDLE_ID/book/pg132 | jq .`
));

gulp.task("c7-b4-version", shell.task(
    `curl -s localhost:60702/api/version`
));