Trova (e uccidi) la porta di blocco del processo 3000 su Mac

Come posso trovare (e uccidere) i processi che ascoltano / usano le mie porte tcp? Sono su mac os x.

A volte, dopo un arresto anomalo o un bug, la mia app rails blocca la porta 3000. Non riesco a trovarla usando ps -ef ...

Quando si fa

rails server

ottengo

Indirizzo già in uso - bind (2) (Errno :: EADDRINUSE)

Aggiornamento 2014:

Per completare alcune delle risposte di seguito: Dopo aver eseguito i comandi kill, potrebbe essere necessario eliminare il file pid rm ~/mypath/myrailsapp/tmp/pids/server.pid

1. Puoi provare netstat

   netstat -vanp tcp | grep 3000
   

2. Per macOS El Capitan e successivi (o se netstat non supporta -p), utilizzarelsof

   sudo lsof -i tcp:3000 
   

3. Per Centos 7 utilizzare

   netstat -vanp --tcp | grep 3000
   

Trova:

sudo lsof -i :3000

Uccidere:

kill -9 <PID>

Niente sopra ha funzionato per me. Qualcun altro con la mia esperienza potrebbe provare quanto segue (ha funzionato per me):

Correre:

lsof -i :3000 (where 3000 is your current port in use)

quindi controllare lo stato del PID riportato:

ps ax | grep <PID>

infine "begone with it":

kill -QUIT <PID>

Un one-liner per estrarre il PID del processo usando la porta 3000 e ucciderlo.

lsof -ti:3000 | xargs kill

Il flag -t rimuove tutto tranne il PID dall'output di lsof, rendendo facile ucciderlo.

La soluzione più semplice :

Per porta singola:

kill $(lsof -ti:3000)  #3000 is the port to be freed

Uccidi più porte con il comando a riga singola:

kill $(lsof -ti:3000,3001)  #here multiple ports 3000 and 3001 are the ports to be freed

lsof -ti: 3000

82500 (ID processo / PID)

lsof -ti: 3001

82499

lsof -ti: 3001.3000

82499 82500

kill $ (lsof -ti: 3001,3000)

Termina i processi 82499 e 82500 in un unico comando.

Per usare questo negli package.jsonscript:

"scripts": { "start": "kill $(lsof -ti:3000,3001) && npm start" }

Questa singola riga di comando è facile da ricordare:

npx kill-port 3000

Per uno strumento più potente con la ricerca:

npx fkill-cli

PS: usano pacchetti javascript di terze parti. npxviene integrato con Node.js.

Fonti: tweet | github

È possibile utilizzare lsof -i:3000.

Questo è "Elenco file aperti". Questo ti dà un elenco dei processi e quali file e porte usano.

Nel tuo .bash_profile, crea un collegamento per terminateil processo 3000:

terminate(){
  lsof -P | grep ':3000' | awk '{print $2}' | xargs kill -9 
}

Quindi, chiama $terminatese è bloccato.

Per terminare forzatamente un processo del genere, utilizzare il seguente comando

lsof -n -i4TCP:3000 

Dove 3000 è il numero di porta in cui è in esecuzione il processo

questo restituisce l'id di processo (PID) ed esegui

kill -9 "PID"

Sostituisci PID con il numero che ottieni dopo aver eseguito il primo comando

lsof -P | grep ':3000' | awk '{print $2}'

Questo ti darà solo il pid, testato su MacOS.

Eseguire nella riga di comando su OS-X El Captain:

kill -kill `lsof -t -i tcp:3000`

L'opzione terse di lsof restituisce solo il PID.

