wisp-python 0.5.1__tar.gz → 0.6.0__tar.gz

{wisp_python-0.5.1/src/wisp_python.egg-info → wisp_python-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wisp-python
-Version: 0.5.1
+Version: 0.6.0
 Summary: An implementation of a Wisp proxy server in Python
 Author: ading2210
 Project-URL: Homepage, https://github.com/MercuryWorkshop/wisp-server-python
@@ -13,7 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: websockets
 Requires-Dist: asyncudp
-Requires-Dist: uvloop
+Requires-Dist: uvloop; sys_platform != "win32" and sys_platform != "cygwin"
 
 # Python Wisp Server
 
@@ -35,7 +35,13 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-To start the server, run `python3 -m wisp.server`. The program accepts the following arguments:
+There are two different versions of the server:
+- Async (`wisp.server`) - The default, based on asyncio. It is more stable, but slower.
+- Threading (`wisp.server.threading`) - An faster alternative based on threading. It is about 40-80% faster, but possibly unstable. If you use Python's experimental [free threading](https://docs.python.org/3/howto/free-threading-python.html) builds, performance will scale linearly with your available CPU cores.
+
+For the best performance use [CPython](https://github.com/python/cpython) 3.11 or newer. [PyPy](https://github.com/pypy/pypy) is not recommended as it is a lot slower than CPython here. 
+
+To start the server, run `python3 -m wisp.server` (or `python3 -m wisp.server.threading`). The program accepts the following arguments:
 ```
 usage: wisp-server-python [-h] [--host HOST] [--port PORT] [--static STATIC] [--limits] [--bandwidth BANDWIDTH] [--connections CONNECTIONS] [--window WINDOW] [--allow-loopback] [--allow-private]
                           [--log-level LOG_LEVEL]
@@ -64,6 +70,7 @@ options:
 - JSON based config files
 - ~~UDP support~~
 - ~~Ability to block local addresses~~
+- Wisp v2 support
 
 ## Copyright:
 This repository is licensed under the GNU AGPL v3.

{wisp_python-0.5.1 → wisp_python-0.6.0}/README.md

@@ -18,7 +18,13 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-To start the server, run `python3 -m wisp.server`. The program accepts the following arguments:
+There are two different versions of the server:
+- Async (`wisp.server`) - The default, based on asyncio. It is more stable, but slower.
+- Threading (`wisp.server.threading`) - An faster alternative based on threading. It is about 40-80% faster, but possibly unstable. If you use Python's experimental [free threading](https://docs.python.org/3/howto/free-threading-python.html) builds, performance will scale linearly with your available CPU cores.
+
+For the best performance use [CPython](https://github.com/python/cpython) 3.11 or newer. [PyPy](https://github.com/pypy/pypy) is not recommended as it is a lot slower than CPython here. 
+
+To start the server, run `python3 -m wisp.server` (or `python3 -m wisp.server.threading`). The program accepts the following arguments:
 ```
 usage: wisp-server-python [-h] [--host HOST] [--port PORT] [--static STATIC] [--limits] [--bandwidth BANDWIDTH] [--connections CONNECTIONS] [--window WINDOW] [--allow-loopback] [--allow-private]
                           [--log-level LOG_LEVEL]
@@ -47,6 +53,7 @@ options:
 - JSON based config files
 - ~~UDP support~~
 - ~~Ability to block local addresses~~
+- Wisp v2 support
 
 ## Copyright:
 This repository is licensed under the GNU AGPL v3.

{wisp_python-0.5.1 → wisp_python-0.6.0}/pyproject.toml

@@ -6,12 +6,12 @@ requires = ["setuptools>=61.0", "toml"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
-packages = ["wisp", "wisp.server"]
+packages = ["wisp", "wisp.server", "wisp.server.threading"]
 package-dir = {"" = "src"}
 
 [project]
 name = "wisp-python"
-version = "0.5.1"
+version = "0.6.0"
 authors = [
   {name="ading2210"},
 ]
@@ -26,7 +26,7 @@ classifiers = [
 dependencies = [
   "websockets",
   "asyncudp",
-  "uvloop"
+  "uvloop; sys_platform != 'win32' and sys_platform != 'cygwin'"
 ]
 
 [project.urls]

wisp_python-0.6.0/src/wisp/server/__main__.py

@@ -0,0 +1,26 @@
+import argparse
+import asyncio
+import sys
+
+try:
+  import uvloop
+  use_uvloop = True
+except ImportError:
+  use_uvloop = False
+
+from wisp.server import http 
+from wisp.server import common 
+
+if __name__ == "__main__":
+  args = common.setup_main()
+
+  try:
+    if use_uvloop:
+      uvloop.run(http.main(args))
+    else:
+      #uvloop doesn't support windows at all so we don't need to print the error
+      if not sys.platform in ("win32", "cygwin"):
+        logging.error("Importing uvloop failed. Falling back to asyncio, which is slower.")
+      asyncio.run(http.main(args))
+  except KeyboardInterrupt:
+    pass

wisp_python-0.5.1/src/wisp/server/__main__.py → wisp_python-0.6.0/src/wisp/server/common.py

@@ -1,17 +1,9 @@
 import argparse
-import asyncio
 import logging
 
-try:
-  import uvloop
-  use_uvloop = True
-except ImportError:
-  use_uvloop = False
-
 import wisp
-import wisp.server.http
 
-if __name__ == "__main__":
+def setup_main():
   parser = argparse.ArgumentParser(
     prog="wisp-server-python",
     description=f"A Wisp server implementation, written in Python (v{wisp.version})"
@@ -35,8 +27,4 @@ if __name__ == "__main__":
     datefmt="%Y/%m/%d - %H:%M:%S"
   )
 
-  if use_uvloop:
-    uvloop.run(wisp.server.http.main(args))
-  else:
-    logging.error("Importing uvloop failed. Falling back to asyncio, which is slower.")
-    asyncio.run(wisp.server.http.main(args))
+  return args

{wisp_python-0.5.1 → wisp_python-0.6.0}/src/wisp/server/connection.py

@@ -46,7 +46,7 @@ class WSProxyConnection:
       await ratelimit.limit_client_bandwidth(self.client_ip, len(data), "ws")
       await self.conn.send(data)
     
-    self.tcp_writer.close()
+    self.conn.close()
   
   async def handle_tcp(self):
     while True:

{wisp_python-0.5.1 → wisp_python-0.6.0}/src/wisp/server/http.py

@@ -61,7 +61,7 @@ async def static_handler(path, request_headers):
 
 async def main(args):
   global static_path
-  logging.info(f"running wisp-server-python v{wisp.version}")
+  logging.info(f"running wisp-server-python v{wisp.version} (async)")
 
   if args.static:
     static_path = pathlib.Path(args.static).resolve()

{wisp_python-0.5.1 → wisp_python-0.6.0}/src/wisp/server/ratelimit.py

@@ -52,3 +52,15 @@ async def reset_limits_timer():
   while True:
     active_clients = {}
     await asyncio.sleep(window_size)
+
+def limit_client_bandwidth_sync(client_ip, length, attr):
+  if not enabled: return
+  inc_client_attr(client_ip, attr, length)
+  while calculate_client_bandwidth(client_ip, attr) > bandwidth_limit:
+    time.sleep(0.01)
+
+def reset_limits_timer_sync():
+  global active_clients
+  while True:
+    active_clients = {}
+    time.sleep(window_size)

wisp_python-0.6.0/src/wisp/server/threading/__init__.py

@@ -0,0 +1,2 @@
+from wisp.server.threading.connection import WispConnection
+from wisp.server.threading.connection import WSProxyConnection

wisp_python-0.6.0/src/wisp/server/threading/__main__.py

@@ -0,0 +1,6 @@
+from wisp.server.threading import http 
+from wisp.server import common 
+
+if __name__ == "__main__":
+  args = common.setup_main()
+  http.main(args)

wisp_python-0.6.0/src/wisp/server/threading/connection.py

@@ -0,0 +1,216 @@
+import struct
+import os
+import logging
+import queue
+import threading
+
+from websockets.exceptions import ConnectionClosed
+
+from wisp.server import ratelimit
+from wisp.server.threading import netsync
+
+queue_size = 128
+static_path = None
+
+#wisp packet format definitions
+#see https://docs.python.org/3/library/struct.html for what these characters mean
+packet_format = "<BI"
+connect_format = "<BH"
+continue_format = "<I"
+close_format = "<B"
+
+class WSProxyConnection:
+  def __init__(self, ws, path, client_ip):
+    self.ws = ws
+    self.path = path
+    self.client_ip = client_ip
+
+  def setup_connection(self):
+    addr_str = self.path.split("/")[-1]
+    self.tcp_host, self.tcp_port = addr_str.split(":")
+    self.tcp_port = int(self.tcp_port)
+
+    try:
+      self.conn = netsync.TCPConnection(self.tcp_host, self.tcp_port)
+      self.conn.connect()
+    except Exception as e:
+      logging.info(f"Creating a WSProxy stream to {self.tcp_host}:{self.tcp_port} failed: {e}")
+      self.ws.close()
+
+  def handle_ws(self):
+    while True:
+      try:
+        data = self.ws.recv()
+      except ConnectionClosed:
+        break
+
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "ws")
+      self.conn.send(data)
+    
+    self.conn.close()
+  
+  def handle_tcp(self):
+    while True:
+      data = self.conn.recv()
+      if len(data) == 0:
+        break #socket closed
+
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "tcp")
+      self.ws.send(data)
+    
+    self.ws.close()
+
+class WispConnection:
+  def __init__(self, ws, path, client_ip, id=None):
+    self.ws = ws
+    self.path = path
+    self.active_streams = {}
+    self.client_ip = client_ip
+    self.id = id
+  
+  #send the initial CONTINUE packet
+  def setup(self):
+    continue_payload = struct.pack(continue_format, queue_size)
+    continue_packet = struct.pack(packet_format, 0x03, 0) + continue_payload
+    self.ws.send(continue_packet)
+  
+  def close(self):
+    #close all active streams when the websocket disconnects
+    for stream_id in list(self.active_streams.keys()):
+      self.close_stream(stream_id)
+    self.ws.close()
+
+  def new_stream(self, stream_id, payload):
+    stream_type, destination_port = struct.unpack(connect_format, payload[:3])
+    hostname = bytes(payload[3:]).decode()
+    logging.debug(f"({self.id}) Creating a new stream to {hostname}:{destination_port}")
+
+    #rate limited
+    stream_count = ratelimit.get_client_attr(self.client_ip, "streams")
+    if ratelimit.enabled and stream_count > ratelimit.connections_limit:
+      self.send_close_packet(stream_id, 0x49)
+      self.close_stream(stream_id)
+      return
+    
+    #info looks valid - try to open the connection now
+    try:
+      if stream_type == 0x01:
+        connection = netsync.TCPConnection(hostname, destination_port)
+      elif stream_type == 0x02: 
+        connection = netsync.UDPConnection(hostname, destination_port)
+      else:
+        raise Exception("Invalid stream type.")
+      self.active_streams[stream_id]["conn"] = connection
+      connection.connect()
+        
+    except Exception as e:
+      logging.warn(f"({self.id}) Creating a new stream to {hostname}:{destination_port} failed: {e}")
+      self.send_close_packet(stream_id, 0x42)
+      self.close_stream(stream_id)
+      return
+    
+    self.active_streams[stream_id]["type"] = stream_type
+    threading.Thread(target=self.stream_ws_to_tcp, args=(stream_id,), daemon=True).start()
+    threading.Thread(target=self.stream_tcp_to_ws, args=(stream_id,), daemon=True).start()
+    ratelimit.inc_client_attr(self.client_ip, "streams")
+  
+  def stream_ws_to_tcp(self, stream_id):
+    while True: 
+      stream = self.active_streams[stream_id]
+      data = stream["queue"].get()
+      if data is None:
+        break
+      try:
+        stream["conn"].send(data)
+      except:
+        break
+
+      #send a CONTINUE packet periodically
+      stream["packets_sent"] += 1
+      if stream["packets_sent"] % queue_size / 4 == 0:
+        buffer_remaining = stream["queue"].maxsize - stream["queue"].qsize()
+        continue_payload = struct.pack(continue_format, buffer_remaining)
+        continue_packet = struct.pack(packet_format, 0x03, stream_id) + continue_payload
+        self.ws.send(continue_packet)
+  
+  def stream_tcp_to_ws(self, stream_id):
+    while True:
+      stream = self.active_streams[stream_id]
+      try:
+        data = stream["conn"].recv()
+      except Exception as e:
+        logging.warn(f"({self.id}) Receiving data from stream failed: {e}")
+        self.send_close_packet(stream_id, 0x03)
+        self.close_stream(stream_id)
+        return
+        
+      if len(data) == 0: #connection closed
+        break
+      data_header = struct.pack(packet_format, 0x02, stream_id)
+
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data_header)+len(data), "tcp")
+      self.ws.send(data_header + data)
+
+    self.send_close_packet(stream_id, 0x02)
+    self.close_stream(stream_id)
+  
+  def send_close_packet(self, stream_id, reason):
+    if not stream_id in self.active_streams:
+      return
+    close_payload = struct.pack(close_format, reason)
+    close_packet = struct.pack(packet_format, 0x04, stream_id) + close_payload
+    self.ws.send(close_packet)
+  
+  def close_stream(self, stream_id):
+    if not stream_id in self.active_streams:
+      return #stream already closed
+    stream = self.active_streams[stream_id]
+    if stream["conn"]:
+      stream["conn"].close()
+
+    #empty the queue and kill it
+    while not stream["queue"].empty():
+      stream["queue"].get()
+    stream["queue"].put(None)
+    del self.active_streams[stream_id]
+  
+  def handle_ws(self):
+    while True:
+      try:
+        data = self.ws.recv()
+      except ConnectionClosed:
+        break
+      except Exception as e:
+        logging.warn(f"({self.id}) Receiving data from websocket failed: {e}")
+        break
+
+      if not isinstance(data, bytes): 
+        continue #ignore non binary frames
+      
+      #implement bandwidth limits
+      ratelimit.limit_client_bandwidth_sync(self.client_ip, len(data), "ws")
+      
+      #get basic packet info
+      payload = memoryview(data)[5:]
+      packet_type, stream_id = struct.unpack(packet_format, data[:5])
+
+      if packet_type == 0x01: #CONNECT packet
+        self.active_streams[stream_id] = {
+          "conn": None,
+          "type": None,
+          "queue": queue.Queue(queue_size),
+          "packets_sent": 0
+        }
+        threading.Thread(target=self.new_stream, args=(stream_id, payload), daemon=True).start()
+      
+      elif packet_type == 0x02: #DATA packet
+        stream = self.active_streams.get(stream_id)
+        if not stream:
+          continue
+        stream["queue"].put(payload)
+      
+      elif packet_type == 0x04: #CLOSE packet
+        reason = struct.unpack(close_format, payload)[0]
+        self.close_stream(stream_id)
+
+    self.close()

