DefStream 0.1.13__44-py3-none-any.whl

DefStream/Inspector/Extensions/__init__.py

@@ -0,0 +1,13 @@
+from .HealthCheck import HealthCheck
+from .Metrics import Metrics
+from .Specifications import Specifications
+from .Console import Console
+from .Dashboard import Dashboard
+
+__all__ = (
+	'HealthCheck',
+	'Metrics',
+	'Specifications',
+	'Console',
+	'Dashboard',
+)

DefStream/Inspector/Inspector.py

@@ -0,0 +1,347 @@
+from logging import getLogger
+from socketserver import ThreadingMixIn
+from sys import exc_info
+from threading import Thread
+from time import monotonic
+from traceback import extract_tb
+from typing import (
+	Callable,
+	Dict,
+	Iterable,
+	Optional,
+	Sequence,
+	TYPE_CHECKING,
+	Tuple,
+)
+from wsgiref.simple_server import (
+	WSGIRequestHandler,
+	ServerHandler,
+	WSGIServer,
+	make_server,
+)
+
+from .Extension import Extension
+from .Response import Response
+
+if TYPE_CHECKING:
+	from ..Worker.Worker import Worker
+
+__all__ = (
+	'Inspector',
+)
+
+
+class Server(
+	ThreadingMixIn,
+	WSGIServer,
+):
+	logger = getLogger('DefStream.Inspector')
+
+	daemon_threads = True
+	block_on_close = False
+
+	def get_request(self):
+		connection, address = super().get_request()
+		connection.settimeout(5)
+		return connection, address
+
+	def handle_error(
+		self,
+		request,
+		client_address,
+	) -> None:
+		_, error, traceback = exc_info()
+		self.logger.error(
+			'HTTP connection handling failed: error_type=%s\n%s',
+			type(error).__name__,
+			''.join(
+				f'  {frame.filename}:{frame.lineno} ({frame.name})\n'
+				for frame in extract_tb(traceback)
+			),
+		)
+		return
+
+
+class InspectorServerHandler(ServerHandler):
+	def log_exception(
+		self,
+		exc_info,
+	) -> None:
+		_, error, traceback = exc_info
+		self.request_handler.logger.error(
+			'WSGI request handling failed: error_type=%s\n%s',
+			type(error).__name__,
+			''.join(
+				f'  {frame.filename}:{frame.lineno} ({frame.name})\n'
+				for frame in extract_tb(traceback)
+			),
+		)
+		return
+
+
+class RequestHandler(WSGIRequestHandler):
+	logger = getLogger('DefStream.Inspector')
+
+	def handle(self) -> None:
+		self.started_at = monotonic()
+		self.path = ''
+		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:
+			self.close_connection = True
+			return
+		if not self.parse_request():
+			return
+		self.logger.debug(
+			'HTTP request received: method=%s path=%s',
+			self.command,
+			self.path.partition('?')[0],
+		)
+		handler = InspectorServerHandler(
+			self.rfile,
+			self.wfile,
+			self.get_stderr(),
+			self.get_environ(),
+			multithread=True,
+		)
+		handler.request_handler = self
+		handler.run(self.server.get_app())
+
+	def log_request(
+		self,
+		code='-',
+		size='-',
+	) -> None:
+		self.logger.info(
+			'HTTP response sent: method=%s path=%s status=%s bytes=%s duration=%s',
+			self.command,
+			self.path.partition('?')[0],
+			code,
+			size if size is not None else '-',
+			monotonic() - self.started_at,
+		)
+		return
+
+	def log_message(
+		self,
+		format: str,
+		*args,
+	) -> None:
+		self.logger.warning('HTTP protocol error or request timeout')
+		return
+
+
+class Inspector:
+	logger = getLogger('DefStream.Inspector')
+
+	def __init__(
+		self,
+		host: str = '127.0.0.1',
+		port: int = 9999,
+		exts: Sequence[Extension] = (),
+	):
+		if isinstance(
+			port,
+			bool,
+		) or not isinstance(
+			port,
+			int,
+		) or not 0 <= port <= 65535:
+			raise ValueError('Inspector port must be between 0 and 65535')
+		self.host = host
+		self.port = port
+		self.exts: Dict[str, Extension] = {}
+		for ext in exts:
+			if not isinstance(
+				ext,
+				Extension,
+			):
+				raise TypeError('Inspector extensions must inherit Extension')
+			if ext.path in self.exts:
+				raise ValueError('Duplicate Inspector path: ' + ext.path)
+			self.exts[ext.path] = ext
+			self.logger.debug(
+				'Inspector extension registered: class=%s path=%s',
+				type(ext).__name__,
+				ext.path,
+			)
+		self.worker: Optional['Worker'] = None
+		self.server: Optional[WSGIServer] = None
+		self.thread: Optional[Thread] = None
+
+	def start(
+		self,
+		worker: 'Worker',
+	) -> None:
+		if self.worker is not None:
+			raise RuntimeError('Inspector can only be attached and started once')
+		self.worker = worker
+		for ext in self.exts.values():
+			self.logger.debug(
+				'Starting Inspector extension: class=%s path=%s',
+				type(ext).__name__,
+				ext.path,
+			)
+			try:
+				ext.start(self)
+			except Exception as error:
+				self.logger.error(
+					'Inspector extension startup failed: class=%s path=%s error=%s',
+					type(ext).__name__,
+					ext.path,
+					type(error).__name__,
+				)
+				raise
+		try:
+			server = make_server(
+				self.host,
+				self.port,
+				self,
+				server_class=Server,
+				handler_class=RequestHandler,
+			)
+		except Exception as error:
+			self.logger.error(
+				'Inspector HTTP server binding failed: error=%s',
+				type(error).__name__,
+			)
+			raise
+		self.server = server
+		thread = Thread(
+			target=self.serve,
+			daemon=True,
+		)
+		self.thread = thread
+		try:
+			thread.start()
+		except BaseException:
+			self.logger.error('Inspector HTTP server thread startup failed')
+			server.server_close()
+			raise
+		self.logger.info(
+			'Inspector HTTP server started: host=%s port=%s',
+			server.server_address[0],
+			server.server_port,
+		)
+
+	def serve(self) -> None:
+		server = self.server
+		if server is None:
+			raise RuntimeError('Inspector server is not initialized')
+		try:
+			server.serve_forever(poll_interval=0.1)
+		except Exception as error:
+			self.logger.error(
+				'Inspector HTTP server failed: error=%s',
+				type(error).__name__,
+			)
+			if self.worker is not None:
+				self.worker.stop()
+			raise
+
+	def stop(self) -> None:
+		server = self.server
+		thread = self.thread
+		if server is not None:
+			try:
+				if thread is not None and thread.is_alive():
+					self.logger.info('Stopping Inspector HTTP server')
+					server.shutdown()
+					thread.join()
+			finally:
+				server.server_close()
+				self.logger.info('Inspector HTTP server stopped')
+
+	def begin(
+		self,
+		task: str,
+	) -> Tuple[Tuple[Extension, object], ...]:
+		return tuple(
+			(
+				ext,
+				ext.begin(task),
+			)
+			for ext in self.exts.values()
+		)
+
+	def end(
+		self,
+		task: str,
+		contexts: Tuple[Tuple[Extension, object], ...],
+		success: Optional[bool],
+	) -> None:
+		for ext, context in contexts:
+			ext.end(
+				task,
+				context,
+				success,
+			)
+
+	def __call__(
+		self,
+		environ: dict,
+		start_response: Callable,
+	) -> Iterable[bytes]:
+		method = environ['REQUEST_METHOD']
+		environ['wsgi.multithread'] = True
+		headers = []
+		ext = self.exts.get(environ['PATH_INFO'])
+		self.logger.debug(
+			'Routing Inspector request: method=%s path=%r extension=%s',
+			method,
+			environ['PATH_INFO'],
+			type(ext).__name__ if ext is not None else 'none',
+		)
+		methods = ext.methods if ext is not None else (
+			'GET',
+			'HEAD',
+		)
+		if method not in methods:
+			response = Response(
+				'405 Method Not Allowed',
+				b'Method not allowed\n',
+				'text/plain; charset=utf-8',
+			)
+			headers.append((
+				'Allow',
+				', '.join(methods),
+			))
+		else:
+			response = ext.handle(
+				self,
+				environ,
+			) if ext is not None else Response(
+				'404 Not Found',
+				b'Not found\n',
+				'text/plain; charset=utf-8',
+			)
+		headers.extend(response.headers)
+		headers.extend((
+			(
+				'Content-Type',
+				response.content_type,
+			),
+			(
+				'Content-Length',
+				str(len(response.body)),
+			),
+			(
+				'Cache-Control',
+				'no-store',
+			),
+		))
+		self.logger.debug(
+			'Inspector response built: status=%s bytes=%d',
+			response.status,
+			len(response.body),
+		)
+		start_response(
+			response.status,
+			headers,
+		)
+		return [b'' if method == 'HEAD' else response.body]