Uno dei modi per terminare un processo su una porta è usare la libreria python: freeport ( https://pypi.python.org/pypi/freeport/0.1.9 ). Una volta installato, semplicemente:

# install freeport
pip install freeport

# Once freeport is installed, use it as follows
$ freeport 3000
Port 3000 is free. Process 16130 killed successfully

Per visualizzare i processi che bloccano la porta:

netstat -vanp tcp | grep 3000

Per uccidere i processi che bloccano la porta:

kill $(lsof -t -i :3000)

Trova la connessione aperta

lsof -i -P | grep -i "ascolta"

Uccidi per ID processo

uccidere -9 'PID'

Trova e uccidi:

Questa singola riga di comando è semplice e funziona correttamente.

kill -9 $(lsof -ti tcp:3000)

Possibili modi per raggiungere questo obiettivo:

superiore

Il comando principale è il modo tradizionale di visualizzare l'utilizzo delle risorse del sistema e vedere i processi che stanno occupando la maggior parte delle risorse di sistema. In alto viene visualizzato un elenco di processi, con quelli che utilizzano la maggior parte della CPU in alto.

ps

Il comando ps elenca i processi in esecuzione. Il seguente comando elenca tutti i processi in esecuzione sul sistema:

ps -A

È inoltre possibile reindirizzare l'output tramite grep per cercare un processo specifico senza utilizzare altri comandi. Il seguente comando cercherà il processo di Firefox:

ps -A | grep firefox

Il modo più comune di trasmettere segnali a un programma è con il comando kill.

kill PID_of_target_process

lsof

Elenco di tutti i file aperti e dei processi che li hanno aperti.

lsof -i -P | grep -i "listen"
kill -9 PID

o

 lsof -i tcp:3000 

lsof -i tcp:port_number - elencherà il processo in esecuzione su quella porta

kill -9 PID - ucciderà il processo

nel tuo caso, lo sarà

lsof -i tcp:3000 dal tuo terminale trova il PID del processo

kill -9 PID

Questi due comandi ti aiuteranno a trovare e terminare il processo del server

1. lsof -wni tcp: 3000
2. uccidi -9 pid

Aggiungi a ~/.bash_profile:

function killTcpListen () {
  kill -QUIT $(sudo lsof -sTCP:LISTEN -i tcp:$1 -t)
}

Quindi, source ~/.bash_profilecorri

killTcpListen 8080

Utilizzando sindresorhus 'il fkill strumento, si può fare questo:

$ fkill :3000

TL; DR:

lsof -ti tcp:3000 -sTCP:LISTEN | xargs kill

Se ti trovi in ​​una situazione in cui ci sono client e server che utilizzano la porta, ad esempio:

$ lsof -i tcp:3000
COMMAND     PID         USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
node       2043 benjiegillam   21u  IPv4 0xb1b4330c68e5ad61      0t0  TCP localhost:3000->localhost:52557 (ESTABLISHED)
node       2043 benjiegillam   22u  IPv4 0xb1b4330c8d393021      0t0  TCP localhost:3000->localhost:52344 (ESTABLISHED)
node       2043 benjiegillam   25u  IPv4 0xb1b4330c8eaf16c1      0t0  TCP localhost:3000 (LISTEN)
Google    99004 benjiegillam  125u  IPv4 0xb1b4330c8bb05021      0t0  TCP localhost:52557->localhost:3000 (ESTABLISHED)
Google    99004 benjiegillam  216u  IPv4 0xb1b4330c8e5ea6c1      0t0  TCP localhost:52344->localhost:3000 (ESTABLISHED)

allora probabilmente non vorrai uccidere entrambi.

In questa situazione puoi usare -sTCP:LISTENsolo per mostrare il pid dei processi che stanno ascoltando. Combinando questo con il -tformato terse è possibile terminare automaticamente il processo:

lsof -ti tcp:3000 -sTCP:LISTEN | xargs kill

Ho fatto una piccola funzione per questo, aggiungerlo al file rc ( .bashrc, .zshrco qualsiasi altra cosa)

function kill-by-port {
  if [ "$1" != "" ]
  then
    kill -9 $(lsof -ni tcp:"$1" | awk 'FNR==2{print $2}')
  else
    echo "Missing argument! Usage: kill-by-port $PORT"
  fi
}

allora puoi semplicemente digitare kill-by-port 3000 per uccidere il tuo server rails (sostituendo 3000 per qualunque porta sia in esecuzione)

in caso contrario, è sempre possibile digitare kill -9 $(cat tmp/pids/server.pid)dalla directory principale delle rotaie

Per uccidere più porte.

$ npx kill-port 3000 8080 8081

Process on port 3000 killed
Process on port 8080 killed
Process on port 8081 killed

Spero che questo aiuto!

Dovresti provare questo, questa tecnica è indipendente dal sistema operativo.

A lato della tua applicazione c'è una cartella chiamata tmp, all'interno della quale c'è un'altra cartella chiamata pids. Tale file contiene il file pid del server. Elimina semplicemente quel file. la porta si uccide automaticamente.

Penso che questo sia il modo semplice.

Ecco una funzione di supporto bash per uccidere più processi per nome o porta

fkill() {
  for i in $@;do export q=$i;if [[ $i == :* ]];then lsof -i$i|sed -n '1!p';
  else ps aux|grep -i $i|grep -v grep;fi|awk '{print $2}'|\
  xargs -I@ sh -c 'kill -9 @&&printf "X %s->%s\n" $q @';done
}

Uso:

$ fkill [process name] [process port]

Esempio:

$ fkill someapp :8080 node :3333 :9000

Puoi provare questo

netstat -vanp tcp | grep 3000

Se vuoi un modo senza codice - apri il gestore attività e forza il nodo kill :)

Io lo uso questo:

cat tmp/pids/server.pid | pbcopy

Poi kill -9 'paste'

Passaggio 1: Trova il server in esecuzione: ps aux | grep puma Passaggio 2: Uccidi quei server Uccidi -9 [numero server]

In mac OS

kill -9 $(lsof -i TCP:3000 | grep LISTEN | awk '{print $2}')