wisp_python-0.6.0/src/wisp/server/threading/http.py

@@ -0,0 +1,104 @@
+import threading
+import multiprocessing
+import pathlib
+import mimetypes
+import logging
+import random
+import sys
+
+from websockets.sync.server import serve
+from websockets.http11 import Response, Headers
+
+import wisp
+from wisp.server import ratelimit
+from wisp.server import net
+from wisp.server.threading import connection
+
+static_path = None
+connections = {}
+
+def connection_handler(websocket):
+  path = websocket.request.path
+  client_ip = websocket.remote_address[0]
+  if client_ip == "127.0.0.1" and "X-Real-IP" in websocket.request.headers:
+    client_ip = websocket.request.headers["X-Real-IP"]
+  origin = websocket.request.headers.get("Origin")
+
+  conn_id = "".join(random.choices("1234567890abcdef", k=8))
+  logging.info(f"({conn_id}) incoming connection on {path} from {client_ip} (origin: {origin})")
+  ratelimit.inc_client_attr(client_ip, "streams")
+
+  if path.endswith("/"):
+    wisp_conn = connection.WispConnection(websocket, path, client_ip, conn_id)
+    connections[websocket] = wisp_conn
+    wisp_conn.setup()
+    wisp_conn.handle_ws()
+    del connections[websocket]
+
+  else:
+    stream_count = ratelimit.get_client_attr(client_ip, "streams")
+    if ratelimit.enabled and stream_count > ratelimit.connections_limit:
+      return
+    wsproxy_conn = connection.WSProxyConnection(websocket, path, client_ip)
+    wsproxy_conn.setup_connection()
+    t1 = threading.Thread(target=wsproxy_conn.handle_ws, daemon=True)
+    t2 = threading.Thread(target=wsproxy_conn.handle_tcp, daemon=True)
+    t1.start(); t2.start()
+    t1.join(); t2.join()
+
+def static_handler(connection, request):
+  if "Upgrade" in request.headers:
+    return
+    
+  response_headers = Headers()
+  response_headers["Server"] = f"wisp-server-python v{wisp.version}"
+  if static_path is None:
+    return Response(204, None, response_headers, body=b"")
+
+  target_path = static_path / request.path[1:]
+
+  if target_path.is_dir():
+    target_path = target_path / "index.html"
+  if not target_path.is_relative_to(static_path):
+    return Response(403, None, response_headers, body="403 forbidden".encode())
+  if not target_path.exists():
+    return Response(404, None, response_headers, body="404 not found".encode())
+  
+  mimetype = mimetypes.guess_type(target_path.name)[0]
+  response_headers["Content-Type"] = mimetype
+
+  static_data = target_path.read_bytes()
+  return Response(200, None, response_headers, body=static_data)
+
+def main(args):
+  global static_path
+  logging.info(f"running wisp-server-python v{wisp.version} (threading)")
+
+  if args.static:
+    static_path = pathlib.Path(args.static).resolve()
+    mimetypes.init()
+    logging.info(f"serving static files from {static_path}")
+  
+  if args.limits:
+    logging.info("enabled rate limits")
+    ratelimit.enabled = True
+    ratelimit.connections_limit = int(args.connections)
+    ratelimit.bandwidth_limit = float(args.bandwidth)
+    ratelimit.window_size = float(args.window)
+
+  net.block_loopback = not args.allow_loopback
+  net.block_private = not args.allow_private
+      
+  threading.Thread(target=ratelimit.reset_limits_timer_sync, daemon=True).start()
+  logging.info(f"listening on {args.host}:{args.port}")
+
+  ws_logger = logging.getLogger("websockets")
+  ws_logger.setLevel(logging.WARN)
+
+  with serve(connection_handler, args.host, int(args.port), process_request=static_handler, compression=None) as server:
+    try:
+      server.serve_forever()
+    except KeyboardInterrupt:
+      for connection in connections.values():
+        connection.close()
+      server.shutdown()

