DefStream-RabbitMQ 0.1.1__py3-none-any.whl

DefStream/Broker/Implements/RabbitMQ/Event.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+from ...Event import (
+	Event as BaseEvent,
+	EventHandler as BaseEventHandler,
+)
+
+from abc import abstractmethod
+
+__all__ = (
+	'Event',
+	'EventHandler',
+)
+
+
+class Event(BaseEvent):
+	"""Event of Event Broker for RabbitMQ"""
+	def __init__(
+		self,
+		channel,
+		queue,
+		consumer,
+		transaction,
+		properties,
+		body,
+	):
+		self.channel = channel
+		self.queue = queue
+		self.consumer = consumer
+		self.transaction = transaction
+		self.properties = properties
+		self.props = properties.headers
+		self.payload = body
+		return
+
+	def __repr__(self):
+		return 'Event(id={}, body={}, type={}, headers={})'.format(
+			self.properties.message_id,
+			self.payload,
+			self.properties.type,
+			self.props,
+		)
+
+	def ack(self):
+		self.channel.basic_ack(self.transaction)
+		return
+
+	def nack(self):
+		self.channel.basic_nack(
+			self.transaction,
+			requeue=True,
+		)
+		return
+
+	def reject(self):
+		self.channel.basic_reject(
+			self.transaction,
+			requeue=False,
+		)
+		return
+
+	def headers(self):
+		return self.props
+
+	def header(
+		self,
+		key,
+	):
+		if key not in self.props:
+			return None
+		return self.props[key]
+
+	@property
+	def src(self):
+		return self.queue
+
+	@property
+	def id(self):
+		return self.properties.message_id
+
+	@property
+	def type(self):
+		return self.properties.type
+
+	@property
+	def body(self):
+		return self.payload
+	
+	@property
+	def priority(self):
+		if not hasattr(
+			self.properties,
+			'priority',
+		):
+			return None
+		return self.properties.priority
+
+
+class EventHandler(BaseEventHandler):
+	"""Event Handler Interface of Event Broker for RabbitMQ"""
+	@abstractmethod
+	def __call__(
+		self,
+		event: Event,
+	):
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))

