Struct RepositoryEnvironment 

pub struct RepositoryEnvironment {

    pub schema: String,
    pub generated_at: String,
    pub resolution: Resolution,
    pub project: ProjectIdentity,
    pub repository: RepositoryIdentity,
    pub vcs: VcsState,
    pub toolchains: Vec<ToolchainState>,
    pub layer: LayerSummary,
    pub workflows: WorkflowCatalogue,
    pub providers: Vec<ProviderState>,
    pub services: Vec<ServiceState>,
    pub reasoning: Option<ReasoningSummary>,
    pub diagnostics: Vec<Diagnostic>,
    pub provenance: Vec<FieldSource>,
}

The snapshot: what this checkout is, right now.

Every surface that reports any of this renders this value. Collections are in a documented, stable order — kinds and workflows by name, services and providers in the order their canonical source declares them, diagnostics in the order they were found — so that two snapshots of the same repository serialise identically apart from RepositoryEnvironment::generated_at.

Fields

schema: String

The contract this document follows, majordomus/repository-environment/v1.

generated_at: String

When it was taken, RFC 3339 in UTC.

resolution: Resolution

How completely it was resolved.

project: ProjectIdentity

What the project is.

repository: RepositoryIdentity

What the checkout is.

vcs: VcsState

What version control says.

toolchains: Vec<ToolchainState>

The toolchains the repository declares, sorted by id.

layer: LayerSummary

What the layer holds.

workflows: WorkflowCatalogue

The workflows a person can run.

providers: Vec<ProviderState>

The provider projections the policy declares, in the policy’s order.

services: Vec<ServiceState>

The local services, in the order the service table declares them.

reasoning: Option<ReasoningSummary>

Reasoning (ADR 0098): operational whatever the advisors, the mode in force, and how many optional advisors can be asked. Absent when the distribution declares none.

diagnostics: Vec<Diagnostic>

Everything that went wrong or is worth knowing, in the order it was found.

provenance: Vec<FieldSource>

Where every field came from.

Implementations

impl RepositoryEnvironment

pub fn schema_id() -> String

The schema identity a document of this shape carries.

pub fn explain(&self, field: &str) -> Option<&FieldSource>

The provenance of one field, by its dotted name.

use majordomus_cli::environment::{FieldSource, RepositoryEnvironment};
let _ = env.explain("project.version");

pub fn digest(&self) -> String

A digest of everything a reader would notice, excluding the moment it was taken. Two snapshots with the same digest say the same thing, which is how the banner decides whether a person has already seen this.

pub fn news_digest(&self) -> String

The digest that decides whether a banner is news: Self::digest without the services.

The entry file watches the server’s lease, so a server coming up re-evaluates entry twice more — once when it claims the lease, once when it publishes its address — and a digest that counted the services made each of those a first look, drawing the whole box again at a person who had just seen it. A server arriving or leaving is not a different repository; the short form names the Cockpit when it answers.

use majordomus_cli::environment::RepositoryEnvironment;
// a server arriving or leaving is not a different repository, so clearing the
// services changes nothing this digest can see
let mut without = env.clone();
without.services.clear();
assert_eq!(env.news_digest(), without.news_digest());
// and with no services left, the two digests are the same value
assert_eq!(without.news_digest(), without.digest());

pub fn service(&self, id: &str) -> Option<&ServiceState>

The service with this id.

pub fn headline_diagnostic(&self) -> Option<&Diagnostic>

The worst thing in the snapshot worth telling a person about, when there is one.

Trait Implementations

impl Clone for RepositoryEnvironment

fn clone(&self) -> RepositoryEnvironment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RepositoryEnvironment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RepositoryEnvironment

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RepositoryEnvironment

impl JsonSchema for RepositoryEnvironment

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 RepositoryEnvironment

fn eq(&self, other: &RepositoryEnvironment) -> 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 RepositoryEnvironment

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 RepositoryEnvironment