wisp_python-0.6.0/src/wisp/server/threading/netsync.py

@@ -0,0 +1,58 @@
+import socket
+import ipaddress
+
+#various network utilities and wrappers - synchronous version
+
+from wisp.server import net
+
+def validate_hostname(host, port, stream_type):
+  addr_str = net.get_ip(host, port, stream_type)
+  net.validate_ip(addr_str)
+  return addr_str
+
+class TCPConnection:
+  def __init__(self, hostname, port):
+    self.hostname = hostname
+    self.port = port
+    self.socket = None
+  
+  def connect(self):
+    addr_str = validate_hostname(self.hostname, self.port, 0x01)
+    self.socket = socket.socket()
+    self.socket.connect((self.hostname, self.port))
+  
+  def recv(self):
+    return self.socket.recv(net.tcp_size)
+  
+  def send(self, data):
+    self.socket.send(data)
+  
+  def close(self):
+    if self.socket is None:
+      return
+    self.socket.shutdown(socket.SHUT_RDWR)
+    self.socket.close()
+
+class UDPConnection:
+  def __init__(self, hostname, port):
+    self.hostname = hostname
+    self.port = port
+    self.socket = None
+  
+  def connect(self):
+    addr_str = validate_hostname(self.hostname, self.port, 0x02)
+    self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    self.socket.bind((self.hostname, self.port))
+  
+  def recv(self):
+    data, addr = self.socket.recvfrom(net.tcp_size)
+    return data
+  
+  def send(self, data):
+    self.socket.sendto(data, (self.hostname, self.port))
+  
+  def close(self):
+    if self.socket is None:
+      return
+    self.socket.shutdown(socket.SHUT_RDWR)
+    self.socket.close()

