Comprehensive comparison for Database technology in Software Development applications

import aerospike
from aerospike import exception as ex
from datetime import datetime, timedelta
import hashlib
import secrets

class SessionManager:
    """
    Production-ready session management system using Aerospike.
    Handles user authentication sessions with TTL and security features.
    """
    
    def __init__(self, hosts, namespace='production', set_name='sessions'):
        self.namespace = namespace
        self.set_name = set_name
        self.config = {
            'hosts': hosts,
            'policies': {
                'timeout': 1000,
                'key': aerospike.POLICY_KEY_SEND,
                'retry': aerospike.POLICY_RETRY_ONCE
            }
        }
        self.client = None
        
    def connect(self):
        """Establish connection to Aerospike cluster"""
        try:
            self.client = aerospike.client(self.config).connect()
            return True
        except ex.ClientError as e:
            print(f"Failed to connect to Aerospike: {e}")
            return False
    
    def create_session(self, user_id, user_data, ttl_seconds=3600):
        """Create a new user session with automatic expiration"""
        if not self.client:
            raise ConnectionError("Aerospike client not connected")
        
        session_token = secrets.token_urlsafe(32)
        session_key = self._generate_session_key(session_token)
        
        session_data = {
            'user_id': user_id,
            'username': user_data.get('username'),
            'email': user_data.get('email'),
            'roles': user_data.get('roles', []),
            'created_at': int(datetime.utcnow().timestamp()),
            'last_accessed': int(datetime.utcnow().timestamp()),
            'ip_address': user_data.get('ip_address'),
            'user_agent': user_data.get('user_agent')
        }
        
        try:
            key = (self.namespace, self.set_name, session_key)
            meta = {'ttl': ttl_seconds}
            self.client.put(key, session_data, meta=meta)
            return session_token
        except ex.RecordError as e:
            print(f"Failed to create session: {e}")
            return None
    
    def validate_session(self, session_token, extend_ttl=True):
        """Validate session and optionally extend TTL on access"""
        if not self.client:
            raise ConnectionError("Aerospike client not connected")
        
        session_key = self._generate_session_key(session_token)
        
        try:
            key = (self.namespace, self.set_name, session_key)
            (key_tuple, meta, bins) = self.client.get(key)
            
            if extend_ttl:
                bins['last_accessed'] = int(datetime.utcnow().timestamp())
                new_meta = {'ttl': 3600}
                self.client.put(key, bins, meta=new_meta)
            
            return {
                'valid': True,
                'user_id': bins.get('user_id'),
                'username': bins.get('username'),
                'roles': bins.get('roles', []),
                'ttl_remaining': meta.get('ttl')
            }
        except ex.RecordNotFound:
            return {'valid': False, 'error': 'Session expired or invalid'}
        except ex.AerospikeError as e:
            print(f"Session validation error: {e}")
            return {'valid': False, 'error': 'Internal error'}
    
    def revoke_session(self, session_token):
        """Explicitly revoke a session (logout)"""
        if not self.client:
            raise ConnectionError("Aerospike client not connected")
        
        session_key = self._generate_session_key(session_token)
        
        try:
            key = (self.namespace, self.set_name, session_key)
            self.client.remove(key)
            return True
        except ex.RecordNotFound:
            return False
        except ex.AerospikeError as e:
            print(f"Failed to revoke session: {e}")
            return False
    
    def get_user_sessions(self, user_id):
        """Retrieve all active sessions for a user using secondary index"""
        if not self.client:
            raise ConnectionError("Aerospike client not connected")
        
        try:
            query = self.client.query(self.namespace, self.set_name)
            query.select('user_id', 'created_at', 'last_accessed', 'ip_address')
            query.where(aerospike.predicates.equals('user_id', user_id))
            
            sessions = []
            for record in query.results():
                sessions.append(record[2])
            
            return sessions
        except ex.AerospikeError as e:
            print(f"Failed to retrieve user sessions: {e}")
            return []
    
    def _generate_session_key(self, session_token):
        """Generate deterministic key from session token"""
        return hashlib.sha256(session_token.encode()).hexdigest()
    
    def close(self):
        """Close Aerospike connection"""
        if self.client:
            self.client.close()

# Example usage
if __name__ == '__main__':
    manager = SessionManager([('127.0.0.1', 3000)])
    
    if manager.connect():
        user_data = {
            'username': 'john_doe',
            'email': '[email protected]',
            'roles': ['user', 'premium'],
            'ip_address': '192.168.1.100',
            'user_agent': 'Mozilla/5.0'
        }
        
        token = manager.create_session('user_12345', user_data, ttl_seconds=7200)
        print(f"Session created: {token}")
        
        validation = manager.validate_session(token)
        print(f"Session valid: {validation}")
        
        manager.revoke_session(token)
        print("Session revoked")
        
        manager.close()