DefEssential 0.1.8__24-py3-none-any.whl

DefEssential/Adapter/Implements/Gunicorn/Server.py

@@ -0,0 +1,152 @@
+from os import name
+from logging import getLogger
+from typing import (
+	Any,
+	Union,
+)
+
+from ....Application import Application
+from ....Startup import startup
+from ...Server import Server as ServerAdapter
+from .Transport import (
+	Body,
+	GunicornApplication as RequestApplication,
+)
+
+__all__ = (
+	'Server',
+)
+
+
+class Server(ServerAdapter):
+	"""Start and stop the application in each Gunicorn worker."""
+
+	logger = getLogger('DefEssential.Server')
+
+	def __init__(
+		self,
+		host: str,
+		port: int,
+		application: Application,
+		*,
+		workers: int = 1,
+		worker_class: Union[str, type] = 'sync',
+		**options: Any,
+	):
+		super().__init__(
+			host,
+			port,
+			application,
+		)
+		if workers < 1:
+			raise ValueError('workers must be at least 1')
+		if 'bind' in options:
+			raise ValueError('Use host and port instead of bind')
+		self.workers = workers
+		self.worker_class = worker_class
+		self.options = options
+		return
+
+	def run(self) -> None:
+		if name == 'nt':
+			raise RuntimeError('Gunicorn requires a POSIX platform; use Linux or WSL')
+		# Gunicorn is an optional dependency and cannot be imported on Windows.
+		from gunicorn.app.base import BaseApplication
+
+		application = self.application
+		options = dict(self.options)
+		when_ready = options.pop('when_ready', None)
+		post_worker_init = options.pop('post_worker_init', None)
+		worker_exit = options.pop('worker_exit', None)
+		pre_request = options.pop('pre_request', None)
+		address = f'[{self.host}]' if ':' in self.host else self.host
+		options.update(
+			bind=f'{address}:{self.port}',
+			workers=self.workers,
+			worker_class=self.worker_class,
+		)
+
+		def ready(server: Any) -> None:
+			if when_ready is not None:
+				when_ready(server)
+			startup(
+				application,
+				'Gunicorn',
+				self.host,
+				self.port,
+			)
+			for listener in server.LISTENERS:
+				self.logger.info(
+					'Server ready: adapter=Gunicorn address=%s',
+					listener.getsockname(),
+				)
+			return
+
+		def start(worker: Any) -> None:
+			application.start()
+			if post_worker_init is not None:
+				post_worker_init(worker)
+			return
+
+		def prepare(
+			worker: Any,
+			request: Any,
+		) -> None:
+			if pre_request is not None:
+				pre_request(
+					worker,
+					request,
+				)
+			request.body = Body(request)
+			if any(
+				key == 'UPGRADE' and value.lower() == 'websocket'
+				for key, value in request.headers
+			):
+				request.force_close()
+			return
+
+		def stop(
+			server: Any,
+			worker: Any,
+		) -> None:
+			try:
+				application.stop()
+			finally:
+				if worker_exit is not None:
+					worker_exit(
+						server,
+						worker,
+					)
+			return
+
+		options.update(
+			when_ready=ready,
+			post_worker_init=start,
+			worker_exit=stop,
+			pre_request=prepare,
+		)
+
+		class GunicornApplication(BaseApplication):
+			def load_config(self) -> None:
+				for key, value in options.items():
+					self.cfg.set(
+						key,
+						value,
+					)
+				return
+
+			def load(self) -> RequestApplication:
+				return RequestApplication(application)
+
+		self.logger.info('Server starting: adapter=Gunicorn host=%s port=%s', self.host, self.port)
+		try:
+			GunicornApplication().run()
+		except SystemExit as error:
+			if error.code:
+				self.logger.error('Server exited unsuccessfully: adapter=Gunicorn code=%s', error.code)
+			raise
+		except Exception:
+			self.logger.exception('Server execution failed: adapter=Gunicorn')
+			raise
+		self.logger.info('Server stopped: adapter=Gunicorn')
+		return

