Crei l'app node.js con express v4.x quindi avvia la tua app entro npm start . La mia domanda è come fermare l'app? C'è una fermata npm ?

MODIFICARE per includere l'errore quando si implementa l'arresto di npm

/home/nodetest2# npm stop

> nodetest2@0.0.1 stop /home/nodetest2
> pkill -s SIGINT nodetest2

pkill: invalid argument for option 's' -- SIGINT

npm ERR! nodetest2@0.0.1 stop: `pkill -s SIGINT nodetest2`
npm ERR! Exit status 2

Sì, anche npm prevede uno script di arresto:

npm help npm-scripts

prestop, stop, poststop: eseguito dal comando npm stop.

Imposta uno dei precedenti nel tuo package.json, quindi usa npm stop

npm help npm-stop

È possibile effettuare questa molto semplice se si imposta in app.js,

process.title = myApp;

E poi in scripts.json,

"scripts": {
    "start": "app.js"
    , "stop": "pkill --signal SIGINT myApp"
}

Detto questo, se fossi stato io, avrei usato pm2o qualcosa che lo gestiva automaticamente sulla base di una spinta git.

Tutte le altre soluzioni qui dipendono dal sistema operativo. Una soluzione indipendente per qualsiasi sistema operativo utilizza socket.io come segue.

package.json ha due script:

"scripts": {
  "start": "node server.js",
  "stop": "node server.stop.js"
}

server.js - La tua solita roba express vive qui

const express = require('express');
const app = express();
const server = http.createServer(app);
server.listen(80, () => {
  console.log('HTTP server listening on port 80');
});

// Now for the socket.io stuff - NOTE THIS IS A RESTFUL HTTP SERVER
// We are only using socket.io here to respond to the npmStop signal
// To support IPC (Inter Process Communication) AKA RPC (Remote P.C.)

const io = require('socket.io')(server);
io.on('connection', (socketServer) => {
  socketServer.on('npmStop', () => {
    process.exit(0);
  });
});

server.stop.js

const io = require('socket.io-client');
const socketClient = io.connect('http://localhost'); // Specify port if your express server is not using default port 80

socketClient.on('connect', () => {
  socketClient.emit('npmStop');
  setTimeout(() => {
    process.exit(0);
  }, 1000);
});

Provalo

npm start (per avviare il server come al solito)

npm stop (questo ora interromperà il tuo server in esecuzione)

Il codice sopra non è stato testato (è una versione ridotta del mio codice, il mio codice funziona) ma si spera che funzioni così com'è. In ogni caso, fornisce la direzione generale da prendere se si desidera utilizzare socket.io per arrestare il server.

