Se eseguo un server con la porta 80 e provo a utilizzare xmlHTTPrequest ottengo questo errore:Error: listen EADDRINUSE

Perché è un problema per nodejs, se voglio fare una richiesta, mentre eseguo un server sulla porta 80? Per i browser web non è un problema: posso navigare su Internet mentre il server è in esecuzione.

Il server è:

  net.createServer(function (socket) {
    socket.name = socket.remoteAddress + ":" + socket.remotePort;
    console.log('connection request from: ' + socket.remoteAddress);
    socket.destroy();
  }).listen(options.port);

E la richiesta:

var xhr = new XMLHttpRequest();

xhr.onreadystatechange = function() {
    sys.puts("State: " + this.readyState);

    if (this.readyState == 4) {
        sys.puts("Complete.\nBody length: " + this.responseText.length);
        sys.puts("Body:\n" + this.responseText);
    }
};

xhr.open("GET", "http://mywebsite.com");
xhr.send();

EADDRINUSEsignifica che il numero di porta che listen()tenta di associare il server è già in uso.

Quindi, nel tuo caso, deve essere già in esecuzione un server sulla porta 80.

Se hai un altro server web in esecuzione su questa porta devi mettere node.js dietro quel server e proxy attraverso di esso.

Dovresti verificare l' listeningevento in questo modo, per vedere se il server è davvero in ascolto:

var http=require('http');

var server=http.createServer(function(req,res){
    res.end('test');
});

server.on('listening',function(){
    console.log('ok, server is running');
});

server.listen(80);

Ciò che mi ha davvero aiutato è stato:

killall -9 node

Ma questo ucciderà un processo di sistema.

Con

ps ax

puoi controllare se ha funzionato.

Il summenzionato killall -9 node, suggerito da Patrick funziona come previsto e risolve il problema, ma potresti voler leggere la parte di modifica di questa stessa risposta sul perché kill -9potrebbe non essere il modo migliore per farlo.

Inoltre, potresti voler indirizzare un singolo processo piuttosto che uccidere ciecamente tutti i processi attivi.

In tal caso, ottenere innanzitutto l'ID processo (PID) del processo in esecuzione su quella porta (ad esempio 8888):

lsof -i tcp:8888

Questo restituirà qualcosa di simile:

COMMAND   PID    USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
node     57385   You   11u  IPv6 0xac745b2749fd2be3      0t0  TCP *:ddi-tcp-1 (LISTEN)

Quindi fai (ps - in realtà no . Continua a leggere di seguito):

kill -9 57385

Puoi leggere un po 'di più su questo qui .

EDIT: stavo leggendo su un argomento abbastanza correlato oggi e mi sono imbattuto in questo interessante thread sul perché non dovrei kill -9un processo .

Generalmente, dovresti usare kill -15 prima di kill -9 per dare al processo target la possibilità di ripulire dopo se stesso. (I processi non possono catturare o ignorare SIGKILL, ma possono e spesso catturano SIGTERM.) Se non dai la possibilità al processo di completare ciò che sta facendo e ripulire, potrebbe lasciare in giro file corrotti (o altri stati) che non sarà in grado di capire una volta riavviato.

Quindi, come detto, è meglio che tu uccida il processo sopra con:

kill -15 57385

EDIT 2 : Come notato in un commento qui molte volte questo errore è una conseguenza del non uscire con garbo da un processo. Ciò significa che, un sacco di gente uscire da un comando nodo (o qualunque altro) utilizzando CTRL + Z . Il modo corretto di interrompere un processo in esecuzione è emettere il comando CTRL + C che esegue un'uscita pulita.

Uscire da un processo nel modo giusto libererà quella porta mentre si spegne. Ciò ti consentirà di riavviare il processo senza doverti preoccupare di ucciderlo da solo prima di poterlo rieseguire.

Solo un avvertimento, Skype a volte ascolterà sulla porta 80 e quindi causerà questo errore se provi ad ascoltare sulla porta 80 da Node.js o qualsiasi altra app.

Puoi disattivare quel comportamento in Skype accedendo alle opzioni e facendo clic su Avanzate -> Connessione -> Usa porta 80 (Deseleziona)

PS Dopo aver apportato questa modifica, non dimenticare di riavviare Skype!

Dovresti provare a terminare il processo in ascolto sulla porta 80.

Killall ucciderà tutte le app del nodo in esecuzione. Potresti non volerlo fare. Con questo comando puoi uccidere solo l'app che è in ascolto su una porta nota.

Se si utilizza unix, provare questo comando:

sudo fuser -k 80/tcp    

Motivo dell'errore: si sta tentando di utilizzare il occupatoport number

Due possibili soluzioni per Windows / Mac

1. Numero di porta attualmente in uso gratuito
2. Selezionare un altro numero di porta per il programma corrente

1. Numero di porta libero

finestre

1. netstat -ano | findstr :4200
2. taskkill /PID 5824 /F

Mac

Puoi provare netstat

