def parse(server_spec: str) -> ServerSpec:
"""
Parses a server mode specification, e.g.:
- http://example.com/
- example.org
- example.com:443
Raises:
ValueError, if the server specification is invalid.
"""
m = server_spec_re.match(server_spec)
if not m:
raise ValueError(f"Invalid server specification: {server_spec}")
# defaulting to https/port 443 may annoy some folks, but it's secure-by-default.
scheme = m.group("scheme") or "https"
if scheme not in ("http", "https"):
raise ValueError(f"Invalid server scheme: {scheme}")
host = m.group("host")
# IPv6 brackets
if host.startswith("[") and host.endswith("]"):
host = host[1:-1]
if not check.is_valid_host(host.encode("idna")):
raise ValueError(f"Invalid hostname: {host}")
if m.group("port"):
port = int(m.group("port"))
else:
port = {"http": 80, "https": 443}[scheme]
if not check.is_valid_port(port):
raise ValueError(f"Invalid port: {port}")
return ServerSpec(scheme, (host, port))
def parse_authority(authority: AnyStr, check: bool) -> Tuple[str, Optional[int]]:
"""Extract the host and port from host header/authority information
Raises:
ValueError, if check is True and the authority information is malformed.
"""
try:
if isinstance(authority, bytes):
authority_str = authority.decode("idna")
else:
authority_str = authority
m = _authority_re.match(authority_str)
if not m:
raise ValueError
host = m.group("host")
if host.startswith("[") and host.endswith("]"):
host = host[1:-1]
if not is_valid_host(host):
raise ValueError
if m.group("port"):
port = int(m.group("port"))
if not is_valid_port(port):
raise ValueError
return host, port
else:
return host, None
except ValueError:
if check:
raise
else:
return always_str(authority, "utf-8", "surrogateescape"), None
def parse(url):
"""
URL-parsing function that checks that
- port is an integer 0-65535
- host is a valid IDNA-encoded hostname with no null-bytes
- path is valid ASCII
Args:
A URL (as bytes or as unicode)
Returns:
A (scheme, host, port, path) tuple
Raises:
ValueError, if the URL is not properly formatted.
"""
parsed = urllib.parse.urlparse(url)
if not parsed.hostname:
raise ValueError("No hostname given")
if isinstance(url, bytes):
host = parsed.hostname
# this should not raise a ValueError,
# but we try to be very forgiving here and accept just everything.
# decode_parse_result(parsed, "ascii")
else:
host = parsed.hostname.encode("idna")
parsed = encode_parse_result(parsed, "ascii")
port = parsed.port
if not port:
port = 443 if parsed.scheme == b"https" else 80
full_path = urllib.parse.urlunparse(
(b"", b"", parsed.path, parsed.params, parsed.query, parsed.fragment)
)
if not full_path.startswith(b"/"):
full_path = b"/" + full_path
if not check.is_valid_host(host):
raise ValueError("Invalid Host")
if not check.is_valid_port(port):
raise ValueError("Invalid Port")
return parsed.scheme, host, port, full_path
def parse(url):
"""
URL-parsing function that checks that
- port is an integer 0-65535
- host is a valid IDNA-encoded hostname with no null-bytes
- path is valid ASCII
Args:
A URL (as bytes or as unicode)
Returns:
A (scheme, host, port, path) tuple
Raises:
ValueError, if the URL is not properly formatted.
"""
parsed = urllib.parse.urlparse(url)
if not parsed.hostname:
raise ValueError("No hostname given")
if isinstance(url, bytes):
host = parsed.hostname
# this should not raise a ValueError,
# but we try to be very forgiving here and accept just everything.
# decode_parse_result(parsed, "ascii")
else:
host = parsed.hostname.encode("idna")
parsed = encode_parse_result(parsed, "ascii")
port = parsed.port
if not port:
port = 443 if parsed.scheme == b"https" else 80
full_path = urllib.parse.urlunparse(
(b"", b"", parsed.path, parsed.params, parsed.query, parsed.fragment)
)
if not full_path.startswith(b"/"):
full_path = b"/" + full_path
if not check.is_valid_host(host):
raise ValueError("Invalid Host")
if not check.is_valid_port(port):
raise ValueError("Invalid Port")
return parsed.scheme, host, port, full_path
def _parse_authority_form(hostport):
"""
Returns (host, port) if hostport is a valid authority-form host specification.
http://tools.ietf.org/html/draft-luotonen-web-proxy-tunneling-01 section 3.1
Raises:
ValueError, if the input is malformed
"""
try:
host, port = hostport.split(b":")
port = int(port)
if not check.is_valid_host(host) or not check.is_valid_port(port):
raise ValueError()
except ValueError:
raise exceptions.HttpSyntaxException("Invalid host specification: {}".format(hostport))
return host, port
def _parse_authority_form(hostport):
"""
Returns (host, port) if hostport is a valid authority-form host specification.
http://tools.ietf.org/html/draft-luotonen-web-proxy-tunneling-01 section 3.1
Raises:
ValueError, if the input is malformed
"""
try:
host, port = hostport.split(b":")
port = int(port)
if not check.is_valid_host(host) or not check.is_valid_port(port):
raise ValueError()
except ValueError:
raise exceptions.HttpSyntaxException(
"Invalid host specification: {}".format(hostport))
return host, port
def parse(server_spec: str) -> ServerSpec:
"""
Parses a server mode specification, e.g.:
- http://example.com/
- example.org
- example.com:443
Raises:
ValueError, if the server specification is invalid.
"""
m = server_spec_re.match(server_spec)
if not m:
raise ValueError(f"Invalid server specification: {server_spec}")
if m.group("scheme"):
scheme = m.group("scheme")
else:
scheme = "https" if m.group("port") in ("443", None) else "http"
if scheme not in ("http", "https"):
raise ValueError(f"Invalid server scheme: {scheme}")
host = m.group("host")
# IPv6 brackets
if host.startswith("[") and host.endswith("]"):
host = host[1:-1]
if not check.is_valid_host(host):
raise ValueError(f"Invalid hostname: {host}")
if m.group("port"):
port = int(m.group("port"))
else:
port = {
"http": 80,
"https": 443
}[scheme]
if not check.is_valid_port(port):
raise ValueError(f"Invalid port: {port}")
return ServerSpec(scheme, (host, port)) # type: ignore
def parse(server_spec: str) -> ServerSpec:
"""
Parses a server mode specification, e.g.:
- http://example.com/
- example.org
- example.com:443
Raises:
ValueError, if the server specification is invalid.
"""
m = server_spec_re.match(server_spec)
if not m:
raise ValueError("Invalid server specification: {}".format(server_spec))
# defaulting to https/port 443 may annoy some folks, but it's secure-by-default.
scheme = m.group("scheme") or "https"
if scheme not in ("http", "https"):
raise ValueError("Invalid server scheme: {}".format(scheme))
host = m.group("host")
# IPv6 brackets
if host.startswith("[") and host.endswith("]"):
host = host[1:-1]
if not check.is_valid_host(host.encode("idna")):
raise ValueError("Invalid hostname: {}".format(host))
if m.group("port"):
port = int(m.group("port"))
else:
port = {
"http": 80,
"https": 443
}[scheme]
if not check.is_valid_port(port):
raise ValueError("Invalid port: {}".format(port))
return ServerSpec(scheme, (host, port))
def _load_webpack_config() -> WebpackConfig:
log.debug(f'Getting config from webpack config using {GET_CONFIG_SCRIPT_PATH}.')
proc = run(['node', GET_CONFIG_SCRIPT_PATH], stdout=PIPE)
log.debug(f'Output: {proc.stdout}.')
config = loads(proc.stdout)
dev_server_host = config.get('dev_server_host', None)
assert isinstance(dev_server_host, str), f'dev_server_host must be a string, got {dev_server_host}.'
assert is_valid_host(dev_server_host), f'dev_server_host must be a valid IP or hostname, got {dev_server_host}.'
if dev_server_host == '0.0.0.0':
dev_server_host = '127.0.0.1'
log.debug(f'Local dev server will use host {dev_server_host}.')
dev_server_port = config.get('dev_server_port', None)
if isinstance(dev_server_port, str):
try:
dev_server_port = int(dev_server_port, 10)
except ValueError:
pass
assert isinstance(dev_server_port, int), f'dev_server_port must be a number, got {dev_server_port}.'
assert is_valid_port(dev_server_port), f'dev_server_port must be a valid port, got {dev_server_port}.'
log.debug(f'Local dev server will use port {dev_server_port}.')
build_dir = config.get('build_dir', None)
assert isinstance(build_dir, str), f'build_dir must be a string, got {build_dir}.'
build_dir = Path(build_dir)
log.debug(f'Local builds will be in {build_dir}.')
upstream_url = config.get('upstream_url', None)
assert isinstance(upstream_url, str), f'upstream_url must be a string, got {upstream_url}.'
try:
parse_url(upstream_url)
except ValueError as e:
assert False, f'upstream_url must be a valid URL, got {upstream_url} ({e}).'
log.debug(f'Upstream builds will be at {upstream_url}.')
return WebpackConfig(dev_server_host, dev_server_port, build_dir, upstream_url)
