test

app.py

@@ -1,5 +1,6 @@
 from fastapi.responses import JSONResponse, FileResponse, Response
 from fastapi import FastAPI, HTTPException, Request
+import mimetypes
 from threading import Thread
 from Instance import Instance
 from api import LoadBalancerAPI
@@ -28,29 +29,52 @@ async def serve_video(file_path: str, request: Request):
     file_size = os.path.getsize(file_path)
     range_header = request.headers.get('range', None)
 
+    # Determine the MIME type based on the file extension
+    mime_type, _ = mimetypes.guess_type(file_path)
+    if mime_type is None:
+        mime_type = 'application/octet-stream'  # Fallback MIME type
+
     if range_header:
-        match = re.match(r'bytes=(\d+)-(\d*)', range_header)
-        if match:
-            start, end = match.groups()
+        # Simple parsing for range values
+        start, end = None, None
+        range_specifier = range_header.replace('bytes=', '').strip()
+        if '-' in range_specifier:
+            start, end = range_specifier.split('-')
             start = int(start)
             end = int(end) if end else file_size - 1
-            
-            if start >= file_size or end >= file_size or start > end:
-                raise HTTPException(status_code=416, detail="Requested range not satisfiable")
-            
-            headers = {
-                'Content-Range': f'bytes {start}-{end}/{file_size}',
-                'Accept-Ranges': 'bytes',
-                'Content-Length': str(end - start + 1),
-                'Content-Type': 'video/mp4'  # Change as per your video format
-            }
-            async with aiofiles.open(file_path, 'rb') as f:
-                await f.seek(start)
-                data = await f.read(end - start + 1)
+
+        # Validate range
+        if start is None or start >= file_size or (end is not None and end >= file_size) or (end is not None and start > end):
+            raise HTTPException(status_code=416, detail="Requested range not satisfiable")
+
+        headers = {
+            'Content-Range': f'bytes {start}-{end or file_size - 1}/{file_size}',
+            'Accept-Ranges': 'bytes',
+            'Content-Length': str((end - start + 1) if end is not None else file_size - start),
+            'Content-Type': mime_type
+        }
+
+        async with aiofiles.open(file_path, 'rb') as f:
+            await f.seek(start)
+            chunk_size = 8192  # Read in 8KB chunks
+            data = bytearray()
+
+            while start <= (end or file_size - 1):
+                remaining = (end or file_size - 1) - start + 1
+                read_size = min(chunk_size, remaining)
+                chunk = await f.read(read_size)
+
+                if not chunk:  # EOF
+                    break
+                
+                data.extend(chunk)
+                start += read_size
+
             return Response(content=data, status_code=206, headers=headers)
-    
+
     # Fallback for serving the whole file if no range requested
-    return FileResponse(file_path)
+    return FileResponse(file_path, media_type=mime_type)
+
 
 @app.get("/")
 async def index():