Scope-Based Resource Management

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

// C++: Stack variables have scope-based lifetimes
 
void demonstrateScopeLifetime() {
    DatabaseConnection global_conn("postgres://...");  // Lives to end of function
    
    {  // New scope
        FileHandle inner_file("data.txt");  // Lives to end of this block
        
        if (condition) {
            Lock guard(mutex);  // Lives to end of if-block
            // Do work while holding lock
        }  // guard destroyed here - lock released
        
        // inner_file still valid here
        
    }  // inner_file destroyed here - file closed
    
    // global_conn still valid here
    
}  // global_conn destroyed here - connection closed
 
 
// Nested scopes for fine-grained control
void finegrainedLifetimes() {
    std::unique_ptr<ExpensiveResource> resource;
    
    {  // Limit scope of setup work
        std::unique_lock<std::mutex> lock(setupMutex);
        resource = createResource();
    }  // Lock released before using resource
    
    // Use resource without holding lock
    resource->process();
    
}  // resource destroyed here
 
 
// Loop scopes - each iteration is a new scope
void processFiles(const std::vector<std::string>& paths) {
    for (const auto& path : paths) {
        FileHandle file(path.c_str(), "r");  // Opened
        processContent(file);
        // file destroyed at end of EACH iteration
    }  // All files have been closed
}
 
 
// Scope-based transaction management
void scopedTransaction(Database& db) {
    Transaction txn(db);  // Transaction starts
    
    auto user = txn.insertUser(userData);
    auto account = txn.createAccount(user.id);
    
    if (!validateAccount(account)) {
        return;  // txn destructor rolls back automatically
    }
    
    txn.commit();  // Explicit commit
    
}  // If not committed, destructor rolls back

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// Pattern 1: Guard Object Pattern
// User gets a guard; releasing the resource is automatic
 
class ConnectionPool {
private:
    std::queue<Connection*> available_;
    std::mutex mutex_;
    
public:
    // Guard that returns connection to pool on destruction
    class ConnectionGuard {
        ConnectionPool& pool_;
        Connection* conn_;
        
    public:
        ConnectionGuard(ConnectionPool& pool, Connection* conn)
            : pool_(pool), conn_(conn) {}
        
        ~ConnectionGuard() {
            pool_.release(conn_);  // Automatic return to pool
        }
        
        // Non-copyable, movable
        ConnectionGuard(const ConnectionGuard&) = delete;
        ConnectionGuard& operator=(const ConnectionGuard&) = delete;
        
        ConnectionGuard(ConnectionGuard&& other) noexcept
            : pool_(other.pool_), conn_(other.conn_) {
            other.conn_ = nullptr;
        }
        
        Connection* operator->() { return conn_; }
        Connection& operator*() { return *conn_; }
    };
    
    ConnectionGuard acquire() {
        std::lock_guard lock(mutex_);
        Connection* conn = available_.front();
        available_.pop();
        return ConnectionGuard(*this, conn);
    }
    
private:
    void release(Connection* conn) {
        if (conn) {
            std::lock_guard lock(mutex_);
            available_.push(conn);
        }
    }
};
 
// Usage - connection automatically returned to pool
void usePool(ConnectionPool& pool) {
    auto conn = pool.acquire();  // Get guard
    conn->query("SELECT 1");
}  // Guard destroyed, connection returned
 
 
// Pattern 2: Callback/Loan Pattern
// User never directly handles the resource
 
class SecureKey {
private:
    std::vector<uint8_t> key_material_;
    
public:
    SecureKey(size_t keySize) : key_material_(keySize) {
        generateRandomBytes(key_material_.data(), keySize);
    }
    
    ~SecureKey() {
        // Secure cleanup - zero memory before freeing
        std::memset(key_material_.data(), 0, key_material_.size());
    }
    
    // Callback pattern - key never escapes this scope
    template<typename F>
    auto useKey(F&& operation) const -> decltype(operation(key_material_.data())) {
        return operation(key_material_.data());
    }
    
    // No methods that return the key data directly!
    // User cannot accidentally keep a reference
};
 