DefStream/Inspector/Response.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+from typing import Tuple
+
+__all__ = (
+	'Response',
+)
+
+
+@dataclass
+class Response:
+	status: str
+	body: bytes
+	content_type: str
+	headers: Tuple[Tuple[str, str], ...] = ()

DefStream/Inspector/__init__.py

@@ -0,0 +1,9 @@
+from .Inspector import Inspector
+from .Extension import Extension
+from .Response import Response
+
+__all__ = (
+	'Inspector',
+	'Extension',
+	'Response',
+)

DefStream/Validator/Pattern.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+from abc import (
+	ABC,
+	abstractmethod,
+)
+
+__all__ = (
+	'Pattern',
+)
+
+
+class Pattern(ABC):
+	"""
+	Pattern Interface Class for Validator
+
+	Sample:
+	from operator import eq
+
+	class SamplePattern(Pattern):
+		def __init__(self, compare):
+			super(SamplePattern, self).__init__(error)
+			self.compare = compare
+			return
+
+		def __call__(self, parameter):
+			if not eq(parameter, self.compare):
+				raise ValueError('{} is not equal to {}'.format(parameter, self.condition))
+			return parameter  # if true, return parameter
+	"""
+	@abstractmethod
+	def __call__(self, parameter):
+		pass
+
+	def __repr__(self):
+		return '{}()'.format(self.__class__.__name__)