DefEssential/Adapter/Implements/Gunicorn/Transport.py

@@ -0,0 +1,171 @@
+from typing import (
+	Any,
+	Mapping,
+)
+
+from ....IO.Readers.ChunkedStream import ChunkedStream
+from ....IO.RequestReader import RequestReader
+from ....IO.ResponseWriter import ResponseWriter
+from ....Response import Response
+from ...WSGI import (
+	StartResponse,
+	WSGIApplication,
+	WSGIResponseWriter,
+	WSGITransport,
+)
+
+__all__ = (
+	'Input',
+	'Body',
+	'Transport',
+	'Writer',
+	'GunicornApplication',
+)
+
+
+class Input:
+	"""Share the Gunicorn parser's buffered input and body state with the framework and worker."""
+
+	def __init__(
+		self,
+		request: Any,
+	):
+		self.unreader = request.unreader
+		headers = dict(request.headers)
+		length = headers.get('CONTENT-LENGTH')
+		self.request_reader = RequestReader(
+			self,
+			size=int(length) if length is not None else None,
+			chunked=headers.get('TRANSFER-ENCODING', '').lower() == 'chunked',
+		)
+		self.body = ChunkedStream(self.request_reader) if self.request_reader.chunked else self.request_reader
+		return
+
+	def read(
+		self,
+		size: int = -1,
+		/,
+	) -> bytes:
+		return self.unreader.read(size)
+
+	def readline(
+		self,
+		size: int = -1,
+		/,
+	) -> bytes:
+		parts = []
+		while size < 0 or len(parts) < size:
+			data = self.unreader.read(1)
+			if not data:
+				break
+			parts.append(data)
+			if data == b'\n':
+				break
+		return b''.join(parts)
+
+
+class Body:
+	"""Preserve the application's read position when the worker discards the remaining body."""
+
+	def __init__(
+		self,
+		request: Any,
+	):
+		self.input = Input(request)
+		return
+
+	def read(
+		self,
+		size: int = -1,
+	) -> bytes:
+		return self.input.body.read(size)
+
+	def readline(
+		self,
+		size: int = -1,
+	) -> bytes:
+		return self.input.body.readline(size)
+
+
+class Transport(WSGITransport):
+	"""Delegate HTTP to Gunicorn and use the raw socket after a 101 upgrade."""
+
+	def __init__(
+		self,
+		start_response: StartResponse,
+		socket: Any,
+	):
+		super().__init__(start_response)
+		self.socket = socket
+		self.upgraded = False
+		return
+
+	def begin(
+		self,
+		response: Response,
+		chunked: bool,
+	) -> None:
+		if response.status != 101:
+			super().begin(
+				response,
+				chunked,
+			)
+			return
+		output = self.start_response(
+			f'{response.status} {response.message}',
+			response.headers(),
+		)
+		output(b'')
+		self.upgraded = True
+		return
+
+	def write(
+		self,
+		data: bytes,
+		/,
+	) -> int:
+		if self.upgraded:
+			self.socket.sendall(data)
+			return len(data)
+		return super().write(data)
+
+
+class Writer(WSGIResponseWriter):
+	def upgrade(
+		self,
+		response: Response,
+	) -> None:
+		ResponseWriter.upgrade(
+			self,
+			response,
+		)
+		return
+
+
+class GunicornApplication(WSGIApplication):
+	"""Provide the same I/O and WebSocket API for sync, gthread, and gevent workers."""
+
+	def request_reader(
+		self,
+		environ: Mapping[str, Any],
+	) -> RequestReader:
+		body = environ['wsgi.input']
+		if not isinstance(body, Body):
+			raise TypeError('Gunicorn input hook was not installed')
+		return body.input.request_reader
+
+	def response_writer(
+		self,
+		environ: Mapping[str, Any],
+		start_response: StartResponse,
+	) -> ResponseWriter:
+		transport = Transport(
+			start_response,
+			environ['gunicorn.socket'],
+		)
+		return Writer(
+			transport.begin,
+			transport,
+			method=environ['REQUEST_METHOD'],
+			version=environ['SERVER_PROTOCOL'],
+		)

