Comprehensive comparison for Database technology in Software Development applications

import aerospike
from aerospike import exception as ex
from aerospike_helpers.operations import operations
import time
import hashlib
import json
from typing import Optional, Dict, Any

class UserSessionManager:
    """
    Production-grade user session management using Aerospike.
    Demonstrates session storage with TTL, atomic operations, and error handling.
    """
    
    def __init__(self, hosts: list, namespace: str = 'production', set_name: str = 'sessions'):
        self.namespace = namespace
        self.set_name = set_name
        
        # Configure Aerospike client with production settings
        config = {
            'hosts': hosts,
            'policies': {
                'timeout': 1000,
                'key': aerospike.POLICY_KEY_SEND,
                'retry': aerospike.POLICY_RETRY_ONCE,
                'connect_timeout': 5000
            }
        }
        
        try:
            self.client = aerospike.client(config).connect()
        except ex.ClientError as e:
            raise Exception(f"Failed to connect to Aerospike: {e}")
    
    def create_session(self, user_id: str, session_data: Dict[str, Any], ttl: int = 3600) -> str:
        """
        Create a new user session with automatic expiration.
        Returns session_id on success.
        """
        session_id = hashlib.sha256(f"{user_id}:{time.time()}".encode()).hexdigest()
        key = (self.namespace, self.set_name, session_id)
        
        bins = {
            'user_id': user_id,
            'created_at': int(time.time()),
            'last_accessed': int(time.time()),
            'data': json.dumps(session_data),
            'access_count': 1
        }
        
        meta = {'ttl': ttl}
        policy = {'exists': aerospike.POLICY_EXISTS_CREATE}
        
        try:
            self.client.put(key, bins, meta=meta, policy=policy)
            return session_id
        except ex.RecordExistsError:
            raise ValueError("Session already exists")
        except ex.AerospikeError as e:
            raise Exception(f"Failed to create session: {e}")
    
    def get_session(self, session_id: str, extend_ttl: bool = True) -> Optional[Dict[str, Any]]:
        """
        Retrieve session and optionally extend TTL.
        Uses atomic operations to update access tracking.
        """
        key = (self.namespace, self.set_name, session_id)
        
        try:
            # Read the record
            (key_tuple, meta, bins) = self.client.get(key)
            
            if extend_ttl:
                # Atomic increment and timestamp update
                ops = [
                    operations.increment('access_count', 1),
                    operations.write('last_accessed', int(time.time())),
                    operations.touch(3600)  # Extend TTL by 1 hour
                ]
                self.client.operate(key, ops)
            
            # Parse and return session data
            return {
                'session_id': session_id,
                'user_id': bins['user_id'],
                'created_at': bins['created_at'],
                'last_accessed': bins['last_accessed'],
                'access_count': bins['access_count'],
                'data': json.loads(bins['data']),
                'ttl': meta['ttl']
            }
            
        except ex.RecordNotFound:
            return None
        except ex.AerospikeError as e:
            raise Exception(f"Failed to retrieve session: {e}")
    
    def update_session_data(self, session_id: str, updated_data: Dict[str, Any]) -> bool:
        """
        Update session data using atomic operations.
        """
        key = (self.namespace, self.set_name, session_id)
        
        try:
            ops = [
                operations.write('data', json.dumps(updated_data)),
                operations.write('last_accessed', int(time.time())),
                operations.touch(3600)
            ]
            self.client.operate(key, ops)
            return True
        except ex.RecordNotFound:
            return False
        except ex.AerospikeError as e:
            raise Exception(f"Failed to update session: {e}")
    
    def delete_session(self, session_id: str) -> bool:
        """
        Delete a session (logout).
        """
        key = (self.namespace, self.set_name, session_id)
        
        try:
            self.client.remove(key)
            return True
        except ex.RecordNotFound:
            return False
        except ex.AerospikeError as e:
            raise Exception(f"Failed to delete session: {e}")
    
    def close(self):
        """Close Aerospike connection."""
        if self.client:
            self.client.close()

# Example usage
if __name__ == '__main__':
    # Initialize session manager
    manager = UserSessionManager([('127.0.0.1', 3000)])
    
    try:
        # Create session
        session_id = manager.create_session(
            user_id='user123',
            session_data={'role': 'admin', 'permissions': ['read', 'write']},
            ttl=7200
        )
        print(f"Session created: {session_id}")
        
        # Retrieve session
        session = manager.get_session(session_id)
        print(f"Session data: {session}")
        
        # Update session
        manager.update_session_data(session_id, {'role': 'admin', 'permissions': ['read', 'write', 'delete']})
        
        # Delete session
        manager.delete_session(session_id)
        
    finally:
        manager.close()