getmyid 0.1.3

Rust client library for whoami Identity-by-PID daemon
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Identity types returned by the whoami daemon.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Runner information containing both client-provided context and
/// server-injected identity fields.
///
/// This object is designed to be passed directly to a config server,
/// which can use it to route and customize configuration based on
/// both the verified identity and client-provided context.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct Runner {
    /// Application-level identity name (injected by whoami).
    #[serde(default)]
    pub identity: String,

    /// Hostname where the process is running (injected by whoami).
    #[serde(default)]
    pub hostname: String,

    /// Process name (injected by whoami).
    #[serde(default)]
    pub process: String,

    /// Process ID (injected by whoami).
    #[serde(default)]
    pub pid: u32,

    /// User ID (injected by whoami).
    #[serde(default)]
    pub uid: u32,

    /// Group ID (injected by whoami).
    #[serde(default)]
    pub gid: u32,

    /// Client-provided instance identifier (optional).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instance_id: Option<u64>,

    /// Client-provided timestamp (optional).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<u64>,

    /// Additional client-provided fields.
    #[serde(flatten, default)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// Client-provided runner context to send to whoami daemon.
///
/// These fields will be merged with server-injected identity fields
/// in the response's `runner` object.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
pub struct RunnerRequest {
    /// Instance identifier for dynamic configuration routing.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instance_id: Option<u64>,

    /// Timestamp for request tracking.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<u64>,

    /// Additional custom fields.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

impl RunnerRequest {
    /// Create a new empty runner request.
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the instance ID.
    pub fn with_instance_id(mut self, id: u64) -> Self {
        self.instance_id = Some(id);
        self
    }

    /// Set the timestamp.
    pub fn with_timestamp(mut self, ts: u64) -> Self {
        self.timestamp = Some(ts);
        self
    }

    /// Set the timestamp to the current Unix timestamp.
    pub fn with_current_timestamp(mut self) -> Self {
        self.timestamp = Some(
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .map(|d| d.as_secs())
                .unwrap_or(0),
        );
        self
    }

    /// Add a custom field.
    pub fn with_field(mut self, key: impl Into<String>, value: impl Into<serde_json::Value>) -> Self {
        self.extra.insert(key.into(), value.into());
        self
    }
}

/// Identity information returned by the whoami daemon.
///
/// This struct contains the application-level identity (name and URLs)
/// and a `runner` object with process/host details and client context.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Identity {
    /// Application-level identity name (from rules.conf).
    pub identity: String,

    /// Identity Management (OAuth2/OIDC) URL for this identity.
    pub idm_url: String,

    /// Configuration/API server URL for this identity.
    pub config_url: String,

    /// Authentication token for this identity.
    pub token: String,

    /// Runner information containing process details and client context.
    /// This object can be passed directly to a config server.
    pub runner: Runner,
}

/// Raw response from the whoami daemon.
#[derive(Debug, Deserialize)]
pub(crate) struct DaemonResponse {
    pub status: String,
    #[serde(flatten)]
    pub data: ResponseData,
}

/// Response data variants.
#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub(crate) enum ResponseData {
    Success {
        identity: String,
        idm_url: String,
        config_url: String,
        token: String,
        runner: Runner,
    },
    Error {
        error_code: String,
        message: String,
    },
}

impl DaemonResponse {
    /// Check if the response indicates success.
    pub fn is_ok(&self) -> bool {
        self.status == "ok"
    }
}