DefEssential/Adapter/Implements/Gunicorn/__init__.py

@@ -0,0 +1,5 @@
+from .Server import Server
+
+__all__ = (
+	'Server',
+)

DefEssential/Adapter/Implements/Python/Server.py

@@ -0,0 +1,273 @@
+from http.server import (
+	BaseHTTPRequestHandler,
+	ThreadingHTTPServer,
+)
+from logging import getLogger
+from typing import (
+	Optional,
+	Union,
+)
+
+from ....Application import Application
+from ....Error import Error
+from ....Request import Request
+from ....IO.RequestReader import RequestReader
+from ....Response import Response
+from ....IO.ResponseWriter import ResponseWriter
+from ....Startup import startup
+from ...Server import Server as ServerAdapter
+from ...RequestHandler import handle_request
+
+__all__ = (
+	'Server',
+	'ServerRequestHandler',
+)
+
+
+class Server(
+	ThreadingHTTPServer,
+	ServerAdapter,
+):
+	"""Run the built-in HTTP transport without external dependencies."""
+
+	daemon_threads = True
+	app: Application
+	logger = getLogger('DefEssential.Server')
+
+	def __init__(
+		self,
+		host: str,
+		port: int,
+		application: Application,
+		*,
+		poll_interval: float = 0.5,
+	):
+		ServerAdapter.__init__(
+			self,
+			host,
+			port,
+			application,
+		)
+		self.app = application
+		self.poll_interval = poll_interval
+		try:
+			ThreadingHTTPServer.__init__(
+				self,
+				(
+					host,
+					port,
+				),
+				ServerRequestHandler,
+			)
+		except Exception:
+			self.logger.exception('Server bind failed: adapter=Python host=%s port=%s', host, port)
+			raise
+		return
+
+	def run(self) -> None:
+		"""Close the listening socket and ensure extensions shut down when serving stops."""
+		with self:
+			self.serve_forever(self.poll_interval)
+		self.logger.info('Server stopped: adapter=Python')
+		return
+
+	def serve_forever(
+		self,
+		poll_interval: float = 0.5,
+	) -> None:
+		host = self.server_address[0]
+		if not isinstance(host, str):
+			raise TypeError('HTTP listen address must be a string')
+		self.logger.info('Server starting: adapter=Python host=%s port=%s', host, self.server_port)
+		startup(
+			self.application,
+			'Python',
+			host,
+			self.server_port,
+		)
+		self.app.start()
+		self.logger.info('Server ready: adapter=Python host=%s port=%s', host, self.server_port)
+		try:
+			super().serve_forever(poll_interval=poll_interval)
+		except KeyboardInterrupt:
+			self.logger.info('Shutdown requested by keyboard interrupt: adapter=Python')
+		except Exception:
+			self.logger.exception('Server execution failed: adapter=Python')
+			raise
+		finally:
+			self.logger.info('Server stopping: adapter=Python')
+			self.app.stop()
+		self.logger.info('Server serving stopped: adapter=Python')
+		return
+
+
+class ServerRequestHandler(BaseHTTPRequestHandler):
+	server: Server
+	protocol_version = 'HTTP/1.1'
+	server_version = 'DefEssential'
+	logger = getLogger('DefEssential.Server')
+
+	def request_reader(self) -> RequestReader:
+		lengths = self.headers.get_all('Content-Length', [])
+		transfers = self.headers.get_all('Transfer-Encoding', [])
+		if len(self.headers.get_all('Content-Type', [])) > 1:
+			raise Error(
+				400,
+				'Duplicate Content-Type',
+			)
+		if len(lengths) > 1 or len(transfers) > 1 or (lengths and transfers):
+			raise Error(
+				400,
+				'Ambiguous request body framing',
+			)
+		size: Optional[int] = None
+		if lengths:
+			if not lengths[0].isascii() or not lengths[0].isdigit():
+				raise Error(
+					400,
+					'Invalid Content-Length',
+				)
+			size = int(lengths[0])
+		if transfers and transfers[0].lower() != 'chunked':
+			raise Error(
+				400,
+				'Unsupported Transfer-Encoding',
+			)
+		return RequestReader(
+			self.rfile,
+			size=size,
+			chunked=bool(transfers),
+		)
+
+	def handle_one_request(self) -> None:
+		self.close_connection = True
+		try:
+			self.raw_requestline = self.rfile.readline(65537)
+			if len(self.raw_requestline) > 65536:
+				self.requestline = ''
+				self.request_version = ''
+				self.command = ''
+				self.send_error(414)
+				return
+			if not self.raw_requestline:
+				return
+			if not self.parse_request():
+				return
+		except ConnectionError:
+			self.logger.warning('Client disconnected before request parsing: adapter=Python')
+			return
+		self.close_connection = True
+		writer = ResponseWriter(
+			self.begin_response,
+			self.wfile,
+			method=self.command,
+			version=self.request_version,
+		)
+
+		def create_request() -> Request:
+			return Request(
+				address=self.client_address[0],
+				port=self.client_address[1],
+				method=self.command,
+				uri=self.path,
+				headers=dict(self.headers.items()),
+				reader=self.request_reader(),
+				writer=writer,
+			)
+
+		try:
+			handle_request(
+				self.server.app,
+				create_request,
+				writer,
+			)
+		except Exception:
+			# The shared handler logs transport errors; finish by closing the connection.
+			self.close_connection = True
+		return
+
+	def begin_response(
+		self,
+		response: Response,
+		chunked: bool,
+	) -> None:
+		length = response.header('Content-Length')
+		self.response_status = response.status
+		self.send_response(
+			response.status,
+			response.message,
+		)
+		no_body = (
+			self.command == 'HEAD'
+			or response.status in (
+				204,
+				205,
+				304,
+			)
+			or response.status < 200
+		)
+		upgrade = response.status == 101
+		excluded = (
+			'content-length',
+			'transfer-encoding',
+		) if upgrade else (
+			'connection',
+			'content-length',
+			'transfer-encoding',
+		)
+		for key, value in response.headers():
+			if key.lower() not in excluded:
+				self.send_header(
+					key,
+					value,
+				)
+		if chunked and not no_body:
+			self.send_header(
+				'Transfer-Encoding',
+				'chunked',
+			)
+		elif length is not None and response.status not in (
+			204,
+			205,
+			304,
+		):
+			self.send_header(
+				'Content-Length',
+				length,
+			)
+		if response.status == 205:
+			self.send_header(
+				'Content-Length',
+				'0',
+			)
+		if not upgrade:
+			self.send_header(
+				'Connection',
+				'close',
+			)
+		self.end_headers()
+		return
+
+	def log_message(
+		self,
+		format: str,
+		*args: object,
+	) -> None:
+		self.logger.debug(
+			'HTTP parser diagnostic: method=%s',
+			ascii(self.command[:32]) if self.command is not None else None,
+		)
+		return
+
+	def log_request(
+		self,
+		code: Union[int, str] = '-',
+		size: Union[int, str] = '-',
+	) -> None:
+		"""Keep shared result logging separate because selecting headers does not complete transmission."""
+		self.logger.debug(
+			'HTTP response headers selected: status=%s method=%s',
+			code,
+			ascii(self.command[:32]) if self.command is not None else None,
+		)
+		return

DefEssential/Adapter/Implements/Python/__init__.py

@@ -0,0 +1,5 @@
+from .Server import Server
+
+__all__ = (
+	'Server',
+)