DefStream/Broker/Implements/RabbitMQ/Exchange.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+
+from ... import (
+	Sendable,
+	Callable,
+)
+
+from .Serializer import (
+	Encoder,
+	Decoder,
+)
+from ...Errors import RemoteError
+from copy import deepcopy
+from math import (
+	ceil,
+	isfinite,
+)
+
+from pika import (
+	BlockingConnection,
+	BasicProperties,
+	ConnectionParameters,
+)
+
+from time import (
+	time,
+	monotonic,
+)
+from enum import Enum
+from uuid import uuid4
+
+from typing import (
+	Any,
+	Dict,
+	Optional,
+)
+
+__all__ = (
+	'Exchange',
+)
+
+
+class Exchange(
+	Sendable,
+	Callable,
+):
+	"""Exchange of Event Broker for RabbitMQ"""
+	def __init__(
+		self,
+		connection: BlockingConnection,
+		encode: Encoder,
+		name: str = None,
+		decode: Optional[Decoder] = None,
+		rpc_parameters: Optional[ConnectionParameters] = None,
+	):
+		self.connection = connection
+		self.encode = encode
+		self.channel = self.connection.channel()
+		self.channel.auto_decode = False
+		self.exchange = name
+		self.decode = decode
+		self.rpc_parameters = rpc_parameters
+		return
+
+	def __del__(self):
+		if self.channel and self.channel.is_open:
+			self.channel.close()
+		return
+	
+	def __str__(self): return self.exchange
+
+	def send(
+		self,
+		body,
+		event: str = None,
+		headers: Dict = {},
+		priority: int = None,
+		expiration: int = None,
+		timestamp: int = None,
+		persistent: bool = True,
+		id: str = None,
+	):
+		if not timestamp: timestamp = int(time())
+		if not id: id = uuid4().hex
+		properties = BasicProperties(
+			type=event if event else '',
+			headers=headers,
+			content_type=self.encode.format,
+			content_encoding=self.encode.charset,
+			priority=priority,
+			timestamp=timestamp,
+			expiration=expiration,
+			message_id=id,
+			delivery_mode=2 if persistent else 1,
+		)
+		self.channel.basic_publish(
+			exchange=self.exchange,
+			routing_key=event if event else '',
+			properties=properties,
+			body=self.encode(body),
+		)
+		return id
+
+	def call(
+		self,
+		body: Any,
+		timeout: float = 5,
+		*,
+		event: Optional[str] = None,
+	) -> Any:
+		if self.rpc_parameters is None or self.decode is None:
+			raise RuntimeError('RPC requires decoder and connection parameters; obtain the exchange through Connection.exchange')
+		if isinstance(
+			timeout,
+			bool,
+		) or not isinstance(
+			timeout,
+			(
+				int,
+				float,
+			),
+		) or not isfinite(timeout) or timeout <= 0:
+			raise ValueError('RPC timeout must be a finite positive number of seconds')
+		deadline = monotonic() + timeout
+		settings = deepcopy(self.rpc_parameters)
+		settings.connection_attempts = 1
+		settings.socket_timeout = min(
+			settings.socket_timeout,
+			timeout,
+		)
+		settings.stack_timeout = timeout
+		settings.blocked_connection_timeout = timeout
+		connection = BlockingConnection(settings)
+		try:
+			channel = connection.channel()
+			reply_queue = channel.queue_declare(
+				queue='',
+				exclusive=True,
+				auto_delete=True,
+			).method.queue
+			channel.confirm_delivery()
+			correlation_id = uuid4().hex
+			responses = []
+
+			def receive(
+				channel,
+				method,
+				properties,
+				payload,
+			):
+				if properties.correlation_id == correlation_id:
+					responses.append((
+						properties,
+						payload,
+					))
+
+			channel.basic_consume(
+				reply_queue,
+				on_message_callback=receive,
+				auto_ack=True,
+			)
+			remaining = deadline - monotonic()
+			if remaining <= 0:
+				raise TimeoutError('RPC timed out before request publication')
+			channel.basic_publish(
+				exchange=self.exchange,
+				routing_key=event if event is not None else '',
+				body=self.encode(body),
+				properties=BasicProperties(
+					reply_to=reply_queue,
+					correlation_id=correlation_id,
+					content_type=self.encode.format,
+					content_encoding=self.encode.charset,
+					expiration=str(max(
+						1,
+						ceil(remaining * 1000),
+					)),
+				),
+				mandatory=True,
+			)
+			while not responses:
+				remaining = deadline - monotonic()
+				if remaining <= 0:
+					raise TimeoutError(f'RPC response timed out for exchange {self.exchange!r} routing_key={event!r}')
+				connection.process_data_events(time_limit=min(
+					remaining,
+					0.1,
+				))
+			properties, payload = responses[0]
+			response = self.decode(
+				payload,
+				properties.content_type,
+				properties.content_encoding,
+			)
+			if not isinstance(
+				response,
+				dict,
+			) or type(response.get('ok')) is not bool:
+				raise ValueError('Invalid RPC response envelope')
+			if response['ok']:
+				if 'result' not in response:
+					raise ValueError('RPC response has no result')
+				return response['result']
+			error = response.get('error')
+			if not isinstance(
+				error,
+				dict,
+			) or not isinstance(
+				error.get('code'),
+				str,
+			) or not isinstance(
+				error.get('message'),
+				str,
+			):
+				raise ValueError('Invalid RPC error response')
+			raise RemoteError(
+				error['code'],
+				error['message'],
+			)
+		finally:
+			if connection.is_open:
+				connection.close()

DefStream/Broker/Implements/RabbitMQ/Policies.py

@@ -0,0 +1,9 @@
+from ...Policies import (
+	Requeue,
+	Reject,
+)
+
+__all__ = (
+	'Requeue',
+	'Reject',
+)