// Usage
void encryptData(SecureKey& key, const std::vector<uint8_t>& data) {
    key.useKey([&](const uint8_t* keyBytes) {
        performEncryption(keyBytes, data);
    });
    // keyBytes pointer is invalid outside callback
}
 
 
// Pattern 3: Builder with Scope Completion
class HttpRequestBuilder {
private:
    HttpClient& client_;
    Request request_;
    
public:
    HttpRequestBuilder(HttpClient& client, std::string url)
        : client_(client) {
        request_.url = std::move(url);
    }
    
    HttpRequestBuilder& header(std::string key, std::string value) {
        request_.headers[key] = value;
        return *this;
    }
    
    // execute() takes ownership and performs the request
    // Builder cannot be used after this
    Response execute() && {  // && means only callable on rvalue
        return client_.send(std::move(request_));
    }
};
 
// Usage - builder consumed by execute
Response response = client.request("https://api.example.com")
    .header("Authorization", token)
    .header("Content-Type", "application/json")
    .execute();  // Builder consumed here

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

from contextlib import ExitStack, contextmanager
from typing import List, Callable, TypeVar
 
T = TypeVar('T')
 
# Basic composition with ExitStack
def process_all_files(paths: List[str]) -> List[str]:
    """Process multiple files with guaranteed cleanup of all."""
    with ExitStack() as stack:
        # Open all files, tracking for cleanup
        files = [stack.enter_context(open(p)) for p in paths]
        
        # Process all files
        return [f.read() for f in files]
    # All files closed, even if one fails
 
 
# Building complex transactions with ExitStack
def complex_operation():
    with ExitStack() as stack:
        # Each resource is tracked as we acquire it
        db = stack.enter_context(get_db_connection())
        
        # Conditional resource acquisition
        if needs_cache:
            cache = stack.enter_context(get_cache_connection())
        else:
            cache = None
        
        # Cleanup callbacks for non-context-manager resources
        temp_file = create_temp_file()
        stack.callback(os.unlink, temp_file)  # Delete on exit
        
        # Operations...
        result = process(db, cache, temp_file)
        
        return result
    # All resources cleaned up in reverse order
 
 
# Composing context managers into new context managers
@contextmanager
def full_transaction(db_url: str, cache_url: str):
    """Create a composed context manager for complete transaction."""
    with ExitStack() as stack:
        db = stack.enter_context(DatabaseConnection(db_url))
        cache = stack.enter_context(CacheConnection(cache_url))
        tx = stack.enter_context(db.begin_transaction())
        
        yield TransactionContext(db=db, cache=cache, tx=tx)
        
        # If we reach here without exception, commit
        tx.commit()
    # On exception: tx.rollback() via its __exit__, then cache & db close
 
 
# Usage of composed context manager
with full_transaction(db_url, cache_url) as ctx:
    user = ctx.db.find_user(user_id)
    ctx.cache.invalidate(f"user:{user_id}")
    ctx.tx.update_user(user, new_data)
# Transaction committed, all connections closed
 
 
# Nested scope manager for hierarchical resources
class ScopedResourceTree:
    """Manage hierarchical resources with proper cleanup order."""
    
    def __init__(self):
        self._stack = ExitStack()
        self._children: List['ScopedResourceTree'] = []
    
    def __enter__(self):
        self._stack.__enter__()
        return self
    
    def __exit__(self, *exc_info):
        # First close all children
        for child in reversed(self._children):
            child.__exit__(*exc_info)
        # Then close own resources
        return self._stack.__exit__(*exc_info)
    
    def add_resource(self, cm):
        """Add a resource to this scope."""
        return self._stack.enter_context(cm)
    
    def create_child_scope(self) -> 'ScopedResourceTree':
        """Create a child scope that closes before parent."""
        child = ScopedResourceTree()
        child.__enter__()
        self._children.append(child)
        return child
 
 
# Hierarchical scope usage
with ScopedResourceTree() as root:
    db = root.add_resource(DatabaseConnection(url))
    
    for shard in shards:
        child_scope = root.create_child_scope()
        shard_conn = child_scope.add_resource(db.connect_shard(shard))
        process_shard(shard_conn)
    
    # All shard connections closed before main db connection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// Rust's ownership system explicitly tracks scope extension
 
