I'm trying to set up a server with python from mac terminal.
I navigate to folder location an use:
python -m SimpleHTTPServer
But this gives me error:
socket.error: [Errno 48] Address already in use
I had previously open a connection using the same command for a different website in a different location in my machine.
You already have a process bound to the default port (8000). If you already ran the same module before, it is most likely that process still bound to the port. Try and locate the other process first:
$ ps -fA | grep python
501 81651 12648 0 9:53PM ttys000 0:00.16 python -m SimpleHTTPServer
The command arguments are included, so you can spot the one running SimpleHTTPServer if more than one python process is active. You may want to test if http://localhost:8000/ still shows a directory listing for local files.
The second number is the process number; stop the server by sending it a signal:
kill 81651
This sends a standard SIGTERM signal; if the process is unresponsive you may have to resort to tougher methods like sending a SIGKILL (kill -s KILL <pid> or kill -9 <pid>) signal instead. See Wikipedia for more details.
Alternatively, run the server on a different port, by specifying the alternative port on the command line:
$ python -m SimpleHTTPServer 8910
Serving HTTP on 0.0.0.0 port 8910 ...
then access the server as http://localhost:8910; where 8910 can be any number from 1024 and up, provided the port is not already taken.
sudo kill -9 PID –
Chancery kill sends a signal to the process, which it can decide to handle (like shut down gracefully or rotate a logfile). These signals are integers (each with a name), the default being 15, meaning TERM or terminate. Using -9 sends signal 9, KILL, which a process can't catch and ignore, and the OS will end the process wether it likes to or not. –
Cotidal Simple solution：
8080:sudo lsof -i:8080
kill $PID
kill -9 $PID //to forcefully kill the port
PID is got from step 1's output.
lsof output might look like, and how to find the process ID (the "XXXX" you list) within the output. For anyone seeing this without that information, it's the second field in the output, under a header label of "PID". –
Nereen Use
sudo lsof -i:5000
This will give you a list of processes using the port if any. Once the list of processes is given, use the id on the PID column to terminate the process use
kill 379 #use the provided PID
Simple one line command to get rid of it, type below command in terminal,
ps -a
This will list out all process, checkout which is being used by Python and type bellow command in terminal,
kill -9 (processID)
For example kill -9 33178
By the way, to prevent this from happening in the first place, simply press Ctrl+C in terminal while SimpleHTTPServer is still running normally. This will "properly" stop the server and release the port so you don't have to find and kill the process again before restarting the server.
You can allow the server to reuse an address with allow_reuse_address.
Whether the server will allow the reuse of an address. This defaults to
False, and can be set in subclasses to change the policy.
import SimpleHTTPServer, SocketServer
PORT = 8000
httpd = SocketServer.TCPServer(("", PORT), SimpleHTTPServer.SimpleHTTPRequestHandler)
httpd.allow_reuse_address = True
print "Serving at port", PORT
httpd.serve_forever()
SocketServer.TCPServer.allow_reuse_address = True (from https://mcmap.net/q/100935/-python-tcpserver-address-already-in-use-but-i-close-the-server-and-i-use-allow_reuse_address ). It is probably cleaner to inherit TCPServer to a new class and set the value there. –
Damaraland You can also serve on the next-highest available port doing something like this in Python:
import SimpleHTTPServer
import SocketServer
Handler = SimpleHTTPServer.SimpleHTTPRequestHandler
port = 8000
while True:
try:
httpd = SocketServer.TCPServer(('', port), Handler)
print 'Serving on port', port
httpd.serve_forever()
except SocketServer.socket.error as exc:
if exc.args[0] != 48:
raise
print 'Port', port, 'already in use'
port += 1
else:
break
If you need to do the same thing for other utilities, it may be more convenient as a bash script:
#!/usr/bin/env bash
MIN_PORT=${1:-1025}
MAX_PORT=${2:-65535}
(netstat -atn | awk '{printf "%s\n%s\n", $4, $4}' | grep -oE '[0-9]*$'; seq "$MIN_PORT" "$MAX_PORT") | sort -R | head -n 1
Set that up as a executable with the name get-free-port and you can do something like this:
someprogram --port=$(get-free-port)
That's not as reliable as the native Python approach because the bash script doesn't capture the port -- another process could grab the port before your process does (race condition) -- but still may be useful enough when using a utility that doesn't have a try-try-again approach of its own.
I am new to Python, but after my brief research I found out that this is typical of sockets being binded. It just so happens that the socket is still being used and you may have to wait to use it. Or, you can just add:
tcpSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
This should make the port available within a shorter time. In my case, it made the port available almost immediately.
This happens when I debug or run a server and when done, instead of Terminating the process, I Disconnect it.
PyCharm asks for these two options when we try to close it while the server is still running
This results that, the process still running in the background on that particular address, hence, Address already in use error.
pkill python
Works for me.
If you have more than one server/application running with python (obviously, at different ports 😅), then get the PID of that process using PORT and kill it.
sudo lsof -i :5000 # here 5000 is the port number
| COMMAND | PID | USER | FD | TYPE | DEVICE | SIZE/OFF | NODE | NAME |
|---------|--------|----------|----|------|--------|----------|------|-------------------------|
| python | 185339 | username | 7u | IPv4 | 598745 | 0t0 | TCP | localhost:5000 (LISTEN) |
| python | 185348 | username | 7u | IPv4 | 598745 | 0t0 | TCP | localhost:5000 (LISTEN) |
| python | 185350 | username | 8u | IPv4 | 598745 | 0t0 | TCP | localhost:5000 (LISTEN) |
kill -9 185339 # here 185339 is the PID from above output; keep the -9 as it is
Check @Andrew's answer to prevent this in future.
References: kill command, kill/pkill/killall, lsof
Namaste 🙏
Just in case above solutions didn't work:
Get the port your process is listening to:
$ ps ax | grep python
Kill the Process
$ kill PROCESS_NAME
I have a raspberry pi, and I am using python web server (using Flask). I have tried everything above, the only solution is to close the terminal(shell) and open it again. Or restart the raspberry pi, because nothing stops that webserver...
Generally speaking, there are 2 common causes for this:
TIME_WAIT state.From now on, assume the port is 8000.
There are different ways. Run one of the following 2, if it's nonempty then it's case 1, otherwise it's case 2.
lsof -i :8000fuser 8000/tcp (or fuser 8000 --namespace tcp)irdmi (or http-alt, etc.)?It just mean 8000 or 8080. Refer to https://serverfault.com/questions/321823/how-to-stop-irdmi-when-running-nginx#321825 .
From man services: "services is a plain ASCII file providing a mapping between human‐friendly textual names
for internet services, and their underlying assigned port numbers and protocol types."
There are different ways.
kill $(lsof -ti:8000) (source)fuser -k 8000:tcp (source)taskkill /F /PID <pid>.TIME_WAIT stateThere are different ways.
sudo ss --all sport = 8000 -K (source)killcx or cutter or restart network serviceTIME_WAIT stateThe following method will print both the listening socket and the possible TIME_WAIT connection.
netstat --all -n | grep :8000 (note -n is needed; --all prints both listening and non-listening socket; see also Command line for looking at specific port)ss --all sport = 8000.This only applies if you are encountering case 2, and the offending program (that previously used that port) is written by you.
Use SO_REUSEADDR option.
socketserver: set allow_reuse_address (documentation). https://mcmap.net/q/100934/-python-errno-98-address-already-in-useRefer to this answer for explanation why TIME_WAIT state exist.
In order to reproduce the problem, you need a client to connect to the server before killing the server.
See also How do SO_REUSEADDR and SO_REUSEPORT differ? .
TIME_WAITNot a recommended method.
This commonly happened use case for any developer.
It is better to have it as function in your local system. (So better to keep this script in one of the shell profile like ksh/zsh or bash profile based on the user preference)
function killport {
kill -9 `lsof -i tcp:"$1" | grep LISTEN | awk '{print $2}'`
}
Usage:
killport port_number
Example:
killport 8080
Adding to the answer from Michael Schmid Just had the problem, to allow rebinding of the port use needs to SUBCLASS the socket server like this:
from socketserver import TCPServer, BaseRequestHandler
from typing import Tuple, Callable
class MySockServer(TCPServer):
def __init__(self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseRequestHandler]):
self.allow_reuse_address = True
super().__init__(server_address, RequestHandlerClass)
because after instantiation, there is not point in changing that flag. Then use it instead of TCPServer or whatever you are using.
This error is returned because an attempt is made to rerun the project while it is still running. Stop and restart the project.
the only solution that worked for me was restarting my laptop.
© 2022 - 2024 — McMap. All rights reserved.
python -m SimpleHTTPServer 8081– OutlawTIME_WAITstate, refer to linux - Python [Errno 98] Address already in use - Stack Overflow . ■ See also unix - How to kill a process running on particular port in Linux? - Stack Overflow for more ways to kill process running on a port. – Mecke