Struct Freeze 

pub struct Freeze {
    pub from: Option<String>,
    pub until: Option<String>,
    pub reason: Option<String>,
    pub tz: ScheduleTz,
}

Fleet-wide change-freeze (#418 Phase 5 — the “メンテナンス窓 / 変更凍結” gap’s global half). Where Constraints::window is a per-schedule time-of-day gate, a Freeze is a single, fleet- global “stop all automated change” switch the operator flips during an incident or a year-end change-freeze. It lives in its own KV singleton (crate::kv::KEY_FREEZE); when present and active, both the backend scheduler and every agent’s local scheduler skip every fire.

Shapes:

• {} (no bounds) — frozen indefinitely until the operator clears it (incident “big red button”).
• { from, until } — frozen only within [from, until), evaluated in tz (planned change-freeze; auto-thaws).

The KV key being absent means “not frozen” — so clearing the freeze is a KV delete, and is_active only ever runs on a freeze the operator actually set.

Fields

from: Option<String>

Frozen from this instant (RFC3339 or bare YYYY-MM-DD in tz). None ⇒ frozen from the beginning of time.

until: Option<String>

Thawed from this instant on, exclusive. None ⇒ frozen with no scheduled end (manual clear required).

reason: Option<String>

Operator-supplied note surfaced on the freeze-skip log and the SPA banner (“year-end change freeze”, “INC-1234”). Advisory.

tz: ScheduleTz

Timezone the bare-date bounds are evaluated in (RFC3339 bounds carry their own offset). Defaults to host-local like a schedule’s tz.

Implementations

impl Freeze

pub fn is_active(&self, now: DateTime<Utc>) -> bool

Is the fleet frozen at now? An empty window (from/until both absent) is frozen unconditionally; otherwise membership of [from, until) in tz. Half-open like Active::contains, but fails CLOSED on an unparseable bound — a freeze is a safety switch, so a corrupt window (only reachable via a hand-edited KV blob; validate rejects it at set time) must mean “frozen”, not “fire normally” (coderabbit #472). This is the one deliberate divergence from active’s fail-OPEN behaviour, where an unparseable bound dormant-skips a schedule.

pub fn validate(&self) -> Result<(), String>

Reject unparseable bounds / from >= until at set time (the API + CLI counterpart to Schedule::validate).

Trait Implementations

impl Clone for Freeze

fn clone(&self) -> Freeze

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Freeze

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Freeze

fn default() -> Freeze

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Freeze

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Freeze

impl JsonSchema for Freeze

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Freeze

fn eq(&self, other: &Freeze) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Freeze

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Freeze