Session Examples

This section contains examples demonstrating the session management capabilities of True Storage.

Basic Session Usage

The following example shows basic session operations:

Basic Session Usage

"""
Basic Session Management Demo

This demo shows the fundamental operations of the True Storage session management system.
"""

from true_storage.session import SessionStore, SessionStoreConfig

def main():
    # Initialize session store with default configuration
    print("🚀 Initializing session store...")
    store = SessionStore()
    
    # Basic key-value operations
    print("\n📝 Basic key-value operations:")
    store['user_id'] = 'user123'  # Dict-style setting
    store.set('username', 'John Doe')  # Method-style setting
    
    print(f"User ID: {store.get('user_id')}")
    print(f"Username: {store['username']}")  # Dict-style getting
    
    # Default values
    print("\n🔄 Using default values:")
    print(f"Age (with default): {store.get('age', default=25)}")
    print(f"Email (with default): {store.get('email', default='no-email')}")
    
    # Check key existence
    print("\n🔍 Checking key existence:")
    print(f"'user_id' exists: {'user_id' in store}")
    print(f"'age' exists: {'age' in store}")
    
    # Store different types of data
    print("\n📦 Storing different data types:")
    store.set('numbers', [1, 2, 3, 4, 5])
    store.set('config', {'theme': 'dark', 'language': 'en'})
    store.set('is_active', True)
    
    print(f"Numbers: {store.get('numbers')}")
    print(f"Config: {store.get('config')}")
    print(f"Is Active: {store.get('is_active')}")
    
    # Delete operations
    print("\n❌ Delete operations:")
    store.delete('username')
    print(f"After deletion, username exists: {'username' in store}")
    
    # Clear all sessions
    print("\n🧹 Clearing all sessions...")
    store.clear()
    print(f"Store size after clear: {len(store)}")

if __name__ == '__main__':
    main()

Key features demonstrated:

• Session creation

• Data storage and retrieval

• Session cleanup

• Basic error handling

Session Expiration

This example demonstrates session expiration handling:

Session Expiration Handling

"""
Session Expiration and Cleanup Demo

This demo demonstrates session expiration and cleanup features of True Storage.
"""

import time
from true_storage.session import SessionStore, SessionStoreConfig

def main():
    # Initialize session store with custom expiration settings
    print("🚀 Initializing session store with custom expiration...")
    config = SessionStoreConfig(
        max_size=100,
        expiration_time=5,  # 5 seconds expiration
        cleanup_interval=2   # Clean up every 2 seconds
    )
    store = SessionStore(config)
    
    # Set some session data
    print("\n📝 Setting session data...")
    store.set('quick_expire', 'This will expire in 5 seconds')
    store.set('user_data', {'name': 'John', 'age': 30})
    
    print("Initial data:")
    print(f"quick_expire: {store.get('quick_expire')}")
    print(f"user_data: {store.get('user_data')}")
    
    # Wait for expiration
    print("\n⏳ Waiting for session expiration (6 seconds)...")
    time.sleep(6)
    
    print("\nAfter waiting:")
    print(f"quick_expire exists: {'quick_expire' in store}")
    print(f"quick_expire value: {store.get('quick_expire', 'EXPIRED!')}")
    print(f"user_data exists: {'user_data' in store}")
    
    # Set data with different expiration times
    print("\n🕒 Setting data with different expiration times...")
    store.set('short_lived', 'Expires quickly')
    store.set('long_lived', 'Stays longer')
    
    print("\nInitial state:")
    print(f"short_lived: {store.get('short_lived')}")
    print(f"long_lived: {store.get('long_lived')}")
    
    print("\n⏳ Waiting for 3 seconds...")
    time.sleep(3)
    
    print("\nAfter 3 seconds:")
    print(f"short_lived: {store.get('short_lived', 'EXPIRED!')}")
    print(f"long_lived: {store.get('long_lived', 'EXPIRED!')}")
    
    # Check session metadata
    print("\n📊 Checking session metadata...")
    if metadata := store.get_metadata('long_lived'):
        print(f"Created at: {metadata.created_at}")
        print(f"Last accessed: {metadata.last_accessed}")
        print(f"Access count: {metadata.access_count}")
        print(f"Status: {metadata.status}")
    
    # Demonstrate cleanup
    print("\n🧹 Demonstrating cleanup...")
    print(f"Store size before cleanup: {len(store)}")
    time.sleep(3)  # Wait for cleanup cycle
    print(f"Store size after cleanup: {len(store)}")
    
    # Stop the session store properly
    print("\n🛑 Stopping session store...")
    store.stop()

