lennyaiko
117 lines
4.0 KiB
Python
117 lines
4.0 KiB
Python
from confluent_kafka import Consumer
|
|
import json
|
|
import logging
|
|
from app.config import settings
|
|
import requests
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class KafkaIntegration:
|
|
_consumer = None
|
|
|
|
_consumer_config = {
|
|
"bootstrap.servers": settings.KAFKA_BROKER,
|
|
"group.id": "loan-service-consumer",
|
|
"auto.offset.reset": "earliest",
|
|
"enable.auto.commit": True,
|
|
}
|
|
|
|
@staticmethod
|
|
def _get_consumer():
|
|
"""Kafka consumer"""
|
|
if not KafkaIntegration._consumer:
|
|
KafkaIntegration._consumer = Consumer(KafkaIntegration._consumer_config)
|
|
logger.info(
|
|
f"Consumer connected to Kafka broker at {KafkaIntegration._consumer_config['bootstrap.servers']}"
|
|
)
|
|
return KafkaIntegration._consumer
|
|
|
|
@staticmethod
|
|
def delivery_report(err, msg):
|
|
"""Called once for each message produced"""
|
|
if err is not None:
|
|
|
|
logger.error(f"Message delivery failed: {err}")
|
|
raise RuntimeError(f"Message delivery failed: {err}")
|
|
|
|
else:
|
|
logger.debug(
|
|
f"Message delivered to {msg.topic()} [{msg.partition()}] @ offset {msg.offset()}"
|
|
)
|
|
|
|
@staticmethod
|
|
def receive_messages(topic, timeout=1.0):
|
|
"""
|
|
Receive messages from a Kafka topic.
|
|
|
|
:param topic: The Kafka topic to subscribe to
|
|
:param timeout: Time to wait for a message (in seconds)
|
|
:return: The message value (decoded) or None if no message is received
|
|
"""
|
|
consumer = KafkaIntegration._get_consumer()
|
|
consumer.subscribe([topic])
|
|
|
|
try:
|
|
msg = consumer.poll(timeout=timeout)
|
|
if msg is None:
|
|
logger.debug(f"No message received from topic {topic} within timeout")
|
|
return None
|
|
if msg.error():
|
|
logger.error(f"Consumer error: {msg.error()}")
|
|
raise RuntimeError(f"Consumer error: {msg.error()}")
|
|
|
|
# Decode and return the message value
|
|
message_value = msg.value().decode("utf-8")
|
|
logger.debug(
|
|
f"Received message from {msg.topic()} [{msg.partition()}] @ offset {msg.offset()}: {message_value}"
|
|
)
|
|
return json.loads(message_value) if message_value else None
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error while receiving message: {e}")
|
|
raise
|
|
|
|
@staticmethod
|
|
def close_consumer():
|
|
"""Shutdown consumer"""
|
|
consumer = KafkaIntegration._get_consumer()
|
|
consumer.clonse()
|
|
logger.info("Kafka consumer closed")
|
|
|
|
@staticmethod
|
|
def is_kafka_running():
|
|
"""
|
|
Check if Kafka broker is reachable by attempting to fetch metadata.
|
|
:return: True if Kafka is running, False otherwise
|
|
"""
|
|
try:
|
|
producer = KafkaIntegration._get_producer()
|
|
# Attempt to fetch metadata for a dummy topic
|
|
metadata = producer.list_topics(timeout=5)
|
|
if metadata.brokers: # If brokers are returned, Kafka is running
|
|
logger.info(f"Kafka broker at {settings.KAFKA_BROKER} is running")
|
|
return True
|
|
else:
|
|
logger.warning(f"No brokers found for {settings.KAFKA_BROKER}")
|
|
return False
|
|
except Exception as e:
|
|
logger.error(f"Kafka broker check failed: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
def _call_disbursement_endpoint(
|
|
message, endpoint_url="http://localhost:8000/loans/disbursement"
|
|
):
|
|
"""Call an HTTP endpoint with the received message"""
|
|
try:
|
|
response = requests.post(endpoint_url, json=message, timeout=5)
|
|
response.raise_for_status()
|
|
logger.info(
|
|
f"Successfully sent message to {endpoint_url}: {response.status_code}"
|
|
)
|
|
print(response.json())
|
|
except requests.exceptions.RequestException as e:
|
|
logger.error(f"Failed to call endpoint {endpoint_url}: {e}")
|
|
raise
|