Banque d'Exercices RabbitMQ - Préparation Examen

Ex 4.1: Service de Calcul Mathématique

Scénario: Client envoie opérations math, serveur calcule et retourne résultat.

#!/usr/bin/env python3
# math_client.py
import pika
import uuid
import json

class MathRpcClient:
    def __init__(self):
        self.connection = pika.BlockingConnection(...)
        self.channel = self.connection.channel()

        result = self.channel.queue_declare(queue='', exclusive=True)
        self.callback_queue = result.method.queue

        self.channel.basic_consume(
            queue=self.callback_queue,
            on_message_callback=self.on_response,
            auto_ack=True
        )

        self.response = None
        self.corr_id = None

    def on_response(self, ch, method, props, body):
        if self.corr_id == props.correlation_id:
            self.response = body.decode()

    def call(self, operation, a, b):
        self.response = None
        self.corr_id = str(uuid.uuid4())

        request = {
            'operation': operation,
            'a': a,
            'b': b
        }

        self.channel.basic_publish(
            exchange='',
            routing_key='rpc_math',
            properties=pika.BasicProperties(
                reply_to=self.callback_queue,
                correlation_id=self.corr_id,
            ),
            body=json.dumps(request).encode()
        )

        print(f"[→] Calling {operation}({a}, {b})...")

        while self.response is None:
            self.connection.process_data_events()

        return json.loads(self.response)

    def close(self):
        self.connection.close()

# Usage
if __name__ == '__main__':
    client = MathRpcClient()

    # Test operations
    operations = [
        ('add', 5, 3),
        ('subtract', 10, 4),
        ('multiply', 6, 7),
        ('divide', 20, 4),
        ('power', 2, 8),
        ('divide', 10, 0),  # Error case
    ]

    for op, a, b in operations:
        result = client.call(op, a, b)
        if 'error' in result:
            print(f"[✗] {op}({a}, {b}) = ERROR: {result['error']}")
        else:
            print(f"[✓] {op}({a}, {b}) = {result['result']}")

    client.close()

#!/usr/bin/env python3
# math_server.py
import pika
import json

def calculate(operation, a, b):
    ops = {
        'add': lambda x, y: x + y,
        'subtract': lambda x, y: x - y,
        'multiply': lambda x, y: x * y,
        'divide': lambda x, y: x / y if y != 0 else None,
        'power': lambda x, y: x ** y,
        'modulo': lambda x, y: x % y if y != 0 else None,
    }

    if operation not in ops:
        return {'error': f'Unknown operation: {operation}'}

    try:
        result = ops[operation](a, b)
        if result is None:
            return {'error': 'Division by zero'}
        return {'result': result}
    except Exception as e:
        return {'error': str(e)}

def on_request(ch, method, props, body):
    request = json.loads(body.decode())

    print(f"[.] Computing {request['operation']}({request['a']}, {request['b']})")

    response = calculate(request['operation'], request['a'], request['b'])

    ch.basic_publish(
        exchange='',
        routing_key=props.reply_to,
        properties=pika.BasicProperties(
            correlation_id=props.correlation_id
        ),
        body=json.dumps(response).encode()
    )

    ch.basic_ack(delivery_tag=method.delivery_tag)
    print(f"[x] Sent result: {response}")

connection = pika.BlockingConnection(...)
channel = connection.channel()

channel.queue_declare(queue='rpc_math')
channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue='rpc_math', on_message_callback=on_request)

print('[*] Math RPC server ready. Waiting for requests...')
channel.start_consuming()

Ex 4.2: Traducteur Unix Pipe (Lab21 Style) ⭐

Scénario EXAMEN: cat input.txt | python translator.py | less

dictionary.ini

[translations]
hello = bonjour
world = monde
cat = chat
dog = chien
house = maison
computer = ordinateur
book = livre
yes = oui
no = non
thank = merci
please = s'il vous plaît

translator.py (Client - lit stdin/écrit stdout)

#!/usr/bin/env python3
import sys
import re
import pika
import uuid