Quando ho provato la soluzione suggerita, mi sono reso conto che il nome della mia app era stato troncato. Ho letto process.titlenella documentazione di nodejs ( https://nodejs.org/docs/latest/api/process.html#process_process_title ) e dice

Su Linux e OS X, è limitato alla dimensione del nome binario più la lunghezza degli argomenti della riga di comando perché sovrascrive la memoria argv.

La mia app non utilizza argomenti, quindi posso aggiungere questa riga di codice al mio file app.js

process.title = process.argv[2];

e poi aggiungi queste poche righe al mio package.jsonfile

  "scripts": {
    "start": "node app.js this-name-can-be-as-long-as-it-needs-to-be",
    "stop": "killall -SIGINT this-name-can-be-as-long-as-it-needs-to-be"
  },

per usare nomi di processo molto lunghi. npm starte il npm stoplavoro, ovviamente, npm stopterminerà sempre tutti i processi in esecuzione, ma per me va bene.

Questo è un problema di versione mintty in alternativa usa cmd. Per terminare il processo del server basta eseguire questo comando:

    taskkill -F -IM node.exe

Su MAC OS X (/ BSD): puoi provare a utilizzare il comando lsof (list open files)

$ sudo lsof -nPi -sTCP:LISTEN

e così

$ kill -9 3320

Verificare con netstat -nptl tutti i processi

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.1:27017         0.0.0.0:*               LISTEN      1736/mongod     
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1594/sshd       
tcp6       0      0 :::3977                 :::*                    LISTEN      6231/nodejs     
tcp6       0      0 :::22                   :::*                    LISTEN      1594/sshd       
tcp6       0      0 :::3200                 :::*                    LISTEN      5535/nodejs 

E uccide semplicemente il processo dal riferimento PID .... Nel mio caso voglio fermare 6231 / nodejs quindi eseguo il seguente comando:

kill -9 6231

Ecco un'altra soluzione che mescola idee dalle risposte precedenti. Adotta l'approccio del "processo di uccisione" mentre affronta la preoccupazione per l'indipendenza dalla piattaforma.

Si basa sul pacchetto tree-kill per gestire l'uccisione dell'albero dei processi del server. Ho trovato che uccidere l'intero albero dei processi è necessario nei miei progetti perché alcuni strumenti (ad esempio babel-node) generano processi figlio. Se hai solo bisogno di uccidere un singolo processo, puoi sostituire tree-kill con il process.kill()metodo integrato .

La soluzione segue (i primi due argomenti spawn()da modificare per riflettere la ricetta specifica per l'esecuzione del server):

build / start-server.js

import { spawn } from 'child_process'
import fs from 'fs'

const child = spawn('node', [
  'dist/server.js'
], {
  detached: true,
  stdio: 'ignore'
})
child.unref()

if (typeof child.pid !== 'undefined') {
  fs.writeFileSync('.server.pid', child.pid, {
    encoding: 'utf8'
  })
}

build / stop-server.js

import fs from 'fs'
import kill from 'tree-kill'

const serverPid = fs.readFileSync('.server.pid', {
  encoding: 'utf8'
})
fs.unlinkSync('.server.pid')

kill(serverPid)

package.json

"scripts": {
  "start": "babel-node build/start-server.js",
  "stop": "babel-node build/stop-server.js"
}

Si noti che questa soluzione scollega lo script di avvio dal server (ovvero npm starttornerà immediatamente e non si bloccherà fino a quando il server non verrà arrestato). Se preferisci il comportamento di blocco tradizionale, rimuovi semplicemente l' options.detachedargomento a spawn()e la chiamata a child.unref().

Se hai già provato ctrl + ce ancora non funziona, potresti provare questo. Questo ha funzionato per me.

1. Esegui la riga di comando come amministratore. Quindi esegui il comando seguente per trovare il processID (PID) che desideri uccidere. Digita il tuo numero di porta<yourPortNumber>

   netstat -ano | findstr :<yourPortNumber>

2. Quindi si esegue questo comando dopo aver identificato il PID.

   taskkill /PID <typeYourPIDhere> /F

Complimenti a @mit $ ingh da http://www.callstack.in/tech/blog/windows-kill-process-by-port-number-157

Se è molto semplice, interrompi il processo ..

localmacpro$ ps
  PID TTY           TIME CMD
 5014 ttys000    0:00.05 -bash
 6906 ttys000    0:00.29 npm   
 6907 ttys000    0:06.39 node /Users/roger_macpro/my-project/node_modules/.bin/webpack-dev-server --inline --progress --config build/webpack.dev.conf.js
 6706 ttys001    0:00.05 -bash
 7157 ttys002    0:00.29 -bash

localmacpro$ kill -9 6907 6906

Per macchine Windows (sono su Windows 10), se CTRL + C (Annulla / Interrompi) Il comando su cli non funziona e lo schermo si presenta in questo modo:

Prova a premere prima INVIO (o qualsiasi tasto lo farebbe) e poi CTRL + C e il processo corrente chiederà se vuoi terminare il lavoro batch:

Forse CTRL + C termina solo il processo padre mentre npm start viene eseguito con altri processi figlio. Non sono abbastanza sicuro del motivo per cui devi premere quel tasto extra prima di CTRL + C, ma funziona meglio che dover chiudere la riga di comando e ricominciare.

Un problema correlato che potresti voler controllare: https://github.com/mysticatea/npm-run-all/issues/74

Per gli ambienti di produzione dovresti usare Forever.js

È così utile per avviare e interrompere il processo del nodo, puoi anche elencare le app in esecuzione.

https://github.com/foreverjs/forever

Puoi usare pm2

https://pm2.keymetrics.io/docs/usage/quick-start/

dopo l'installazione basta digitare il terminale

pm2 start app.js e poi

pm2 stop 0 per fermare il tuo server

Nel caso in cui il tuo file json non abbia uno script per fermare l'app, un'opzione che uso è semplicemente premendo ctrl + C sul cmd.

Tutta la (3) soluzione è:

1- ctlr + C

2- nel file json wreite uno script che si ferma

"scripts": {"stop": "killall -SIGINT this-name-can-be-as-long-as-it-need-to-be"},

* rispetto al comando write // npm stop //

3- Riavviare il pc

Devi premere la combinazione ctrl + z Il mio sistema operativo è Ubuntu