dsh_api 0.9.0

DSH resource management API client
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
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

//! # Additional methods to manage nodepools
//!
//! Module that contains methods and functions to manage nodepools.
//!
//! # Generated methods
//!
//! [`DshApiClient`] methods that are generated from the `openapi` specification.
//!
//! * [`get_nodepool_actual(id) -> NodepoolActual`](DshApiClient::get_nodepool_actual)
//! * [`get_nodepool_ids() -> [id]`](DshApiClient::get_nodepool_ids)
//! * [`get_nodepool_status(id) -> AllocationStatus`](DshApiClient::get_nodepool_status)
//!
//! # Derived methods
//!
//! [`DshApiClient`] methods that add extra capabilities but do not directly call the
//! DSH resource management API. These derived methods depend on the API methods for this.
//!
//! * [`nodepools() -> [(id, nodepool)]`](DshApiClient::nodepools)
//! * [`nodepool_with_dependant_applications(id) -> (nodepool, [dependant])`](DshApiClient::nodepool_with_dependant_applications)
//! * [`nodepools_with_dependant_applications() -> [(id, nodepool, [dependant])]`](DshApiClient::nodepools_with_dependant_applications)

use crate::application_types::ApplicationValues;
use crate::dsh_api_client::DshApiClient;
use crate::error::DshApiResult;
use crate::types::{Application, NodeFeatures, NodepoolActual};
use crate::DependantApplication;
#[allow(unused_imports)]
use crate::DshApiError;
use futures::future::try_join_all;
use futures::try_join;
use itertools::Itertools;
use std::collections::HashMap;

/// # Additional methods to manage nodepools
///
/// Module that contains methods to manage nodepools.
/// * Derived methods - DshApiClient methods that add extra capabilities
///   but depend on the API methods.
///
/// # Derived methods
///
/// [`DshApiClient`] methods that add extra capabilities but do not directly call the
/// DSH resource management API. These derived methods depend on the API methods for this.
///
/// * [`nodepools() -> [(id, nodepool)]`](DshApiClient::nodepools)
/// * [`nodepool_with_dependant_applications(id) -> (nodepool, [dependant])`](DshApiClient::nodepool_with_dependant_applications)
/// * [`nodepools_with_dependant_applications() -> [(id, nodepool, [dependant])]`](DshApiClient::nodepools_with_dependant_applications)
impl DshApiClient {
  /// # Get all nodepools
  ///
  /// Returns all nodepool ids and configurations.
  ///
  /// # Returns
  /// * `Ok<(String, NodepoolActual)>` - Nodepool ids and configurations, sorted alphabetically.
  /// * `Err<`[`DshApiError`]`>` - When the request could not be processed by the DSH.
  pub async fn nodepools(&self) -> DshApiResult<Vec<(String, NodepoolActual)>> {
    let nodepool_ids = self.get_nodepool_ids().await?;
    let nodepool_actuals = try_join_all(nodepool_ids.iter().map(|nodepool_id| self.get_nodepool_actual(nodepool_id))).await?;
    Ok(nodepool_ids.into_iter().zip(nodepool_actuals).collect_vec())
  }

  /// # Get nodepool with usage dependant applications
  ///
  /// Returns the configuration of a given nodepool with the ids and instance numbers of the
  /// applications that depend on the nodepool.
  ///
  /// # Parameters
  /// * `nodepool_id` - Identifies the requested nodepool.
  ///
  /// # Returns
  /// * `Ok<(NodepoolActual, Vec<DependantApplication<()>>)>` - Tuple containing the nodepool
  ///   configuration and the dependant applications.
  /// * `Err<`[`DshApiError`]`>` - when the request could not be processed by the DSH
  pub async fn nodepool_with_dependant_applications(&self, nodepool_id: &str) -> DshApiResult<(NodepoolActual, Vec<DependantApplication<NodeFeatures>>)> {
    let (nodepool_actual, applications) = try_join!(self.get_nodepool_actual(nodepool_id), self.get_application_configuration_map(),)?;
    let mut dependants: Vec<DependantApplication<NodeFeatures>> = vec![];
    for ApplicationValues { id, application, values } in nodepool_from_applications(nodepool_id, &applications) {
      dependants.push(DependantApplication::new(
        id.to_string(),
        application.instances,
        values.into_iter().cloned().collect_vec(),
      ));
    }
    Ok((nodepool_actual, dependants))
  }

