Struct k8_metadata_client::DoNothingClient

pub struct DoNothingClient();

Trait Implementations

impl MetadataClient for DoNothingClient

type MetadataClientError = DoNothingError

fn retrieve_item<'life0, 'life1, 'async_trait, S, M>(
    &'life0 self,
    _metadata: &'life1 M
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, Self::MetadataClientError>> + Send + 'async_trait>> where
    K8Obj<S>: DeserializeOwned,
    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

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>, Self::MetadataClientError>> + Send + 'async_trait>> where
    S: Spec,
    N: Into<NameSpace> + Send + Sync,
    S: 'async_trait,
    N: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

fn delete_item_with_option<'life0, 'life1, 'async_trait, S, M>(
    &'life0 self,
    _metadata: &'life1 M,
    _options: Option<DeleteOptions>
) -> Pin<Box<dyn Future<Output = Result<DeleteStatus<S>, Self::MetadataClientError>> + 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, 

fn create_item<'life0, 'async_trait, S>(
    &'life0 self,
    _value: InputK8Obj<S>
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, Self::MetadataClientError>> + Send + 'async_trait>> where
    InputK8Obj<S>: Serialize + Debug,
    K8Obj<S>: DeserializeOwned,
    S: Spec + Send,
    S: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

create new object

fn update_status<'life0, 'life1, 'async_trait, S>(
    &'life0 self,
    _value: &'life1 UpdateK8ObjStatus<S>
) -> Pin<Box<dyn Future<Output = Result<K8Obj<S>, Self::MetadataClientError>> + Send + 'async_trait>> where
    UpdateK8ObjStatus<S>: Serialize + Debug,
    K8Obj<S>: DeserializeOwned,
    S: Spec + Send + Sync,
    S::Status: Send + Sync,
    S: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

update status

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>, Self::MetadataClientError>> + 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 object with arbitrary patch

fn watch_stream_since<S, N>(
    &self,
    _namespace: N,
    _resource_version: Option<String>
) -> BoxStream<'_, TokenStreamResult<S, Self::MetadataClientError>> where
    K8Watch<S>: DeserializeOwned,
    S: Spec + Send + 'static,
    S::Header: Send + 'static,
    S::Status: Send + 'static,
    N: Into<NameSpace>, 

stream items since resource versions

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

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

fn delete_item<'life0, 'life1, 'async_trait, S, M>(
    &'life0 self,
    metadata: &'life1 M
) -> Pin<Box<dyn Future<Output = Result<DeleteStatus<S>, Self::MetadataClientError>> + 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, 

fn apply<'life0, 'async_trait, S>(
    &'life0 self,
    value: InputK8Obj<S>
) -> Pin<Box<dyn Future<Output = Result<ApplyResult<S>, Self::MetadataClientError>> + Send + 'async_trait>> where
    S: Spec,
    Self::MetadataClientError: From<Error> + From<DiffError> + Send,
    S: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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

fn patch_obj<'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>> + 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 obj

fn watch_stream_now<S>(
    &self,
    ns: String
) -> BoxStream<'_, TokenStreamResult<S, Self::MetadataClientError>> where
    S: Spec + 'static, 

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

Check if the object exists, return true or false.