elasticctl 0.7.5

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
79
80
81
82

use super::parse_file_format;
use crate::cli::{Cli, ExceptionsAction};
use crate::cmd;
use crate::context::Context;
use elasticctl_api::exceptions::ListFilter;
use elasticctl_core::{Error, ErrorKind};
use serde_json::Value;

pub(crate) async fn exceptions(args: &Cli, action: &ExceptionsAction) -> Result<Value, Error> {
    match action {
        ExceptionsAction::List {
            list_type,
            tag,
            namespace,
            search,
        } => {
            let f = ListFilter {
                list_type: list_type.clone(),
                tag: tag.clone(),
                namespace: namespace.clone(),
                search: search.clone(),
            };
            match Context::build(&args.global) {
                Ok(ctx) => cmd::exceptions::list(&ctx, &f).await,
                Err(e) => Err(e),
            }
        }
        ExceptionsAction::Get { list_id, namespace } => match Context::build(&args.global) {
            Ok(ctx) => cmd::exceptions::get(&ctx, list_id, namespace.as_deref()).await,
            Err(e) => Err(e),
        },
        // Local only: no context, credential check, transport, or
        // capability probe.
        ExceptionsAction::Validate { path } => cmd::exceptions::validate(path),
        ExceptionsAction::Export {
            list_ids,
            tag,
            namespace,
            format_file,
        } => match parse_file_format(format_file) {
            Ok(format) => match Context::build(&args.global) {
                Ok(ctx) => {
                    cmd::exceptions::export(
                        &ctx,
                        list_ids,
                        tag.as_deref(),
                        namespace.as_deref(),
                        args.global.out.as_deref(),
                        format,
                    )
                    .await
                }
                Err(e) => Err(e),
            },
            Err(e) => Err(e),
        },
        ExceptionsAction::Import {
            path,
            overwrite,
            skip_existing,
        } => match Context::build(&args.global) {
            Ok(ctx) => cmd::exceptions::import(&ctx, path, *overwrite, *skip_existing).await,
            Err(e) => Err(e),
        },
        // Reject empty selectors before building a context so this cannot
        // express an unscoped mutation.
        ExceptionsAction::Delete {
            list_ids,
            namespace,
        } if list_ids.is_empty() => Err(Error::new(
            ErrorKind::Error,
            "Name at least one exception list to delete",
        )),
        ExceptionsAction::Delete {
            list_ids,
            namespace,
        } => match Context::build(&args.global) {
            Ok(ctx) => cmd::exceptions::delete(&ctx, list_ids, namespace.as_deref()).await,
            Err(e) => Err(e),
        },
    }
}