środa, 26 lutego 2020

Som Labs - IMx6 ULL - Debian - Serwer HTTP, TCP NodeJs

W tym wpisie chciałbym opisać sposób przygotowania NodeJs.
Znalezione obrazy dla zapytania som labs 6ull
[Źródło: https://somlabs.com/product/visionsom-6ull/]

Instalacja


Tutaj polecam artykuł umieszczony na forum sunduino link. Autor wyjaśnia w nim jak w prosty sposób zainstalować najnowszą wersję NodeJs na modułach Som. O ile z samym NodeJs nie ma problemów jeśli chodzi o instalację oraz obsługę to instalator pakietów npm nie chce współpracować z najnowszą zainstalowaną wersją środowiska Node. Co oznacza, że instalacja pakietów jest niemożliwa.

Poniżej wklejam krótki opis komend do wprowadzenia w konsoli:

  1. apt update - aktualizacja
  2. apt install curl - narzędzie do przesyłania danych ze składnia URL
  3. curl -sL https://deb.nodesource.com/setup_10.x -o nodesource_setup.sh - pobranie pakietów źródłowych
  4. bash nodesource_setup.sh - uruchomienie skrypt, który pobierze potrzebne pakiety
  5. apt install nodejs - instalacja nodejs oraz npm
  7. Po instalacji można już sprawdzić wersję nodejs oraz npm:
  8. nodejs -v
  9. npm -v

Przykładowe aplikację:


Poniżej przykładowe aplikacje dla serwera HTTP. Są to lekko zmodyfikowane programy umieszczone na stronie mikrokontrolery.pl link.

Uruchomienie podstawowego serwera HTTP:

Podstawowy serwer http NodeJs:

  1. var http = require ('http');            //Import biblioteki
  2. var PORT = 80;                          //Port
  4. //Stworzenie serwera, uruchomienie nasłuchiwania
  5. var server = http.createServer (function handler (request, response) {
  6.   response.writeHead (200, {'Content-Type': 'text/plain'});
  7.   response.end ('Hello World!');
  8. }).listen (PORT);

Gdy zostanie podany numer portu jako 80 to w przeglądarce internetowej wystarczy wpisać adres IP urządzenia. Gdy natomiast zostanie podana inna wartość np. 3000. To należy ją wpisać podczas otwierania strony np. 192.168.2.10:3000.

Uruchomienie serwera HTTP z obsługą plików html:

  1. var http = require ('http');
  2. var fs = require ('fs');
  3. var index = fs.readFileSync (__dirname + '/index/index.html');
  5. var PORT = 8080;
  6. var server = http.createServer (function handler (request, response) {
  7.   response.writeHead (200, {'Content-Type': 'text/html'});
  8.   response.end (index);
  9. }).listen(PORT);

Dane wyświetlane na stronie umieszczone w pliku index.html:

  1. <!DOCTYPE html>
  2. <html>
  3.   <head>
  4.   </head>
  5.   <body>
  6.     <h1>Serwer Dziala</h1>
  7.   </body>
  8. </html>

W przypadku nagłego wyłączenia programu można skorzystać z narzędzia netstat:

  1. apt-get install net-tools

Po zainstalowaniu należy wpisać:

  1. netstat -nlp | grep :<PORT>

Pozwoli to na wyświetlenie który proces blokuje port wykorzystywany przez przygotowany program testowy:

  1. tcp  0  0 0.0.0.0:<PORT>  0.0.0.0:*  LISTEN  1073/node

Teraz w celu zabicia procesu należy wpisać:

  1. kill 1073

Jeśli podane polecenie nie zadziała to należy ustawić odpowiednią flagę (SIGKILL):

  1. kill -9 1073

Obsługa strony internetowej z wykorzystaniem biblioteki socket.io. Pozwala ona na przygotowanie strony, która zmienia się w czasie rzeczywistym bez konieczności przeładowania całości.

Instalacja biblioteki odbywa się po wprowadzeniu następującej komendy:

  1. npm install socket.io

Po zainstalowaniu biblioteki można przejść do obsługi następującego przykładu.

Plik js:

  1. var http = require('http');
  2. var fs = require('fs');
  3. var index = fs.readFileSync(__dirname + '/index/index.html');
  4. var PORT = 8080;
  5. var counterVal = 0;
  7. var app = http.createServer(function(req, res) {
  8.     res.writeHead(200, {'Content-Type': 'text/html'});
  9.     res.end(index);
  10. });
  12. var io = require('socket.io').listen(app);
  14. function sendTime() {
  15.     counterVal++;
  16.     io.emit('time', { time: counterVal + ' - ' +  new Date().toJSON()});
  17. }
  19. setInterval(sendTime, 1000);
  21. io.on('connection', function(socket) {
  22.     socket.emit('welcome', { message: 'Welcome!', id: socket.id });
  23.     socket.on('client', console.log);
  24. });
  26. app.listen(PORT, () => console.log('HTTP server with socket.io'));
  28. process.on('SIGTERM', () => {
  29.   console.info('SIGTERM RECEIVED');
  30.   console.log('Closing http server');
  31.   server.close(() => {
  32.   });
  33. });

W powyższym przykładzie tworzony jest server TCP wraz z przesyłaniem danych z aktualnym czasem oraz numerem przesłanej wiadomości w sesji.

Ostatnia część pozwala na wyłączenie serwera. Dzięki temu wykorzystywany port nie będzie blokowany.

Plik HTML:

  1. <!DOCTYPE HTML>
  2. <html>
  3.     <head>
  4.         <script src='/socket.io/socket.io.js'></script>
  5.         <script>
  6.             var socket = io();
  8.             socket.on('welcome', function(data) {
  9.                 addMessage(data.message);
  10.                 socket.emit('client', {data: 'Client', id: data.id});
  11.             });
  12.             socket.on('time', function(data) {
  13.                 addMessage(data.time);
  14.             });
  15.             socket.on('error', console.error.bind(console));
  16.             socket.on('message', console.log.bind(console));
  18.             function addMessage(message) {
  19.                 var text = document.createTextNode(message),
  20.                     el = document.createElement('li'),
  21.                     messages = document.getElementById('messages');
  22.                 el.appendChild(text);
  23.                 messages.appendChild(el);
  24.             }
  25.         </script>
  26.     </head>
  27.     <body>
  28.         <ul id='messages'></ul>
  29.     </body>
  30. </html>

W kolejnym przykładzie opiszę sposób przygotowania prostej aplikacji służącej jako serwer TCP:

  1. const net = require('net');
  2. var PORT = 1001;
  4. net.createServer(socket => {
  5.         socket.on('data', function(data){
  6.                 console.log('Receive: %s', data.toString())
  7.                 socket.write(data.toString())
  8.         })
  9. }).listen(PORT);

Sprawdzenie działania można wykonać np. za pomocą programu Herkules:


W terminalu wyświetlą się następujące komunikaty:


Poniżej bardziej rozbudowany przykład serwera TCP:

  1. const net = require('net');
  2. const PORT = 1001;
  3. const server = net.createServer();
  4. var counter = 0;
  6. console.log('Server on Port: ' + PORT);
  8. process.on('uncaughtException', e => {
  9.     if (e.code !== 'ECONNRESET') {
  10.         console.log(e);
  11.     }
  12. });
  14. server.on('listening', () => {
  15.   console.log('Server listening');
  16. })
  18. server.on('connection', socket => {
  19.   console.info('new client');
  21.   socket.on('data', message => {
  22.     const receivedData = message.toString('utf8');
  24.     console.info(`receive ${message.length} bytes, [${receivedData}]`);
  26.     if (receivedData === 'temp') {
  27.         socket.write('temp:23.6;hum:56%');
  28.     }
  29.     else if (receivedData === 'time')
  30.     {
  31.         socket.write(new Date().toString());
  32.     }
  33.     else if (receivedData === 'counter')
  34.     {
  35.         counter++;
  36.         socket.write(counter.toString());
  37.     }
  38.     else {
  39.         socket.write('===>' + receivedData);
  40.     }
  41.   });
  43.   socket.on('end', () => {
  44.     console.info('disconnect from client');
  45.   });
  47.   socket.on('close', () => {
  48.     console.info('socket close');
  49.   });
  50.   socket.on('timeout', () => {
  51.     console.error('socket timeout');
  52.   });
  54.   socket.write(`Connected on port: ${PORT}, Socket_remote_add: ${socket.remoteA$
  55. });
  57. server.on('error', err => {
  58.   console.error('Server error', err);
  59. });
  61. server.on('close', () => {
  62.   console.log('Server shutdown');
  63. });
  65. server.listen(PORT);
Autor: o
Etykiety: ,