DefStream/Broker/Implements/RabbitMQ/Queue.py

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+
+from ... import (
+	Sendable,
+	Callable,
+	Poppable,
+)
+
+from .Serializer import (
+	Encoder,
+	Decoder,
+)
+from .Event import Event
+from ...Errors import RemoteError
+from copy import deepcopy
+from math import (
+	ceil,
+	isfinite,
+)
+
+from pika import (
+	BlockingConnection,
+	BasicProperties,
+	ConnectionParameters,
+)
+
+from time import (
+	time,
+	sleep,
+	monotonic,
+)
+from uuid import uuid4
+
+from typing import (
+	Any,
+	Optional,
+	Dict,
+)
+
+__all__ = (
+	'Queue'
+)
+
+
+class Queue(
+	Sendable,
+	Callable,
+	Poppable,
+):
+	"""Queue of Event Broker for RabbitMQ"""
+	def __init__(
+		self,
+		connection: BlockingConnection,
+		encode: Encoder,
+		decode: Decoder,
+		name: str = None,
+		rpc_parameters: Optional[ConnectionParameters] = None,
+	):
+		self.connection = connection
+		self.encode = encode
+		self.decode = decode
+		self.channel = self.connection.channel()
+		self.channel.auto_decode = False
+		self.queue = name
+		self.event = None
+		self.rpc_parameters = rpc_parameters
+		return
+
+	def __del__(self):
+		if self.channel and self.channel.is_open:
+			self.channel.close()
+		return
+	
+	def __str__(self): return self.queue
+
+	def send(
+		self,
+		body,
+		event: str = None,
+		headers: Dict = {},
+		priority: int = None,
+		expiration: int = None,
+		timestamp: int = None,
+		persistent: bool = True,
+		id: str = None,
+		reply_to: str = None,
+		correlation_id: str = None,
+	):
+		if not timestamp: timestamp = int(time())
+		if not id: id = uuid4().hex
+		properties = BasicProperties(
+			type=event if event else '',
+			headers=headers,
+			content_type=self.encode.format,
+			content_encoding=self.encode.charset,
+			priority=priority,
+			timestamp=timestamp,
+			expiration=expiration,
+			message_id=id,
+			delivery_mode=2 if persistent else 1,
+			reply_to=reply_to,
+			correlation_id=correlation_id,
+		)
+		self.channel.basic_publish(
+			exchange='',
+			routing_key=self.queue,
+			properties=properties,
+			body=self.encode(body)
+		)
+		return id
+
+	def call(
+		self,
+		body: Any,
+		timeout: float = 5,
+	) -> Any:
+		if self.rpc_parameters is None:
+			raise RuntimeError('RPC requires connection parameters; obtain the queue through Connection.queue')
+		if isinstance(
+			timeout,
+			bool,
+		) or not isinstance(
+			timeout,
+			(
+				int,
+				float,
+			),
+		) or not isfinite(timeout) or timeout <= 0:
+			raise ValueError('RPC timeout must be a finite positive number of seconds')
+		deadline = monotonic() + timeout
+		settings = deepcopy(self.rpc_parameters)
+		settings.connection_attempts = 1
+		settings.socket_timeout = min(
+			settings.socket_timeout,
+			timeout,
+		)
+		settings.stack_timeout = timeout
+		settings.blocked_connection_timeout = timeout
+		connection = BlockingConnection(settings)
+		try:
+			channel = connection.channel()
+			reply_queue = channel.queue_declare(
+				queue='',
+				exclusive=True,
+				auto_delete=True,
+			).method.queue
+			channel.confirm_delivery()
+			correlation_id = uuid4().hex
+			responses = []
+
+			def receive(
+				channel,
+				method,
+				properties,
+				payload,
+			):
+				if properties.correlation_id == correlation_id:
+					responses.append((
+						properties,
+						payload,
+					))
+
+			channel.basic_consume(
+				reply_queue,
+				on_message_callback=receive,
+				auto_ack=True,
+			)
+			remaining = deadline - monotonic()
+			if remaining <= 0:
+				raise TimeoutError('RPC timed out before request publication')
+			channel.basic_publish(
+				exchange='',
+				routing_key=self.queue,
+				body=self.encode(body),
+				properties=BasicProperties(
+					reply_to=reply_queue,
+					correlation_id=correlation_id,
+					content_type=self.encode.format,
+					content_encoding=self.encode.charset,
+					expiration=str(max(
+						1,
+						ceil(remaining * 1000),
+					)),
+				),
+				mandatory=True,
+			)
+			while not responses:
+				remaining = deadline - monotonic()
+				if remaining <= 0:
+					raise TimeoutError(f'RPC response timed out for queue {self.queue!r}')
+				connection.process_data_events(time_limit=min(
+					remaining,
+					0.1,
+				))
+			properties, payload = responses[0]
+			response = self.decode(
+				payload,
+				properties.content_type,
+				properties.content_encoding,
+			)
+			if not isinstance(
+				response,
+				dict,
+			) or type(response.get('ok')) is not bool:
+				raise ValueError('Invalid RPC response envelope')
+			if response['ok']:
+				if 'result' not in response:
+					raise ValueError('RPC response has no result')
+				return response['result']
+			error = response.get('error')
+			if not isinstance(
+				error,
+				dict,
+			) or not isinstance(
+				error.get('code'),
+				str,
+			) or not isinstance(
+				error.get('message'),
+				str,
+			):
+				raise ValueError('Invalid RPC error response')
+			raise RemoteError(
+				error['code'],
+				error['message'],
+			)
+		finally:
+			if connection.is_open:
+				connection.close()
+
+	def pop(self, timeout: int = None) -> Optional[Event]:
+		channel = self.channel
+		channel.basic_qos(0, 1, False)
+		deadline = time() + (timeout / 1000) if timeout else None
+		while True:
+			method, properties, body = channel.basic_get(queue=self.queue, auto_ack=False)
+			if method:
+				return Event(
+					channel,
+					self.queue,
+					None,
+					method.delivery_tag,
+					properties,
+					self.decode(body, properties.content_type, properties.content_encoding),
+				)
+			if deadline and time() >= deadline:
+				break
+			sleep(0.1)
+		return

