// A watch that uses DeserializeGuard to skip resources which fail to deserialize.
// Any deserialization errors are logged as warnings and the event is skipped.
fn guarded_watch<R>(
    runtime: &mut kubert::Runtime<Option<Bound>>,
    watcher_config: watcher::Config,
) -> impl Stream<Item = watcher::Event<R>>
where
    R: Resource + DeserializeOwned + Clone + Debug + Send + 'static,
    R::DynamicType: Default,
{
    runtime
        .watch_all::<DeserializeGuard<R>>(watcher_config)
        .filter_map(async |item| {
            let log_warning = |t: &DeserializeGuard<R>| {
                if let Err(ref err) = t.0 {
                    tracing::warn!(
                        "skipping invalid {} resource {}/{}: {}",
                        R::kind(&Default::default()),
                        t.namespace().unwrap_or("<cluster>".to_string()),
                        t.name_any(),
                        err
                    );
                }
            };

            match item {
                watcher::Event::Apply(t) => {
                    log_warning(&t);
                    t.0.ok().map(watcher::Event::Apply)
                }
                watcher::Event::Delete(t) => {
                    log_warning(&t);
                    t.0.ok().map(watcher::Event::Delete)
                }
                watcher::Event::InitApply(t) => {
                    log_warning(&t);
                    t.0.ok().map(watcher::Event::InitApply)
                }
                watcher::Event::Init => Some(watcher::Event::Init),
                watcher::Event::InitDone => Some(watcher::Event::InitDone),
            }
        })
}