Attualmente sembra che per qualsiasi modifica al codice in un'app sails.js sia necessario arrestare manualmente il server sails ed eseguirlo di sails liftnuovo prima di poter vedere le modifiche.

Mi chiedevo se esiste un modo durante l'esecuzione in modalità di sviluppo per riavviare automaticamente il server Sails quando rileva una modifica del codice?

Devi usare un watcher come forever , nodemon o qualcos'altro ...

Esempio

1. Installa per sempre eseguendo:

   sudo npm install -g forever

2. Eseguirlo:

   forever -w start app.js

Per evitare un riavvio infinito perché Sails scrive nella .tmpcartella, puoi creare un .foreverignorefile nella directory del tuo progetto e inserire questo contenuto all'interno:

**/.tmp/**
**/views/**
**/assets/**

Vedi il problema su GitHub: riavvio per sempre a causa di /.tmp .

Puoi usare sails-hook-autoreload

Solleva l'app normalmente e quando aggiungi / modifichi / rimuovi un modello o un file di controller, tutti i controller ei modelli verranno ricaricati senza dover abbassare / rilanciare l'app.

Ad esempio con nodemonper guardare api e directory di configurazione

.nodemonignore Contenuti

views/*
.tmp/*
.git/*

Esegui il comando dopo aver creato .nodemonignore

$> nodemon -w api -w config

Esempio per il supervisore per ignorare 3 directory

$> supervisor -i .tmp,.git,views app.js

Se stai usando Sails 0.11, puoi installare questo hook per ricaricare automaticamente quando cambi modello o controller (le viste non richiedono il ricaricamento):

npm install sails-hook-autoreload

https://www.npmjs.com/package/sails-hook-autoreload

installare nodemonglobalmente o localmente.

npm install nodemon --save
npm install nodemon -g

installare sailslocalmente nel progetto come segue

npm install sails --save

poi cambia package.json

a partire dal

"scripts": {
  "debug": "node debug app.js",
  "start": "node app.js"
},

per

"scripts": {
   "debug": "node debug app.js",
   "start": "node app.js",
   "dev": "export NODE_ENV=development && nodemon --ignore 'tmp/*' app.js && exit 0"
},

poi

npm run dev

Ho avuto lo stesso problema e l'ho risolto usando grunt-watch e grunt-forever con le attività sails @ beta. Il risultato sono 4 comandi grugniti:

AGGIORNAMENTO: le attività sono disponibili nella versione attuale di vele (non è più beta:>)

• inizio Avvia il server
• stop Arresta il server
• riavvia Riavvia il server
• startWatch Avvia il server e attende le modifiche per riavviarlo (utilizzando grunt-watch). Questa è probabilmente la tua soluzione, ma anche gli altri comandi sono utili.

Ecco il codice: sto usando sails @ beta, che include una directory delle attività , non so se è inclusa nelle versioni precedenti:

• Prima di tutto devi installare per sempre nella tua directory di vele:

  npm install grunt-forever --save-dev

• task / config / forever.js Configura l'attività per sempre.

  module.exports = function(grunt) {
    grunt.config.set('forever', {
      server: {
         options: {
            index: 'app.js',
            logDir: 'logs'
         }
      }
    });
  
    grunt.loadNpmTasks('grunt-forever');
  };

• task / config / watch.js ( modifica ) Modifica l'attività di controllo per aggiungere una nuova regola

  // api and assets default rules
  ,
  server: {
      // Server files to watch:
      files: [
          'api/**/*',
          'config/**/*'
      ],
  
      // Restart server
      tasks: ['forever:server:restart']
  }

• task / register / watchForever.js Registra le tue attività personalizzate (questo file può essere rinominato come vuoi)

  module.exports = function(grunt) {
  // Starts server
    grunt.registerTask('start', [
      'compileAssets',
      'linkAssetsBuild',
      'clean:build',
      'copy:build',
      'forever:server:start'
    ]);
  
    // Restarts the server (if necessary) and waits for changes
    grunt.registerTask('startWatch', [
      'restart',
      'watch:server'
    ]);
  
    // Restarts server
    grunt.registerTask('restart', [
      'forever:server:restart'
    ]);
  
    // Stops server
    grunt.registerTask('stop', [
      'forever:server:stop'
   ]);
  };

Con questo dovresti essere in grado di usare

    grunt startWatch

e fai in modo che il tuo server attenda il riavvio delle modifiche:>

Spero che questo abbia aiutato!

Meglio che tu usi

npm install -g nodemon

Lo sto usando e mi aiuterà a migliorare la mia velocità di sviluppo. non è necessario modificare alcun file per questo !.

dopo l'installazione

nodemon app.js

Per chiunque arrivi a questa domanda ora, sembra che ciò non sia più necessario: un'applicazione avviata con sails liftavrà un'attività di controllo grugnito in esecuzione e le modifiche al codice saranno visibili senza riavvio.

All'inizio non mi ero reso conto che questo stesse accadendo perché non c'è nulla che indichi cosa sta succedendo nella console, ma sembra funzionare senza un riavvio (sto usando Sails 0.11)