Struct PackagePolicy 

#[non_exhaustive]
pub struct PackagePolicy {
    pub id: String,
    pub name: String,
    pub namespace: String,
    pub description: Option<String>,
    pub enabled: Option<bool>,
    pub revision: u64,
    pub package: PackageRef,
    pub policy_ids: Vec<String>,
    pub inputs: Value,
    pub vars: Option<Value>,
    pub version: Option<String>,
    pub extra: Map<String, Value>,
}

A package policy as Kibana returns it. Reads use Fleet’s full format; creation and simplified replacement responses use the simplified format.

Debug output omits inputs, variables and other fields, which can hold credentials.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: String

name: String

namespace: String

description: Option<String>

enabled: Option<bool>

revision: u64

Configuration revision, distinct from the opaque concurrency version.

package: PackageRef

policy_ids: Vec<String>

inputs: Value

Full-format inputs are an array; simplified inputs are an object keyed by input name.

vars: Option<Value>

Package-level variables.

version: Option<String>

Opaque concurrency token, sent back by PackagePolicy::edit.

extra: Map<String, Value>

Implementations

impl PackagePolicy

pub fn edit(&self) -> PackagePolicyEdit

A replacement for this policy in the full format. It keeps the current inputs, variables and assignments until changed, and is bound to the policy’s ID and concurrency token. If the response has simplified inputs, fetch the full policy with Fleet::get_package_policy before editing it. Sending an edit requires full inputs and a nonempty concurrency token; construction does not check them. Response-only compiled_input fields are removed from the inputs.

use security_client_rs::fleet::PackagePolicy;
use serde_json::{from_value, json, to_value};

let policy: PackagePolicy = from_value(json!({
    "id": "integration-a", "name": "system-1", "namespace": "default",
    "revision": 2, "version": "opaque-token", "policy_ids": ["policy-a"],
    "package": {"name": "system", "version": "2.24.0"},
    "inputs": [{"type": "logfile", "enabled": true, "streams": [],
                "compiled_input": {"type": "logfile"}}]
}))?;
let body = to_value(policy.edit().name("SOC system"))?;
assert_eq!(body["version"], "opaque-token");
assert_eq!(body["policy_ids"], json!(["policy-a"]));
assert_eq!(body["inputs"][0]["enabled"], true);
assert!(body["inputs"][0].get("compiled_input").is_none());
assert!(body.get("id").is_none()); // The edit binds the URL's ID instead.

Trait Implementations

impl Clone for PackagePolicy

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PackagePolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PackagePolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PackagePolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.