webserver improvements mostly

sketch/gamma.py

···
 # renderer config
 scale_power = 12
 scale = 2 ** scale_power
-origin = -0.5, 0.5
-span = 1, 1
+origin = 0, 0
+span = 15, 15
 stretch = 1, 1
 zooms = [
-        ((0.45, 0.55), (0.3,0.4)),
-        ((0.25, 0.5), (0.25,0.5))
         ]
 
 # particle distribution: sample domain points
···
         core = math.sqrt(2 * math.pi) * torch.exp(t * torch.log(zpos) - zpos)
         z[~reflect] = core
     return z
+
+
+a = 2.0j
+b = 2.0
+kernel_xs = torch.tensor([a + b, a - b, -a + b, -a - b], device=device)
+kernel_xs -= kernel_xs.mean()
+
+def velu_like(z):
+    acc = z
+    for xQ in kernel_xs:
+        acc += 1 / (z - xQ)
+    return acc
 
 
 def gamma_to_rgb(gz):
···
     # compute Gamma(p)
     gz = grid.clone()#gamma_approx(p_positions)
 
-    for i in range(20):
-        gz = gamma_approx(gz)
+    for i in range(2):
+        gz = gamma_approx(gz)#velu_like(gz)
 
         naniter += gz.isnan() * 1.0
 
···
         #insert_at_coords(coords, rgb, scratch, mapping)
 
 
-        scratch[:,:,0] = gz.real
-        scratch[:,:,2] = gz.imag
-        scratch[:,:,1] = naniter / naniter.max()
+        #scratch[:,:,0] = gz.real
+        #scratch[:,:,2] = gz.imag
+        #scratch[:,:,1] = naniter / naniter.max()
+
+        scratch[:,:,0] = (torch.angle(gz) + math.pi)
+        scratch[:,:,1] = torch.log(torch.abs(gz) + 1e-12) / 30
+        scratch[:,:,1] /= scratch[:,:,2].max()
+        scratch[:,:,2] = torch.cos(scratch[:,:,0] / 2)
+        scratch[:,:,0] = torch.abs(torch.sin(scratch[:,:,0] / 2))
+
 
         # normalization/centering like plume_c does
         #scratch[:,:,2] -= scratch[:,:,2].mean()

sketch/webserver.py

···
 
 #from lib import log
 
-# TODO make it upgrade to https instead of just fucking throwing exceptions
+MODE = "local"
 
-HOST = "0.0.0.0"
-PORT = 1313
-BASE_DIR = Path("./webui").resolve()
-USE_SSL = False
+if MODE == "local":
+    HOST = "0.0.0.0"
+    PORT, SSL_PORT = 1313, None
+    BASE_DIR = Path("./webui").resolve()
+    USE_SSL = False
+    SSL_CERT = "/home/ponder/ponder/certs/cert.pem"
+    SSL_KEY = "/home/ponder/ponder/certs/key.pem"
+elif MODE == "remote":
+    HOST = "ponder.ooo"
+    PORT, SSL_PORT = 80, 443
+    BASE_DIR = Path("./webui").resolve()
+    USE_SSL = True
+    SSL_KEY="/etc/letsencrypt/live/ponder.ooo/privkey.pem"
+    SSL_CERT="/etc/letsencrypt/live/ponder.ooo/fullchain.pem"
 
 ROUTES = {
     "/": "content/main.html",
···
     ".orb": "text/x-orb"
 }
 
-SSL_CERT = "/home/ponder/ponder/certs/cert.pem"
-SSL_KEY = "/home/ponder/ponder/certs/key.pem"
 
 def guess_mime_type(path):
     return MIME_TYPES.get(Path(path).suffix, "application/octet-stream")
···
 def build_response(status_code, body=b"", content_type="text/plain"):
     reason = {
         200: "OK",
+        301: "Moved Permanently",
         400: "Bad Request",
         404: "Not Found",
         405: "Method Not Allowed",
···
         f"\r\n"
     ).encode() + body
 
-def route(req_path):
-    if req_path == "/":
-        return "content/main.html"
-    if any(req_path.endswith(x) for x in [".html", ".png"]):
-        return f"content/{req_path}"
-    if any(req_path.endswith(x) for x in [".wgsl"]):
-        return f"content/wgsl/{req_path}"
-    if any(req_path.endswith(x) for x in [".orb"]):
-        return f"content/orb/{req_path}"
-    if req_path.endswith(".js"):
-        return f"js/{req_path}"
-    return req_path[1:]
+def route(path):
+    path = path.relative_to('/') if path.is_absolute() else path
+
+    if path == Path():
+        return BASE_DIR / "content/main.html"
+
+    suffix = path.suffix
+
+    if suffix in [".html", ".png"]:
+        return BASE_DIR / Path("content") / path
+    if suffix in [".wgsl"]:
+        return BASE_DIR / Path("content/wgsl") / path
+    if suffix in [".orb"]:
+        return BASE_DIR / Path("content/orb") / path
+    if suffix in [".js"]:
+        return BASE_DIR / Path("js") / path
+    return BASE_DIR / path
 
 def handle_request(request_data):
     try:
