Sistema Distribuído de E-commerce com Algoritmo Chandy-Lamport

Este projeto implementa um sistema distribuído de e-commerce com 3 nós (Carrinho, Pagamentos e Estoque) utilizando o algoritmo Chandy-Lamport para checkpointing e recovery.

Índice

• Arquitetura
• Componentes
• Algoritmo Chandy-Lamport
• Instalação
• Execução
• Demonstração
• Docker
• Estrutura do Projeto

Arquitetura

O sistema é composto por 3 nós que se comunicam via sockets TCP:

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  Cart Service   │    │ Payment Service │    │ Stock Service   │
│   (Porta 8001)  │◄──►│   (Porta 8002)  │◄──►│   (Porta 8003)  │
└─────────────────┘    └─────────────────┘    └─────────────────┘
        ▲                        ▲                        ▲
        │                        │                        │
        └────────────────────────┼────────────────────────┘
                                 │
                    Comunicação ponto-a-ponto

Componentes

1. Serviço de Carrinho (cart_service)

   • Gerencia carrinhos de compra dos usuários
   • Verifica estoque antes de adicionar produtos
   • Comunica-se com Pagamentos para finalizar compras

2. Serviço de Pagamentos (payment_service)

   • Processa pagamentos
   • Mantém saldo dos usuários
   • Comunica-se com Estoque para atualização após pagamento

3. Serviço de Estoque (stock_service)

   • Gerencia inventário de produtos
   • Verifica disponibilidade
   • Atualiza estoque após vendas

Algoritmo Chandy-Lamport

O algoritmo de Chandy-Lamport para snapshot distribuído é implementado com as seguintes etapas:

1. Início do Snapshot:

   • Um nó inicia o snapshot salvando seu estado local
   • Envia markers para todos os outros nós
   • Começa a gravar mensagens em todos os canais de entrada

2. Propagação:

   • Quando um nó recebe um marker pela primeira vez:
     • Salva seu estado local
     • Envia markers para todos os outros nós
     • Começa a gravar mensagens em todos os canais, exceto o que enviou o marker
   • Para um marker subsequente:
     • Para de gravar mensagens no canal de onde veio o marker

3. Finalização:

   • Quando um nó recebe markers de todos os canais, o snapshot local está completo
   • O snapshot global é composto pelos snapshots locais de todos os nós

4. Recuperação:

   • O sistema pode ser restaurado para o estado salvo no snapshot

Instalação

Requisitos

• Python 3.8+
• Docker compose

Execução

Para executar o sistema:

# Construir e iniciar todos os serviços
docker compose up --build

# Em segundo plano
docker compose up --build -d

# Ver logs
docker compose logs -f

# Parar todos os serviços
docker compose down

Para executar o controlador de snapshots em Docker:

docker compose exec controller_service python src/controller.py

Estrutura do Projeto

.
├── checkpoints/         # Diretório para armazenar checkpoints
├── src/
│   ├── __init__.py
│   ├── main.py          # Ponto de entrada principal
│   ├── node.py          # Classe base para os nós
│   ├── cart_service.py  # Serviço de Carrinho
│   ├── payment_service.py # Serviço de Pagamentos
│   └── stock_service.py # Serviço de Estoque
├── Dockerfile           # Configuração para contêiner Docker
└── docker-compose.yml   # Configuração para orquestração de contêineres

Funcionamento do Algoritmo

Snapshot e Recovery

1. Snapshot Local

   • Cada nó salva seu estado atual (carrinhos, pagamentos, estoque)
   • Registra mensagens em trânsito durante o snapshot

2. Snapshot Global

   • Combinação dos snapshots locais de todos os nós
   • Garante uma visão consistente do sistema distribuído

3. Recovery

   • Restaura o estado dos nós para o momento do snapshot
   • Recria o estado global do sistema