auv-core 0.0.22

Domain-facing local and remote operation interface for AUV
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
133
134
135
136
137
138
139
140
141
142
143

//! Unresolved resource selection shared by interface adapters.

/// Root resource selectors shared by command-like interface adapters.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RootSelection {
  /// Exact Device name selector.
  pub device_name: Option<String>,
  /// Device ID-prefix selector.
  pub device_id: Option<String>,
  /// Run ID-prefix selector.
  pub run_id: Option<String>,
}

/// Canonical resources resolved from a root selection.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ResolvedSelection {
  /// Selected Device, including one inherited from a single-Device Run.
  pub device: Option<crate::devices::Device>,
  /// Selected Run.
  pub run: Option<crate::runs::Run>,
}

/// Failure while resolving a root resource selection.
#[derive(Debug, thiserror::Error)]
pub enum SelectionError {
  /// Device selection failed.
  #[error(transparent)]
  Device(#[from] crate::devices::DeviceError),
  /// Run selection failed.
  #[error(transparent)]
  Run(#[from] crate::runs::RunError),
  /// The Device name and ID selectors resolve to different Devices.
  #[error("--device and --device-id select different Devices ({by_name:?} and {by_id:?})")]
  DeviceConflict {
    /// Canonical Device selected by name.
    by_name: String,
    /// Canonical Device selected by ID prefix.
    by_id: String,
  },
}

/// Failure while connecting and resolving a selected client.
#[derive(Debug, thiserror::Error)]
pub enum SelectedClientError {
  /// Resolving the connection context failed.
  #[error(transparent)]
  Context(#[from] crate::ContextError),
  /// Run or Device placement failed.
  #[error(transparent)]
  Placement(#[from] crate::client::PlacementError),
  /// Root resource selection failed.
  #[error(transparent)]
  Selection(#[from] SelectionError),
}

impl RootSelection {
  /// Returns whether no root resource selector is present.
  pub fn is_empty(&self) -> bool {
    self.device_name.is_none() && self.device_id.is_none() && self.run_id.is_none()
  }

  /// Builds the non-secret context used to resolve this selection.
  pub fn context(&self, endpoint: Option<&str>) -> crate::AuvContext {
    crate::AuvContext {
      device_id: self.device_id.clone(),
      device_name: self.device_name.clone(),
      run_id: self.run_id.clone(),
      daemon_endpoint: endpoint.map(str::to_string),
      ..crate::AuvContext::default()
    }
  }

  /// Builds the validated Device selector represented by the root fields.
  pub fn device_selector(&self) -> Result<Option<crate::resource::DeviceSelector>, crate::resource::IdentityError> {
    match (&self.device_id, &self.device_name) {
      (Some(id), Some(name)) => Ok(Some(crate::resource::DeviceSelector::parse_id(id)?.with_name(name.clone()))),
      (Some(id), None) => Ok(Some(crate::resource::DeviceSelector::parse_id(id)?)),
      (None, Some(name)) => Ok(Some(crate::resource::DeviceSelector::by_name(name.clone()))),
      (None, None) => Ok(None),
    }
  }
}

impl crate::Client {
  /// Connects using explicit root selection or optional local discovery, then
  /// resolves the selected resources with the same policy for every frontend.
  pub async fn selected(
    endpoint: Option<&str>,
    selection: &RootSelection,
  ) -> Result<Option<(Self, ResolvedSelection)>, SelectedClientError> {
    let client = if selection.is_empty() {
      let Some(client) = Self::discover(endpoint).await? else {
        return Ok(None);
      };
      client
    } else {
      Self::from_context(selection.context(endpoint)).await?
    };
    let resolved = client.resolve(selection).await?;
    Ok(Some((client, resolved)))
  }

  /// Resolves canonical resources against this connected client.
  pub async fn resolve(&self, selection: &RootSelection) -> Result<ResolvedSelection, SelectionError> {
    let by_id = match selection.device_id.as_deref() {
      Some(value) => {
        let selector = crate::resource::DeviceSelector::parse_id(value).map_err(crate::devices::DeviceError::from)?;
        Some(self.devices().get(&selector).await?)
      }
      None => None,
    };
    let by_name = match selection.device_name.as_deref() {
      Some(value) => Some(self.devices().get(&crate::resource::DeviceSelector::by_name(value)).await?),
      None => None,
    };
    if let (Some(by_id), Some(by_name)) = (&by_id, &by_name)
      && by_id.id != by_name.id
    {
      return Err(SelectionError::DeviceConflict {
        by_name: by_name.id.to_string(),
        by_id: by_id.id.to_string(),
      });
    }
    let run = match selection.run_id.as_deref() {
      Some(value) => {
        let selector = crate::resource::RunSelector::parse(value).map_err(crate::runs::RunError::from)?;
        Some(self.runs().get(&selector).await?)
      }
      None => None,
    };
    let mut device = by_id.or(by_name);
    if device.is_none()
      && let Some(run) = &run
      && let [device_id] = run.devices.as_slice()
    {
      device = Some(self.devices().get(&crate::resource::DeviceSelector::by_id(device_id.as_str())).await?);
    }
    if let (Some(run), Some(device)) = (&run, &device) {
      run.validate_device(Some(&device.id))?;
    }
    Ok(ResolvedSelection { device, run })
  }
}