DefStream/Validator/Patterns/Array.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from typing import Any
+
+__all__ = (
+	'IsElementOf',
+)
+
+
+class IsElementOf(Pattern):
+	def __init__(self, *args):
+		self.patterns = args
+		return
+
+	def __call__(self, parameter: Any) -> Any:
+		_ = list(parameter)
+		for pattern in self.patterns:
+			for i, e in enumerate(_):
+				_[i] = pattern(e)
+		return type(parameter)(_)
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(p) for p in self.patterns]
+			)
+		)

DefStream/Validator/Patterns/Common.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from operator import eq
+
+__all__ = (
+	'SetDefault',
+	'IsToNone',
+	'IsNotToNone',
+	'IsNotEmpty',
+)
+
+
+class SetDefault(Pattern):
+	def __init__(self, default):
+		self.default = default
+		return
+
+	def __call__(self, parameter):
+		if parameter == None:
+			return self.default
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.default
+		)
+	
+
+class IsToNone(Pattern):
+	def __init__(self, *args):
+		self.patterns = args
+		return
+
+	def __call__(self, parameter):
+		if parameter is None:
+			return parameter
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join([p.__repr__() for p in self.patterns])
+		)
+
+
+class IsNotToNone(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if parameter is None:
+			if self.error:
+				raise self.error
+			raise ValueError('{} is None'.format(parameter))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join([p.__repr__() for p in self.patterns])
+		)
+
+
+class IsNotEmpty(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if eq(len(parameter), 0):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be not empty'.format(parameter))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join([p.__repr__() for p in self.patterns])
+		)
+

DefStream/Validator/Patterns/Compare.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from operator import eq, ne, gt, ge, lt, le
+
+__all__ = (
+	'IsIn',
+	'IsNotIn',
+	'IsEqualTo',
+	'IsNotEqualTo',
+	'IsGreaterThan',
+	'IsGreaterEqualTo',
+	'IsLessThan',
+	'IsLessEqualTo',
+)
+
+
+class IsIn(Pattern):
+	def __init__(self, *args, error=None):
+		self.compares = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if parameter not in self.compares:
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be in {}'.format(parameter, self.compares))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(c) for c in self.compares]
+			)
+		)
+
+
+class IsNotIn(Pattern):
+	def __init__(self, *args, error=None):
+		self.compares = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if parameter in self.compares:
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be not in {}'.format(parameter, self.compares))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(c) for c in self.compares]
+			)
+		)
+
+
+class IsEqualTo(Pattern):
+	def __init__(self, equal, error=None):
+		self.equal = equal
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not eq(parameter, self.equal):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must equal to {}'.format(parameter, self.equal))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.equal
+		)
+
+
+class IsNotEqualTo(Pattern):
+	def __init__(self, equal, error=None):
+		self.equal = equal
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not ne(parameter, self.equal):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must not equal to {}'.format(parameter, self.equal))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.equal
+		)
+
+
+class IsGreaterEqualTo(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not ge(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be greater equal to {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)
+
+
+class IsGreaterThan(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not gt(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be greater than {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)
+
+
+class IsLessEqualTo(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not le(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be less equal to {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)
+
+
+class IsLessThan(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not lt(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be less than {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)