class TranslatorRPC:
    def __init__(self):
        self.connection = pika.BlockingConnection(
            pika.ConnectionParameters(
                host='concurp1.isc.heia-fr.ch',
                port=5072,
                credentials=pika.PlainCredentials('guest', 'guest')
            )
        )
        self.channel = self.connection.channel()

        result = self.channel.queue_declare(queue='', exclusive=True)
        self.callback_queue = result.method.queue

        self.channel.basic_consume(
            queue=self.callback_queue,
            on_message_callback=self.on_response,
            auto_ack=True
        )

        self.response = None
        self.corr_id = None

    def on_response(self, ch, method, props, body):
        if self.corr_id == props.correlation_id:
            self.response = body.decode()

    def translate(self, word):
        self.response = None
        self.corr_id = str(uuid.uuid4())

        self.channel.basic_publish(
            exchange='',
            routing_key='translate_rpc',
            properties=pika.BasicProperties(
                reply_to=self.callback_queue,
                correlation_id=self.corr_id,
            ),
            body=word.encode()
        )

        while self.response is None:
            self.connection.process_data_events()

        return self.response

    def close(self):
        self.connection.close()

def main():
    translator = TranslatorRPC()

    try:
        # Read from stdin line by line
        for line in sys.stdin:
            # Split into words and punctuation
            tokens = re.findall(r'\b\w+\b|[^\w\s]', line)

            translated_tokens = []
            for token in tokens:
                if token.isalpha():
                    # Translate word
                    translated = translator.translate(token.lower())

                    # Preserve original case
                    if token.isupper():
                        translated = translated.upper()
                    elif token[0].isupper():
                        translated = translated.capitalize()

                    translated_tokens.append(translated)
                else:
                    # Keep punctuation/numbers as-is
                    translated_tokens.append(token)

            # Write to stdout
            print(' '.join(translated_tokens))

    finally:
        translator.close()

if __name__ == '__main__':
    main()

translation_server.py (Server avec ConfigParser)

#!/usr/bin/env python3
import pika
import configparser
import sys

# Load dictionary from config file
config = configparser.ConfigParser()
config.read('dictionary.ini')

DICTIONARY = dict(config.items('translations'))

def translate(word):
    """Translate word using dictionary, return original if not found"""
    return DICTIONARY.get(word.lower(), word)

def on_request(ch, method, props, body):
    word = body.decode()
    translation = translate(word)

    ch.basic_publish(
        exchange='',
        routing_key=props.reply_to,
        properties=pika.BasicProperties(
            correlation_id=props.correlation_id
        ),
        body=translation.encode()
    )

    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(
    pika.ConnectionParameters(
        host='concurp1.isc.heia-fr.ch',
        port=5072,
        credentials=pika.PlainCredentials('guest', 'guest')
    )
)
channel = connection.channel()

channel.queue_declare(queue='translate_rpc')
channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue='translate_rpc', on_message_callback=on_request)

print('[*] Translation server ready')
channel.start_consuming()

Usage:

# Terminal 1: Start server
python translation_server.py

# Terminal 2: Test translator
echo "Hello world" | python translator.py
# Output: bonjour monde

# Or with file
cat input.txt | python translator.py > output.txt

# Example input.txt:
# Hello cat and dog.
# Thank you for the book!

# Expected output:
# bonjour chat and chien.
# merci you for the livre!

Ex 4.3: Service de Validation de Données

Scénario: Client envoie data pour validation (email, phone, etc). Serveur valide et retourne résultat.

#!/usr/bin/env python3
# validator_server.py
import pika
import json
import re

def validate_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

def validate_phone(phone):
    pattern = r'^\+?[0-9]{10,15}$'
    return bool(re.match(pattern, phone.replace(' ', '').replace('-', '')))

def validate(data_type, value):
    validators = {
        'email': validate_email,
        'phone': validate_phone,
        'url': lambda v: v.startswith('http://') or v.startswith('https://'),
        'positive_int': lambda v: v.isdigit() and int(v) > 0,
    }

    if data_type not in validators:
        return {'valid': False, 'error': f'Unknown type: {data_type}'}

    is_valid = validators[data_type](value)
    return {'valid': is_valid}

def on_request(ch, method, props, body):
    request = json.loads(body.decode())
    response = validate(request['type'], request['value'])

    ch.basic_publish(
        exchange='',
        routing_key=props.reply_to,
        properties=pika.BasicProperties(correlation_id=props.correlation_id),
        body=json.dumps(response).encode()
    )

    ch.basic_ack(delivery_tag=method.delivery_tag)

connection = pika.BlockingConnection(...)
channel = connection.channel()

channel.queue_declare(queue='validator_rpc')
channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue='validator_rpc', on_message_callback=on_request)

print('[*] Validator RPC server ready')
channel.start_consuming()