asteri 1.0.0__py3-none-any.whl

asteri/__main__.py

@@ -0,0 +1,199 @@
+import logging
+import argparse
+import sys
+import os
+from asteri.arbiter import Arbiter
+from asteri.workers.sync import SyncWorker
+from asteri.workers.gthread import GThreadWorker
+from asteri.workers.asgi import ASGIWorker
+try:
+    from asteri.workers.gevent import GeventWorker
+except ImportError:
+    GeventWorker = None
+from asteri.utils import logger, print_banner, Colors, setup_logging
+
+def import_app(app_path):
+    """Import application from string 'module:callable'."""
+    try:
+        module_path, app_name = app_path.split(":")
+        sys.path.insert(0, os.getcwd())
+        module = __import__(module_path)
+        return getattr(module, app_name)
+    except Exception as e:
+        logger.error(f"Could not import app '{Colors.BOLD}{app_path}{Colors.ENDC}': {e}")
+        sys.exit(1)
+
+def main():
+    print_banner()
+    
+    parser = argparse.ArgumentParser(
+        prog="asteri",
+        description=f"{Colors.BOLD}Asteri: High Performance Web Server{Colors.ENDC}",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        add_help=True
+    )
+    
+    # Positional Arguments
+    parser.add_argument("app", nargs="?", help="Application path (e.g., myapp:app)")
+    
+    # Config Group
+    config_group = parser.add_argument_group("Config")
+    config_group.add_argument("-c", "--config", help="The Asteri config file.")
+    config_group.add_argument("-v", "--version", action="version", version="Asteri v1.0.0")
+    config_group.add_argument("--check-config", action="store_true", help="Check the configuration and exit.")
+    config_group.add_argument("--print-config", action="store_true", help="Print the configuration settings.")
+
+    # Network Group
+    net_group = parser.add_argument_group("Network")
+    net_group.add_argument("-b", "--bind", action="append", help="The socket to bind.")
+    net_group.add_argument("--backlog", type=int, default=2048, help="The maximum number of pending connections.")
+    net_group.add_argument("--reuse-port", action="store_true", help="Set the SO_REUSEPORT flag.")
+
+    # Worker Group
+    worker_group = parser.add_argument_group("Workers")
+    worker_group.add_argument("-w", "--workers", type=int, default=1, help="The number of worker processes.")
+    worker_group.add_argument("-k", "--worker-class", default="sync", choices=["sync", "gthread", "asgi", "gevent"],
+                             help="The type of workers to use.")
+    worker_group.add_argument("--threads", type=int, default=1, help="The number of worker threads.")
+    worker_group.add_argument("--worker-connections", type=int, default=1000, help="Max simultaneous clients.")
+    worker_group.add_argument("--max-requests", type=int, default=0, help="Max requests before worker restart.")
+    worker_group.add_argument("--max-requests-jitter", type=int, default=0, help="Jitter for max-requests.")
+    worker_group.add_argument("-t", "--timeout", type=int, default=30, help="Worker timeout in seconds.")
+    worker_group.add_argument("--graceful-timeout", type=int, default=30, help="Timeout for graceful restart.")
+    worker_group.add_argument("--keep-alive", type=int, default=2, help="Keep-alive timeout.")
+    worker_group.add_argument("--preload", action="store_true", help="Load app code before forking.")
+
+    # Security/SSL Group
+    sec_group = parser.add_argument_group("Security")
+    sec_group.add_argument("--keyfile", help="SSL key file")
+    sec_group.add_argument("--certfile", help="SSL certificate file")
+    sec_group.add_argument("--ca-certs", help="CA certificates file")
+    sec_group.add_argument("--ssl-version", type=int, default=2, help="SSL version to use.")
+    sec_group.add_argument("--ciphers", help="SSL Cipher suite to use.")
+    sec_group.add_argument("-u", "--user", help="Switch worker processes to run as this user.")
+    sec_group.add_argument("-g", "--group", help="Switch worker process to run as this group.")
+    sec_group.add_argument("-m", "--umask", type=int, default=0, help="Bit mask for file mode.")
+
+    # Logging Group
+    log_group = parser.add_argument_group("Logging")
+    log_group.add_argument("--access-logfile", help="The Access log file.")
+    log_group.add_argument("--error-logfile", "--log-file", help="The Error log file.")
+    log_group.add_argument("--log-level", default="info", choices=["debug", "info", "warning", "error", "critical"])
+    log_group.add_argument("--capture-output", action="store_true", help="Redirect stdout/stderr to error log.")
+    log_group.add_argument("--access-logformat", help="The access log format.")
+
+    # Process Group
+    proc_group = parser.add_argument_group("Process")
+    proc_group.add_argument("-D", "--daemon", action="store_true", help="Daemonize the process.")
+    proc_group.add_argument("-p", "--pid", help="PID filename.")
+    proc_group.add_argument("--chdir", help="Change directory before loading apps.")
+    proc_group.add_argument("-e", "--env", action="append", help="Set environment variables.")
+    proc_group.add_argument("-n", "--name", help="Process name for setproctitle.")
+    proc_group.add_argument("--reload", action="store_true", help="Restart workers on code changes.")
+
+    # HTTP limits
+    http_group = parser.add_argument_group("HTTP Limits")
+    http_group.add_argument("--limit-request-line", type=int, default=4094)
+    http_group.add_argument("--limit-request-fields", type=int, default=100)
+    http_group.add_argument("--limit-request-field_size", type=int, default=8190)
+
+    # HTTP/2 Group
+    h2_group = parser.add_argument_group("HTTP/2")
+    h2_group.add_argument("--http-protocols", default="h1", help="HTTP protocols to support (e.g., h1,h2)")
+    h2_group.add_argument("--http2-max-concurrent-streams", type=int, default=100)
+
+    args = parser.parse_args()
+
+    # 1. Load Config File if provided
+    if args.config and os.path.exists(args.config):
+        config_namespace = {}
+        with open(args.config) as f:
+            exec(f.read(), config_namespace)
+        for key, value in config_namespace.items():
+            if hasattr(args, key.lower()):
+                setattr(args, key.lower(), value)
+
+    # Ensure bind is always a list
+    if args.bind and isinstance(args.bind, str):
+        args.bind = [args.bind]
+    elif not args.bind:
+        args.bind = ["127.0.0.1:8000"]
+
+    # 2. Check Config
+    if args.check_config or args.print_config:
+        if args.print_config:
+            print(f"{Colors.BOLD}Resolved Configuration:{Colors.ENDC}")
+            for arg in vars(args):
+                print(f"  {arg}: {getattr(args, arg)}")
+        sys.exit(0)
+
+    # 3. Handle Chdir
+    if args.chdir:
+        os.chdir(args.chdir)
+        sys.path.insert(0, os.getcwd())
+
+    # 4. Handle Env
+    if args.env:
+        for env_var in args.env:
+            if "=" in env_var:
+                k, v = env_var.split("=", 1)
+                os.environ[k] = v
+
+    # 5. Logging setup
+    log_file = args.error_logfile
+    log_level_name = (args.log_level or "info").upper()
+    log_level = getattr(logging, log_level_name, logging.INFO)
+    setup_logging(log_file=log_file, level=log_level)
+    
+    worker_map = {
+        "sync": SyncWorker,
+        "gthread": GThreadWorker,
+        "asgi": ASGIWorker,
+        "gevent": GeventWorker
+    }
+    
+    worker_class = worker_map[args.worker_class]
+    if worker_class is None:
+        logger.error(f"Worker class '{args.worker_class}' is not available.")
+        sys.exit(1)
+
+    if not args.app:
+        parser.print_help()
+        sys.exit(1)
+
+    # Preload
+    if args.preload:
+        from asteri.utils import import_app
+        import_app(args.app)
+    
+    # Setup binds
+    binds = args.bind if args.bind else ["127.0.0.1:8000"]
+    
+    arbiter = Arbiter(
+        args.app, worker_class, 
+        num_workers=args.workers, 
+        bind=binds[0], 
+        reload=args.reload,
+        certfile=args.certfile,
+        keyfile=args.keyfile,
+        daemon=args.daemon,
+        pidfile=args.pid,
+        user=args.user,
+        group=args.group,
+        umask=args.umask,
+        proc_name=args.name,
+        timeout=args.timeout
+    )
+    
+    logger.info(f"Booting {Colors.CYAN}{args.worker_class}{Colors.ENDC} workers...")
+    
+    try:
+        arbiter.start()
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        logger.error(f"Fatal error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

asteri/arbiter.py

@@ -0,0 +1,204 @@
+import os
+import signal
+import socket
+import sys
+import time
+from .utils import logger, set_proctitle, Colors
+
+try:
+    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEventHandler
+    WATCHDOG_AVAILABLE = True
+except ImportError:
+    WATCHDOG_AVAILABLE = False
+
+class Arbiter:
+    """The Master process that manages workers."""
+    
+    def __init__(self, app_path, worker_class, num_workers=1, bind="0.0.0.0:8000", reload=False, certfile=None, keyfile=None,
+                 daemon=False, pidfile=None, user=None, group=None, umask=0, proc_name=None, timeout=30):
+        self.app_path = app_path
+        self.worker_class = worker_class
+        self.num_workers = num_workers
+        self.bind = bind
+        self.reload = reload
+        self.certfile = certfile
+        self.keyfile = keyfile
+        self.daemon = daemon
+        self.pidfile = pidfile
+        self.user = user
+        self.group = group
+        self.umask = umask
+        self.proc_name = proc_name or "master"
+        self.timeout = timeout
+        self.workers = {} # pid -> worker_instance
+        self.sock = None
+        self.alive = True
+        self.pid = os.getpid()
+        self.reloader = None
+
+    def start(self):
+        if self.daemon:
+            self.daemonize()
+        
+        if self.pidfile:
+            self.write_pid()
+            
+        if self.umask:
+            os.umask(self.umask)
+
+        set_proctitle(self.proc_name)
+        logger.info(f"Starting Asteri Arbiter (pid: {Colors.BOLD}{os.getpid()}{Colors.ENDC})")
+        
+        if self.reload and WATCHDOG_AVAILABLE:
+            self.setup_reloader()
+        elif self.reload:
+            logger.warning("Watchdog not available, falling back to manual reload.")
+        
+        # Create listener socket
+        host, port = self.bind.split(":")
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        
+        if self.certfile and self.keyfile:
+            import ssl
+            context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            context.load_cert_chain(certfile=self.certfile, keyfile=self.keyfile)
+            self.sock = context.wrap_socket(self.sock, server_side=True)
+            logger.info(f"SSL {Colors.GREEN}enabled{Colors.ENDC} ({self.certfile})")
+        
+        self.sock.bind((host, int(port)))
+        self.sock.listen(1024)
+        self.sock.setblocking(False)
+        
+        scheme = "https" if self.certfile else "http"
+        logger.info(f"Listening on {Colors.UNDERLINE}{scheme}://{self.bind}{Colors.ENDC}")
+        
+        self.setup_signals()
+        self.manage_workers()
+
+    def setup_reloader(self):
+        class ReloadHandler(FileSystemEventHandler):
+            def __init__(self, arbiter):
+                self.arbiter = arbiter
+            def on_modified(self, event):
+                if event.src_path.endswith('.py'):
+                    logger.info(f"Change detected in {Colors.BOLD}{os.path.basename(event.src_path)}{Colors.ENDC}. Reloading...")
+                    self.arbiter.stop_workers(signal.SIGTERM)
+
+        self.reloader = Observer()
+        self.reloader.schedule(ReloadHandler(self), os.getcwd(), recursive=True)
+        self.reloader.start()
+        logger.info(f"Auto-reload {Colors.GREEN}enabled{Colors.ENDC} (watchdog)")
+
+    def daemonize(self):
+        """Standard double-fork daemonization."""
+        if os.fork() > 0: sys.exit(0)
+        os.setsid()
+        if os.fork() > 0: sys.exit(0)
+        
+        # Redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+        si = open(os.devnull, 'r')
+        so = open(os.devnull, 'a+')
+        se = open(os.devnull, 'a+')
+        os.dup2(si.fileno(), sys.stdin.fileno())
+        os.dup2(so.fileno(), sys.stdout.fileno())
+        os.dup2(se.fileno(), sys.stderr.fileno())
+
+    def write_pid(self):
+        with open(self.pidfile, 'w') as f:
+            f.write(str(os.getpid()))
+
+    def switch_user(self):
+        if not self.user and not self.group:
+            return
+        import pwd, grp
+        if self.group:
+            gid = grp.getgrnam(self.group).gr_gid
+            os.setgid(gid)
+        if self.user:
+            uid = pwd.getpwnam(self.user).pw_uid
+            os.setuid(uid)
+
+    def setup_signals(self):
+        signal.signal(signal.SIGCHLD, self.handle_chld)
+        signal.signal(signal.SIGTERM, self.handle_exit)
+        signal.signal(signal.SIGINT, self.handle_exit)
+        signal.signal(signal.SIGHUP, self.handle_hup)
+        signal.signal(signal.SIGQUIT, self.handle_quit)
+
+    def handle_chld(self, sig, frame):
+        """Worker died."""
+        self.wakeup()
+
+    def handle_exit(self, sig, frame):
+        self.alive = False
+        self.stop_workers(signal.SIGTERM)
+
+    def handle_quit(self, sig, frame):
+        self.alive = False
+        self.stop_workers(signal.SIGQUIT)
+
+    def handle_hup(self, sig, frame):
+        """Reload workers."""
+        logger.info("Reloading workers...")
+        self.stop_workers(signal.SIGTERM)
+
+    def wakeup(self):
+        """Force loop to check workers."""
+        pass
+
+    def stop_workers(self, sig):
+        import psutil
+        for pid in list(self.workers.keys()):
+            try:
+                p = psutil.Process(pid)
+                p.send_signal(sig)
+            except psutil.NoSuchProcess:
+                if pid in self.workers:
+                    del self.workers[pid]
+
+    def spawn_worker(self):
+        worker = self.worker_class(0, self.pid, self.sock, self.app_path, self.timeout)
+        pid = os.fork()
+        
+        if pid == 0: # Child
+            try:
+                self.switch_user()
+                worker.init_process()
+                worker.run()
+                sys.exit(0)
+            except Exception as e:
+                logger.error(f"Worker error: {e}")
+                sys.exit(1)
+        else: # Parent
+            self.workers[pid] = worker
+            return pid
+
+    def manage_workers(self):
+        while self.alive:
+            # Maintain worker count
+            while len(self.workers) < self.num_workers:
+                self.spawn_worker()
+            
+            # Reaping dead children
+            try:
+                pid, status = os.waitpid(-1, os.WNOHANG)
+                while pid > 0:
+                    if pid in self.workers:
+                        del self.workers[pid]
+                    pid, status = os.waitpid(-1, os.WNOHANG)
+            except ChildProcessError:
+                pass
+                
+            time.sleep(1.0)
+            
+        # Cleanup
+        if self.reloader:
+            self.reloader.stop()
+            self.reloader.join()
+        
+        logger.info("Asteri shutting down.")
+        self.sock.close()

asteri/http.py

@@ -0,0 +1,120 @@
+import socket
+import io
+import http.client
+from .utils import logger
+
+class HTTPRequest:
+    def __init__(self, method, path, version, headers, body=None):
+        self.method = method
+        self.path = path
+        self.version = version
+        self.headers = headers
+        self.body = body
+
+class HTTPParser:
+    @staticmethod
+    def parse(raw_data):
+        """Simple HTTP/1.1 parser."""
+        try:
+            # Split headers and body
+            header_part, _, body = raw_data.partition(b"\r\n\r\n")
+            lines = header_part.split(b"\r\n")
+            
+            if not lines or not lines[0]:
+                return None
+
+            # Request line
+            request_line = lines[0].decode('ascii').split()
+            if len(request_line) < 3:
+                return None
+            
+            method, path, version = request_line
+            
+            # Headers
+            headers = {}
+            for line in lines[1:]:
+                if b":" in line:
+                    key, value = line.split(b":", 1)
+                    headers[key.decode('ascii').lower().strip()] = value.decode('ascii').strip()
+            
+            return HTTPRequest(method, path, version, headers, body)
+        except Exception as e:
+            logger.error(f"Failed to parse HTTP request: {e}")
+            return None
+
+try:
+    import h2.connection
+    import h2.events
+    H2_AVAILABLE = True
+except ImportError:
+    H2_AVAILABLE = False
+
+class HTTP2Handler:
+    """Professional HTTP/2 handler using 'h2' library."""
+    PREFACE = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+    
+    @staticmethod
+    def is_http2(data):
+        return data.startswith(HTTP2Handler.PREFACE)
+
+    def __init__(self, sock):
+        self.sock = sock
+        self.conn = h2.connection.H2Connection()
+        self.conn.initiate_connection()
+        self.sock.sendall(self.conn.data_to_send())
+
+    def handle(self):
+        """Main HTTP/2 event loop for a connection."""
+        if not H2_AVAILABLE:
+            logger.error("HTTP/2 requested but 'h2' library is missing.")
+            return
+
+        while True:
+            try:
+                data = self.sock.recv(65535)
+                if not data: break
+                
+                events = self.conn.receive_data(data)
+                for event in events:
+                    if isinstance(event, h2.events.RequestReceived):
+                        self.handle_request(event)
+                
+                data_to_send = self.conn.data_to_send()
+                if data_to_send:
+                    self.sock.sendall(data_to_send)
+            except Exception as e:
+                logger.debug(f"H2 Connection closed: {e}")
+                break
+
+    def handle_request(self, event):
+        # Convert H2 headers to dict
+        headers = dict(event.headers)
+        method = headers.get(':method')
+        path = headers.get(':path')
+        
+        # This would then call the app... for now just logging
+        logger.info(f"H2 Request: {method} {path}")
+        
+        # Simple H2 Response
+        response_headers = [
+            (':status', '200'),
+            ('content-type', 'text/plain'),
+            ('server', 'Asteri'),
+        ]
+        self.conn.send_headers(event.stream_id, response_headers)
+        self.conn.send_data(event.stream_id, b"Hello from Asteri (HTTP/2)!", end_stream=True)
+        self.sock.sendall(self.conn.data_to_send())
+
+def build_http_response(status_code, headers, body):
+    """Build a standard HTTP/1.1 response."""
+    status_text = http.client.responses.get(status_code, "Unknown")
+    response = f"HTTP/1.1 {status_code} {status_text}\r\n"
+    
+    if "Content-Length" not in headers and body:
+        headers["Content-Length"] = str(len(body))
+    
+    for key, value in headers.items():
+        response += f"{key}: {value}\r\n"
+    
+    response += "\r\n"
+    return response.encode('ascii') + (body if isinstance(body, bytes) else body.encode('utf-8'))

asteri/utils.py

@@ -0,0 +1,93 @@
+import logging
+import os
+import sys
+
+class Colors:
+    PURPLE = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    WHITE = '\033[97m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+class PrettyFormatter(logging.Formatter):
+    def format(self, record):
+        level_color = {
+            logging.INFO: Colors.GREEN,
+            logging.WARNING: Colors.YELLOW,
+            logging.ERROR: Colors.RED,
+            logging.DEBUG: Colors.BLUE
+        }.get(record.levelno, Colors.ENDC)
+        
+        timestamp = self.formatTime(record, self.datefmt)
+        msg = super().format(record)
+        # We only want to color the level and maybe the process ID
+        return f"{Colors.BLUE}[{timestamp}]{Colors.ENDC} {Colors.BOLD}[{record.process}]{Colors.ENDC} {level_color}[{record.levelname}]{Colors.ENDC} {record.getMessage()}"
+
+def setup_logging(level=logging.INFO, log_file=None):
+    """Set up the default logger for Asteri."""
+    logger = logging.getLogger("asteri")
+    logger.setLevel(level)
+    
+    if logger.handlers:
+        for handler in list(logger.handlers):
+            logger.removeHandler(handler)
+            
+    # Console handler
+    handler = logging.StreamHandler(sys.stdout)
+    formatter = PrettyFormatter(datefmt='%H:%M:%S')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    
+    # File handler if requested
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_formatter = logging.Formatter(
+            '[%(asctime)s] [%(process)d] [%(levelname)s] %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S %z'
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+logger = setup_logging()
+
+def print_banner():
+    banner = f"""
+        {Colors.BOLD}{Colors.PURPLE}*ASTERI*{Colors.ENDC}
+         {Colors.CYAN}v1.0.0{Colors.ENDC}
+    {Colors.BOLD}{Colors.CYAN}ASTERI{Colors.ENDC} {Colors.YELLOW}Web Server{Colors.ENDC}
+    """
+    print(banner)
+
+def set_proctitle(title):
+    """Attempt to set the process title for better visibility in ps/top."""
+    try:
+        import setproctitle
+        setproctitle.setproctitle(f"asteri: {title}")
+    except ImportError:
+        # Fallback if setproctitle is not installed (dependency-free requirement)
+        pass
+
+def import_app(app_path):
+    """Import application from string 'module:callable'."""
+    try:
+        module_path, app_name = app_path.split(":")
+        sys.path.insert(0, os.getcwd())
+        # Force re-import by removing from sys.modules if it exists
+        if module_path in sys.modules:
+            del sys.modules[module_path]
+        module = __import__(module_path)
+        return getattr(module, app_name)
+    except Exception as e:
+        logger.error(f"Could not import app '{Colors.BOLD}{app_path}{Colors.ENDC}': {e}")
+        raise e
+
+def get_num_workers():
+    """Returns a default number of workers based on CPU count."""
+    return os.cpu_count() * 2 + 1

asteri/uwsgi.py

@@ -0,0 +1,50 @@
+import struct
+from .utils import logger
+
+class UWSGIHandler:
+    """Parser for the uWSGI binary protocol."""
+    
+    @staticmethod
+    def parse(data):
+        """
+        Parses uWSGI packet.
+        Header: 4 bytes [modifier1, size_low, size_high, modifier2]
+        """
+        if len(data) < 4:
+            return None, None
+            
+        modifier1, size, modifier2 = struct.unpack("<BHB", data[:4])
+        
+        # Check if we have enough data
+        if len(data) < 4 + size:
+            return None, None
+            
+        var_data = data[4:4+size]
+        vars_dict = {}
+        
+        pos = 0
+        while pos < size:
+            if pos + 2 > size: break
+            key_len = struct.unpack("<H", var_data[pos:pos+2])[0]
+            pos += 2
+            if pos + key_len > size: break
+            key = var_data[pos:pos+key_len].decode('ascii')
+            pos += key_len
+            
+            if pos + 2 > size: break
+            val_len = struct.unpack("<H", var_data[pos:pos+2])[0]
+            pos += 2
+            if pos + val_len > size: break
+            val = var_data[pos:pos+val_len].decode('ascii')
+            pos += val_len
+            
+            vars_dict[key] = val
+            
+        return vars_dict, modifier1
+
+    @staticmethod
+    def is_uwsgi(data):
+        """Heuristic check for uWSGI protocol."""
+        if len(data) < 4: return False
+        # modifier1 is usually 0 for WSGI
+        return data[0] == 0

asteri/workers/asgi.py

@@ -0,0 +1,74 @@
+import asyncio
+import socket
+import io
+from .base import BaseWorker
+from ..http import build_http_response
+
+class ASGIWorker(BaseWorker):
+    def run(self):
+        self.init_process()
+        asyncio.run(self.main_loop())
+
+    async def main_loop(self):
+        self.socket.setblocking(False)
+        loop = asyncio.get_running_loop()
+        
+        while self.alive:
+            try:
+                client, addr = await loop.sock_accept(self.socket)
+                asyncio.create_task(self.handle_asgi_request(client))
+            except Exception:
+                await asyncio.sleep(0.1)
+
+    async def handle_asgi_request(self, sock):
+        try:
+            data = await asyncio.get_running_loop().sock_recv(sock, 4096)
+            if not data: return
+
+            from ..http import HTTPParser
+            req = HTTPParser.parse(data)
+            if not req: return
+
+            scope = self.build_asgi_scope(req)
+            
+            response_started = False
+            response_body = b""
+            status_code = 200
+            headers = []
+
+            async def receive():
+                return {'type': 'http.request', 'body': req.body or b"", 'more_body': False}
+
+            async def send(message):
+                nonlocal response_started, response_body, status_code, headers
+                if message['type'] == 'http.response.start':
+                    status_code = message['status']
+                    headers = {k.decode('ascii'): v.decode('ascii') for k, v in message.get('headers', [])}
+                    response_started = True
+                elif message['type'] == 'http.response.body':
+                    response_body += message.get('body', b"")
+                    if not message.get('more_body', False):
+                        await asyncio.get_running_loop().sock_sendall(
+                            sock, 
+                            build_http_response(status_code, headers, response_body)
+                        )
+
+            await self.app(scope, receive, send)
+        except Exception:
+            pass
+        finally:
+            sock.close()
+
+    def build_asgi_scope(self, req):
+        return {
+            'type': 'http',
+            'asgi': {'version': '3.0', 'spec_version': '2.0'},
+            'http_version': '1.1',
+            'method': req.method,
+            'scheme': 'http',
+            'path': req.path.split('?')[0],
+            'query_string': req.path.split('?')[1].encode('ascii') if '?' in req.path else b'',
+            'headers': [(k.encode('ascii'), v.encode('ascii')) for k, v in req.headers.items()],
+            'client': ('127.0.0.1', 0),
+            'server': ('127.0.0.1', 8000),
+        }

asteri/workers/base.py

@@ -0,0 +1,90 @@
+import os
+import signal
+import socket
+import time
+from ..utils import logger, set_proctitle, Colors
+
+class BaseWorker:
+    def __init__(self, age, ppid, socket, app_path, timeout):
+        self.age = age
+        self.ppid = ppid
+        self.socket = socket
+        self.app_path = app_path
+        self.app = None
+        self.timeout = timeout
+        self.alive = True
+        self.booted = False
+
+    def init_process(self):
+        """Initialize worker process."""
+        from ..utils import import_app
+        self.app = import_app(self.app_path)
+        
+        # Set up signals
+        signal.signal(signal.SIGQUIT, self.handle_quit)
+        signal.signal(signal.SIGTERM, self.handle_exit)
+        signal.signal(signal.SIGINT, self.handle_exit)
+        
+        # Reset signals to default that might have been ignored in parent
+        signal.signal(signal.SIGCHLD, signal.SIG_DFL)
+        
+        self.booted = True
+        set_proctitle(f"worker [{self.__class__.__name__}]")
+        logger.info(f"Worker spawned (pid: {Colors.BOLD}{os.getpid()}{Colors.ENDC})")
+
+    def handle_quit(self, sig, frame):
+        self.alive = False
+
+    def handle_exit(self, sig, frame):
+        self.alive = False
+        os._exit(0)
+
+    def run(self):
+        raise NotImplementedError()
+
+    def handle_request(self, client_sock):
+        """Common logic to determine protocol and dispatch."""
+        try:
+            data = client_sock.recv(4096)
+            if not data:
+                return
+
+            from ..http import HTTPParser, HTTP2Handler, build_http_response
+            from ..uwsgi import UWSGIHandler
+
+            # Internal Status Dashboard
+            if b"GET /asteri-status" in data:
+                status_body = f"Asteri Web Server Status\n"
+                status_body += f"Worker PID: {os.getpid()}\n"
+                status_body += f"Parent PID: {self.ppid}\n"
+                status_body += f"Worker Type: {self.__class__.__name__}\n"
+                client_sock.sendall(build_http_response(200, {"Content-Type": "text/plain"}, status_body))
+                return
+
+            if HTTP2Handler.is_http2(data):
+                h2_handler = HTTP2Handler(client_sock)
+                # We need to pass the initial data if it contains more than preface
+                # But for now, handle() will recv more data
+                h2_handler.handle()
+                return
+            elif UWSGIHandler.is_uwsgi(data):
+                vars, mod = UWSGIHandler.parse(data)
+                if vars:
+                    self.handle_uwsgi(client_sock, vars)
+            else:
+                req = HTTPParser.parse(data)
+                if req:
+                    self.handle_http(client_sock, req)
+        except Exception as e:
+            logger.error(f"Error handling request: {e}")
+        finally:
+            try:
+                client_sock.close()
+            except:
+                pass
+
+    def handle_http(self, sock, req):
+        raise NotImplementedError()
+
+    def handle_uwsgi(self, sock, env):
+        raise NotImplementedError()

asteri/workers/gevent.py

@@ -0,0 +1,29 @@
+import os
+import socket
+from .sync import SyncWorker
+from ..utils import logger
+
+try:
+    import gevent
+    import gevent.monkey
+    from gevent.server import StreamServer
+    GEVENT_AVAILABLE = True
+except ImportError:
+    GEVENT_AVAILABLE = False
+
+class GeventWorker(SyncWorker):
+    def run(self):
+        if not GEVENT_AVAILABLE:
+            logger.error("Gevent is not installed. Please install it with 'pip install gevent' to use this worker.")
+            return
+
+        # Monkey patch
+        gevent.monkey.patch_all()
+        
+        self.init_process()
+        
+        def handle(client_sock, address):
+            self.handle_request(client_sock)
+
+        server = StreamServer(self.socket, handle)
+        server.serve_forever()

asteri/workers/gthread.py

@@ -0,0 +1,25 @@
+import os
+import socket
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from .sync import SyncWorker
+
+class GThreadWorker(SyncWorker):
+    def __init__(self, age, ppid, socket, app, timeout, threads=4):
+        super().__init__(age, ppid, socket, app, timeout)
+        self.threads = threads
+
+    def run(self):
+        self.init_process()
+        self.socket.settimeout(1.0)
+        
+        with ThreadPoolExecutor(max_workers=self.threads) as executor:
+            while self.alive:
+                try:
+                    client, addr = self.socket.accept()
+                    executor.submit(self.handle_request, client)
+                except socket.timeout:
+                    if os.getppid() != self.ppid:
+                        self.alive = False
+                except Exception:
+                    continue

asteri/workers/sync.py

@@ -0,0 +1,83 @@
+import os
+import socket
+import sys
+import io
+from .base import BaseWorker
+from ..http import build_http_response
+
+class SyncWorker(BaseWorker):
+    def run(self):
+        self.init_process()
+        
+        # Configure socket to be non-blocking with a timeout for select-like behavior
+        self.socket.settimeout(1.0)
+        
+        while self.alive:
+            try:
+                client, addr = self.socket.accept()
+                self.handle_request(client)
+            except socket.timeout:
+                # Check parent process (Arbiter) is still alive
+                if sys.platform != 'win32' and os.getppid() != self.ppid:
+                    self.alive = False
+                    break
+            except Exception as e:
+                if self.alive:
+                    pass # Log or handle accept errors
+
+    def handle_http(self, sock, req):
+        """Standard WSGI handling for HTTP/1.1."""
+        env = self.build_wsgi_environ(req)
+        self.execute_wsgi(sock, env)
+
+    def handle_uwsgi(self, sock, env):
+        """WSGI handling for uWSGI protocol."""
+        self.execute_wsgi(sock, env)
+
+    def build_wsgi_environ(self, req):
+        env = {
+            'REQUEST_METHOD': req.method,
+            'SCRIPT_NAME': '',
+            'PATH_INFO': req.path.split('?')[0],
+            'QUERY_STRING': req.path.split('?')[1] if '?' in req.path else '',
+            'SERVER_NAME': 'localhost',
+            'SERVER_PORT': '8000',
+            'SERVER_PROTOCOL': 'HTTP/1.1',
+            'wsgi.version': (1, 0),
+            'wsgi.url_scheme': 'http',
+            'wsgi.input': io.BytesIO(req.body or b""),
+            'wsgi.errors': sys.stderr,
+            'wsgi.multithread': False,
+            'wsgi.multiprocess': True,
+            'wsgi.run_once': False,
+        }
+        for k, v in req.headers.items():
+            env[f"HTTP_{k.upper().replace('-', '_')}"] = v
+        
+        if 'content-type' in req.headers:
+            env['CONTENT_TYPE'] = req.headers['content-type']
+        if 'content-length' in req.headers:
+            env['CONTENT_LENGTH'] = req.headers['content-length']
+            
+        return env
+
+    def execute_wsgi(self, sock, env):
+        response_data = []
+        headers_set = []
+
+        def start_response(status, headers, exc_info=None):
+            headers_set.extend([status, headers])
+            return response_data.append
+
+        try:
+            result = self.app(env, start_response)
+            status_code = int(headers_set[0].split()[0])
+            headers = dict(headers_set[1])
+            
+            body = b"".join(result) if hasattr(result, '__iter__') else result
+            if hasattr(result, 'close'):
+                result.close()
+
+            sock.sendall(build_http_response(status_code, headers, body))
+        except Exception as e:
+            sock.sendall(build_http_response(500, {}, f"WSGI Error: {e}"))

asteri-1.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: asteri
+Version: 1.0.0
+License-File: LICENSE
+Requires-Dist: setproctitle>=1.3.3
+Requires-Dist: watchdog>=3.0.0
+Requires-Dist: h2>=4.1.0
+Requires-Dist: gevent>=23.9.1
+Requires-Dist: psutil>=5.9.0
+Dynamic: license-file
+Dynamic: requires-dist

asteri-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+asteri/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asteri/__main__.py,sha256=cOPIBk7slyQaT-OjWoq4kBKtFv17Gv9a_F6rBH-VpfI,8382
+asteri/arbiter.py,sha256=mhz_t8O_gwVLE7gchD5BvZm94cXtKak6O4_sdl5cpMs,6818
+asteri/http.py,sha256=DiIXOyDrDoCGYURKXKD-bzjMEXHvygeCnLcSgjuXgSA,3961
+asteri/utils.py,sha256=ahY7qJQJXaEAPzW-YsRi4gMmboNbtH9OCHra3wsw058,3069
+asteri/uwsgi.py,sha256=hUdbDexLhQQ1sLtAK9IyMfsJEczQwLr-Odkx01ZK4dY,1462
+asteri/workers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asteri/workers/asgi.py,sha256=AOr1dTyzBk4VlPsGknO1t07A7vDvQI1fhpImHYH32uE,2683
+asteri/workers/base.py,sha256=azd61dWYYOr7n47aH-vdQ4H9b_LR6K1R2TUOAhCF8Ww,3068
+asteri/workers/gevent.py,sha256=KIciq--ml7wi6jv-XxGeO2RGa5dFhBNnO4q42dPBt3g,744
+asteri/workers/gthread.py,sha256=VB32vibNpcT5xzFa-o9Q_iDHvGwncFzI3Z09ZOcrrdc,842
+asteri/workers/sync.py,sha256=h8BQtt3RfC5AR0BtJ0Du_l2FBGvqklrQc6jTOJffWrY,2900
+asteri-1.0.0.dist-info/licenses/LICENSE,sha256=O75LkbUP4RP8OKRx7RfZHXQ-qJjE_ipCCichMzulrRs,1068
+asteri-1.0.0.dist-info/METADATA,sha256=hwiVZDCYxcX5jyuX2jMde332zd9Agf_9wp1nhzsOqcI,267
+asteri-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+asteri-1.0.0.dist-info/entry_points.txt,sha256=e8zqH5clzgec97YjP_aVsdMMjzlT-Y_syrft5ZyT06Y,48
+asteri-1.0.0.dist-info/top_level.txt,sha256=Q6UkJRR0ftchLXGRnD4mpQ4iZXrwDJRmoB23hxJhZKg,7
+asteri-1.0.0.dist-info/RECORD,,

asteri-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

asteri-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+asteri = asteri.__main__:main

asteri-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IshikawaUta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

asteri-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+asteri