init.sh

#!/bin/bash
# Fixed Protocol Buffer compilation for Go + Python integration

cd ~/distributed-systems

# Create proper directory structure for protocol buffers
mkdir -p shared-protocols/proto
mkdir -p go-services/pkg/proto
mkdir -p python-services/proto

# Create the common.proto file in the correct location
cat > shared-protocols/proto/common.proto << 'EOF'
syntax = "proto3";

package common;
option go_package = "./common";

// Common request/response patterns
message HealthCheckRequest {}

message HealthCheckResponse {
  string status = 1;
  int64 timestamp = 2;
}

// Distributed caching service
service CacheService {
  rpc Get(GetRequest) returns (GetResponse);
  rpc Put(PutRequest) returns (PutResponse);
  rpc Delete(DeleteRequest) returns (DeleteResponse);
  rpc HealthCheck(HealthCheckRequest) returns (HealthCheckResponse);
}

message GetRequest {
  string key = 1;
}

message GetResponse {
  string value = 1;
  bool found = 2;
  int64 timestamp = 3;
}

message PutRequest {
  string key = 1;
  string value = 2;
  int32 ttl_seconds = 3;
}

message PutResponse {
  bool success = 1;
  string message = 2;
}

message DeleteRequest {
  string key = 1;
}

message DeleteResponse {
  bool success = 1;
  string message = 2;
}

// Analytics service for cross-language communication
service AnalyticsService {
  rpc RecordEvent(EventRequest) returns (EventResponse);
  rpc GetMetrics(MetricsRequest) returns (MetricsResponse);
}

message EventRequest {
  string event_type = 1;
  string user_id = 2;
  map<string, string> properties = 3;
  int64 timestamp = 4;
}

message EventResponse {
  bool success = 1;
  string event_id = 2;
}

message MetricsRequest {
  string metric_name = 1;
  int64 start_time = 2;
  int64 end_time = 3;
}

message MetricsResponse {
  repeated MetricPoint points = 1;
}

message MetricPoint {
  int64 timestamp = 1;
  double value = 2;
}
EOF

# Create build script for protocol compilation
cat > shared-protocols/build.sh << 'EOF'
#!/bin/bash
# Protocol Buffer compilation script

set -e

PROTO_DIR="proto"
GO_OUT="../go-services/pkg/proto"
PYTHON_OUT="../python-services/proto"

echo "🔨 Compiling Protocol Buffers..."

# Create output directories
mkdir -p $GO_OUT
mkdir -p $PYTHON_OUT

# Compile for Go
echo "📦 Generating Go code..."
protoc \
    --proto_path=$PROTO_DIR \
    --go_out=$GO_OUT \
    --go-grpc_out=$GO_OUT \
    --go_opt=paths=source_relative \
    --go-grpc_opt=paths=source_relative \
    $PROTO_DIR/*.proto

# Compile for Python
echo "🐍 Generating Python code..."
python -m grpc_tools.protoc \
    --proto_path=$PROTO_DIR \
    --python_out=$PYTHON_OUT \
    --grpc_python_out=$PYTHON_OUT \
    $PROTO_DIR/*.proto
# Create __init__.py files for Python package
touch $PYTHON_OUT/__init__.py

# Fix Python import issues (common problem with protobuf)
echo "🔧 Fixing Python imports..."
for file in $PYTHON_OUT/*_pb2_grpc.py; do
    if [ -f "$file" ]; then
        sed -i 's/import common_pb2/from . import common_pb2/g' "$file"
    fi
done

echo "✅ Protocol compilation complete!"
echo "📁 Go files: $GO_OUT"
echo "📁 Python files: $PYTHON_OUT"
EOF

chmod +x shared-protocols/build.sh

# Create Makefile for easy development
cat > Makefile << 'EOF'
.PHONY: proto build-go build-python test clean dev-up dev-down

# Protocol buffer compilation
proto:
	cd shared-protocols && ./build.sh

# Go development
build-go:
	cd go-services && go mod tidy && go build ./...

test-go:
	cd go-services && go test ./...

run-cache:
	cd go-services && go run cmd/cache-service/main.go

# Python development
build-python:
	cd python-services && source venv/bin/activate && pip install -r requirements.txt

test-python:
	cd python-services && source venv/bin/activate && python -m pytest

run-orchestrator:
	cd python-services && source venv/bin/activate && python -m orchestrator

# Development environment
dev-up:
	docker-compose -f docker-compose.dev.yml up -d

dev-down:
	docker-compose -f docker-compose.dev.yml down

# Full build
build: proto build-go build-python

# Clean generated files
clean:
	rm -rf go-services/pkg/proto/*
	rm -rf python-services/proto/*
	cd go-services && go clean ./...

# Development workflow
dev: clean proto build dev-up
	@echo "🚀 Development environment ready!"
	@echo "💾 Cache service: make run-cache"
	@echo "🐍 Python orchestrator: make run-orchestrator"
	@echo "📊 Grafana: http://localhost:3000"
	@echo "🔍 Jaeger: http://localhost:16686"
EOF

# Set up Go module properly
cd go-services
if [ ! -f go.mod ]; then
    go mod init github.com/yourusername/distributed-systems/go-services
fi

# Add essential Go dependencies
go get google.golang.org/grpc@latest
go get google.golang.org/protobuf@latest
go get github.com/prometheus/client_golang@latest
go get github.com/redis/go-redis/v9@latest
go get github.com/stretchr/testify@latest

# Set up Python requirements
cd ../python-services
cat > requirements.txt << 'EOF'
# gRPC and Protocol Buffers
grpcio==1.59.0
grpcio-tools==1.59.0
protobuf==4.24.4

# Async and networking
aiohttp==3.8.6
asyncio-mqtt==0.13.0
uvloop==0.17.0

# Data processing
redis==5.0.1
kafka-python==2.0.2
pandas==2.1.2
numpy==1.25.2

# Web framework
fastapi==0.104.1
uvicorn==0.24.0
websockets==12.0

# Monitoring and observability
prometheus-client==0.18.0
structlog==23.2.0

# Testing
pytest==7.4.3
pytest-asyncio==0.21.1
httpx==0.25.1

# Database
sqlalchemy==2.0.23
asyncpg==0.29.0

# Development
black==23.10.1
flake8==6.1.0
mypy==1.7.0
EOF

# Install Python dependencies
source venv/bin/activate
pip install -r requirements.txt

# Now compile the protocols
cd ../shared-protocols
./build.sh

echo ""
echo "✅ Protocol Buffer setup complete!"
echo ""
echo "🎯 Quick test - run these commands:"
echo "1. make proto          # Compile protocol buffers"
echo "2. make build-go       # Build Go services"
echo "3. make build-python   # Install Python dependencies"
echo "4. make dev-up         # Start development services"
echo ""
echo "📁 Your generated files:"
echo "   - Go: go-services/pkg/proto/"
echo "   - Python: python-services/proto/"