  /// # Returns all nodepools with their dependant applications
  ///
  /// Returns a sorted list of all nodepool ids, nodepool configurations and lists of applications
  /// that use them.
  ///
  /// # Returns
  /// * `Ok<(NodepoolActual, Vec<DependantApplication<()>>)>` - Tuple containing the nodepool ids,
  ///   configurations and dependant applications.
  /// * `Err<`[`DshApiError`]`>` - when the request could not be processed by the DSH
  pub async fn nodepools_with_dependant_applications(&self) -> DshApiResult<Vec<(String, NodepoolActual, Vec<DependantApplication<NodeFeatures>>)>> {
    let (nodepools, applications): (Vec<(String, NodepoolActual)>, HashMap<String, Application>) = try_join!(self.nodepools(), self.get_application_configuration_map())?;
    let mut nodepools_tuples = Vec::<(String, NodepoolActual, Vec<DependantApplication<NodeFeatures>>)>::new();
    for (nodepool_id, nodepool_actual) in nodepools {
      let mut dependant_applications: Vec<DependantApplication<NodeFeatures>> = vec![];
      for ApplicationValues { id, application, values } in nodepool_from_applications(&nodepool_id, &applications) {
        dependant_applications.push(DependantApplication::new(
          id.to_string(),
          application.instances,
          values.into_iter().cloned().collect_vec(),
        ));
      }
      nodepools_tuples.push((nodepool_id, nodepool_actual, dependant_applications));
    }
    Ok(nodepools_tuples)
  }
}

/// # Get nodepool from applications
///
/// Find nodepool configurations in all `Applications`.
///
/// # Parameters
/// * `nodepool_id` - Nodepool to look for.
/// * `applications` - Hashmap containing id/application pairs.
///
/// # Returns
/// `Vec<ApplicationValues<&NodeFeatures>>` - List of tuples containing:
/// * Application id,
/// * Application reference,
/// * Single item list containing the node features.
///
/// The list is sorted by application id.
pub fn nodepool_from_applications<'a>(nodepool_id: &str, applications: &'a HashMap<String, Application>) -> Vec<ApplicationValues<'a, &'a NodeFeatures>> {
  let mut application_tuples = applications
    .iter()
    .filter_map(|(application_id, application)| match &application.node_features {
      Some(node_features) => {
        if node_features.nodepool == nodepool_id {
          Some(ApplicationValues::new(application_id, application, vec![node_features]))
        } else {
          None
        }
      }
      None => None,
    })
    .collect_vec();
  application_tuples.sort();
  application_tuples
}

/// # Get all nodepools from applications
///
/// Get all nodepools from all `Applications`.
///
/// # Parameters
/// * `applications` - Hashmap containing id/application pairs.
///
/// # Returns
/// `Vec<ApplicationValues<(&str, Path)>>` - list of tuples containing:
/// * Application id,
/// * Application reference,
/// * Single item list containing the node features.
///
/// The list is sorted by application id.
pub fn nodepools_from_applications(applications: &HashMap<String, Application>) -> Vec<ApplicationValues<&NodeFeatures>> {
  let mut application_tuples = applications
    .iter()
    .filter_map(|(application_id, application)| match &application.node_features {
      Some(node_features) => Some(ApplicationValues::new(application_id, application, vec![node_features])),
      None => None,
    })
    .collect_vec();
  application_tuples.sort();
  application_tuples
}