WIP before remove of channelwriter

2023-08-24 20:42:50 +02:00
parent 26ee621a84
commit 9b03cfe666
20 changed files with 385 additions and 300 deletions
@@ -0,0 +1,104 @@
+use crate::access::Error;
+use crate::session::ScySession;
+use futures_util::Future;
+use futures_util::FutureExt;
+use netpod::log::*;
+use scylla::frame::value::ValueList;
+use scylla::prepared_statement::PreparedStatement;
+use scylla::transport::errors::QueryError;
+use scylla::QueryResult;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+use std::time::Instant;
+
+pub struct InsertLoopFut<'a> {
+    futs: Vec<Pin<Box<dyn Future<Output = Result<QueryResult, QueryError>> + Send + 'a>>>,
+    fut_ix: usize,
+    polled: usize,
+    ts_create: Instant,
+    ts_poll_start: Instant,
+}
+
+impl<'a> InsertLoopFut<'a> {
+    pub fn new<V>(scy: &'a ScySession, query: Option<&'a PreparedStatement>, values: Vec<V>, skip_insert: bool) -> Self
+    where
+        V: ValueList + Send + Sync + 'static,
+    {
+        let mut values = values;
+        if skip_insert {
+            values.clear();
+        }
+        // TODO
+        // Can I store the values in some better generic form?
+        // Or is it acceptable to generate all insert futures right here and poll them later?
+        let futs: Vec<_> = values
+            .into_iter()
+            .map(|vs| {
+                todo!("InsertLoopFut");
+                //let fut = scy.execute(query, vs);
+                let fut = futures_util::future::ready(Err(QueryError::TimeoutError));
+                Box::pin(fut) as _
+            })
+            .collect();
+        let tsnow = Instant::now();
+        Self {
+            futs,
+            fut_ix: 0,
+            polled: 0,
+            ts_create: tsnow,
+            ts_poll_start: tsnow,
+        }
+    }
+}
+
+impl<'a> Future for InsertLoopFut<'a> {
+    type Output = Result<(), Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        use Poll::*;
+        if self.polled == 0 {
+            self.ts_poll_start = Instant::now();
+        }
+        self.polled += 1;
+        if self.futs.is_empty() {
+            return Ready(Ok(()));
+        }
+        loop {
+            let fut_ix = self.fut_ix;
+            break match self.futs[fut_ix].poll_unpin(cx) {
+                Ready(k) => match k {
+                    Ok(_) => {
+                        self.fut_ix += 1;
+                        if self.fut_ix >= self.futs.len() {
+                            if false {
+                                let tsnow = Instant::now();
+                                let dt_created = tsnow.duration_since(self.ts_create).as_secs_f32() * 1e3;
+                                let dt_polled = tsnow.duration_since(self.ts_poll_start).as_secs_f32() * 1e3;
+                                info!(
+                                    "InsertLoopFut  polled {}  dt_created {:6.2} ms  dt_polled {:6.2} ms",
+                                    self.polled, dt_created, dt_polled
+                                );
+                            }
+                            continue;
+                        } else {
+                            Ready(Ok(()))
+                        }
+                    }
+                    Err(e) => {
+                        let tsnow = Instant::now();
+                        let dt_created = tsnow.duration_since(self.ts_create).as_secs_f32() * 1e3;
+                        let dt_polled = tsnow.duration_since(self.ts_poll_start).as_secs_f32() * 1e3;
+                        warn!(
+                            "InsertLoopFut  polled {}  dt_created {:6.2} ms  dt_polled {:6.2} ms",
+                            self.polled, dt_created, dt_polled
+                        );
+                        warn!("InsertLoopFut  done Err  {e:?}");
+                        Ready(Err(e.into()))
+                    }
+                },
+                Pending => Pending,
+            };
+        }
+    }
+}