cartel-pg 0.22.0

Async PostgreSQL driver for the dope runtime
Documentation 
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

use std::{cell::Cell, mem::MaybeUninit};

use dope::{core::driver::route::KeyTag, manifold::client::conn};
use o3::depot::{self, index::Initialized};

use crate::port::{
    Disposition,
    pool::{access, slot, slot::Phase},
    replies,
};

#[derive(Clone, Copy)]
enum Lifecycle {
    Vacant,
    Handshaking,
    Ready {
        access: access::State,
        receiving: bool,
    },
    Closing {
        failure: replies::Failure,
        disposition: Disposition,
    },
}

/// Initializes binding storage before publishing any live lifecycle state.
/// Deactivation preserves that Copy binding until its next epoch replaces it.
pub(super) struct State<'d, const ID: u8> {
    bound: Cell<MaybeUninit<slot::Bound<'d, ID>>>,
    phase: Cell<Lifecycle>,
}

impl<'d, const ID: u8> State<'d, ID> {
    pub(super) fn new() -> Self {
        Self {
            bound: Cell::new(MaybeUninit::uninit()),
            phase: Cell::new(Lifecycle::Vacant),
        }
    }

    pub(super) fn get(&self) -> Phase<'d, ID> {
        let phase = self.phase.get();
        if matches!(phase, Lifecycle::Vacant) {
            return Phase::Vacant;
        }
        // SAFETY: set writes the binding before publishing any live variant.
        let bound = unsafe { self.bound.get().assume_init() };
        match phase {
            Lifecycle::Vacant => Phase::Vacant,
            Lifecycle::Handshaking => Phase::Handshaking(bound),
            Lifecycle::Ready { access, .. } => Phase::Ready { bound, access },
            Lifecycle::Closing {
                failure,
                disposition: fate,
            } => Phase::Closing {
                bound,
                failure,
                disposition: fate,
            },
        }
    }

    pub(super) fn set(&self, phase: Phase<'d, ID>) {
        let (bound, phase) = match phase {
            Phase::Vacant => {
                self.phase.set(Lifecycle::Vacant);
                return;
            }
            Phase::Handshaking(bound) => (bound, Lifecycle::Handshaking),
            Phase::Ready { bound, access } => (
                bound,
                Lifecycle::Ready {
                    access,
                    // Ready-to-Ready transitions preserve this connection's input admission.
                    receiving: self.is_receiving(),
                },
            ),
            Phase::Closing {
                bound,
                failure,
                disposition: fate,
            } => (
                bound,
                Lifecycle::Closing {
                    failure,
                    disposition: fate,
                },
            ),
        };
        self.bound.set(MaybeUninit::new(bound));
        self.phase.set(phase);
    }

    pub(super) fn is_receiving(&self) -> bool {
        matches!(
            self.phase.get(),
            Lifecycle::Ready {
                receiving: true,
                ..
            }
        )
    }

    pub(super) fn set_receiving(&self, token: conn::Id<'d, KeyTag<ID>>, receiving: bool) -> bool {
        let Lifecycle::Ready {
            access,
            receiving: current,
        } = self.phase.get()
        else {
            return false;
        };
        if current == receiving {
            return false;
        }
        // SAFETY: every live lifecycle retains the binding initialized by set.
        let bound = unsafe { self.bound.get().assume_init() };
        if bound.token != token {
            return false;
        }
        self.phase.set(Lifecycle::Ready { access, receiving });
        true
    }

    pub(super) fn listed(
        proof: depot::raw::Proof<&slot::Slot<'d, ID>, Initialized<slot::Bound<'d, ID>>>,
    ) -> slot::Bound<'d, ID> {
        // SAFETY: ready storage publishes a selector member only after bind
        // initialized this exact slot. Its membership proof is retained for
        // this synchronous selection; no generation transition intervenes.
        unsafe { proof.into_inner().phase.bound.get().assume_init() }
    }
}