codex-helper-core 0.15.0

Core library for codex-helper.
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

use crate::lb::{CooldownBackoff, LoadBalancer};
use crate::logging::now_ms;
use crate::state::ProxyState;

use super::attempt_target::AttemptTarget;

pub(super) async fn record_attempt_success(
    state: &ProxyState,
    service_name: &str,
    lb: Option<&LoadBalancer>,
    target: &AttemptTarget,
    failure_threshold_cooldown_secs: u64,
    cooldown_backoff: CooldownBackoff,
) {
    match target {
        AttemptTarget::Legacy(selected) => {
            if let Some(lb) = lb {
                lb.record_result_with_backoff(
                    selected.index,
                    true,
                    failure_threshold_cooldown_secs,
                    cooldown_backoff,
                );
            }
        }
        AttemptTarget::ProviderEndpoint(provider_target) => {
            state
                .record_provider_endpoint_attempt_success(
                    service_name,
                    provider_target.provider_endpoint.clone(),
                    now_ms(),
                )
                .await;
        }
    }
}

pub(super) async fn record_attempt_failure(
    state: &ProxyState,
    service_name: &str,
    lb: Option<&LoadBalancer>,
    target: &AttemptTarget,
    failure_threshold_cooldown_secs: u64,
    cooldown_backoff: CooldownBackoff,
) {
    match target {
        AttemptTarget::Legacy(selected) => {
            if let Some(lb) = lb {
                lb.record_result_with_backoff(
                    selected.index,
                    false,
                    failure_threshold_cooldown_secs,
                    cooldown_backoff,
                );
            }
        }
        AttemptTarget::ProviderEndpoint(provider_target) => {
            state
                .record_provider_endpoint_attempt_failure(
                    service_name,
                    provider_target.provider_endpoint.clone(),
                    failure_threshold_cooldown_secs,
                    cooldown_backoff,
                )
                .await;
        }
    }
}

pub(super) async fn penalize_attempt_target(
    state: &ProxyState,
    service_name: &str,
    lb: Option<&LoadBalancer>,
    target: &AttemptTarget,
    cooldown_secs: u64,
    reason: &str,
    cooldown_backoff: CooldownBackoff,
) {
    match target {
        AttemptTarget::Legacy(selected) => {
            if let Some(lb) = lb {
                lb.penalize_with_backoff(selected.index, cooldown_secs, reason, cooldown_backoff);
            }
        }
        AttemptTarget::ProviderEndpoint(provider_target) => {
            state
                .penalize_provider_endpoint_attempt(
                    service_name,
                    provider_target.provider_endpoint.clone(),
                    cooldown_secs,
                    cooldown_backoff,
                )
                .await;
        }
    }
}