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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: wisp-python
-Version: 0.6.0
+Version: 0.7.0
 Summary: An implementation of a Wisp proxy server in Python
 Author: ading2210
 Project-URL: Homepage, https://github.com/MercuryWorkshop/wisp-server-python
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: websockets
 Requires-Dist: asyncudp
 Requires-Dist: uvloop; sys_platform != "win32" and sys_platform != "cygwin"
+Dynamic: license-file
 
 # Python Wisp Server
 
@@ -35,18 +36,16 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-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:
+There used to be an experimental "threading" variant of the server. This has been removed due to its instability and difficulty of maintenance.
+
+To start the server, run `python3 -m wisp.server`. 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]
+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] [--threads THREADS]
 
-A Wisp server implementation, written in Python (v0.5.0)
+A Wisp server implementation, written in Python (v0.7.0)
 
 options:
   -h, --help            show this help message and exit
@@ -63,6 +62,7 @@ options:
   --allow-private       Allow connections to private IP addresses.
   --log-level LOG_LEVEL
                         The log level (either debug, info, warning, error, or critical).
+  --threads THREADS     The number of threads to run the server on. By default it uses all CPU cores.
 ```
 
 ## Roadmap:

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

@@ -18,18 +18,16 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-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:
+There used to be an experimental "threading" variant of the server. This has been removed due to its instability and difficulty of maintenance.
+
+To start the server, run `python3 -m wisp.server`. 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]
+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] [--threads THREADS]
 
-A Wisp server implementation, written in Python (v0.5.0)
+A Wisp server implementation, written in Python (v0.7.0)
 
 options:
   -h, --help            show this help message and exit
@@ -46,6 +44,7 @@ options:
   --allow-private       Allow connections to private IP addresses.
   --log-level LOG_LEVEL
                         The log level (either debug, info, warning, error, or critical).
+  --threads THREADS     The number of threads to run the server on. By default it uses all CPU cores.
 ```
 
 ## Roadmap:

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

