Move workspace crates into subfolder

crates/streams/src/frames/eventsfromframes.rs

@@ -0,0 +1,99 @@
+use err::Error;
+use futures_util::Stream;
+use futures_util::StreamExt;
+use items_0::framable::FrameTypeInnerStatic;
+use items_0::streamitem::Sitemty;
+use items_0::streamitem::StreamItem;
+use items_2::frame::decode_frame;
+use items_2::inmem::InMemoryFrame;
+use netpod::log::*;
+use serde::de::DeserializeOwned;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+
+pub struct EventsFromFrames<O> {
+    inp: Pin<Box<dyn Stream<Item = Result<StreamItem<InMemoryFrame>, Error>> + Send>>,
+    dbgdesc: String,
+    errored: bool,
+    completed: bool,
+    _m1: PhantomData<O>,
+}
+
+impl<O> EventsFromFrames<O> {
+    pub fn new(
+        inp: Pin<Box<dyn Stream<Item = Result<StreamItem<InMemoryFrame>, Error>> + Send>>,
+        dbgdesc: String,
+    ) -> Self {
+        Self {
+            inp,
+            dbgdesc,
+            errored: false,
+            completed: false,
+            _m1: PhantomData,
+        }
+    }
+}
+
+impl<O> Stream for EventsFromFrames<O>
+where
+    O: FrameTypeInnerStatic + DeserializeOwned + Unpin,
+{
+    type Item = Sitemty<O>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        use Poll::*;
+        let span = span!(Level::INFO, "EvFrFr", id = tracing::field::Empty);
+        span.record("id", &self.dbgdesc);
+        let _spg = span.enter();
+        loop {
+            break if self.completed {
+                panic!("poll_next on completed");
+            } else if self.errored {
+                self.completed = true;
+                Ready(None)
+            } else {
+                match self.inp.poll_next_unpin(cx) {
+                    Ready(Some(Ok(item))) => match item {
+                        StreamItem::Log(item) => {
+                            //info!("{}  {:?}  {}", item.node_ix, item.level, item.msg);
+                            Ready(Some(Ok(StreamItem::Log(item))))
+                        }
+                        StreamItem::Stats(item) => Ready(Some(Ok(StreamItem::Stats(item)))),
+                        StreamItem::DataItem(frame) => match decode_frame::<Sitemty<O>>(&frame) {
+                            Ok(item) => match item {
+                                Ok(item) => match item {
+                                    StreamItem::Log(k) => {
+                                        //info!("rcvd log: {}  {:?}  {}", k.node_ix, k.level, k.msg);
+                                        Ready(Some(Ok(StreamItem::Log(k))))
+                                    }
+                                    item => Ready(Some(Ok(item))),
+                                },
+                                Err(e) => {
+                                    error!("rcvd err: {}", e);
+                                    self.errored = true;
+                                    Ready(Some(Err(e)))
+                                }
+                            },
+                            Err(e) => {
+                                error!("frame payload  len {}  tyid {}  {}", frame.buf().len(), frame.tyid(), e);
+                                self.errored = true;
+                                Ready(Some(Err(e)))
+                            }
+                        },
+                    },
+                    Ready(Some(Err(e))) => {
+                        self.errored = true;
+                        Ready(Some(Err(e)))
+                    }
+                    Ready(None) => {
+                        self.completed = true;
+                        Ready(None)
+                    }
+                    Pending => Pending,
+                }
+            };
+        }
+    }
+}