if __name__ == '__main__':
    main()

Key features demonstrated:

• Setting session timeouts

• Handling expired sessions

• Auto-cleanup

• Time-based operations

Session Locking

The following example shows thread-safe session operations:

Thread-Safe Session Operations

"""
Session Locking Demo

This demo shows how to use session locking for thread-safe operations.
"""

import threading
import time
from true_storage.session import SessionStore, SessionStoreConfig, StorageError

def worker(name: str, store: SessionStore, key: str):
    """Worker function that tries to access and modify a locked session."""
    try:
        print(f"\n👤 Worker {name}: Attempting to access key '{key}'")
        value = store.get(key)
        print(f"👤 Worker {name}: Read value: {value}")
        
        # Try to modify the value
        new_value = f"Modified by {name}"
        store.set(key, new_value)
        print(f"👤 Worker {name}: Successfully modified value to: {new_value}")
        
    except StorageError as e:
        print(f"❌ Worker {name}: Access denied - {e}")

def main():
    # Initialize session store with shorter lock timeout
    print("🚀 Initializing session store...")
    config = SessionStoreConfig(
        max_size=100,
        max_lock_time=5  # 5 seconds maximum lock time
    )
    store = SessionStore(config)
    
    # Set initial data
    key = 'shared_data'
    store.set(key, 'Initial value')
    
    # Demonstrate basic locking
    print("\n🔒 Basic locking demonstration:")
    print(f"Initial value: {store.get(key)}")
    
    # Lock the session
    print("\nLocking session...")
    store.lock(key)
    
    # Try to access locked session
    try:
        store.set(key, 'New value')
        print("✅ Set new value (shouldn't happen when locked)")
    except StorageError as e:
        print(f"❌ Failed to set value: {e}")
    
    # Check lock status
    status = store.get_status(key)
    print(f"\n📊 Session status: {status}")
    
    # Unlock the session
    print("\n🔓 Unlocking session...")
    store.unlock(key)
    
    # Demonstrate concurrent access
    print("\n🔄 Demonstrating concurrent access...")
    
    # Lock the session again
    store.lock(key)
    
    # Create worker threads
    threads = []
    for i in range(3):
        thread = threading.Thread(
            target=worker,
            args=(f"Worker-{i}", store, key)
        )
        threads.append(thread)
        thread.start()
    
    # Wait a bit before unlocking
    print("\n⏳ Waiting with lock held...")
    time.sleep(2)
    
    # Unlock for workers
    print("\n🔓 Unlocking for workers...")
    store.unlock(key)
    
    # Wait for all threads to complete
    for thread in threads:
        thread.join()
    
    # Show final value
    print(f"\n📝 Final value: {store.get(key)}")
    
    # Demonstrate lock timeout
    print("\n⏲️ Demonstrating lock timeout...")
    store.lock(key, duration=3)  # Lock for 3 seconds
    print("Session locked for 3 seconds")
    
    print("Waiting for lock to expire...")
    time.sleep(4)
    
    # Try to access after timeout
    try:
        store.set(key, 'After timeout')
        print("✅ Successfully set value after lock timeout")
    except StorageError as e:
        print(f"❌ Failed to set value: {e}")
    
    # Stop the session store
    print("\n🛑 Stopping session store...")
    store.stop()

