import requests
import time
import math

def send_webhook_with_retry(url, payload, headers, max_retries=5, initial_delay=1):
    for i in range(max_retries):
        try:
            response = requests.post(url, json=payload, headers=headers, timeout=10)
            response.raise_for_status() # 200 이외의 응답 코드는 예외 발생
            print(f"Webhook successfully sent to {url}")
            return True
        except requests.exceptions.RequestException as e:
            print(f"Webhook sending failed (attempt {i+1}/{max_retries}): {e}")
            if i < max_retries - 1:
                delay = initial_delay * (2 ** i) + (0.5 * initial_delay * (2 ** i) * (2 * i + 1)) # Jitter 추가
                delay = min(delay, 60) # 최대 지연 시간 제한
                print(f"Retrying in {delay:.2f} seconds...")
                time.sleep(delay)
    print(f"Webhook failed after {max_retries} attempts to {url}")
    return False

# 예시 사용
webhook_url = "http://localhost:5000/receive-webhook" # 실제 Webhook 수신 서버 URL
event_payload = {"event_type": "user_created", "user_id": "123", "data": {"name": "John Doe"}}
headers = {"Content-Type": "application/json"}

# send_webhook_with_retry(webhook_url, event_payload, headers)

import hashlib
import hmac
import json
import requests
from flask import Flask, request

app = Flask(__name__)

# 이 키는 송신자와 수신자가 공유하는 비밀 키여야 합니다.
WEBHOOK_SECRET = "your-very-secret-key"

def generate_signature(payload, secret):
    # 페이로드를 JSON 문자열로 변환하고 UTF-8로 인코딩
    body = json.dumps(payload, separators=(,, :)).encode(utf-8)
    # HMAC-SHA256 해시 생성
    signature = hmac.new(secret.encode(utf-8), body, hashlib.sha256).hexdigest()
    return f"sha256={signature}"

@app.route(/send-event, methods=[POST])
def send_event():
    event_payload = {"event_type": "order_completed", "order_id": "ORD_12345", "amount": 100.0}
    webhook_url = "http://localhost:5001/receive-webhook" # 수신 서버 URL

    signature = generate_signature(event_payload, WEBHOOK_SECRET)
    headers = {
        "Content-Type": "application/json",
        "X-Webhook-Signature": signature
    }

    try:
        response = requests.post(webhook_url, json=event_payload, headers=headers, timeout=5)
        response.raise_for_status()
        return {"message": "Event sent successfully"}, 200
    except requests.exceptions.RequestException as e:
        return {"error": f"Failed to send webhook: {e}"}, 500

if __name__ == __main__:
    # 이 부분은 송신 서버 역할을 가정합니다.
    # 실제 환경에서는 Flask 앱을 직접 실행하는 대신, 웹 서버(Gunicorn, uWSGI)를 통해 실행됩니다.
    # app.run(port=5000)
    pass

import hashlib
import hmac
import json
from flask import Flask, request, abort

app = Flask(__name__)

# 이 키는 송신자와 수신자가 공유하는 비밀 키여야 합니다.
WEBHOOK_SECRET = "your-very-secret-key"

def verify_signature(payload, received_signature, secret):
    # 수신된 페이로드를 JSON 문자열로 변환 (송신자와 동일한 방식으로 정규화)
    # Flask의 request.data는 bytes이므로 바로 사용 가능
    body = payload # request.data는 이미 bytes
    
    # HMAC-SHA256 해시 생성
    expected_signature = hmac.new(secret.encode(utf-8), body, hashlib.sha256).hexdigest()
    
    # 접두사 sha256= 제거 후 비교
    return hmac.compare_digest(f"sha256={expected_signature}", received_signature)

@app.route(/receive-webhook, methods=[POST])
def receive_webhook():
    signature = request.headers.get(X-Webhook-Signature)
    if not signature:
        print("Signature header missing.")
        abort(400, "Signature header missing")

    # request.data를 사용하여 원본 바디를 가져옴 (request.json을 사용하면 이미 파싱되어 원본 바디를 얻을 수 없음)
    payload_bytes = request.data 
    
    if not verify_signature(payload_bytes, signature, WEBHOOK_SECRET):
        print("Signature verification failed.")
        abort(403, "Invalid signature")

    try:
        event_data = request.json # 검증 후 JSON으로 파싱
        print(f"Webhook received and verified: {event_data}")
        # 여기서 실제 이벤트 처리 로직 수행
        # 예: 데이터베이스 업데이트, 다른 서비스 호출 등
        return {"message": "Webhook received successfully"}, 200
    except Exception as e:
        print(f"Error processing webhook: {e}")
        abort(500, "Error processing webhook")

