Rename new watcher Event names and remove one that cannot happen

kube-runtime/src/controller/mod.rs

@@ -1750,7 +1750,7 @@ mod tests {
         let (queue_tx, queue_rx) = futures::channel::mpsc::unbounded::<ObjectRef<ConfigMap>>();
         let (store_rx, mut store_tx) = reflector::store();
         let mut applier = pin!(applier(
-            |obj, _| {
+            |_obj, _| {
                 Box::pin(async move {
                     // Try to flood the rescheduling buffer buffer by just putting it back in the queue immediately
                     //println!("reconciling {:?}", obj.metadata.name);
@@ -1763,7 +1763,7 @@ mod tests {
             queue_rx.map(Result::<_, Infallible>::Ok),
             Config::default(),
         ));
-        store_tx.apply_watcher_event(&watcher::Event::Restart);
+        store_tx.apply_watcher_event(&watcher::Event::Ready);
         for i in 0..items {
             let obj = ConfigMap {
                 metadata: ObjectMeta {

kube-runtime/src/reflector/dispatcher.rs

@@ -167,9 +167,9 @@ pub(crate) mod test {
         let st = stream::iter([
             Ok(Event::Apply(foo.clone())),
             Err(Error::TooManyObjects),
-            Ok(Event::RestartInit),
-            Ok(Event::RestartPage(vec![foo, bar])),
-            Ok(Event::Restart),
+            Ok(Event::Init),
+            Ok(Event::InitPage(vec![foo, bar])),
+            Ok(Event::Ready),
         ]);
 
         let (reader, writer) = reflector::store_shared(10);
@@ -192,15 +192,15 @@ pub(crate) mod test {
         assert_eq!(reader.len(), 1);
 
         let restarted = poll!(reflect.next());
-        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::RestartInit)))));
+        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::Init)))));
         assert_eq!(reader.len(), 1);
 
         let restarted = poll!(reflect.next());
-        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::RestartPage(_))))));
+        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::InitPage(_))))));
         assert_eq!(reader.len(), 1);
 
         let restarted = poll!(reflect.next());
-        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::Restart)))));
+        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::Ready)))));
         assert_eq!(reader.len(), 2);
 
         assert!(matches!(poll!(reflect.next()), Poll::Ready(None)));
@@ -219,13 +219,13 @@ pub(crate) mod test {
             Ok(Event::Delete(foo.clone())),
             Ok(Event::Apply(foo.clone())),
             Err(Error::TooManyObjects),
-            Ok(Event::RestartInit),
-            Ok(Event::RestartPage(vec![foo.clone(), bar.clone()])),
-            Ok(Event::Restart),
+            Ok(Event::Init),
+            Ok(Event::InitPage(vec![foo.clone(), bar.clone()])),
+            Ok(Event::Ready),
         ]);
 
         let foo = Arc::new(foo);
-        let bar = Arc::new(bar);
+        let _bar = Arc::new(bar);
 
         let (_, writer) = reflector::store_shared(10);
         let subscriber = writer.subscribe().unwrap();
@@ -257,17 +257,17 @@ pub(crate) mod test {
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::RestartInit)))
+            Poll::Ready(Some(Ok(Event::Init)))
         ));
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::RestartPage(_))))
+            Poll::Ready(Some(Ok(Event::InitPage(_))))
         ));
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::Restart)))
+            Poll::Ready(Some(Ok(Event::Ready)))
         ));
 
         // these don't come back in order atm:
@@ -287,9 +287,9 @@ pub(crate) mod test {
         let bar = testpod("bar");
         let st = stream::iter([
             Ok(Event::Apply(foo.clone())),
-            Ok(Event::RestartInit),
-            Ok(Event::RestartPage(vec![foo.clone(), bar.clone()])),
-            Ok(Event::Restart),
+            Ok(Event::Init),
+            Ok(Event::InitPage(vec![foo.clone(), bar.clone()])),
+            Ok(Event::Ready),
         ]);
 
         let foo = Arc::new(foo);
@@ -314,19 +314,19 @@ pub(crate) mod test {
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::RestartInit)))
+            Poll::Ready(Some(Ok(Event::Init)))
         ));
         assert_eq!(poll!(subscriber.next()), Poll::Pending);
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::RestartPage(_))))
+            Poll::Ready(Some(Ok(Event::InitPage(_))))
         ));
         assert_eq!(poll!(subscriber.next()), Poll::Pending);
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::Restart)))
+            Poll::Ready(Some(Ok(Event::Ready)))
         ));
         drop(reflect);
 