if __name__ == '__main__':
    main()

Key features demonstrated:

• Thread synchronization

• Lock acquisition

• Deadlock prevention

• Concurrent access

Session Persistence

This example demonstrates session persistence features:

Session Persistence

"""
Session Persistence and Recovery Demo

This demo shows how to use session persistence features for data durability.
"""

import os
import time
from pathlib import Path
from true_storage.session import SessionStore, SessionStoreConfig

def main():
    # Setup persistence directory
    persistence_dir = Path("session_data")
    persistence_dir.mkdir(exist_ok=True)
    persistence_path = str(persistence_dir / "sessions.json")
    
    # Initialize session store with persistence
    print("🚀 Initializing session store with persistence...")
    config = SessionStoreConfig(
        max_size=100,
        persistence_path=persistence_path,
        backup_interval=5,  # Backup every 5 seconds
        enable_logging=True
    )
    store = SessionStore(config)
    
    # Check if we have any restored sessions
    print("\n📥 Checking for restored sessions...")
    print(f"Current store size: {len(store)}")
    
    # Set some session data
    print("\n📝 Setting new session data...")
    store.set('user_prefs', {
        'theme': 'dark',
        'language': 'en',
        'notifications': True
    })
    store.set('cart_items', [
        {'id': 1, 'name': 'Widget', 'quantity': 2},
        {'id': 2, 'name': 'Gadget', 'quantity': 1}
    ])
    
    # Wait for automatic backup
    print("\n⏳ Waiting for automatic backup (6 seconds)...")
    time.sleep(6)
    
    # Verify data was persisted
    print("\n🔍 Verifying persistence file...")
    if os.path.exists(persistence_path):
        print(f"✅ Persistence file exists at: {persistence_path}")
        print(f"File size: {os.path.getsize(persistence_path)} bytes")
    
    # Simulate application restart
    print("\n🔄 Simulating application restart...")
    store.stop()
    
    print("\n⏳ Waiting a moment...")
    time.sleep(2)
    
    # Create new store instance
    print("\n🚀 Creating new store instance...")
    new_store = SessionStore(config)
    
    # Verify data was restored
    print("\n🔍 Verifying restored data...")
    print("\nRestored user preferences:")
    print(new_store.get('user_prefs'))
    print("\nRestored cart items:")
    print(new_store.get('cart_items'))
    
    # Demonstrate atomic updates
    print("\n⚡ Demonstrating atomic updates...")
    for i in range(5):
        new_store.set(f'counter_{i}', i)
        print(f"Set counter_{i} = {i}")
        time.sleep(1)  # Allow time for backup
    
    # Final verification
    print("\n📊 Final store statistics:")
    print(f"Total sessions: {len(new_store)}")
    print(f"Persistence file size: {os.path.getsize(persistence_path)} bytes")
    
    # Clean up
    print("\n🧹 Cleaning up...")
    new_store.stop()
    
    # Optionally remove persistence file
    if input("\nRemove persistence file? (y/n): ").lower() == 'y':
        os.remove(persistence_path)
        persistence_dir.rmdir()
        print("✅ Persistence file and directory removed")
    else:
        print(f"ℹ️ Persistence file kept at: {persistence_path}")

if __name__ == '__main__':
    main()

Key features demonstrated:

• Session storage backends

• Data persistence

• Recovery mechanisms

• Backend configuration

Advanced Session Features

This example shows advanced session management features:

Advanced Session Features

"""
Advanced Session Features Demo

This demo showcases advanced features of the True Storage session management system.
"""

import threading
import time
import logging
from datetime import datetime
from true_storage.session import SessionStore, SessionStoreConfig

