Jak automatycznie ponownie załadować pliki w Node.js?

Jakieś pomysły na to, jak mogę wdrożyć automatyczne przeładowywanie plików w Node.js? Mam dość ponownego uruchamiania serwera za każdym razem, gdy zmieniam plik. Najwyraźniej require()funkcja Node.js nie ładuje plików, jeśli były już wymagane, więc muszę zrobić coś takiego:

var sys     = require('sys'), 
    http    = require('http'),
    posix   = require('posix'),
    json    = require('./json');

var script_name = '/some/path/to/app.js';
this.app = require('./app').app;

process.watchFile(script_name, function(curr, prev){
    posix.cat(script_name).addCallback(function(content){
        process.compile( content, script_name );
    });
});

http.createServer(this.app).listen( 8080 );

A w pliku app.js mam:

var file = require('./file');
this.app = function(req, res) { 
    file.serveFile( req, res, 'file.js');  
}

Ale to też nie działa - pojawia się błąd w process.compile()stwierdzeniu, że „wymaganie” nie jest zdefiniowane. process.compileewaluuje app.js , ale nie ma pojęcia o globalsach node.js.

Dobrym, aktualne alternatywa supervisorjest nodemon:

Monitoruj wszelkie zmiany w aplikacji node.js i automatycznie uruchom ponownie serwer - idealny do programowania

Aby użyć nodemon:

$ npm install nodemon -g
$ nodemon app.js

superwizor węzła jest niesamowity

użycie do ponownego uruchomienia po zapisaniu:

npm nadzorca instalacji -g
supervisor app.js

przez isaacs - http://github.com/isaacs/node-supervisor

znalazłem prosty sposób:

delete require.cache['/home/shimin/test2.js']

Jeśli ktoś nadal podejdzie do tego pytania i chce je rozwiązać przy użyciu tylko standardowych modułów, podałem prosty przykład:

var process = require('process');
var cp = require('child_process');
var fs = require('fs');

var server = cp.fork('server.js');
console.log('Server started');

fs.watchFile('server.js', function (event, filename) {
    server.kill();
    console.log('Server stopped');
    server = cp.fork('server.js');
    console.log('Server started');
});

process.on('SIGINT', function () {
    server.kill();
    fs.unwatchFile('server.js');
    process.exit();
});

Ten przykład dotyczy tylko jednego pliku (server.js), ale można go dostosować do wielu plików przy użyciu tablicy plików, pętli for, aby uzyskać wszystkie nazwy plików, lub oglądając katalog:

fs.watch('./', function (event, filename) { // sub directory changes are not seen
    console.log(`restart server`);
    server.kill();
    server = cp.fork('server.js');    
})

Ten kod został stworzony dla Node.js 0.8 API, nie jest on dostosowany do określonych potrzeb, ale będzie działał w niektórych prostych aplikacjach.

AKTUALIZACJA: Ta funkcja jest zaimplementowana w moim module simpleR , repozytorium GitHub

nodemon pojawił się pierwszy podczas wyszukiwania w Google i wydaje się, że załatwia sprawę:

npm install nodemon -g
cd whatever_dir_holds_my_app
nodemon app.js

Istnieje Node-Supervisor, który możesz zainstalować

npm install supervisor

patrz http://github.com/isaacs/node-supervisor

Edycja: Moja odpowiedź jest nieaktualna. Node.js to bardzo szybko zmieniająca się technologia.

Zastanawiałem się także nad przeładowaniem modułów. Zmodyfikowałem node.js i opublikowałem źródło na Github pod nalply / node . Jedyną różnicą jest funkcja require. Ma opcjonalny drugi argument reload.

require(url, reload)

Aby przeładować app.jsw bieżącym katalogu, użyj

app = require("./app", true);

Napisz coś takiego, a masz automatyczne przeładowanie:

process.watchFile(script_name, function(curr, prev) {
    module = reload(script_name, true);
});

Jedyny problem, jaki widzę, to zmienna module, ale teraz nad tym pracuję.

nodemonjest świetny. Po prostu dodaję więcej parametrów do debugowania i oglądania.

pakiet.json

  "scripts": {
    "dev": "cross-env NODE_ENV=development nodemon --watch server --inspect ./server/server.js"
  }

Komenda: nodemon --watch server --inspect ./server/server.js

Natomiast:

--watch serverPonownie uruchom aplikację przy zmianie .js, .mjs, .coffee, .litcoffee, oraz .jsonpliki w serverfolderze (w zestawie podfoldery).

--inspect Włącz zdalny debugowanie.

./server/server.js Punkt wejścia

Następnie dodaj następującą konfigurację do launch.json(VS Code) i rozpocznij debugowanie w dowolnym momencie.

