Struct SysHandler 

pub struct SysHandler<'a> { /* private fields */ }

Implementations

impl SysHandler<'_>

pub async fn list_audit_devices( &self, ) -> Result<HashMap<String, AuditDevice>, VaultError>

pub async fn enable_audit( &self, path: &str, params: &AuditParams, ) -> Result<(), VaultError>

pub async fn disable_audit(&self, path: &str) -> Result<(), VaultError>

impl SysHandler<'_>

pub async fn health(&self) -> Result<HealthResponse, VaultError>

pub async fn leader(&self) -> Result<LeaderResponse, VaultError>

impl SysHandler<'_>

pub async fn read_lease(&self, lease_id: &str) -> Result<LeaseInfo, VaultError>

pub async fn renew_lease( &self, lease_id: &str, increment: Option<&str>, ) -> Result<LeaseRenewal, VaultError>

pub async fn revoke_lease(&self, lease_id: &str) -> Result<(), VaultError>

pub async fn revoke_prefix(&self, prefix: &str) -> Result<(), VaultError>

impl SysHandler<'_>

pub async fn list_mounts( &self, ) -> Result<HashMap<String, MountInfo>, VaultError>

pub async fn mount( &self, path: &str, params: &MountParams, ) -> Result<(), VaultError>

pub async fn unmount(&self, path: &str) -> Result<(), VaultError>

pub async fn tune_mount( &self, path: &str, params: &MountTuneParams, ) -> Result<(), VaultError>

pub async fn read_mount_tune( &self, path: &str, ) -> Result<MountConfig, VaultError>

pub async fn list_auth_mounts( &self, ) -> Result<HashMap<String, AuthMountInfo>, VaultError>

pub async fn enable_auth( &self, path: &str, params: &AuthMountParams, ) -> Result<(), VaultError>

pub async fn disable_auth(&self, path: &str) -> Result<(), VaultError>

pub async fn read_auth_tune( &self, path: &str, ) -> Result<MountConfig, VaultError>

impl SysHandler<'_>

pub async fn list_namespaces(&self) -> Result<Vec<String>, VaultError>

pub async fn create_namespace( &self, path: &str, ) -> Result<NamespaceInfo, VaultError>

pub async fn delete_namespace(&self, path: &str) -> Result<(), VaultError>

impl SysHandler<'_>

pub async fn list_plugins( &self, plugin_type: &str, ) -> Result<Vec<String>, VaultError>

pub async fn read_plugin( &self, plugin_type: &str, name: &str, ) -> Result<PluginInfo, VaultError>

pub async fn register_plugin( &self, params: &RegisterPluginRequest, ) -> Result<(), VaultError>

pub async fn deregister_plugin( &self, plugin_type: &str, name: &str, ) -> Result<(), VaultError>

pub async fn reload_plugin(&self, plugin: &str) -> Result<(), VaultError>

impl SysHandler<'_>

pub async fn list_policies(&self) -> Result<Vec<String>, VaultError>

pub async fn read_policy(&self, name: &str) -> Result<PolicyInfo, VaultError>

pub async fn write_policy( &self, name: &str, rules: &str, ) -> Result<(), VaultError>

pub async fn delete_policy(&self, name: &str) -> Result<(), VaultError>

impl SysHandler<'_>

pub async fn list_rate_limit_quotas(&self) -> Result<Vec<String>, VaultError>

pub async fn read_rate_limit_quota( &self, name: &str, ) -> Result<RateLimitQuota, VaultError>

pub async fn write_rate_limit_quota( &self, name: &str, params: &RateLimitQuotaRequest, ) -> Result<(), VaultError>

pub async fn delete_rate_limit_quota( &self, name: &str, ) -> Result<(), VaultError>

impl SysHandler<'_>

pub async fn raft_config(&self) -> Result<RaftConfig, VaultError>

pub async fn raft_autopilot_state(&self) -> Result<AutopilotState, VaultError>

pub async fn raft_remove_peer(&self, server_id: &str) -> Result<(), VaultError>

pub async fn raft_snapshot(&self) -> Result<Vec<u8>, VaultError>

Take a Raft snapshot, returning the raw snapshot bytes

pub async fn raft_snapshot_restore( &self, snapshot: &[u8], ) -> Result<(), VaultError>

Restore a Raft snapshot from raw bytes

impl SysHandler<'_>

pub async fn rekey_init( &self, params: &RekeyInitRequest, ) -> Result<RekeyStatus, VaultError>

