Struct Process

pub struct Process {

    pub auid: Option<i64>,
    pub cmd_line: Option<String>,
    pub container: Option<Container>,
    pub created_time: Option<i64>,
    pub created_time_dt: Option<String>,
    pub egid: Option<i64>,
    pub euid: Option<i64>,
    pub file: Option<File>,
    pub group: Option<Group>,
    pub integrity: Option<String>,
    pub integrity_id: Option<ProcessIntegrityId>,
    pub lineage: Vec<String>,
    pub loaded_modules: Vec<String>,
    pub name: Option<String>,
    pub namespace_pid: Option<i64>,
    pub parent_process: Box<Option<Process>>,
    pub pid: Option<i64>,
    pub sandbox: Option<String>,
    pub session: Option<Session>,
    pub terminated_time: Option<i64>,
    pub terminated_time_dt: Option<String>,
    pub tid: Option<i64>,
    pub uid: Option<String>,
    pub user: Option<User>,
    pub xattributes: Option<Object>,
}

Process

JSON schema

{
 "type": "object",
 "properties": {
   "auid": {
     "type": "integer"
   },
   "cmd_line": {
     "type": "string"
   },
   "container": {
     "$ref": "#/$defs/container"
   },
   "created_time": {
     "type": "integer"
   },
   "created_time_dt": {
     "type": "string"
   },
   "egid": {
     "type": "integer"
   },
   "euid": {
     "type": "integer"
   },
   "file": {
     "$ref": "#/$defs/file"
   },
   "group": {
     "$ref": "#/$defs/group"
   },
   "integrity": {
     "type": "string"
   },
   "integrity_id": {
     "type": "integer",
     "enum": [
       3,
       6,
       0,
       1,
       2,
       99,
       4,
       5
     ]
   },
   "lineage": {
     "type": "array",
     "items": {
       "type": "string"
     }
   },
   "loaded_modules": {
     "type": "array",
     "items": {
       "type": "string"
     }
   },
   "name": {
     "type": "string"
   },
   "namespace_pid": {
     "type": "integer"
   },
   "parent_process": {
     "$ref": "#/$defs/process"
   },
   "pid": {
     "type": "integer"
   },
   "sandbox": {
     "type": "string"
   },
   "session": {
     "$ref": "#/$defs/session"
   },
   "terminated_time": {
     "type": "integer"
   },
   "terminated_time_dt": {
     "type": "string"
   },
   "tid": {
     "type": "integer"
   },
   "uid": {
     "type": "string"
   },
   "user": {
     "$ref": "#/$defs/user"
   },
   "xattributes": {
     "$ref": "#/$defs/object"
   }
 }
}

Fields

auid: Option<i64>

cmd_line: Option<String>

container: Option<Container>

created_time: Option<i64>

created_time_dt: Option<String>

egid: Option<i64>

euid: Option<i64>

file: Option<File>

group: Option<Group>

integrity: Option<String>

integrity_id: Option<ProcessIntegrityId>

lineage: Vec<String>

loaded_modules: Vec<String>

name: Option<String>

namespace_pid: Option<i64>

parent_process: Box<Option<Process>>

pid: Option<i64>

sandbox: Option<String>

session: Option<Session>

terminated_time: Option<i64>

terminated_time_dt: Option<String>

tid: Option<i64>

uid: Option<String>

user: Option<User>

xattributes: Option<Object>

Implementations

impl Process

pub fn builder() -> Process

Trait Implementations

impl Clone for Process

fn clone(&self) -> Process

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Process

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Process

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Process> for Process

fn from(value: &Process) -> Self

Converts to this type from the input type.

impl From<Process> for Process

fn from(value: Process) -> Self

Converts to this type from the input type.

impl Serialize for Process

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Process> for Process

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Process) -> Result<Self, ConversionError>

Performs the conversion.