canic-host 0.111.0

Host-side App build and desired-state Fleet reconciliation library for Canic workspaces
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

//! Select a clean supplied-ID reset using current management authority only.

use crate::{
    fleet_ensure::{
        model::{
            DesiredFleet,
            infrastructure_bootstrap::{
                BootstrapCoordinatorSelection, InfrastructureBootstrapRecord,
            },
        },
        ops::{
            self, EnsurePaths,
            capacity_import::{
                admission::survey::CapacityImportSurveyStore, journal::CapacityImportJournalStore,
            },
            infrastructure_bootstrap::{
                InfrastructureBootstrapError, automatic, survey::BootstrapSurvey,
            },
        },
    },
    icp::IcpCli,
};
use std::path::Path;

/// Freeze original observations under durable inspection allowances before reset review.
pub(super) fn survey(
    workspace: &Path,
    desired: &DesiredFleet,
    icp: &IcpCli,
) -> Result<InfrastructureBootstrapRecord, InfrastructureBootstrapError> {
    let paths = EnsurePaths::under(workspace, &desired.environment, &desired.fleet);
    ops::operation_selection::retirement::prepare_bootstrap(&paths, desired)?;
    let owner = CapacityImportJournalStore::open(&paths)?;
    let digest = automatic::bind(&paths, desired)?;
    if let Some(source) = automatic::retained(&paths)? {
        return Ok(source);
    }
    let agent = automatic::agent(icp, desired)?;
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()?;
    let custody = runtime.block_on(automatic::custody(&paths, desired, &agent))?;
    let ids = automatic::direct_ids(desired, &custody)?;
    let mut persistence = CapacityImportSurveyStore::open_bootstrap(&owner, &paths, digest, &ids)?;
    let mut samples = Vec::new();
    for id in ids {
        let sample = if let Some(sample) = persistence.sample(id) {
            sample.clone()
        } else {
            let prepared = runtime.block_on(BootstrapSurvey::prepare_sample(&agent, id))?;
            persistence.reserve(id)?;
            let sample = runtime.block_on(prepared.observe())?;
            persistence.retain(sample.clone())?;
            sample
        };
        samples.push(sample);
    }
    let declarations =
        automatic::declarations(desired, &custody, &samples, &agent.read_root_key())?;
    let mut survey = BootstrapSurvey::begin(
        &paths,
        desired,
        BootstrapCoordinatorSelection::Initialize,
        &declarations,
    )?;
    survey.ledger(desired, icp)?;
    runtime.block_on(survey.finish(&paths, desired, &agent, samples))
}