// Returning ownership - resource escapes factory scope
fn create_resource() -> FileHandle {
    let file = FileHandle::open("data.txt")?;
    // file ownership is MOVED to caller
    file  // Not 'return', just the expression
}
 
fn use_created_resource() {
    let my_file = create_resource();  // Ownership transferred here
    my_file.read();
}  // my_file dropped here, not in create_resource
 
 
// Moving into collections
fn store_resources() -> Vec<FileHandle> {
    let mut files = Vec::new();
    
    for path in paths {
        let file = FileHandle::open(path)?;  // Created here
        files.push(file);  // Ownership moved to vector
    }
    
    files  // Ownership of entire vector (and contents) returned
}  // If we returned files, nothing is dropped here
 
 
// Async contexts - ownership across await points
async fn async_file_operation() -> Result<String, Error> {
    let file = File::open("data.txt").await?;  // Opened
    
    // file ownership held across await
    let content = read_file(&file).await?;
    
    Ok(content)
}  // file dropped when future completes
 
 
// Explicit scope extension with Rc/Arc
use std::rc::Rc;
 
fn shared_resource() {
    let resource = Rc::new(ExpensiveData::load());
    
    // Multiple owners
    let consumer1 = Consumer::new(Rc::clone(&resource));
    let consumer2 = Consumer::new(Rc::clone(&resource));
    
    // resource lives until ALL Rc references are dropped
}
 
 
// ManuallyDrop for controlled non-RAII scenarios
use std::mem::ManuallyDrop;
 
struct OptionallyOwned<T> {
    data: ManuallyDrop<T>,
    owned: bool,
}
 
impl<T> OptionallyOwned<T> {
    fn owned(data: T) -> Self {
        Self { data: ManuallyDrop::new(data), owned: true }
    }
    
    fn borrowed(data: T) -> Self {
        Self { data: ManuallyDrop::new(data), owned: false }
    }
}
 
