dsh_api 0.10.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

#[allow(unused_imports)]
#[path = "common.rs"]
mod common;

use crate::common::{initialize_logger, print_header};
use dsh_api::bucket::BucketInjection;
use dsh_api::dsh_api_client_factory::DshApiClientFactory;
use dsh_api::types::{AllocationStatus, Bucket, BucketStatus};
use dsh_api::{Dependant, DependantApp, DependantApplication};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), String> {
  initialize_logger();

  let bucket_id = "eds";

  let client_factory = DshApiClientFactory::default();
  let client = client_factory.client().await?;

  print_header("get_bucket_ids");
  let bucket_ids: Vec<String> = client.get_bucket_ids().await?;
  for bucket_id in bucket_ids {
    println!("{}", bucket_id);
  }

  print_header("buckets");
  let buckets: Vec<(String, BucketStatus)> = client.buckets().await?;
  for (bucket_id, bucket_status) in buckets {
    println!("{} -> {}", bucket_id, bucket_status);
  }

  print_header("bucket_name");
  let bucket_name: String = client.bucket_name(bucket_id).await?;
  println!("{} -> {}", bucket_id, bucket_name);

  print_header("get_bucket");
  let bucket: BucketStatus = client.get_bucket(bucket_id).await?;
  println!("{} -> {}", bucket_id, bucket);

  print_header("get_bucket_actual");
  let bucket_actual: Bucket = client.get_bucket_actual(bucket_id).await?;
  println!("{} -> {}", bucket_id, bucket_actual);

  print_header("get_bucket_status");
  let bucket_status: AllocationStatus = client.get_bucket_status(bucket_id).await?;
  println!("{} -> {}", bucket_id, bucket_status);

  print_header("get_bucket_configuration");
  let bucket_configuration: Bucket = client.get_bucket_configuration(bucket_id).await?;
  println!("{} -> {}", bucket_id, bucket_configuration);

  print_header("bucket_ids_with_dependants");
  let bucket_ids_with_dependants: Vec<(String, Vec<Dependant<BucketInjection>>)> = client.bucket_ids_with_dependants().await?;
  for (bucket_id, dependants) in bucket_ids_with_dependants {
    println!("{} -> {}", bucket_id, bucket_status);
    for dependant in dependants {
      println!("  {}", dependant);
    }
  }

  print_header("bucket_map");
  let bucket_map: HashMap<String, BucketStatus> = client.bucket_map().await?;
  println!("{:?}", bucket_map);

  print_header("buckets_with_dependants");
  let buckets_with_dependants: Vec<(String, BucketStatus, Vec<Dependant<BucketInjection>>)> = client.buckets_with_dependants().await?;
  for (bucket_id, bucket_status, dependants) in buckets_with_dependants {
    println!("{} -> {}", bucket_id, bucket_status);
    for dependant in dependants {
      println!("  {}", dependant);
    }
  }

  print_header("buckets_with_dependant_applications");
  let buckets_with_dependant_applications: Vec<(String, BucketStatus, Vec<DependantApplication<BucketInjection>>)> = client.buckets_with_dependant_applications().await?;
  for (bucket_id, _, dependants) in buckets_with_dependant_applications {
    println!("{}", bucket_id);
    for dependant in dependants {
      println!("  {}", dependant);
    }
  }

  print_header("buckets_with_dependant_apps");
  let buckets_with_dependant_apps: Vec<(String, BucketStatus, Vec<DependantApp>)> = client.buckets_with_dependant_apps().await?;
  for (bucket_id, _, dependants) in buckets_with_dependant_apps {
    println!("{}", bucket_id);
    for dependant in dependants {
      println!("  {}", dependant);
    }
  }

  print_header("bucket_secrets");
  let (access_key_id, _) = client.bucket_secrets().await?;
  println!("{}, ********", access_key_id);

  Ok(())
}