Struct k8_client::K8Client

pub struct K8Client { /* fields omitted */ }

K8 Cluster accessible thru API

Implementations

impl K8Client

pub fn default() -> Result<Self, ClientError>

pub fn new(config: K8Config) -> Result<Self, ClientError>

pub async fn retrieve_items_inner<S, N, '_>(
    &'_ self,
    namespace: N,
    options: Option<ListOptions>
) -> Result<K8List<S>, ClientError> where
    S: Spec,
    N: Into<NameSpace> + Send + Sync, 

Trait Implementations

impl Debug for K8Client

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

Formats the value using the given formatter.

impl MetadataClient for K8Client

type MetadataClientError = ClientError

pub fn retrieve_item<'life0, 'life1, 'async_trait, S, M>(
    &'life0 self,
    metadata: &'life1 M
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, ClientError>> + Send + 'async_trait>> where
    S: Spec,
    M: K8Meta + Send + Sync,
    S: 'async_trait,
    M: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

retrieval a single item

pub fn retrieve_items_with_option<'life0, 'async_trait, S, N>(
    &'life0 self,
    namespace: N,
    option: Option<ListArg>
) -> Pin<Box<dyn Future<Output = Result<K8List<S>, ClientError>> + Send + 'async_trait>> where
    S: Spec,
    N: Into<NameSpace> + Send + Sync,
    S: 'async_trait,
    N: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

pub fn retrieve_items_in_chunks<'a, S, N>(
    self: Arc<Self>,
    namespace: N,
    limit: u32,
    option: Option<ListArg>
) -> BoxStream<'a, K8List<S>> where
    S: Spec + 'static,
    N: Into<NameSpace> + Send + Sync + 'static, 

returns stream of items in chunks

pub fn delete_item_with_option<'life0, 'life1, 'async_trait, S, M>(
    &'life0 self,
    metadata: &'life1 M,
    option: Option<DeleteOptions>
) -> Pin<Box<dyn Future<Output = Result<DeleteStatus<S>, ClientError>> + Send + 'async_trait>> where
    S: Spec,
    M: K8Meta + Send + Sync,
    S: 'async_trait,
    M: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

pub fn create_item<'life0, 'async_trait, S>(
    &'life0 self,
    value: InputK8Obj<S>
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, ClientError>> + Send + 'async_trait>> where
    S: Spec,
    S: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

create new object

pub fn update_status<'life0, 'life1, 'async_trait, S>(
    &'life0 self,
    value: &'life1 UpdateK8ObjStatus<S>
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, ClientError>> + Send + 'async_trait>> where
    S: Spec,
    S: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

update status

pub fn patch<'life0, 'life1, 'life2, 'async_trait, S, M>(
    &'life0 self,
    metadata: &'life1 M,
    patch: &'life2 Value,
    merge_type: PatchMergeType
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, ClientError>> + Send + 'async_trait>> where
    S: Spec,
    M: K8Meta + Display + Send + Sync,
    S: 'async_trait,
    M: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

patch existing with spec

pub fn watch_stream_since<S, N>(
    &self,
    namespace: N,
    resource_version: Option<String>
) -> BoxStream<'_, TokenStreamResult<S, Self::MetadataClientError>> where
    S: Spec + 'static,
    S::Status: 'static,
    S::Header: 'static,
    N: Into<NameSpace>, 

stream items since resource versions

#[must_use]pub fn retrieve_items<'life0, 'async_trait, S, N>(
    &'life0 self,
    namespace: N
) -> Pin<Box<dyn Future<Output = Result<K8List<S>, Self::MetadataClientError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    N: Into<NameSpace> + Send + Sync + 'async_trait,
    S: Spec + 'async_trait,
    Self: 'async_trait, 

retrieve all items a single chunk this may cause client to hang if there are too many items

#[must_use]pub fn delete_item<'life0, 'life1, 'async_trait, S, M>(
    &'life0 self,
    metadata: &'life1 M
) -> Pin<Box<dyn Future<Output = Result<DeleteStatus<S>, Self::MetadataClientError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    M: K8Meta + Send + Sync + 'async_trait,
    S: Spec + 'async_trait,
    Self: 'async_trait, 

#[must_use]pub fn apply<'life0, 'async_trait, S>(
    &'life0 self,
    value: K8SpecObj<S, InputObjectMeta>
) -> Pin<Box<dyn Future<Output = Result<ApplyResult<S>, Self::MetadataClientError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    S: Spec + 'async_trait,
    Self: 'async_trait,
    Self::MetadataClientError: From<Error>,
    Self::MetadataClientError: From<DiffError>,
    Self::MetadataClientError: Send, 

apply object, this is similar to kubectl apply for now, this doesn't do any optimization if object doesn't exist, it will be created if object exist, it will be patched by using strategic merge diff

#[must_use]pub fn patch_spec<'life0, 'life1, 'life2, 'async_trait, S, M>(
    &'life0 self,
    metadata: &'life1 M,
    patch: &'life2 Value
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, Self::MetadataClientError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    M: K8Meta + Display + Send + Sync + 'async_trait,
    S: Spec + 'async_trait,
    Self: 'async_trait, 

patch existing spec

pub fn watch_stream_now<S>(
    &self,
    ns: String
) -> Pin<Box<dyn Stream<Item = Result<Vec<Result<K8Watch<S>, Self::MetadataClientError>, Global>, Self::MetadataClientError>> + Send, Global>> where
    S: Spec + 'static, 

#[must_use]pub fn exists<'life0, 'life1, 'async_trait, S, M>(
    &'life0 self,
    metadata: &'life1 M
) -> Pin<Box<dyn Future<Output = Result<bool, Self::MetadataClientError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    M: K8Meta + Display + Send + Sync + 'async_trait,
    S: Spec + 'async_trait,
    Self: 'async_trait, 

Check if the object exists, return true or false.