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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

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

const APP_NAME: &str = "my-app";
const PLATFORM_NAME: &str = "np-aws-lz-dsh";
const PROXY: &str = "my-proxy";
const SERVICE_NAME: &str = "my-service";
const TENANT_NAME: &str = "my-tenant";
const VHOST: &str = "my-vhost";

use crate::common::initialize_logger;
use dsh_api::platform::{DshPlatform, VhostZone};
use std::error::Error;

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

  match DshPlatform::try_default() {
    Ok(default_platform) => println!("default platform is {}", default_platform.name()),
    Err(error) => println!("no default platform, {}", error),
  }

  println!();

  match DshPlatform::try_from(PLATFORM_NAME) {
    Ok(default_platform) => print_platform(default_platform),
    Err(error) => println!("{}", error),
  }

  println!();

  for platform in DshPlatform::all() {
    println!("{} / {} -> {}", platform.name(), platform.alias(), platform.description());
  }

  Ok(())
}

fn print_platform(platform: DshPlatform) {
  println!("full name                        {}", platform.name());
  println!("description                      {}", platform.description());
  println!("alias                            {}", platform.alias());
  println!("is production                    {}", platform.is_production());
  println!("cloud provider                   {}", platform.cloud_provider());
  println!("access token endpoint            {}", platform.access_token_endpoint());
  println!("realm                            {}", platform.realm());
  println!("public domain                    {}", platform.public_domain());
  match platform.private_domain() {
    Some(private_domain) => println!("private domain                   {}", private_domain),
    None => println!("private domain                   not specified"),
  }
  println!();
  println!("domain console                   {}", platform.console_domain());
  println!("domain internal                  {}", platform.internal_domain(TENANT_NAME));
  println!("domain internal service          {}", platform.internal_service_domain(TENANT_NAME, SERVICE_NAME));
  println!("domain rest api                  {}", platform.rest_api_domain());
  println!("endpoint mqtt token              {}", platform.mqtt_token_endpoint());
  println!("endpoint rest api                {}", platform.rest_api_endpoint());
  match platform.tenant_private_vhost_domain(TENANT_NAME, VHOST) {
    Ok(private_vhost_domain) => println!("private domain vhost             {}", private_vhost_domain),
    Err(error) => println!("private domain vhost             {}", error),
  }
  println!("public domain app                {}", platform.tenant_public_app_domain(TENANT_NAME, APP_NAME));
  println!("public domain vhost              {}", platform.public_vhost_domain(VHOST));
  println!("robot client id                  {}", platform.robot_client_id());
  println!("robot client id tenant           {}", platform.robot_tenant_client_id(TENANT_NAME));

  println!("url app catalog tenant           {}", platform.tenant_app_catalog_url(TENANT_NAME));
  println!(
    "url app catalog tenant app       {}",
    platform.tenant_app_catalog_app_url(TENANT_NAME, "kpn", APP_NAME)
  );
  println!("url console                      {}", platform.console_url());
  println!("url console tenant               {}", platform.tenant_console_url(TENANT_NAME));
  println!("url console tenant app           {}", platform.tenant_app_console_url(TENANT_NAME, SERVICE_NAME));
  println!(
    "url console tenant service       {}",
    platform.tenant_service_console_url(TENANT_NAME, SERVICE_NAME)
  );
  println!("url data catalog tenant          {}", platform.tenant_data_catalog_url(TENANT_NAME));
  println!("url monitoring tenant            {}", platform.tenant_monitoring_url(TENANT_NAME));
  println!("url swagger                      {}", platform.swagger_url());
  println!("url tracing                      {}", platform.tracing_url());

  match platform.tenant_domain(TENANT_NAME, VhostZone::Private) {
    Ok(tenant_private_domain) => println!("private domain tenant            {}", tenant_private_domain),
    Err(error) => println!("private domain tenant            {}", error),
  }
  match platform.tenant_proxy_bootstrap_servers(TENANT_NAME, PROXY, VhostZone::Private, 3) {
    Ok(boostrap_servers) => println!("proxy private bootstrap servers  {}", boostrap_servers.join("\n                                 ")),
    Err(error) => println!("proxy private bootstrap servers  {}", error),
  }
  match platform.tenant_proxy_schema_store_host(TENANT_NAME, PROXY, VhostZone::Private) {
    Ok(schema_store_host) => println!("proxy private schema store host  {}", schema_store_host),
    Err(error) => println!("proxy private schema store host  {}", error),
  }

  println!(
    "public domain tenant             {}",
    platform.tenant_domain(TENANT_NAME, VhostZone::Public).unwrap()
  );
  println!(
    "proxy public bootstrap servers   {}",
    platform
      .tenant_proxy_bootstrap_servers(TENANT_NAME, PROXY, VhostZone::Public, 3)
      .unwrap()
      .join("\n                                 ")
  );
  println!(
    "proxy public schema store host   {}",
    platform.tenant_proxy_schema_store_host(TENANT_NAME, PROXY, VhostZone::Public).unwrap()
  );
}