netstat -vanp tcp | grep 3000

Per OSX El Capitan e successivi (o se il tuo netstat non supporta -p), usa lsof

sudo lsof -i tcp:3000

se ciò non risolve il problema, gli Macutenti possono fare riferimento alla discussione completa su questo problema Trova (e uccidi) la porta di blocco del processo 3000 su Mac

2. Cambia il numero di porta?

finestre

set PORT=5000

Mac

export PORT=5000

In un controller env, è possibile utilizzare:

pkill node prima di eseguire lo script dovrebbe fare il lavoro.

Ricorda che questo comando ucciderà tutto node processi, il che potrebbe essere giusto se hai un contenitore che esegue solo un'istanza, il nostro hai un tale ambiente dove puoi garantirlo.

In qualsiasi altro scenario, ti consiglio di utilizzare un comando per eliminare un determinato ID processo o nome che hai trovato cercandolo a livello di codice. come se il tuo processo fosse chiamato, node-server-1 che potresti fare pkill node-server-1.

Questa risorsa potrebbe essere utile per capire: https://www.thegeekstuff.com/2009/12/4-ways-to-kill-a-process-kill-killall-pkill-xkill/

L'applicazione è già in esecuzione su quella porta 8080. Utilizzare questo codice per eliminare la porta ed eseguire nuovamente il codice

sudo lsof -t -i tcp:8080 | xargs kill -9

Un'altra cosa che può dare questo errore sono due server HTTP nello stesso codice nodo. Stavo aggiornando un po 'di codice da Express 2 a Express 3 e avevo questo ...

http.createServer(app).listen(app.get('port'), function(){            
  console.log('Express server listening on port ' + app.get('port')); 
});        

// tons of shit.

http.createServer(app).listen(app.get('port'), function(){            
  console.log('Express server listening on port ' + app.get('port')); 
});                                                                   

E ha innescato questo errore.

Questo funziona per me (sto usando Mac). Esegui questo comando

lsof -PiTCP -sTCP:LISTEN

Verrà visualizzato un elenco di porte utilizzate dal sistema. Trova il PIDnodo in esecuzione

COMMAND     PID          USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
node      17269 hientrq   16u  IPv6 0xc42959c6fa30c3b9      0t0  TCP *:51524 (LISTEN)
node      17269 hientrq   19u  IPv4 0xc42959c71ae86fc1      0t0  TCP localhost:1337 (LISTEN)

e corri kill -9 [YOUR_PID]