class SessionMonitor:
    """Utility class to monitor session store metrics."""
    
    def __init__(self, store: SessionStore):
        self.store = store
        self.start_time = time.time()
        self._stop_monitor = threading.Event()
        self._monitor_thread = threading.Thread(
            target=self._monitor_loop,
            daemon=True
        )
        self._monitor_thread.start()
    
    def _monitor_loop(self):
        while not self._stop_monitor.is_set():
            active_sessions = len(self.store)
            total_accesses = sum(
                metadata.access_count
                for metadata in self.store._metadata.values()
            )
            print(f"\n📊 Monitor Stats ({datetime.now().strftime('%H:%M:%S')})")
            print(f"Active Sessions: {active_sessions}")
            print(f"Total Accesses: {total_accesses}")
            print(f"Uptime: {int(time.time() - self.start_time)} seconds")
            self._stop_monitor.wait(5)
    
    def stop(self):
        self._stop_monitor.set()
        self._monitor_thread.join()

def session_worker(name: str, store: SessionStore):
    """Worker function that performs various session operations."""
    for i in range(5):
        try:
            # Create a session
            key = f"worker_{name}_session_{i}"
            store.set(key, {
                'worker': name,
                'iteration': i,
                'timestamp': time.time()
            })
            
            # Simulate some work
            time.sleep(0.5)
            
            # Access the session
            data = store.get(key)
            if data:
                # Modify the session
                data['accessed'] = True
                store.set(key, data)
            
            # Sometimes lock the session
            if i % 2 == 0:
                store.lock(key, duration=1)
                time.sleep(0.5)
                store.unlock(key)
            
        except Exception as e:
            logging.error(f"Worker {name} error: {e}")

def main():
    # Configure logging
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s'
    )
    
    # Initialize session store with advanced configuration
    print("🚀 Initializing session store with advanced features...")
    config = SessionStoreConfig(
        max_size=1000,
        expiration_time=30,
        cleanup_interval=5,
        enable_logging=True,
        log_level=logging.INFO
    )
    store = SessionStore(config)
    
    # Start session monitoring
    print("\n📈 Starting session monitoring...")
    monitor = SessionMonitor(store)
    
    # Create worker threads
    print("\n👥 Starting worker threads...")
    workers = []
    for i in range(3):
        worker = threading.Thread(
            target=session_worker,
            args=(f"Worker-{i}", store)
        )
        workers.append(worker)
        worker.start()
    
    # Demonstrate metadata tracking
    print("\n📊 Demonstrating metadata tracking...")
    test_key = 'metadata_test'
    store.set(test_key, 'test_value')
    
    # Access the value multiple times
    for _ in range(5):
        store.get(test_key)
        time.sleep(0.1)
    
    # Display metadata
    if metadata := store.get_metadata(test_key):
        print(f"\nSession Metadata for '{test_key}':")
        print(f"Created: {datetime.fromtimestamp(metadata.created_at)}")
        print(f"Last Accessed: {datetime.fromtimestamp(metadata.last_accessed)}")
        print(f"Access Count: {metadata.access_count}")
        print(f"Status: {metadata.status}")
    
    # Demonstrate session status transitions
    print("\n🔄 Demonstrating session status transitions...")
    status_key = 'status_test'
    store.set(status_key, 'initial_value')
    
    print(f"Initial status: {store.get_status(status_key)}")
    
    store.lock(status_key)
    print(f"After lock: {store.get_status(status_key)}")
    
    store.unlock(status_key)
    print(f"After unlock: {store.get_status(status_key)}")
    
    # Wait for workers to complete
    print("\n⏳ Waiting for workers to complete...")
    for worker in workers:
        worker.join()
    
    # Final statistics
    print("\n📈 Final Statistics:")
    print(f"Total Sessions: {len(store)}")
    print("Session Keys:", list(store.keys()))
    
    # Stop monitoring and cleanup
    print("\n🛑 Stopping services...")
    monitor.stop()
    store.stop()

if __name__ == '__main__':
    main()

Key features demonstrated:

• Custom session handlers

• Event callbacks

• Session migration

• Advanced configuration