pub async fn rekey_status(&self) -> Result<RekeyStatus, VaultError>

pub async fn rekey_cancel(&self) -> Result<(), VaultError>

pub async fn rekey_update( &self, key: &SecretString, nonce: &str, ) -> Result<RekeyStatus, VaultError>

pub async fn generate_root_init( &self, params: &GenerateRootInitRequest, ) -> Result<GenerateRootStatus, VaultError>

pub async fn generate_root_status( &self, ) -> Result<GenerateRootStatus, VaultError>

pub async fn generate_root_cancel(&self) -> Result<(), VaultError>

pub async fn generate_root_update( &self, key: &SecretString, nonce: &str, ) -> Result<GenerateRootStatus, VaultError>

pub async fn remount( &self, from: &str, to: &str, ) -> Result<RemountStatus, VaultError>

pub async fn metrics_json(&self) -> Result<Value, VaultError>

pub async fn host_info(&self) -> Result<HostInfo, VaultError>

pub async fn internal_counters_activity(&self) -> Result<Value, VaultError>

pub async fn version_history( &self, ) -> Result<Vec<VersionHistoryEntry>, VaultError>

pub async fn rewrap(&self, token: &SecretString) -> Result<WrapInfo, VaultError>

pub async fn in_flight_requests( &self, ) -> Result<HashMap<String, InFlightRequest>, VaultError>

impl SysHandler<'_>

pub async fn seal_status(&self) -> Result<SealStatus, VaultError>

pub async fn seal(&self) -> Result<(), VaultError>

pub async fn unseal(&self, key: &SecretString) -> Result<SealStatus, VaultError>

pub async fn init( &self, params: &InitParams, ) -> Result<InitResponse, VaultError>

pub async fn step_down(&self) -> Result<(), VaultError>

impl SysHandler<'_>

pub async fn unwrap<T: DeserializeOwned>( &self, token: &SecretString, ) -> Result<T, VaultError>

pub async fn unwrap_str<T: DeserializeOwned>( &self, token: &str, ) -> Result<T, VaultError>

Convenience wrapper that accepts a plain &str token

pub async fn wrap_lookup( &self, token: &SecretString, ) -> Result<WrapInfo, VaultError>

pub async fn capabilities( &self, token: &SecretString, paths: &[&str], ) -> Result<HashMap<String, Vec<String>>, VaultError>

pub async fn capabilities_self( &self, paths: &[&str], ) -> Result<HashMap<String, Vec<String>>, VaultError>

pub async fn key_status(&self) -> Result<KeyStatus, VaultError>

pub async fn rotate_encryption_key(&self) -> Result<(), VaultError>

Trait Implementations

impl<'a> Debug for SysHandler<'a>

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

Formats the value using the given formatter.

impl SysOperations for SysHandler<'_>

async fn health(&self) -> Result<HealthResponse, VaultError>

async fn leader(&self) -> Result<LeaderResponse, VaultError>

async fn seal_status(&self) -> Result<SealStatus, VaultError>

async fn seal(&self) -> Result<(), VaultError>

async fn unseal(&self, key: &SecretString) -> Result<SealStatus, VaultError>

async fn init(&self, params: &InitParams) -> Result<InitResponse, VaultError>

async fn step_down(&self) -> Result<(), VaultError>

async fn list_mounts(&self) -> Result<HashMap<String, MountInfo>, VaultError>

async fn mount( &self, path: &str, params: &MountParams, ) -> Result<(), VaultError>

async fn unmount(&self, path: &str) -> Result<(), VaultError>

async fn tune_mount( &self, path: &str, params: &MountTuneParams, ) -> Result<(), VaultError>

async fn read_mount_tune(&self, path: &str) -> Result<MountConfig, VaultError>

async fn list_auth_mounts( &self, ) -> Result<HashMap<String, AuthMountInfo>, VaultError>

async fn enable_auth( &self, path: &str, params: &AuthMountParams, ) -> Result<(), VaultError>

async fn disable_auth(&self, path: &str) -> Result<(), VaultError>

async fn read_auth_tune(&self, path: &str) -> Result<MountConfig, VaultError>

async fn list_policies(&self) -> Result<Vec<String>, VaultError>

async fn read_policy(&self, name: &str) -> Result<PolicyInfo, VaultError>

async fn write_policy(&self, name: &str, rules: &str) -> Result<(), VaultError>