EADDRINUSEsignifica che la porta (che proviamo ad ascoltare nell'applicazione nodo) è già in uso. Per superare, dobbiamo identificare quale processo è in esecuzione con quella porta.

Ad esempio, se stiamo provando ad ascoltare la nostra applicazione nodo nella porta 3000. Dobbiamo verificare se quella porta è già utilizzata da qualsiasi altro processo.

passo 1:

$sudo netstat -plunt |grep :3000

Che il comando sopra dia il risultato sotto.

tcp6       0      0 :::3000                 :::*                    LISTEN      25315/node

passo 2:

Ora hai l'ID processo (25315), uccidi quel processo.

kill -9 25315

Fase 3:

npm run start

Nota: questa soluzione per utenti Linux.

lsof -i:3000;
kill -9 $(lsof -t -i:3000);
// 3000 is a your port
// This "lsof -i:3000;" command will show PID 
kill PID 
ex: kill 129393

sudo kill $ (sudo lsof -t -i: 80)

per uccisione forzata

sudo kill -9 $ (sudo lsof -t -i: 80)

usa sopra cmd per uccidere una porta particolare ed esegui il tuo server

Prova entrambi i comandi e interromperà tutto il processo del nodo.

killall 9 node
pkill node
npm start 

Questo errore si verifica quando si esegue un processo su una porta su cui si desidera eseguire l'applicazione.

come ottenere quale processo in esecuzione su quel port => comando: sudo netstat -ap | grep: 3000

output: otterrai le informazioni sul processo che sta usando quella porta

tcp 0 0 Indirizzo IP: 3000 : ASCOLTA 26869 / nodo

Ora puoi uccidere quel processo sudo kill -9 26869

Nel comando seguente sostituisci portNumber

sudo lsof -t -i tcp:portNumber | xargs kill -9

EADDRINUSE indica che la porta dell'app nodejs è già in uso.

• Ora hai terminato il processo / app in esecuzione su quella porta.
• Trova l'id processo dell'app:

lsof -i tcp: 3000

• Ora otterrai ID processo da questo.
• Esegui questo:

kill -9 processId

C'è un modo per terminare il processo usando Task Manager:

Questa soluzione è solo per Windows

1. Vai al Task Manager (o usando il collegamento Ctrl+ Shift+ Esc)

2. Su "Processi in background", trova i processi "Node.js" e terminali (fai clic con il pulsante destro del mouse e scegli "Termina operazione")

3. Ora dovresti essere in grado di ricominciare

Ho visto questo errore in precedenza (nel nodo) con http.client e, come ricordo, il problema riguardava il fatto di non inizializzare httpClient o impostare opzioni errate nella creazione di httpClient e / o nella richiesta url.

Anch'io ho lo stesso problema, e semplicemente chiudo il terminale, apro un nuovo terminale ed eseguo

node server.js

ancora. che funziona per me, un po 'di tempo devo solo aspettare qualche secondo fino a quando non funziona di nuovo.

Ma questo funziona solo su una macchina sviluppatore anziché su una console del server.

Errore: ascoltare EADDRINUSE significa che la porta che si desidera assegnare / associare al server delle applicazioni è già in uso. Puoi assegnare un'altra porta alla tua applicazione.

O se vuoi assegnare la stessa porta all'app. Quindi uccidere l'applicazione in esecuzione sulla porta desiderata.

Per un'applicazione nodo ciò che puoi provare è, trova l'id di processo per l'app nodo:

ps -aux | grep node

Dopo aver ottenuto l'ID del processo, fallo

kill process_id

Su Debian ho scoperto di funzionare sulla porta 80, è necessario emettere il comando come root, ad es

sudo node app.js

spero possa essere d'aiuto

Nel mio caso Apache HTTP Server è stato eseguito sulla porta 80 l'ho risolto emettendo il comando come root

sudo killall httpd

Aggiornare

Se Jenkin è installato e in esecuzione sul tuo Mac;

1. Puoi verificarlo con sudo lsof -i tcp:8080
2. Se sì, e vuoi fermare Jenkins solo una volta, esegui: sudo launchctl unload /Library/LaunchDaemons/org.jenkins-ci.plist

Sembra che ci sia un altro Nodo di processo in esecuzione. Controllalo digitandolo nella tua console (Linux / Mac):

ps aux|grep node

e chiudilo con:

kill -9 <NodeProcessId>

O uso alternato

ng serve --port <AnotherFreePortNumber>

per servire il tuo progetto su un porto libero di tua scelta.

Durante l'uccisione di NODE_PORT, potrebbe uccidere il processo Chrome o qualsiasi cosa stia ascoltando la stessa porta e questo è fastidioso.

Questo script di shell può essere utile - nel mio caso la porta è 1337 ma puoi cambiarla in qualsiasi momento

# LOGIC

CHROME_PIDS=`pidof chrome`
PORT_PIDS=`lsof -t -i tcp:1337`

for pid in $PORT_PIDS
do

if [[ ${CHROME_PIDS} != *$pid* ]];then

    # NOT FOUND IN CHROME PIDS

    echo "Killing $pid..."
    ps -p "$pid"

    kill -kill "$pid"
    fi

done

sails lift
# OR 'node app' OR whatever that starts your node

exit

Nel mio caso uso un web hosting ma è lo stesso nell'host locale, ho usato:

ps -aef | grep 'node' 

per guardare il processo del nodo quindi, la console mostra il processo con PID. per terminare il processo devi usare questo comando:

kill -9 PID

dove PID è l'id del processo dal comando sopra.

Due server non possono ascoltare sulla stessa porta, quindi controlla se altri server sono in ascolto sulla stessa porta, controlla anche la sincronizzazione del browser se è in esecuzione sulla stessa porta

Per altre persone su Windows 10 con nodo as localhoste in esecuzione su una porta come 3500, non 80 ...

Cosa non funziona:

killall    ?  command not found
ps -aux | grep 'node'     ?     ps:  user x unknown 

Cosa mostra le informazioni ma non funziona ancora:

 ps -aef | grep 'node'
 ps ax
 kill -9 61864

Cosa funziona:

Git Bash o Powershell su Windows

  net -a -o | grep 3500   (whatever port you are looking for) 

Notare il PID (all'estrema destra)
non sono riuscito killalla lavorare ... quindi

1. Apri il tuo task manager
2. Nella scheda Processi, fare clic con il tasto destro su Nome o su qualsiasi colonna e selezionare per includere PID
3. Ordina per PID, quindi fai clic con il tasto destro sul PID destro e fai clic su Termina attività.

Ora dopo quell'esercizio non così divertente su Windows, mi sono reso conto che posso usare Task Manager e trovare il motore Node e finirlo.

Cordiali saluti, stavo usando Visual Studio Code per eseguire Node sulla porta 3500 e utilizzo la shell Git Bash all'interno del codice VS. Ero uscito con grazia con Ctrl + C, ma a volte questo non lo uccide. Non voglio cambiare porta o riavviare, quindi ha funzionato. Spero che aiuti gli altri. Altrimenti è documentazione per me stesso.

Per gli utenti di Windows, eseguire il comando seguente nella finestra di PowerShell per terminare tutti i processi del nodo.

Stop-Process -processname node

L'opzione che funziona per me:

Correre:

ps -ax | grep node

Otterrai qualcosa del tipo:

 8078 pts/7    Tl     0:01 node server.js
 8489 pts/10   S+     0:00 grep --color=auto node    
 kill -9 8078