{
    "type": "node",
    "request": "attach",
    "name": "Attach",
    "protocol": "inspector",
    "port": 9229
}

Zauważ, że lepiej jest zainstalować nodemonjako zależność projektową od deweloperów. Członkowie zespołu nie muszą go instalować ani zapamiętywać argumentów poleceń, po prostu npm run devzaczynają hakować.

Zobacz więcej na temat nodemondokumentów: https://github.com/remy/nodemon#monitoring-multiple-directories

Na liście mailingowej node.js pojawił się najnowszy wątek na ten temat. Krótka odpowiedź brzmi: nie, obecnie nie jest możliwe automatyczne ponowne ładowanie wymaganych plików, ale kilka osób opracowało łatki, które dodają tę funkcję.

jeszcze innym rozwiązaniem tego problemu jest używanie na zawsze

Inną przydatną funkcją Forever jest to, że może opcjonalnie ponownie uruchomić aplikację po zmianie plików źródłowych. Dzięki temu nie trzeba ręcznie restartować za każdym razem, gdy dodajesz funkcję lub naprawiasz błąd. Aby uruchomić na zawsze w tym trybie, użyj flagi -w:

forever -w start server.js

node-dev działa świetnie. npminstall node-dev

Daje nawet powiadomienie na pulpicie, gdy serwer jest ponownie ładowany i daje powodzenie lub błędy w komunikacie.

uruchom aplikację w wierszu poleceń za pomocą:

node-dev app.js

Oto post na blogu o Hot Reloading for Node. Udostępnia gałąź węzła github , której można użyć do zastąpienia instalacji węzła, aby włączyć ponowne ładowanie na gorąco.

Z bloga:

var requestHandler = require('./myRequestHandler');

