security-client-rs 0.1.1

Async Kibana client for security operations and Fleet management
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

//! Integration packages from the package registry.
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};

use super::{Fleet, Item, Items};
use crate::{Scope, http::Method, request::endpoint};

#[derive(Clone, Debug, Deserialize, Serialize)]
#[non_exhaustive]
pub struct Package {
    pub name: String,
    pub version: String,
    #[serde(default)]
    pub title: Option<String>,
    #[serde(default)]
    pub description: Option<String>,
    /// For example `installed` or `not_installed`.
    #[serde(default)]
    pub status: Option<String>,
    #[serde(flatten)]
    pub extra: Map<String, Value>,
}

impl<'a> Fleet<'a> {
    /// Packages available from the configured registry, with install status.
    pub fn list_packages(&self) -> ListPackages<'a> {
        ListPackages(self.0.request(
            Method::GET,
            Scope::Space,
            &["api", "fleet", "epm", "packages"],
        ))
    }

    pub fn get_package(&self, name: &str, version: &str) -> GetPackage<'a> {
        GetPackage(self.0.request(
            Method::GET,
            Scope::Space,
            &["api", "fleet", "epm", "packages", name, version],
        ))
    }

    /// Installs package assets such as index templates and dashboards.
    pub fn install_package(&self, name: &str, version: &str) -> InstallPackage<'a> {
        InstallPackage(
            self.0
                .request(
                    Method::POST,
                    Scope::Space,
                    &["api", "fleet", "epm", "packages", name, version],
                )
                .json(&json!({})),
        )
    }

    pub fn uninstall_package(&self, name: &str, version: &str) -> UninstallPackage<'a> {
        UninstallPackage(self.0.request(
            Method::DELETE,
            Scope::Space,
            &["api", "fleet", "epm", "packages", name, version],
        ))
    }
}

endpoint! {
    /// `GET /api/fleet/epm/packages`
    ListPackages => Items<Package>
}

impl ListPackages<'_> {
    pub fn category(self, category: &str) -> Self {
        Self(self.0.param("category", category))
    }

    pub fn prerelease(self, include: bool) -> Self {
        Self(self.0.param("prerelease", include))
    }
}

endpoint! {
    /// `GET /api/fleet/epm/packages/{pkgName}/{pkgVersion}`
    GetPackage => Item<Package>
}

endpoint! {
    /// `POST /api/fleet/epm/packages/{pkgName}/{pkgVersion}`
    InstallPackage => Value
}

impl InstallPackage<'_> {
    /// Reinstalls or installs despite version constraints.
    pub fn force(self, force: bool) -> Self {
        Self(self.0.field("force", force))
    }

    pub fn ignore_constraints(self, ignore: bool) -> Self {
        Self(self.0.field("ignore_constraints", ignore))
    }
}

endpoint! {
    /// `DELETE /api/fleet/epm/packages/{pkgName}/{pkgVersion}`
    UninstallPackage => Value
}

impl UninstallPackage<'_> {
    /// Deletes the package even when it has active package policies.
    pub fn force(self, force: bool) -> Self {
        Self(self.0.param("force", force))
    }
}