Add backup and benchmark scripts with environment setup

Implement backup and benchmark scripts for RavenChain, enhancing data management and performance testing capabilities. Update .gitignore to include new directories and add environment configuration files for development. Create a setup script to initialize the development environment and generate necessary directories and SSL certificates.

Author: raythurman2386

.gitignore

@@ -20,6 +20,10 @@ wheels/
 .installed.cfg
 *.egg
 .pytest_cache/
+backups/
+logs/
+certs/
+data/
 
 # Virtual Environment
 venv/
@@ -38,6 +42,8 @@ ENV/
 # Local development settings
 .env
 .env.local
+.env.development
+.env.production
 
 # System Files
 .DS_Store

config/__init__.py

@@ -0,0 +1 @@
+

scripts/backup.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Backup script for RavenChain data and wallets.
+Creates compressed backups with timestamps.
+"""
+import os
+import shutil
+import logging
+from datetime import datetime
+from pathlib import Path
+from config.logging import setup_logging
+
+logger = setup_logging("ravenchain.backup")
+
+
+def create_backup(data_dir: str = "data", backup_dir: str = "backups"):
+    try:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = Path(backup_dir) / f"ravenchain_backup_{timestamp}"
+
+        # Create backup directory if it doesn't exist
+        Path(backup_dir).mkdir(parents=True, exist_ok=True)
+
+        # Create backup
+        shutil.make_archive(
+            str(backup_path),
+            "gztar",
+            data_dir,
+        )
+
+        logger.info(
+            "Backup created successfully", backup_file=f"{backup_path}.tar.gz", timestamp=timestamp
+        )
+
+        # Clean old backups (keep last 5)
+        cleanup_old_backups(backup_dir)
+
+    except Exception as e:
+        logger.error("Backup failed", error=str(e), exc_info=True)
+        raise
+
+
+def cleanup_old_backups(backup_dir: str, keep_last: int = 5):
+    """Remove old backups, keeping only the specified number of recent ones."""
+    try:
+        backups = sorted(Path(backup_dir).glob("ravenchain_backup_*.tar.gz"), key=os.path.getmtime)
+
+        # Remove old backups
+        for backup in backups[:-keep_last]:
+            backup.unlink()
+            logger.info("Removed old backup", file=str(backup))
+
+    except Exception as e:
+        logger.error("Cleanup failed", error=str(e), exc_info=True)
+
+
+if __name__ == "__main__":
+    create_backup()

scripts/benchmark.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Benchmark script for RavenChain performance testing.
+Tests transaction processing, mining speed, and chain validation.
+"""
+import time
+import statistics
+from typing import List, Tuple, Dict
+from config.logging import setup_logging
+from ravenchain.blockchain import Blockchain
+from ravenchain.wallet import Wallet
+
+logger = setup_logging("ravenchain.benchmark")
+
+
+class BlockchainBenchmark:
+    def __init__(self, difficulty: int = 2):
+        self.blockchain = Blockchain(difficulty=difficulty)
+        self.wallet = Wallet()
+        self.wallet_registry: Dict[str, Wallet] = {self.wallet.address: self.wallet}
+
+    def benchmark_mining(self, num_blocks: int = 5) -> List[float]:
+        """Benchmark mining performance."""
+        mining_times = []
+
+        for _ in range(num_blocks):
+            # Add some transactions
+            for _ in range(3):
+                recipient = Wallet()
+                self.wallet_registry[recipient.address] = recipient
+                self.blockchain.add_transaction(
+                    self.wallet.address, recipient.address, 1.0, wallet=self.wallet
+                )
+
+            # Time the mining process
+            start_time = time.time()
+            self.blockchain.mine_pending_transactions(self.wallet.address)
+            mining_times.append(time.time() - start_time)
+
+        return mining_times
+
+    def benchmark_transaction_processing(self, num_transactions: int = 100) -> float:
+        """Benchmark transaction processing speed."""
+        start_time = time.time()
+
+        for _ in range(num_transactions):
+            recipient = Wallet()
+            self.wallet_registry[recipient.address] = recipient
+            self.blockchain.add_transaction(
+                self.wallet.address, recipient.address, 1.0, wallet=self.wallet
+            )
+
+        return time.time() - start_time
+
+    def benchmark_chain_validation(self) -> float:
+        """Benchmark chain validation speed."""
+        # First, create a decent-sized chain
+        for _ in range(5):
+            recipient = Wallet()
+            self.wallet_registry[recipient.address] = recipient
+            self.blockchain.add_transaction(
+                self.wallet.address, recipient.address, 1.0, wallet=self.wallet
+            )
+            self.blockchain.mine_pending_transactions(self.wallet.address)
+
+        # Time the validation
+        start_time = time.time()
+        self.blockchain.is_chain_valid(self.wallet_registry)
+        return time.time() - start_time
+
+
+def run_benchmarks() -> Tuple[List[float], float, float]:
+    """Run all benchmarks and return results."""
+    try:
+        benchmark = BlockchainBenchmark()
+
+        # Mining benchmark
+        logger.info("Starting mining benchmark")
+        mining_times = benchmark.benchmark_mining()
+        avg_mining_time = statistics.mean(mining_times)
+        logger.info(
+            "Mining benchmark complete", avg_time=f"{avg_mining_time:.2f}s", times=mining_times
+        )
+
+        # Transaction processing benchmark
+        logger.info("Starting transaction processing benchmark")
+        tx_time = benchmark.benchmark_transaction_processing()
+        logger.info(
+            "Transaction benchmark complete",
+            total_time=f"{tx_time:.2f}s",
+            transactions_per_second=f"{100/tx_time:.2f}",
+        )
+
+        # Chain validation benchmark
+        logger.info("Starting chain validation benchmark")
+        validation_time = benchmark.benchmark_chain_validation()
+        logger.info("Validation benchmark complete", validation_time=f"{validation_time:.2f}s")
+
+        return mining_times, tx_time, validation_time
+
+    except Exception as e:
+        logger.error("Benchmark failed", error=str(e), exc_info=True)
+        raise
+
+
+if __name__ == "__main__":
+    run_benchmarks()