DefStream/Broker/Implements/RabbitMQ/Serializer.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+from abc import (
+	ABCMeta,
+	abstractmethod,
+)
+
+from json import (
+	dumps,
+	loads,
+)
+from typing import Any
+
+__all__ = (
+	'Encoder',
+	'Decoder',
+	'JavaScriptObjectNotationEncoder',
+	'JavaScriptObjectNotationDecoder',
+)
+
+class Encoder(metaclass=ABCMeta):
+	"""Encoder Interface"""
+	@abstractmethod
+	def __call__(self, obj: Any) -> bytes:
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))
+
+	@property
+	@abstractmethod
+	def format(self) -> str:
+		raise NotImplementedError('{} must be implemented format'.format(self.__class__.__name__))	
+
+	@property
+	@abstractmethod
+	def charset(self) -> str:
+		raise NotImplementedError('{} must be implemented charset'.format(self.__class__.__name__))
+	
+
+class Decoder(metaclass=ABCMeta):
+	"""Decoder Interface"""
+	@abstractmethod
+	def __call__(self, obj: bytes, format: str, charset: str) -> Any:
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))
+
+
+class JavaScriptObjectNotationEncoder(Encoder):
+	"""JavaScriptObjectNotation Encoder"""
+	def __call__(self, obj: Any) -> bytes:
+		return dumps(obj, ensure_ascii=False).encode(self.charset)
+
+	@property
+	def format(self) -> str: return 'application/json'
+
+	@property
+	def charset(self) -> str: return 'utf-8'
+
+
+class JavaScriptObjectNotationDecoder(Decoder):
+	"""JavaScriptObjectNotation Decoder"""
+	def __call__(self, obj: bytes, format: str, charset: str) -> Any:
+		if format != 'application/json': raise ValueError('format is not support')
+		return loads(obj.decode(charset))