manta-cli 1.62.3

Another CLI for ALPS
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

use anyhow::{Context, Error};
use manta_backend_dispatcher::{
  interfaces::{cfs::CfsTrait, ims::ImsTrait},
  types::ims::Image,
};

use crate::manta_backend_dispatcher::StaticBackendDispatcher;

/// This function retrieves the list of image IDs related to a CFS configuration name.
/// It first checks the CFS sessions for any succeeded sessions that built an image related to the
/// CFS configuration. Then, it checks if the image ID exists in the IMS.
pub async fn get_image_vec_related_cfs_configuration_name(
  backend: &StaticBackendDispatcher,
  shasta_token: &str,
  shasta_base_url: &str,
  shasta_root_cert: &[u8],
  cfs_configuration_name: String,
) -> Result<Vec<Image>, Error> {
  log::info!(
    "Searching in CFS sessions for image ID related to CFS configuration '{}'",
    cfs_configuration_name
  );

  // Get all CFS sessions related which has succeeded and built an image related to CFS
  // configuration

  // Get all CFS sessions which has succeeded
  let cfs_session_vec = backend
    .get_sessions(
      shasta_token,
      shasta_base_url,
      shasta_root_cert,
      None,
      None,
      None,
      None,
      None,
      None,
      None,
      Some(true),
      None,
    )
    .await
    .context("Failed to get CFS sessions from backend")?;

  // Filter CFS sessions to the ones related to CFS configuration and built an image (target
  // definition is 'image' and it actually has at least one artifact)
  let cfs_session_image_succeeded_vec =
    cfs_session_vec.iter().filter(|cfs_session| {
      cfs_session
        .get_configuration_name()
        .is_some_and(|name| name.eq(&cfs_configuration_name))
        && cfs_session
          .get_target_def()
          .is_some_and(|def| def.eq("image"))
        && cfs_session.get_first_result_id().is_some()
    });

  let mut boot_image_id_vec = Vec::new();

  // Find image in CFS sessions
  for cfs_session in cfs_session_image_succeeded_vec {
    let cfs_session_name = cfs_session.name.clone();

    for image_id in cfs_session.get_result_id_vec() {
      log::info!(
        "Checking if result_id {} in CFS session {} exists",
        image_id,
        cfs_session_name
      );

      // Get IMS image related to the CFS session
      let image_vec_rslt =
        backend.get_images(shasta_token, Some(&image_id)).await;

      match image_vec_rslt {
        Ok(mut image_vec) => {
          log::info!(
            "Found the image ID '{}' related to CFS sesison '{}'",
            image_id,
            cfs_session_name,
          );

          boot_image_id_vec.append(&mut image_vec);
        }
        Err(e) => {
          log::warn!(
            "Failed to fetch image '{}' for CFS session '{}': {}",
            image_id,
            cfs_session_name,
            e
          );
        }
      }
    }
  }

  Ok(boot_image_id_vec)
}