scripts/generate_test_data.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Generate test data for RavenChain development and testing.
+Creates wallets, transactions, and mines blocks.
+"""
+import random
+from pathlib import Path
+from config.logging import setup_logging
+from ravenchain.blockchain import Blockchain
+from ravenchain.wallet import Wallet
+
+logger = setup_logging("ravenchain.testdata")
+
+
+def generate_test_data(
+    num_wallets: int = 5,
+    num_transactions: int = 20,
+    min_amount: float = 0.1,
+    max_amount: float = 10.0,
+):
+    try:
+        # Initialize blockchain
+        blockchain = Blockchain(difficulty=2)
+        wallets = []
+
+        # Create wallets
+        logger.info("Creating test wallets", count=num_wallets)
+        for i in range(num_wallets):
+            wallet = Wallet()
+            wallets.append(wallet)
+            logger.debug(f"Created wallet {i+1}", address=wallet.address)
+
+        # Generate transactions
+        logger.info("Generating test transactions", count=num_transactions)
+        for _ in range(num_transactions):
+            sender = random.choice(wallets)
+            receiver = random.choice([w for w in wallets if w != sender])
+            amount = random.uniform(min_amount, max_amount)
+
+            blockchain.add_transaction(sender.address, receiver.address, amount, wallet=sender)
+
+            # Mine a block after every few transactions
+            if random.random() < 0.3:  # 30% chance to mine
+                miner = random.choice(wallets)
+                blockchain.mine_pending_transactions(miner.address)
+                logger.info("Mined a new block", miner=miner.address)
+
+        # Mine any remaining transactions
+        if blockchain.pending_transactions:
+            miner = random.choice(wallets)
+            blockchain.mine_pending_transactions(miner.address)
+            logger.info("Mined final block", miner=miner.address)
+
+        # Log final state
+        logger.info(
+            "Test data generation complete",
+            total_blocks=len(blockchain.chain),
+            total_wallets=len(wallets),
+            total_transactions=num_transactions,
+        )
+
+        return blockchain, wallets
+
+    except Exception as e:
+        logger.error("Test data generation failed", error=str(e), exc_info=True)
+        raise
+
+
+if __name__ == "__main__":
+    generate_test_data()

scripts/setup_dev.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+Development environment setup script for RavenChain.
+Creates necessary directories, generates test certificates, and sets up initial configuration.
+"""
+import os
+import sys
+from pathlib import Path
+from config.logging import setup_logging
+
+logger = setup_logging("ravenchain.setup")
+
+
+def setup_development_environment():
+    """Set up the development environment."""
+    try:
+        # Create necessary directories
+        directories = ["data", "logs", "backups", "certs", "config"]
+
+        for directory in directories:
+            Path(directory).mkdir(parents=True, exist_ok=True)
+            logger.info(f"Created directory: {directory}")
+
+        # Create development environment file if it doesn't exist
+        env_file = Path(".env.development")
+        if not env_file.exists():
+            env_content = """# Development Environment Configuration
+ENVIRONMENT=development
+DEBUG=1
+RAVENCHAIN_DATA_DIR=data
+RAVENCHAIN_LOGS_DIR=logs
+MINING_DIFFICULTY=2
+LOG_LEVEL=DEBUG
+LOG_JSON=1
+
+# Database Configuration (for future use)
+# DB_HOST=localhost
+# DB_PORT=5432
+# DB_NAME=ravenchain
+# DB_USER=ravenchain
+# DB_PASSWORD=ravenchain
+
+# API Configuration (for future use)
+# API_HOST=0.0.0.0
+# API_PORT=8000
+# API_WORKERS=4
+# CORS_ORIGINS=http://localhost:3000
+"""
+            env_file.write_text(env_content)
+            logger.info("Created development environment file")
+
+        # Create test SSL certificates for development
+        if not Path("certs/dev.key").exists():
+            os.system(
+                "openssl req -x509 -newkey rsa:4096 -keyout certs/dev.key "
+                "-out certs/dev.crt -days 365 -nodes -subj '/CN=localhost'"
+            )
+            logger.info("Generated development SSL certificates")
+
+        # Initialize git hooks if in a git repository
+        git_dir = Path(".git")
+        if git_dir.exists():
+            hooks_dir = git_dir / "hooks"
+
+            # Create pre-commit hook
+            pre_commit = hooks_dir / "pre-commit"
+            pre_commit_content = """#!/bin/sh
+# Activate virtual environment and run tests
+. "./venv/Scripts/activate"
+python -m pytest tests/
+"""
+            pre_commit.write_text(pre_commit_content)
+            pre_commit.chmod(0o755)
+            logger.info("Set up git pre-commit hook")
+
+        logger.info("Development environment setup complete")
+
+    except Exception as e:
+        logger.error("Setup failed", error=str(e), exc_info=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    setup_development_environment()