@@ -346,6 +346,7 @@ pub(crate) mod test {
         let foo = testpod("foo");
         let bar = testpod("bar");
         let st = stream::iter([
+            //TODO: include a ready event here to avoid dealing with Init?
             Ok(Event::Apply(foo.clone())),
             Ok(Event::Apply(bar.clone())),
             Ok(Event::Apply(foo.clone())),

kube-runtime/src/reflector/mod.rs

@@ -242,9 +242,9 @@ mod tests {
             store_w,
             stream::iter(vec![
                 Ok(watcher::Event::Apply(cm_a.clone())),
-                Ok(watcher::Event::RestartInit),
-                Ok(watcher::Event::RestartPage(vec![cm_b.clone()])),
-                Ok(watcher::Event::Restart),
+                Ok(watcher::Event::Init),
+                Ok(watcher::Event::InitPage(vec![cm_b.clone()])),
+                Ok(watcher::Event::Ready),
             ]),
         )
         .map(|_| ())

kube-runtime/src/reflector/store.rs

@@ -108,17 +108,22 @@
                 let key = obj.to_object_ref(self.dyntype.clone());
                 self.store.write().remove(&key);
             }
-            watcher::Event::RestartInit => {
+            watcher::Event::Init => {
                 self.buffer = AHashMap::new();
             }
-            watcher::Event::RestartPage(new_objs) => {
+            watcher::Event::InitPage(new_objs) => {
                 let new_objs = new_objs
                     .iter()
                     .map(|obj| (obj.to_object_ref(self.dyntype.clone()), Arc::new(obj.clone())))
                     .collect::<AHashMap<_, _>>();
                 self.buffer.extend(new_objs);
             }
-            watcher::Event::Restart => {
+            watcher::Event::InitApply(obj) => {
+                let key = obj.to_object_ref(self.dyntype.clone());
+                let obj = Arc::new(obj.clone());
+                self.buffer.insert(key, obj);
+            }
+            watcher::Event::Ready => {
                 let mut store = self.store.write();
 
                 // Swap the buffer into the store
@@ -134,15 +139,6 @@
                     ready_tx.init(())
                 }
             }
-            watcher::Event::RestartApply(obj) => {
-                let key = obj.to_object_ref(self.dyntype.clone());
-                let obj = Arc::new(obj.clone());
-                self.buffer.insert(key, obj);
-            }
-            watcher::Event::RestartDelete(obj) => {
-                let key = obj.to_object_ref(self.dyntype.clone());
-                self.buffer.remove(&key);
-            }
         }
     }
 
@@ -157,7 +153,7 @@
                     dispatcher.broadcast(obj_ref).await;
                 }
 
-                watcher::Event::Restart => {
+                watcher::Event::Ready => {
                     let obj_refs: Vec<_> = {
                         let store = self.store.read();
                         store.keys().cloned().collect()

kube-runtime/src/utils/event_flatten.rs

@@ -37,19 +37,19 @@
                 break Some(Ok(item));
             }
             let var_name = match ready!(me.stream.as_mut().poll_next(cx)) {
-                Some(Ok(Event::Apply(obj) | Event::RestartApply(obj))) => Some(Ok(obj)),
-                Some(Ok(Event::Delete(obj) | Event::RestartDelete(obj))) => {
+                Some(Ok(Event::Apply(obj) | Event::InitApply(obj))) => Some(Ok(obj)),
+                Some(Ok(Event::Delete(obj))) => {
                     if *me.emit_deleted {
                         Some(Ok(obj))
                     } else {
                         continue;
                     }
                 }
-                Some(Ok(Event::RestartPage(objs))) => {
+                Some(Ok(Event::InitPage(objs))) => {
                     *me.queue = objs.into_iter();
                     continue;
                 }
-                Some(Ok(Event::RestartInit | Event::Restart)) => continue,
+                Some(Ok(Event::Init | Event::Ready)) => continue,
                 Some(Err(err)) => Some(Err(err)),
                 None => return Poll::Ready(None),
             };
@@ -72,7 +72,7 @@
             Ok(Event::Apply(1)),
             Ok(Event::Delete(0)),
             Ok(Event::Apply(2)),
-            Ok(Event::RestartPage(vec![1, 2])),
+            Ok(Event::InitPage(vec![1, 2])),
             Err(Error::TooManyObjects),
             Ok(Event::Apply(2)),
         ]);

kube-runtime/src/utils/event_modify.rs

@@ -56,7 +56,7 @@ pub(crate) mod test {
         let st = stream::iter([
             Ok(Event::Apply(0)),
             Err(Error::TooManyObjects),
-            Ok(Event::RestartPage(vec![10])),
+            Ok(Event::InitPage(vec![10])),
         ]);
         let mut ev_modify = pin!(EventModify::new(st, |x| {
             *x += 1;
@@ -75,7 +75,7 @@ pub(crate) mod test {
         let restarted = poll!(ev_modify.next());
         assert!(matches!(
             restarted,
-            Poll::Ready(Some(Ok(Event::RestartPage(vec)))) if vec == [11]
+            Poll::Ready(Some(Ok(Event::InitPage(vec)))) if vec == [11]
         ));
 
         assert!(matches!(poll!(ev_modify.next()), Poll::Ready(None)));

kube-runtime/src/utils/reflect.rs

@@ -74,9 +74,9 @@ pub(crate) mod test {
         let st = stream::iter([
             Ok(Event::Apply(foo.clone())),
             Err(Error::TooManyObjects),
-            Ok(Event::RestartInit),
-            Ok(Event::RestartPage(vec![foo, bar])),
-            Ok(Event::Restart),
+            Ok(Event::Init),
+            Ok(Event::InitPage(vec![foo, bar])),
+            Ok(Event::Ready),
         ]);
         let (reader, writer) = reflector::store();
 
@@ -97,17 +97,17 @@ pub(crate) mod test {
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::RestartInit)))
+            Poll::Ready(Some(Ok(Event::Init)))
         ));
         assert_eq!(reader.len(), 1);
 
         let restarted = poll!(reflect.next());
-        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::RestartPage(_))))));
+        assert!(matches!(restarted, Poll::Ready(Some(Ok(Event::InitPage(_))))));
         assert_eq!(reader.len(), 1);
 
         assert!(matches!(
             poll!(reflect.next()),
-            Poll::Ready(Some(Ok(Event::Restart)))
+            Poll::Ready(Some(Ok(Event::Ready)))
         ));
         assert_eq!(reader.len(), 2);