impl<T> Drop for OptionallyOwned<T> {
    fn drop(&mut self) {
        if self.owned {
            // SAFETY: We only drop if we own it, and only once
            unsafe { ManuallyDrop::drop(&mut self.data); }
        }
        // If borrowed, data is NOT dropped - original owner handles it
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

import asyncio
from contextlib import asynccontextmanager
from typing import AsyncIterator
 
# Async context managers for async resources
class AsyncDatabaseConnection:
    async def __aenter__(self):
        self.conn = await asyncpg.connect(self.url)
        return self.conn
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.conn.close()
 
 
# Using asynccontextmanager decorator
@asynccontextmanager
async def managed_http_session() -> AsyncIterator[aiohttp.ClientSession]:
    """Create an HTTP session with proper async cleanup."""
    async with aiohttp.ClientSession() as session:
        yield session
    # Session closed when exiting async with
 
 
# Resource valid across await points
async def fetch_all_pages(urls: list[str]) -> list[str]:
    async with managed_http_session() as session:
        results = []
        for url in urls:
            # Session remains valid across await
            async with session.get(url) as response:
                content = await response.text()
                results.append(content)
        return results
    # Session closed after all awaits complete
 
 
# Handling cancellation
async def cancellation_safe_operation():
    """Ensure cleanup happens even on cancellation."""
    resource = await acquire_async_resource()
    try:
        while True:
            await do_work(resource)
            await asyncio.sleep(1)
    except asyncio.CancelledError:
        # Task was cancelled - cleanup explicitly
        await resource.cleanup()
        raise  # Re-raise to propagate cancellation
    finally:
        # Or use finally for guaranteed cleanup
        await resource.close()
 
 
# Structured concurrency with TaskGroup (Python 3.11+)
async def structured_concurrent_work():
    """Resources are scoped to the TaskGroup."""
    async with AsyncDatabaseConnection() as db:
        async with asyncio.TaskGroup() as tg:
            # All tasks share the db connection
            # db is guaranteed to outlive all tasks
            for item in items:
                tg.create_task(process_item(db, item))
        # TaskGroup exits only when ALL tasks complete
        # Then db connection is closed
    # This structure guarantees: tasks complete -> db closes
 
 
# AsyncExitStack for dynamic async resource management
async def dynamic_async_resources(urls: list[str]):
    async with AsyncExitStack() as stack:
        # Dynamically acquire resources as needed
        sessions = []
        for url in urls:
            session = await stack.enter_async_context(
                aiohttp.ClientSession(url)
            )
            sessions.append(session)
        
        # All sessions valid here
        results = await asyncio.gather(*[
            fetch_from(s) for s in sessions
        ])
        
        return results
    # All sessions closed in reverse order

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

import org.junit.jupiter.api.*;
import static org.assertj.core.api.Assertions.*;
import java.util.concurrent.atomic.*;
 
class ResourceManagementTest {
    
    // Track cleanup state
    static class TrackingResource implements AutoCloseable {
        final int id;
        static final List<Integer> closeOrder = new ArrayList<>();
        boolean closed = false;
        
        TrackingResource(int id) {
            this.id = id;
        }
        
        @Override
        public void close() {
            closed = true;
            closeOrder.add(id);
        }
        
        static void reset() {
            closeOrder.clear();
        }
    }
    
    @BeforeEach
    void setup() {
        TrackingResource.reset();
    }
    
    @Test
    void resourcesClosedInReverseOrder() {
        try (
            var r1 = new TrackingResource(1);
            var r2 = new TrackingResource(2);
            var r3 = new TrackingResource(3)
        ) {
            // Use resources
        }
        
        // Verify reverse order: 3, 2, 1
        assertThat(TrackingResource.closeOrder)
            .containsExactly(3, 2, 1);
    }
    
    @Test
    void resourcesClosedOnException() {
        try {
            try (var r = new TrackingResource(1)) {
                throw new RuntimeException("Simulated failure");
            }
        } catch (RuntimeException e) {
            // Expected
        }
        
        // Verify resource was still closed
        assertThat(TrackingResource.closeOrder).containsExactly(1);
    }
    
    @Test
    void closeExceptionSuppressedNotLost() {
        class FailingResource implements AutoCloseable {
            @Override
            public void close() {
                throw new RuntimeException("Close failed");
            }
        }
        
        try (var r = new FailingResource()) {
            throw new IllegalStateException("Primary exception");
        } catch (IllegalStateException e) {
            // Primary exception is thrown
            assertThat(e.getMessage()).isEqualTo("Primary exception");
            
            // Close exception is suppressed
            assertThat(e.getSuppressed())
                .hasSize(1)
                .extracting(Throwable::getMessage)
                .containsExactly("Close failed");
        }
    }
    
    @Test
    void nestedResourcesCleanedUpOnInnerException() {
        try {
            try (var outer = new TrackingResource(1)) {
                try (var inner = new TrackingResource(2)) {
                    throw new RuntimeException("Inner failure");
                }
            }
        } catch (RuntimeException e) {
            // Expected
        }
        
        // Both resources closed, inner first
        assertThat(TrackingResource.closeOrder).containsExactly(2, 1);
    }
    
    // Testing async cleanup
    @Test
    void asyncResourceCleanup() throws Exception {
        var cleanedUp = new CompletableFuture<Boolean>();
        
        AsyncResource resource = new AsyncResource(cleanedUp);
        
        CompletableFuture<Void> operation = CompletableFuture.runAsync(() -> {
            try (resource) {
                doAsyncWork();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        
        operation.get(5, TimeUnit.SECONDS);
        
        // Verify async cleanup happened
        assertThat(cleanedUp.get(1, TimeUnit.SECONDS)).isTrue();
    }
}
 
// Testing mock/spy approach
class PooledResourceTest {
    @Test
    void connectionReturnedToPoolOnException() {
        ConnectionPool pool = mock(ConnectionPool.class);
        Connection conn = mock(Connection.class);
        when(pool.acquire()).thenReturn(new ConnectionGuard(pool, conn));
        
        try {
            pool.withConnection(c -> {
                throw new SQLException("Query failed");
            });
        } catch (SQLException e) {
            // Expected
        }
        
        // Verify connection was returned to pool
        verify(pool).release(conn);
    }
}