elasticctl 0.7.4

Operate Elastic Security as code with a safety-first CLI for security engineers.
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

use super::parse_content_format;
use crate::cli::{Cli, DashboardBundleAction, DashboardsAction};
use crate::cmd;
use crate::context::Context;
use elasticctl_core::{Error, ErrorKind};
use serde_json::Value;

pub(crate) async fn dashboards(args: &Cli, action: &DashboardsAction) -> Result<Value, Error> {
    match action {
        DashboardsAction::List { search, tag, limit } => match Context::build(&args.global) {
            Ok(ctx) => {
                let filter = elasticctl_api::dashboards_ops::DashboardFilter {
                    search: search.clone(),
                    tag: tag.clone(),
                    limit: *limit,
                };
                cmd::dashboards::list(&ctx, &filter).await
            }
            Err(e) => Err(e),
        },
        DashboardsAction::Get { selector } => match Context::build(&args.global) {
            Ok(ctx) => cmd::dashboards::get(&ctx, selector).await,
            Err(e) => Err(e),
        },
        // Local artifact validation must not read config or construct a
        // transport, so it remains usable in an offline checkout.
        DashboardsAction::Validate { path } => cmd::dashboards::validate(path),
        DashboardsAction::Export {
            selectors,
            format_file,
        } => match parse_content_format(format_file) {
            Ok(format) => match Context::build(&args.global) {
                Ok(ctx) => {
                    cmd::dashboards::export(&ctx, selectors, args.global.out.as_deref(), format)
                        .await
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        },
        DashboardsAction::Import {
            path,
            overwrite,
            skip_existing,
        } => match cmd::dashboards::validate_import_artifact(path) {
            Ok(()) => match Context::build(&args.global) {
                Ok(ctx) => cmd::dashboards::import(&ctx, path, *overwrite, *skip_existing).await,
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        },
        // Reject empty selectors before building a context so this cannot
        // express an unscoped mutation.
        DashboardsAction::Delete { selectors } if selectors.is_empty() => Err(Error::new(
            ErrorKind::Error,
            "Name at least one dashboard to delete",
        )),
        DashboardsAction::Delete { selectors } => match Context::build(&args.global) {
            Ok(ctx) => cmd::dashboards::delete(&ctx, selectors).await,
            Err(e) => Err(e),
        },
        DashboardsAction::Bundle { action } => match action {
            DashboardBundleAction::Export { selectors } => match Context::build(&args.global) {
                Ok(ctx) => {
                    cmd::dashboards::export_bundle(&ctx, selectors, args.global.out.as_deref())
                        .await
                }
                Err(e) => Err(e),
            },
            DashboardBundleAction::Import { path, overwrite } => {
                match Context::build(&args.global) {
                    Ok(ctx) => cmd::dashboards::bundle_import(&ctx, path, *overwrite).await,
                    Err(e) => Err(e),
                }
            }
        },
    }
}