process.watchFile('./myRequestHandler', function () {
  module.unCacheModule('./myRequestHandler');
  requestHandler = require('./myRequestHandler');
}

var reqHandlerClosure = function (req, res) {
  requestHandler.handle(req, res);
}

http.createServer(reqHandlerClosure).listen(8000);

Teraz, za każdym razem, gdy zmodyfikujesz myRequestHandler.js, powyższy kod zauważy i zastąpi lokalnego requestHandler nowym kodem. Wszelkie istniejące żądania będą nadal używać starego kodu, a wszelkie nowe przychodzące żądania będą używać nowego kodu. Wszystko to bez wyłączania serwera, odrzucania żądań, przedwczesnego zabijania żądań, a nawet polegania na inteligentnym module równoważenia obciążenia.

Pracuję nad stworzeniem raczej małego „węzła”, który jest w stanie dowolnie ładować / zwalniać moduły (tzn. Możesz być w stanie zrestartować część aplikacji bez wyłączania całej aplikacji). Włączam (bardzo głupie) zarządzanie zależnościami, więc jeśli chcesz zatrzymać moduł, wszystkie moduły, które od niego zależą, również zostaną zatrzymane.

Jak dotąd tak dobrze, ale potem natknąłem się na problem z ponownym załadowaniem modułu. Najwyraźniej można po prostu usunąć moduł z „wymaganej” pamięci podręcznej i wykonać zadanie. Ponieważ nie jestem zainteresowany bezpośrednią zmianą kodu źródłowego węzła, wymyśliłem bardzo hacky-hack, czyli: wyszukaj w stosie śledzenie ostatniego wywołania funkcji „wymagaj”, pobierz odniesienie do jego pola „pamięci podręcznej” i… cóż, usuń odwołanie do węzła:

    var args = arguments
    while(!args['1'] || !args['1'].cache) {
        args = args.callee.caller.arguments
    }
    var cache = args['1'].cache
    util.log('remove cache ' + moduleFullpathAndExt)
    delete( cache[ moduleFullpathAndExt ] )

Jeszcze łatwiej, właściwie:

var deleteCache = function(moduleFullpathAndExt) {
  delete( require.cache[ moduleFullpathAndExt ] )
}

Najwyraźniej to działa dobrze. Nie mam pojęcia, co oznaczają te argumenty [„1”], ale spełnia swoje zadanie. Wierzę, że faceci z węzła kiedyś wdrożą funkcję przeładowania, więc sądzę, że na razie to rozwiązanie jest również do przyjęcia. (btw. moja „rzecz” będzie tutaj: https://github.com/cheng81/wirez , idź tam za kilka tygodni i powinieneś zobaczyć, o czym mówię)

Możesz użyć nodemon z NPM . A jeśli używasz generatora Express, możesz użyć tego polecenia w folderze projektu:

nodemon npm start

lub w trybie debugowania

DEBUG=yourapp:* nodemon npm start

możesz także uruchomić bezpośrednio

nodemon your-app-file.js

Mam nadzieję, że to pomoże.

rozwiązanie na: http://github.com/shimondoodkin/node-hot-reload

zauważ, że musisz sam zadbać o wykorzystane referencje.

oznacza to, że zrobiłeś: var x = wymagany („foo”); y = x; z = x.bar; i gorąco przeładowałem to.

oznacza to, że musisz zastąpić odniesienia przechowywane w x, yiz. w gorącej funkcji oddzwaniania.

niektórzy ludzie mylą gorący przeładowanie z automatycznym restartem mój moduł nodejs-autorestart ma również integrację upstart, aby umożliwić automatyczne uruchamianie podczas rozruchu. jeśli masz małą aplikację, automatyczne ponowne uruchomienie jest w porządku, ale gdy masz dużą aplikację, ponowne ładowanie na gorąco jest bardziej odpowiednie. po prostu dlatego, że przeładowanie na gorąco jest szybsze.

Podoba mi się również mój moduł dopływu węzłów.

Nie trzeba używać nodemona lub innych podobnych narzędzi. Po prostu użyj możliwości swojego IDE.

Prawdopodobnie najlepszy jest IntelliJ WebStorm gorącą funkcji reload (automatyczne przeładowanie serwera i przeglądarki) dla node.js .

Oto metoda niskiej technologii do użycia w systemie Windows. Umieść to w pliku wsadowym o nazwie serve.bat:

@echo off

:serve
start /wait node.exe %*
goto :serve

Teraz zamiast uruchamiać się node app.jsz powłoki cmd, uruchomserve app.js .

Spowoduje to otwarcie nowego okna powłoki z serwerem. Plik wsadowy zostanie zablokowany (z powodu/wait ), dopóki nie zamkniesz okna powłoki, w którym to momencie oryginalna powłoka cmd zapyta „Zakończyć zadanie wsadowe (T / N)?” Jeśli odpowiesz „N”, serwer zostanie ponownie uruchomiony.

Za każdym razem, gdy chcesz zrestartować serwer, zamknij okno serwera i odpowiedz „N” w powłoce cmd.

struktura mojej aplikacji:

NodeAPP (folder)
   |-- app (folder)
      |-- all other file is here
   |-- node_modules (folder)
   |-- package.json
   |-- server.js (my server file)

pierwsza instalacja przeładuj za pomocą tego polecenia:

npm install [-g] [--save-dev] reload

następnie zmień pakiet.json :

"scripts": {
    "start": "nodemon -e css,ejs,js,json --watch app"
}

teraz musisz użyć przeładowania w pliku serwera :

var express = require('express');
var reload = require('reload');
var app = express();

app.set('port', process.env.PORT || 3000);

var server = app.listen(app.get('port'), function() {
    console.log( 'server is running on port ' + app.get('port'));
});

reload(server, app);

i dla ostatniej zmiany, koniec odpowiedzi wyślij ten skrypt :

<script src="/reload/reload.js"></script>

teraz uruchom aplikację z tym kodem:

npm start

Użyj tego:

function reload_config(file) {
  if (!(this instanceof reload_config))
    return new reload_config(file);
  var self = this;

  self.path = path.resolve(file);

  fs.watchFile(file, function(curr, prev) {
    delete require.cache[self.path];
    _.extend(self, require(file));
  });

  _.extend(self, require(file));
}

Teraz musisz tylko:

var config = reload_config("./config");

I konfiguracja zostanie automatycznie ponownie załadowana :)

loaddir to moje rozwiązanie do szybkiego ładowania katalogu, rekurencyjnie.

może wrócić

{ 'path/to/file': 'fileContents...' } lub { path: { to: { file: 'fileContents'} } }

Ma, callbackktóry zostanie wywołany, gdy plik zostanie zmieniony.

Obsługuje sytuacje, w których pliki są wystarczająco duże, aby watchwywołać je przed zakończeniem pisania.

Używam go w projektach od około roku, a ostatnio dodałem do niego obietnice.

Pomóż mi przetestować bitwę!

https://github.com/danschumann/loaddir

Możesz użyć automatycznego przeładowania, aby przeładować moduł bez zamykania serwera.

zainstalować

npm install auto-reload

przykład

data.json

{ "name" : "Alan" }

test.js

var fs = require('fs');
var reload = require('auto-reload');
var data = reload('./data', 3000); // reload every 3 secs

// print data every sec
setInterval(function() {
    console.log(data);
}, 1000);

// update data.json every 3 secs
setInterval(function() {
    var data = '{ "name":"' + Math.random() + '" }';
    fs.writeFile('./data.json', data);
}, 3000);

Wynik:

{ name: 'Alan' }
{ name: 'Alan' }
{ name: 'Alan' }
{ name: 'Alan' }
{ name: 'Alan' }
{ name: '0.8272748321760446' }
{ name: '0.8272748321760446' }
{ name: '0.8272748321760446' }
{ name: '0.07935990858823061' }
{ name: '0.07935990858823061' }
{ name: '0.07935990858823061' }
{ name: '0.20851597073487937' }
{ name: '0.20851597073487937' }
{ name: '0.20851597073487937' }

innym prostym rozwiązaniem jest użycie fs.readFile zamiast użycia wymaga zapisania pliku tekstowego zawierającego obiekt json i utworzenia odstępu czasu na serwerze w celu przeładowania tego obiektu.

plusy:

• nie ma potrzeby korzystania z zewnętrznych bibliotek
• istotne dla produkcji (przeładowywanie pliku konfiguracyjnego przy zmianie)
• łatwe do wdrożenia

Cons:

• nie można ponownie załadować modułu - tylko plik zawierający dane klucz-wartość

Dla osób używających Vagrant i PHPStorm, obserwator plików jest szybszy

• wyłącz natychmiastową synchronizację plików, aby uruchomić komendę tylko podczas zapisywania, a następnie utwórz zakres dla plików * .js i katalogów roboczych i dodaj to polecenie

  vagrant ssh -c "/var/www/gadelkareem.com/forever.sh restart"

gdzie jest forever.sh

#!/bin/bash

cd /var/www/gadelkareem.com/ && forever $1 -l /var/www/gadelkareem.com/.tmp/log/forever.log -a app.js

Niedawno doszedłem do tego pytania, ponieważ zwykli podejrzani nie pracowali z połączonymi pakietami. Jeśli jesteś podobny do mnie i korzystasz z niego npm linkpodczas programowania, aby efektywnie pracować nad projektem złożonym z wielu pakietów, ważne jest, aby zmiany zachodzące w zależnościach również powodowały przeładowanie.

Po wypróbowaniu node-mon i pm2, nawet postępując zgodnie z instrukcjami dotyczącymi dodatkowego oglądania folderu node_modules, nadal nie wykryli zmian. Chociaż w odpowiedziach jest kilka niestandardowych rozwiązań, dla czegoś takiego oddzielny pakiet jest czystszy. Natknąłem się na node-dev dziś i działa idealnie bez żadnych opcji i konfiguracji.

Z pliku Readme:

W przeciwieństwie do narzędzi takich jak supervisor lub nodemon nie skanuje systemu plików w poszukiwaniu plików do obejrzenia. Zamiast tego łączy się z funkcją Node's (), aby oglądać tylko te pliki, które były faktycznie wymagane.

const cleanCache = (moduleId) => {
    const module = require.cache[moduleId];
    if (!module) {
        return;
    }
    // 1. clean parent
    if (module.parent) {
        module.parent.children.splice(module.parent.children.indexOf(module), 1);
    }
    // 2. clean self
    require.cache[moduleId] = null;
};

Możesz to zrobić odświeżając przeglądarkę . Aplikacja węzła uruchomi się ponownie automatycznie, strona wyników w przeglądarce również zostanie automatycznie odświeżona. Minusem jest to, że musisz umieścić fragment kodu js na wygenerowanej stronie. Oto repozytorium dla działającego przykładu.

const http = require('http');
const hostname = 'localhost';
const port = 3000;

const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/html; charset=UTF-8');
    res.write('Simple refresh!');
    res.write(`<script src=${process.env.BROWSER_REFRESH_URL}></script>`);
    res.end();
})

server.listen(port, hostname, () => {
    console.log(`Server running at http://${hostname}:${port}/`);

    if (process.send) {
        process.send({ event: 'online', url: `http://${hostname}:${port}/` })
    }

});

Próbowałem pm2 : instalacja jest łatwa i łatwa w użyciu; wynik jest satysfakcjonujący. Musimy jednak zadbać o to, które wydanie pm2 chcemy. pm 2 runtime to darmowa wersja, natomiast pm2 plus i pm2 Enterprise nie są darmowe.

Jeśli chodzi o Strongloop , moja instalacja nie powiodła się lub nie została ukończona, więc nie mogłem z niej korzystać.

Obecnie używany jest serwer deweloperski WebPack z opcją hot. możesz dodać taki skrypt w pliku package.json:"hot": "cross-env NODE_ENV=development webpack-dev-server --hot --inline --watch-poll",

a każda zmiana w plikach spowoduje automatyczną rekompilację