{wisp_python-0.5.1 → wisp_python-0.6.0/src/wisp_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wisp-python
-Version: 0.5.1
+Version: 0.6.0
 Summary: An implementation of a Wisp proxy server in Python
 Author: ading2210
 Project-URL: Homepage, https://github.com/MercuryWorkshop/wisp-server-python
@@ -13,7 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: websockets
 Requires-Dist: asyncudp
-Requires-Dist: uvloop
+Requires-Dist: uvloop; sys_platform != "win32" and sys_platform != "cygwin"
 
 # Python Wisp Server
 
@@ -35,7 +35,13 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-To start the server, run `python3 -m wisp.server`. The program accepts the following arguments:
+There are two different versions of the server:
+- Async (`wisp.server`) - The default, based on asyncio. It is more stable, but slower.
+- Threading (`wisp.server.threading`) - An faster alternative based on threading. It is about 40-80% faster, but possibly unstable. If you use Python's experimental [free threading](https://docs.python.org/3/howto/free-threading-python.html) builds, performance will scale linearly with your available CPU cores.
+
+For the best performance use [CPython](https://github.com/python/cpython) 3.11 or newer. [PyPy](https://github.com/pypy/pypy) is not recommended as it is a lot slower than CPython here. 
+
+To start the server, run `python3 -m wisp.server` (or `python3 -m wisp.server.threading`). The program accepts the following arguments:
 ```
 usage: wisp-server-python [-h] [--host HOST] [--port PORT] [--static STATIC] [--limits] [--bandwidth BANDWIDTH] [--connections CONNECTIONS] [--window WINDOW] [--allow-loopback] [--allow-private]
                           [--log-level LOG_LEVEL]
@@ -64,6 +70,7 @@ options:
 - JSON based config files
 - ~~UDP support~~
 - ~~Ability to block local addresses~~
+- Wisp v2 support
 
 ## Copyright:
 This repository is licensed under the GNU AGPL v3.

{wisp_python-0.5.1 → wisp_python-0.6.0}/src/wisp_python.egg-info/SOURCES.txt

@@ -5,10 +5,16 @@ src/wisp/__init__.py
 src/wisp/util.py
 src/wisp/server/__init__.py
 src/wisp/server/__main__.py
+src/wisp/server/common.py
 src/wisp/server/connection.py
 src/wisp/server/http.py
 src/wisp/server/net.py
 src/wisp/server/ratelimit.py
+src/wisp/server/threading/__init__.py
+src/wisp/server/threading/__main__.py
+src/wisp/server/threading/connection.py
+src/wisp/server/threading/http.py
+src/wisp/server/threading/netsync.py
 src/wisp_python.egg-info/PKG-INFO
 src/wisp_python.egg-info/SOURCES.txt
 src/wisp_python.egg-info/dependency_links.txt

wisp_python-0.6.0/src/wisp_python.egg-info/requires.txt

@@ -0,0 +1,5 @@
+websockets
+asyncudp
+
+[:sys_platform != "win32" and sys_platform != "cygwin"]
+uvloop

wisp_python-0.5.1/src/wisp_python.egg-info/requires.txt

@@ -1,3 +0,0 @@
-websockets
-asyncudp
-uvloop