async fn delete_policy(&self, name: &str) -> Result<(), VaultError>

async fn read_lease(&self, lease_id: &str) -> Result<LeaseInfo, VaultError>

async fn renew_lease( &self, lease_id: &str, increment: Option<&str>, ) -> Result<LeaseRenewal, VaultError>

async fn revoke_lease(&self, lease_id: &str) -> Result<(), VaultError>

async fn revoke_prefix(&self, prefix: &str) -> Result<(), VaultError>

async fn list_audit_devices( &self, ) -> Result<HashMap<String, AuditDevice>, VaultError>

async fn enable_audit( &self, path: &str, params: &AuditParams, ) -> Result<(), VaultError>

async fn disable_audit(&self, path: &str) -> Result<(), VaultError>

async fn unwrap<T: DeserializeOwned + Send>( &self, token: &SecretString, ) -> Result<T, VaultError>

async fn wrap_lookup( &self, token: &SecretString, ) -> Result<WrapInfo, VaultError>

async fn capabilities( &self, token: &SecretString, paths: &[&str], ) -> Result<HashMap<String, Vec<String>>, VaultError>

async fn capabilities_self( &self, paths: &[&str], ) -> Result<HashMap<String, Vec<String>>, VaultError>

async fn key_status(&self) -> Result<KeyStatus, VaultError>

async fn rotate_encryption_key(&self) -> Result<(), VaultError>

async fn list_plugins( &self, plugin_type: &str, ) -> Result<Vec<String>, VaultError>

async fn read_plugin( &self, plugin_type: &str, name: &str, ) -> Result<PluginInfo, VaultError>

async fn register_plugin( &self, params: &RegisterPluginRequest, ) -> Result<(), VaultError>

async fn deregister_plugin( &self, plugin_type: &str, name: &str, ) -> Result<(), VaultError>

async fn reload_plugin(&self, plugin: &str) -> Result<(), VaultError>

async fn raft_config(&self) -> Result<RaftConfig, VaultError>

async fn raft_autopilot_state(&self) -> Result<AutopilotState, VaultError>

async fn raft_remove_peer(&self, server_id: &str) -> Result<(), VaultError>

async fn raft_snapshot(&self) -> Result<Vec<u8>, VaultError>

async fn raft_snapshot_restore(&self, snapshot: &[u8]) -> Result<(), VaultError>

async fn in_flight_requests( &self, ) -> Result<HashMap<String, InFlightRequest>, VaultError>

async fn list_namespaces(&self) -> Result<Vec<String>, VaultError>

async fn create_namespace( &self, path: &str, ) -> Result<NamespaceInfo, VaultError>

async fn delete_namespace(&self, path: &str) -> Result<(), VaultError>

async fn list_rate_limit_quotas(&self) -> Result<Vec<String>, VaultError>

async fn read_rate_limit_quota( &self, name: &str, ) -> Result<RateLimitQuota, VaultError>

async fn write_rate_limit_quota( &self, name: &str, params: &RateLimitQuotaRequest, ) -> Result<(), VaultError>

async fn delete_rate_limit_quota(&self, name: &str) -> Result<(), VaultError>

async fn rekey_init( &self, params: &RekeyInitRequest, ) -> Result<RekeyStatus, VaultError>

async fn rekey_status(&self) -> Result<RekeyStatus, VaultError>

async fn rekey_cancel(&self) -> Result<(), VaultError>

async fn rekey_update( &self, key: &SecretString, nonce: &str, ) -> Result<RekeyStatus, VaultError>

async fn generate_root_init( &self, params: &GenerateRootInitRequest, ) -> Result<GenerateRootStatus, VaultError>

async fn generate_root_status(&self) -> Result<GenerateRootStatus, VaultError>

async fn generate_root_cancel(&self) -> Result<(), VaultError>

async fn generate_root_update( &self, key: &SecretString, nonce: &str, ) -> Result<GenerateRootStatus, VaultError>

async fn remount( &self, from: &str, to: &str, ) -> Result<RemountStatus, VaultError>

async fn metrics_json(&self) -> Result<Value, VaultError>

async fn host_info(&self) -> Result<HostInfo, VaultError>

async fn internal_counters_activity(&self) -> Result<Value, VaultError>

async fn version_history(&self) -> Result<Vec<VersionHistoryEntry>, VaultError>

async fn rewrap(&self, token: &SecretString) -> Result<WrapInfo, VaultError>