···
         if method != "GET":
             return build_response(405, b"Method Not Allowed")
 
-        req_path = urlparse(unquote(raw_path)).path
+        req_path = Path(urlparse(unquote(raw_path)).path).resolve(strict=False)
 
-        norm_path = os.path.normpath(req_path)
+        routed_path = route(req_path).resolve(strict=False)
 
-        if ".." in norm_path:
+        if not routed_path.is_relative_to(BASE_DIR):
             return build_response(400, b"Fuck You")
 
-        file_path = route(norm_path)
-
-        if not file_path:
-            return build_response(404, b"Not Found")
-
-        full_path = BASE_DIR / file_path
-        if not full_path.exists():
+        if not routed_path.exists():
             return build_response(404, b"File not found")
 
-        with open(full_path, "rb") as f:
+        with open(routed_path, "rb") as f:
             body = f.read()
-            return build_response(200, body, guess_mime_type(file_path))
+            return build_response(200, body, guess_mime_type(routed_path))
 
     except Exception as e:
         return build_response(500, f"Server error: {e}".encode())
 
-def main():
+
+
+def build_redirect_response(location):
+    return (
+        f"HTTP/1.1 301 Moved Permanently\r\n"
+        f"Location: {location}\r\n"
+        f"Content-Length: 0\r\n"
+        f"Connection: close\r\n"
+        f"\r\n"
+    ).encode()
+
+def handle_http_redirect(conn):
+    request = conn.recv(4096)
+    try:
+        lines = request.decode().split("\r\n")
+        if lines:
+            method, raw_path, *_ = lines[0].split()
+            path = urlparse(unquote(raw_path)).path
+        else:
+            path = "/"
+    except:
+        path = "/"
+    redirect = build_redirect_response(f"https://{HOST}{path}")
+    conn.sendall(redirect)
+
+def http_redirect_server():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
+        server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        server.bind((HOST, PORT))
+        server.listen()
+        print(f"redirecting on {HOST}:{PORT}")
+        while True:
+            try:
+                conn, addr = server.accept()
+            except KeyboardInterrupt:
+                break
+            except:
+                continue
+            with conn:
+                try:
+                    handle_http_redirect(conn)
+                except:
+                    pass
+
+
+def ssl_main():
     ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
     ssl_ctx.load_cert_chain(certfile=SSL_CERT, keyfile=SSL_KEY)
 
+    #threading.Thread(target=http_redirect_server, daemon=True).start()
+
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
         server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        server.bind((HOST, PORT))
+        server.bind((HOST, SSL_PORT))
         server.listen()
-        print(f"Serving HTTPS on {HOST}:{PORT}")
+        print(f"Serving HTTPS on {HOST}:{SSL_PORT}")
         while True:
             try:
                 conn, addr = server.accept()
-                if USE_SSL:
-                    with ssl_ctx.wrap_socket(conn, server_side=True) as ssl_conn:
-                        request = ssl_conn.recv(4096)
-                        response = handle_request(request)
-                        ssl_conn.sendall(response)
-                else:
-                    request = conn.recv(4096)
+                conn.settimeout(10.0)
+                with ssl_ctx.wrap_socket(conn, server_side=True) as ssl_conn:
+                    request = ssl_conn.recv(4096)
                     response = handle_request(request)
-                    conn.sendall(response)
+                    ssl_conn.sendall(response)
+            except KeyboardInterrupt:
+                raise
+            except TimeoutError:
+                continue
+            except Exception as e:
+                print(f"Error: {e}")
+                exit()
+
+
+def main():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
+        server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        server.bind((HOST, PORT))
+        server.listen()
+        print(f"Serving HTTP on {HOST}:{PORT}")
+        while True:
+            try:
+                conn, addr = server.accept()
+                request = conn.recv(4096)
+                response = handle_request(request)
+                conn.sendall(response)
             except KeyboardInterrupt:
                 raise
-            except:
+            except Exception as e:
+                print(e)
                 break
 
 if __name__ == "__main__":
-    main()
+    if USE_SSL:
+        ssl_main()
+    else:
+        main()

webui/content/orb/projective_shift.orb

···
     in
 
     z_{n+1} = (r + cos(theta-phi))e^{i theta psi} - c
-    where z_n = r cos theta
+    where z_n = r e^{i theta}
 } }
 
 b{click and drag} to move around, b{scroll} to zoom in and out; b{press F} to go fullscreen