@@ -6,12 +6,12 @@ requires = ["setuptools>=61.0", "toml"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
-packages = ["wisp", "wisp.server", "wisp.server.threading"]
+packages = ["wisp", "wisp.server"]
 package-dir = {"" = "src"}
 
 [project]
 name = "wisp-python"
-version = "0.6.0"
+version = "0.7.0"
 authors = [
   {name="ading2210"},
 ]

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

@@ -0,0 +1,4 @@
+from wisp.server import cli
+
+if __name__ == "__main__":
+  cli.main()

wisp_python-0.7.0/src/wisp/server/cli.py

@@ -0,0 +1,86 @@
+import asyncio
+import argparse
+import pathlib
+import sys
+import logging
+import multiprocessing
+
+try:
+  import uvloop
+  use_uvloop = True
+except ImportError:
+  use_uvloop = False
+
+import wisp
+from wisp.server import http 
+from wisp.server import net
+
+def run_async(func, *args, **kwargs):
+  try:
+    if use_uvloop:
+      uvloop.run(func(*args, **kwargs))
+    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(func(*args, **kwargs))
+  except KeyboardInterrupt:
+    pass
+
+def run_http(args):
+  run_async(http.main, args)
+
+def main():
+  parser = argparse.ArgumentParser(
+    prog="wisp-server-python",
+    description=f"A Wisp server implementation, written in Python (v{wisp.version})"
+  )
+
+  parser.add_argument("--host", default="127.0.0.1", help="The hostname the server will listen on.")
+  parser.add_argument("--port", default=6001, help="The TCP port the server will listen on.")
+  parser.add_argument("--static", help="Where static files are served from.")
+  parser.add_argument("--limits", action="store_true", help="Enable rate limits.")
+  parser.add_argument("--bandwidth", default=1000, help="Bandwidth limit per IP, in kilobytes per second.")
+  parser.add_argument("--connections", default=30, help="New connections limit per IP.")
+  parser.add_argument("--window", default=60, help="Fixed window length for rate limits, in seconds.")
+  parser.add_argument("--allow-loopback", action="store_true", help="Allow connections to loopback IP addresses.")
+  parser.add_argument("--allow-private", action="store_true", help="Allow connections to private IP addresses.")
+  parser.add_argument("--log-level", default="info", help="The log level (either debug, info, warning, error, or critical).")
+  parser.add_argument("--threads", default=0, help="The number of threads to run the server on. By default it uses all CPU cores.")
+  args = parser.parse_args()
+
+  logging.basicConfig(
+    format="[%(asctime)s] %(levelname)-8s %(message)s",
+    level=getattr(logging, args.log_level.upper()),
+    datefmt="%Y/%m/%d - %H:%M:%S"
+  )
+
+  logging.info(f"running wisp-server-python v{wisp.version} (async)")
+  if args.static:
+    static_path = pathlib.Path(args.static).resolve()
+    logging.info(f"serving static files from {static_path}")
+  if args.limits:
+    logging.info("enabled rate limits")
+  logging.info(f"listening on {args.host}:{args.port}")
+
+  threads = int(args.threads)
+  if net.reuse_port_supported():
+    if threads == 0:
+      threads = multiprocessing.cpu_count()
+    logging.info(f"running using {threads} threads")
+
+    processes = []
+    for i in range(0, int(threads)):
+      process = multiprocessing.Process(target=run_http, args=(args,), daemon=True)
+      processes.append(process)
+      process.start()
+    try:
+      for process in processes:
+        process.join()
+    except KeyboardInterrupt:
+      pass
+  
+  else:
+    if threads != 0:
+      logging.warn("the --threads option is not supported on this platform")
+    run_http(args)

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

@@ -128,7 +128,7 @@ class WispConnection:
 
       #send a CONTINUE packet periodically
       stream["packets_sent"] += 1
-      if stream["packets_sent"] % queue_size / 4 == 0:
+      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

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

@@ -61,18 +61,15 @@ async def static_handler(path, request_headers):
 
 async def main(args):
   global static_path
-  logging.info(f"running wisp-server-python v{wisp.version} (async)")
 
   if args.static:
     static_path = pathlib.Path(args.static).resolve()
     request_handler = static_handler
     mimetypes.init()
-    logging.info(f"serving static files from {static_path}")
   else:
     request_handler = None
   
   if args.limits:
-    logging.info("enabled rate limits")
     ratelimit.enabled = True
     ratelimit.connections_limit = int(args.connections)
     ratelimit.bandwidth_limit = float(args.bandwidth)
@@ -82,10 +79,10 @@ async def main(args):
   net.block_private = not args.allow_private
       
   limit_task = asyncio.create_task(ratelimit.reset_limits_timer())
-  logging.info(f"listening on {args.host}:{args.port}")
-
   ws_logger = logging.getLogger("websockets")
   ws_logger.setLevel(logging.WARN)
 
-  async with serve(connection_handler, args.host, int(args.port), process_request=request_handler, compression=None):
+  reuse_port = net.reuse_port_supported()
+
+  async with serve(connection_handler, args.host, int(args.port), reuse_port=reuse_port, process_request=request_handler, compression=None):
     await asyncio.Future()

{wisp_python-0.6.0 → wisp_python-0.7.0}/src/wisp/server/net.py

@@ -9,6 +9,9 @@ tcp_size = 64*1024
 block_loopback = False
 block_private = False
 
+def reuse_port_supported():
+  return hasattr(socket, "SO_REUSEPORT")
+
 def get_ip(host, port, stream_type):
   if stream_type == 0x01:
     proto = socket.IPPROTO_TCP

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: wisp-python
-Version: 0.6.0
+Version: 0.7.0
 Summary: An implementation of a Wisp proxy server in Python
 Author: ading2210
 Project-URL: Homepage, https://github.com/MercuryWorkshop/wisp-server-python
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: websockets
 Requires-Dist: asyncudp
 Requires-Dist: uvloop; sys_platform != "win32" and sys_platform != "cygwin"
+Dynamic: license-file
 
 # Python Wisp Server
 
@@ -35,18 +36,16 @@ pip3 install wisp-python
 ```
 
 ## Running the Server:
-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:
+There used to be an experimental "threading" variant of the server. This has been removed due to its instability and difficulty of maintenance.
+
+To start the server, run `python3 -m wisp.server`. 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]
+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] [--threads THREADS]
 
-A Wisp server implementation, written in Python (v0.5.0)
+A Wisp server implementation, written in Python (v0.7.0)
 
 options:
   -h, --help            show this help message and exit
@@ -63,6 +62,7 @@ options:
   --allow-private       Allow connections to private IP addresses.
   --log-level LOG_LEVEL
                         The log level (either debug, info, warning, error, or critical).
+  --threads THREADS     The number of threads to run the server on. By default it uses all CPU cores.
 ```
 
 ## Roadmap:

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

@@ -5,16 +5,11 @@ 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/cli.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/server/__main__.py

@@ -1,26 +0,0 @@
-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.6.0/src/wisp/server/common.py

@@ -1,30 +0,0 @@
-import argparse
-import logging
-
-import wisp
-
-def setup_main():
-  parser = argparse.ArgumentParser(
-    prog="wisp-server-python",
-    description=f"A Wisp server implementation, written in Python (v{wisp.version})"
-  )
-
-  parser.add_argument("--host", default="127.0.0.1", help="The hostname the server will listen on.")
-  parser.add_argument("--port", default=6001, help="The TCP port the server will listen on.")
-  parser.add_argument("--static", help="Where static files are served from.")
-  parser.add_argument("--limits", action="store_true", help="Enable rate limits.")
-  parser.add_argument("--bandwidth", default=1000, help="Bandwidth limit per IP, in kilobytes per second.")
-  parser.add_argument("--connections", default=30, help="New connections limit per IP.")
-  parser.add_argument("--window", default=60, help="Fixed window length for rate limits, in seconds.")
-  parser.add_argument("--allow-loopback", action="store_true",help="Allow connections to loopback IP addresses.")
-  parser.add_argument("--allow-private", action="store_true", help="Allow connections to private IP addresses.")
-  parser.add_argument("--log-level", default="info", help="The log level (either debug, info, warning, error, or critical).")
-  args = parser.parse_args()
-
-  logging.basicConfig(
-    format="[%(asctime)s] %(levelname)-8s %(message)s",
-    level=getattr(logging, args.log_level.upper()),
-    datefmt="%Y/%m/%d - %H:%M:%S"
-  )
-
-  return args

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

@@ -1,2 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,216 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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()