Upgrade
python-Upgrade Migration Planning
- Pre-upgrade Assessment
python
# compatibility_check.py
import ast
import sys
from pathlib import Path
class Python311CompatibilityChecker(ast.NodeVisitor):
def __init__(self):
self.issues = []
def visit_Import(self, node):
"""Check for deprecated modules"""
deprecated_modules = ['imp', 'distutils']
for alias in node.names:
if alias.name in deprecated_modules:
self.issues.append(f"Line {node.lineno}: {alias.name} is deprecated")
self.generic_visit(node)
def visit_FunctionDef(self, node):
"""Check for deprecated function patterns"""
if node.name.startswith('assert') and len(node.args.args) == 0:
self.issues.append(f"Line {node.lineno}: Empty assert statements deprecated")
self.generic_visit(node)
def check_codebase_compatibility(source_dir):
"""Check entire codebase for Python 3.11 compatibility"""
checker = Python311CompatibilityChecker()
for py_file in Path(source_dir).rglob("*.py"):
try:
with open(py_file, 'r', encoding='utf-8') as f:
tree = ast.parse(f.read(), filename=str(py_file))
checker.visit(tree)
except SyntaxError as e:
checker.issues.append(f"{py_file}: Syntax error - {e}")
return checker.issues
- Upgrade Process Phase 1: Environment Preparation
bash
#!/bin/bash
# upgrade_phase1.sh
# Backup current environment
./backup_env.sh
# Create new Python 3.11.11 environment
python3.11 -m venv venv_new
source venv_new/bin/activate
# Install updated requirements
pip install --upgrade pip setuptools wheel
pip install -r requirements.txt
Phase 2: Testing and Validation
bash
#!/bin/bash
# upgrade_phase2.sh
# Run compatibility checks
python compatibility_check.py src/
# Run full test suite
python -m pytest tests/ -v --tb=short
# Run performance benchmarks
python benchmarks/performance_test.py
# Security scan
safety check
bandit -r src/
Phase 3: Deployment
bash
#!/bin/bash
# upgrade_phase3.sh
# Blue-green deployment
if [ "$1" = "blue" ]; then
TARGET_ENV="blue"
CURRENT_ENV="green"
else
TARGET_ENV="green"
CURRENT_ENV="blue"
fi
# Deploy to target environment
docker build -t myapp:${TARGET_ENV} .
docker stop myapp-${TARGET_ENV} || true
docker run -d --name myapp-${TARGET_ENV} \
-p 8080:8080 \
myapp:${TARGET_ENV}
# Health check
sleep 30
curl -f http://localhost:8080/health || exit 1
# Switch load balancer
# (Implementation depends on your load balancer)
switch_load_balancer.sh ${TARGET_ENV}
# Stop old environment
docker stop myapp-${CURRENT_ENV}
- Rollback Plan
bash
#!/bin/bash
# rollback.sh
BACKUP_DATE="$1"
if [ -z "$BACKUP_DATE" ]; then
echo "Usage: $0 <backup_date>"
exit 1
fi
# Stop current services
systemctl stop myapp
# Restore from backup
./restore_env.sh "$BACKUP_DATE"
# Verify rollback
source /opt/myapp/venv/bin/activate
python -c "import sys; print(sys.version)"
curl -f http://localhost:8080/health
echo "Rollback completed successfully"
- Post-upgrade Validation
python
# post_upgrade_validation.py
import sys
import importlib
import subprocess
import json
def validate_python_version():
"""Validate Python version"""
expected = (3, 11, 11)
actual = sys.version_info[:3]
assert actual >= expected, f"Expected Python {expected}, got {actual}"
def validate_critical_imports():
"""Validate all critical modules can be imported"""
critical_modules = [
'flask', 'gunicorn', 'psycopg2', 'redis', 'celery',
'prometheus_client', 'requests', 'json', 'ssl'
]
failed_imports = []
for module in critical_modules:
try:
importlib.import_module(module)
print(f"✓ {module} imported successfully")
except ImportError as e:
failed_imports.append(f"{module}: {e}")
print(f"✗ {module} failed to import: {e}")
return failed_imports
def validate_application_functionality():
"""Validate core application functionality"""
tests = [
{
'name': 'Database Connection',
'command': ['python', '-c', 'import psycopg2; conn = psycopg2.connect("host=localhost"); conn.close()'],
'timeout': 10
},
{
'name': 'Redis Connection',
'command': ['python', '-c', 'import redis; r = redis.Redis(); r.ping()'],
'timeout': 5
},
{
'name': 'HTTP Server',
'command': ['curl', '-f', 'http://localhost:8080/health'],
'timeout': 5
}
]
results = []
for test in tests:
try:
result = subprocess.run(
test['command'],
timeout=test['timeout'],
capture_output=True,
text=True
)
if result.returncode == 0:
results.append(f"✓ {test['name']}: PASS")
else:
results.append(f"✗ {test['name']}: FAIL - {result.stderr}")
except subprocess.TimeoutExpired:
results.append(f"✗ {test['name']}: TIMEOUT")
except Exception as e:
results.append(f"✗ {test['name']}: ERROR - {e}")
return results
def run_post_upgrade_validation():
"""Run complete post-upgrade validation"""
print("=" * 50)
print("Python 3.11.11 Post-Upgrade Validation")
print("=" * 50)
# Version validation
try:
validate_python_version()
print("✓ Python version validation: PASS")
except AssertionError as e:
print(f"✗ Python version validation: FAIL - {e}")
return False
# Import validation
failed_imports = validate_critical_imports()
if failed_imports:
print(f"✗ Import validation: FAIL")
for failure in failed_imports:
print(f" - {failure}")
return False
else:
print("✓ Import validation: PASS")
# Functionality validation
print("\nApplication Functionality Tests:")
functionality_results = validate_application_functionality()
for result in functionality_results:
print(f" {result}")
# Performance baseline
print("\nPerformance Baseline:")
try:
import time
start_time = time.time()
# Simple performance test
sum(i**2 for i in range(100000))
end_time = time.time()
print(f" Computation test: {end_time - start_time:.4f} seconds")
except Exception as e:
print(f" Performance test failed: {e}")
print("\n" + "=" * 50)
print("Validation completed successfully!")
return True
if __name__ == "__main__":
success = run_post_upgrade_validation()
sys.exit(0 if success else 1)