def available_ports(
low: int = 1024,
high: int = 65535,
exclude_ranges: Optional[List[Tuple[int, int]]] = None,
) -> Set[int]:
"""
Returns a set of possible ports (excluding system,
ephemeral and well-known ports).
Pass ``high`` and/or ``low`` to limit the port range.
"""
if exclude_ranges is None:
exclude_ranges = []
available = utils.ranges_to_set(UNASSIGNED_RANGES)
exclude = utils.ranges_to_set(
# Motivation behind excluding ephemeral port ranges:
# let's say you decided to use an ephemeral local port
# as a persistent port, and "reserve" it to your software.
# OS won't know about it, and still can try to use this port.
# This is not a problem if your service is always running and occupying
# this port (OS would pick next one). But if the service is temporarily
# not using the port (because of restart of other reason),
# OS might reuse the same port,
# which might prevent the service from starting.
ephemeral.port_ranges() + exclude_ranges +
[SYSTEM_PORT_RANGE, (SYSTEM_PORT_RANGE[1], low), (high, 65536)])
return available.difference(exclude)
def available_ports(low=1024, high=65535, exclude_ranges=None):
"""
Returns a set of possible ports (excluding system,
ephemeral and well-known ports).
Pass ``high`` and/or ``low`` to limit the port range.
"""
if exclude_ranges is None:
exclude_ranges = []
available = utils.ranges_to_set(UNASSIGNED_RANGES)
exclude = utils.ranges_to_set(
ephemeral.port_ranges() + exclude_ranges +
[SYSTEM_PORT_RANGE, (SYSTEM_PORT_RANGE[1], low), (high, 65536)])
return available.difference(exclude)
def available_ports(low=1024, high=65535, exclude_ranges=None):
"""
Returns a set of possible ports (excluding system,
ephemeral and well-known ports).
Pass ``high`` and/or ``low`` to limit the port range.
"""
if exclude_ranges is None:
exclude_ranges = []
available = utils.ranges_to_set(UNASSIGNED_RANGES)
exclude = utils.ranges_to_set(
ephemeral.port_ranges() + exclude_ranges +
[
SYSTEM_PORT_RANGE,
(SYSTEM_PORT_RANGE[1], low),
(high, 65536)
]
)
return available.difference(exclude)
def get_port(
ports: Union[None, str, int, Tuple[int, int], Set[int], List[str],
List[int], List[Tuple[int, int]], List[Set[int]],
List[Union[Set[int], Tuple[int, int]]],
List[Union[str, int, Tuple[int, int], Set[int]]], ]
) -> Optional[int]:
"""
Retuns a random available port. If there's only one port passed
(e.g. 5000 or '5000') function does not check if port is available.
If there's -1 passed as an argument, function returns None.
:param str|int|tuple|set|list ports:
exact port (e.g. '8000', 8000)
randomly selected port (None) - any random available port
[(2000,3000)] or (2000,3000) - random available port from a given range
[{4002,4003}] or {4002,4003} - random of 4002 or 4003 ports
[(2000,3000), {4002,4003}] -random of given range and set
:returns: a random free port
:raises: ValueError
"""
if ports == -1:
return None
elif not ports:
return select_random(None)
try:
return int(ports) # type: ignore[arg-type]
except TypeError:
pass
ports_set: Set[int] = set()
try:
if not isinstance(ports, list):
ports = [ports]
ranges: Set[int] = utils.ranges_to_set(
filter_by_type(ports, tuple) # type: ignore[arg-type]
)
nums: Set[int] = set(filter_by_type(ports, int))
sets: Set[int] = set(
chain(*filter_by_type(
ports,
(set, frozenset) # type: ignore[arg-type]
)))
ports_set = ports_set.union(ranges, sets, nums)
except ValueError:
raise PortForException(
"Unknown format of ports: %s.\n"
'You should provide a ports range "[(4000,5000)]"'
'or "(4000,5000)" or a comma-separated ports set'
'"[{4000,5000,6000}]" or list of ints "[400,5000,6000,8000]"'
'or all of them "[(20000, 30000), {48889, 50121}, 4000, 4004]"' %
(ports, ))
return select_random(ports_set)
def test_good_port_ranges():
ranges = [
(10, 15), # too short
(100, 200), # good
(220, 245), # a bit short
(300, 330), # good
(440, 495), # also good
]
ports = ranges_to_set(ranges)
good_ranges = port_for.good_port_ranges(ports, 20, 3)
assert good_ranges == [(103, 197), (443, 492), (303, 327)], good_ranges
def test_good_port_ranges():
ranges = [
(10, 15), # too short
(100, 200), # good
(220, 245), # a bit short
(300, 330), # good
(440, 495), # also good
]
ports = ranges_to_set(ranges)
good_ranges = port_for.good_port_ranges(ports, 20, 3)
assert good_ranges == [(103, 197), (443, 492), (303, 327)], good_ranges
def _unassigned_ports():
""" Returns a set of all unassigned ports (according to IANA and Wikipedia) """
free_ports = ranges_to_set(_parse_ranges(_iana_unassigned_port_ranges()))
known_ports = ranges_to_set(_wikipedia_known_port_ranges())
return free_ports.difference(known_ports)
def available_good_ports(min_range_len=20, border=3):
return utils.ranges_to_set(
good_port_ranges(min_range_len=min_range_len, border=border)
)
def available_good_ports(min_range_len=20, border=3):
return utils.ranges_to_set(
good_port_ranges(min_range_len=min_range_len, border=border))
def _unassigned_ports():
"""Return a set of all unassigned ports (according to IANA and Wikipedia)"""
free_ports = ranges_to_set(_parse_ranges(_iana_unassigned_port_ranges()))
known_ports = ranges_to_set(_wikipedia_known_port_ranges())
return free_ports.difference(known_ports)
def available_good_ports(min_range_len: int = 20, border: int = 3) -> Set[int]:
return utils.ranges_to_set(
good_port_ranges(min_range_len=min_range_len, border=border))