if __name__ == __main__:
    app.run(port=5001) # 수신 서버는 5001 포트에서 실행

from flask import Flask, request, abort
import uuid

app = Flask(__name__)

# 임시로 처리된 멱등성 키를 저장하는 딕셔너리 (실제로는 DB나 Redis 사용)
processed_idempotency_keys = {}

@app.route(/idempotent-webhook, methods=[POST])
def idempotent_webhook():
    idempotency_key = request.headers.get(X-Idempotency-Key)
    if not idempotency_key:
        abort(400, "Idempotency-Key header missing")

    if idempotency_key in processed_idempotency_keys:
        # 이미 처리된 요청이므로, 이전 결과를 반환하거나 성공 응답만 보냄
        print(f"Idempotent request with key {idempotency_key} already processed. Returning previous result.")
        return processed_idempotency_keys[idempotency_key], 200 # 이전 응답을 반환하는 예시

    try:
        event_data = request.json
        print(f"Processing new idempotent webhook with key {idempotency_key}: {event_data}")
        
        # 실제 이벤트 처리 로직
        # 예: DB에 데이터 삽입/업데이트, 외부 서비스 호출 등
        
        response_data = {"message": f"Event processed successfully for key {idempotency_key}"}
        processed_idempotency_keys[idempotency_key] = response_data # 처리 결과 저장
        return response_data, 200
    except Exception as e:
        print(f"Error processing idempotent webhook: {e}")
        abort(500, "Error processing webhook")

if __name__ == __main__:
    # 예시: 클라이언트가 멱등성 키를 생성하여 보냄
    # requests.post(
    #     "http://localhost:5000/idempotent-webhook",
    #     json={"data": "some_value"},
    #     headers={"X-Idempotency-Key": str(uuid.uuid4())}
    # )
    app.run(port=5002)

# 가상의 메시지 큐 사용 예시
# 실제로는 RabbitMQ, Kafka, SQS 등의 클라이언트 라이브러리를 사용합니다.

class MessageQueue:
    def __init__(self):
        self.queue = []

    def publish(self, message):
        self.queue.append(message)
        print(f"Message published to queue: {message[event_type]}")

    def consume(self):
        if self.queue:
            return self.queue.pop(0)
        return None

# 송신자 측 (Producer)
message_queue = MessageQueue()

def handle_event_and_publish_webhook(event_data, webhook_target_url, secret_key):
    # 이벤트 처리 로직 ...
    
    # Webhook 페이로드 생성
    payload = {"event_type": event_data["type"], "data": event_data["payload"]}
    
    # 시그니처 생성 (선택 사항, 큐에 넣기 전에 생성하거나 워커에서 생성)
    # signature = generate_signature(payload, secret_key)
    
    # 큐에 메시지 발행
    message_queue.publish({
        "url": webhook_target_url,
        "payload": payload,
        "headers": {"Content-Type": "application/json"},
        "secret": secret_key # 워커에서 시그니처 검증 및 생성에 사용
    })
    print("Webhook event queued for sending.")

# 워커 측 (Consumer)
def webhook_worker():
    while True:
        message = message_queue.consume()
        if message:
            print(f"Worker consuming message: {message[payload][event_type]}")
            # 여기에서 send_webhook_with_retry 함수를 호출하여 실제 Webhook 전송
            # send_webhook_with_retry(message[url], message[payload], message[headers])
            # 실제 시그니처 생성 및 헤더 추가 로직 포함
            
            # (예시) 시그니처 재 생성 및 추가
            signature = generate_signature(message[payload], message[secret])
            message[headers][X-Webhook-Signature] = signature
            
            send_webhook_with_retry(message[url], message[payload], message[headers])
            
        time.sleep(1) # 실제 워커는 폴링 또는 큐의 콜백을 사용

# 예시 사용:
# event_data = {"type": "user_registered", "payload": {"id": "user_456"}}
# handle_event_and_publish_webhook(event_data, "http://localhost:5001/receive-webhook", WEBHOOK_SECRET)
# # 백그라운드에서 webhook_worker() 실행