130 lines
4.9 KiB
Rust
130 lines
4.9 KiB
Rust
use crate::collect::Collect;
|
|
use crate::collect::CollectResult;
|
|
use crate::firsterr::non_empty;
|
|
use crate::firsterr::only_first_err;
|
|
use crate::json_stream::events_stream_to_json_stream;
|
|
use crate::json_stream::JsonStream;
|
|
use crate::plaineventsstream::dyn_events_stream;
|
|
use crate::streamtimeout::StreamTimeout2;
|
|
use crate::tcprawclient::OpenBoxedBytesStreamsBox;
|
|
use futures_util::StreamExt;
|
|
use items_0::collect_s::CollectableDyn;
|
|
use items_0::on_sitemty_data;
|
|
use netpod::log::*;
|
|
use netpod::ChannelTypeConfigGen;
|
|
use netpod::Cluster;
|
|
use netpod::HasTimeout;
|
|
use netpod::ReqCtx;
|
|
use query::api4::events::PlainEventsQuery;
|
|
use serde_json::Value as JsonValue;
|
|
use std::time::Duration;
|
|
use std::time::Instant;
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
#[cstm(name = "PlainEventsJson")]
|
|
pub enum Error {
|
|
Stream(#[from] crate::plaineventsstream::Error),
|
|
Json(#[from] serde_json::Error),
|
|
Collect(#[from] crate::collect::Error),
|
|
}
|
|
|
|
pub async fn plain_events_json(
|
|
evq: &PlainEventsQuery,
|
|
ch_conf: ChannelTypeConfigGen,
|
|
ctx: &ReqCtx,
|
|
_cluster: &Cluster,
|
|
open_bytes: OpenBoxedBytesStreamsBox,
|
|
timeout_provider: Box<dyn StreamTimeout2>,
|
|
) -> Result<CollectResult<JsonValue>, Error> {
|
|
debug!("plain_events_json evquery {:?}", evq);
|
|
let deadline = Instant::now() + evq.timeout().unwrap_or(Duration::from_millis(4000));
|
|
|
|
let stream = dyn_events_stream(evq, ch_conf, ctx, open_bytes).await?;
|
|
|
|
let stream = stream.map(move |k| {
|
|
on_sitemty_data!(k, |mut k: Box<dyn items_0::Events>| {
|
|
if let Some(j) = k
|
|
.as_any_mut()
|
|
.downcast_mut::<items_2::channelevents::ChannelEvents>()
|
|
{
|
|
use items_0::AsAnyMut;
|
|
match j {
|
|
items_2::channelevents::ChannelEvents::Events(m) => {
|
|
if let Some(g) = m
|
|
.as_any_mut()
|
|
.downcast_mut::<items_2::eventsdim0::EventsDim0<netpod::EnumVariant>>()
|
|
{
|
|
trace!("consider container EnumVariant");
|
|
let mut out = items_2::eventsdim0enum::EventsDim0Enum::new();
|
|
for (&ts, val) in g.tss.iter().zip(g.values.iter()) {
|
|
out.push_back(ts, val.ix(), val.name_string());
|
|
}
|
|
let k: Box<dyn CollectableDyn> = Box::new(out);
|
|
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
|
|
} else {
|
|
trace!(
|
|
"consider container channel events other events {}",
|
|
k.type_name()
|
|
);
|
|
let k: Box<dyn CollectableDyn> = Box::new(k);
|
|
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
|
|
}
|
|
}
|
|
items_2::channelevents::ChannelEvents::Status(_) => {
|
|
trace!(
|
|
"consider container channel events status {}",
|
|
k.type_name()
|
|
);
|
|
let k: Box<dyn CollectableDyn> = Box::new(k);
|
|
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
|
|
}
|
|
}
|
|
} else {
|
|
trace!("consider container else {}", k.type_name());
|
|
let k: Box<dyn CollectableDyn> = Box::new(k);
|
|
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
|
|
}
|
|
})
|
|
});
|
|
|
|
//let stream = PlainEventStream::new(stream);
|
|
//let stream = EventsToTimeBinnable::new(stream);
|
|
//let stream = TimeBinnableToCollectable::new(stream);
|
|
let stream = Box::pin(stream);
|
|
debug!("plain_events_json boxed stream created");
|
|
let collected = Collect::new(
|
|
stream,
|
|
deadline,
|
|
evq.events_max(),
|
|
evq.bytes_max(),
|
|
Some(evq.range().clone()),
|
|
None,
|
|
timeout_provider,
|
|
)
|
|
.await?;
|
|
debug!("plain_events_json collected");
|
|
if let CollectResult::Some(x) = collected {
|
|
let jsval = x.to_json_value()?;
|
|
debug!("plain_events_json json serialized");
|
|
Ok(CollectResult::Some(jsval))
|
|
} else {
|
|
debug!("plain_events_json timeout");
|
|
Ok(CollectResult::Timeout)
|
|
}
|
|
}
|
|
|
|
pub async fn plain_events_json_stream(
|
|
evq: &PlainEventsQuery,
|
|
ch_conf: ChannelTypeConfigGen,
|
|
ctx: &ReqCtx,
|
|
open_bytes: OpenBoxedBytesStreamsBox,
|
|
timeout_provider: Box<dyn StreamTimeout2>,
|
|
) -> Result<JsonStream, Error> {
|
|
trace!("plain_events_json_stream");
|
|
let stream = dyn_events_stream(evq, ch_conf, ctx, open_bytes).await?;
|
|
let stream = events_stream_to_json_stream(stream, timeout_provider);
|
|
let stream = non_empty(stream);
|
|
let stream = only_first_err(stream);
|
|
Ok(Box::pin(stream))
|
|
}
|