Implement the initial set of reporter events

crates/report/src/aggregator.rs

@@ -0,0 +1,121 @@
+//! Implementation of the report aggregator task which consumes the events sent by the various
+//! reporters and combines them into a single unified report.
+
+use std::{
+    collections::BTreeSet,
+    fs::OpenOptions,
+    path::PathBuf,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use anyhow::Result;
+use revive_dt_config::Arguments;
+use revive_dt_format::corpus::Corpus;
+use serde::Serialize;
+use tokio::sync::{
+    broadcast::{Sender, channel},
+    mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel},
+};
+
+use crate::{
+    SubscribeToEventsEvent,
+    reporter_event::ReporterEvent,
+    runner_event::{CorpusFileDiscoveryEvent, MetadataFileDiscoveryEvent, Reporter, RunnerEvent},
+};
+
+pub struct ReportAggregator {
+    /* Internal Report State */
+    report: Report,
+    /* Channels */
+    runner_tx: Option<UnboundedSender<RunnerEvent>>,
+    runner_rx: UnboundedReceiver<RunnerEvent>,
+    listener_tx: Sender<ReporterEvent>,
+}
+
+impl ReportAggregator {
+    pub fn new(config: Arguments) -> Self {
+        let (runner_tx, runner_rx) = unbounded_channel::<RunnerEvent>();
+        let (listener_tx, _) = channel::<ReporterEvent>(1024);
+        Self {
+            report: Report::new(config),
+            runner_tx: Some(runner_tx),
+            runner_rx,
+            listener_tx,
+        }
+    }
+
+    pub fn into_task(mut self) -> (Reporter, impl Future<Output = Result<()>>) {
+        let reporter = self
+            .runner_tx
+            .take()
+            .map(Into::into)
+            .expect("Can't fail since this can only be called once");
+        (reporter, async move { self.aggregate().await })
+    }
+
+    async fn aggregate(mut self) -> Result<()> {
+        while let Some(event) = self.runner_rx.recv().await {
+            match event {
+                RunnerEvent::ExecutionCompleted(..) => break,
+                RunnerEvent::SubscribeToEvents(event) => {
+                    self.handle_subscribe_to_events_event(*event);
+                }
+                RunnerEvent::CorpusFileDiscovery(event) => {
+                    self.handle_corpus_file_discovered_event(*event)
+                }
+                RunnerEvent::MetadataFileDiscovery(event) => {
+                    self.handle_metadata_file_discovery_event(*event);
+                }
+            }
+        }
+
+        let file_name = {
+            let current_timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
+            let mut file_name = current_timestamp.to_string();
+            file_name.push_str(".json");
+            file_name
+        };
+        let file_path = self.report.config.directory().join(file_name);
+        let file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .read(false)
+            .open(file_path)?;
+        serde_json::to_writer_pretty(file, &self.report)?;
+
+        Ok(())
+    }
+
+    fn handle_subscribe_to_events_event(&self, event: SubscribeToEventsEvent) {
+        let _ = event.tx.send(self.listener_tx.subscribe());
+    }
+
+    fn handle_corpus_file_discovered_event(&mut self, event: CorpusFileDiscoveryEvent) {
+        self.report.corpora.push(event.corpus);
+    }
+
+    fn handle_metadata_file_discovery_event(&mut self, event: MetadataFileDiscoveryEvent) {
+        self.report.metadata_files.insert(event.path);
+    }
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct Report {
+    /// The configuration that the tool was started up with.
+    pub config: Arguments,
+    /// The list of corpus files that the tool found.
+    pub corpora: Vec<Corpus>,
+    /// The list of metadata files that were found by the tool.
+    pub metadata_files: BTreeSet<PathBuf>,
+}
+
+impl Report {
+    pub fn new(config: Arguments) -> Self {
+        Self {
+            config,
+            corpora: Default::default(),
+            metadata_files: Default::default(),
+        }
+    }
+}

crates/report/src/common.rs

@@ -0,0 +1,24 @@
+//! Common types and functions used throughout the crate.
+
+use std::path::PathBuf;
+
+use revive_dt_common::define_wrapper_type;
+use revive_dt_compiler::Mode;
+use revive_dt_format::case::CaseIdx;
+use serde::{Deserialize, Serialize};
+use serde_with::{DisplayFromStr, serde_as};
+
+define_wrapper_type!(
+    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    pub struct MetadataFilePath(PathBuf);
+);
+
+/// An absolute specifier for a test.
+#[serde_as]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
+pub struct TestSpecifier {
+    #[serde_as(as = "DisplayFromStr")]
+    pub solc_mode: Mode,
+    pub metadata_file_path: PathBuf,
+    pub case_idx: CaseIdx,
+}

crates/report/src/lib.rs

@@ -1 +1,10 @@
 //! This crate implements the reporting infrastructure for the differential testing tool.
+
+mod aggregator;
+mod common;
+mod reporter_event;
+mod runner_event;
+
+pub use aggregator::*;
+pub use reporter_event::*;
+pub use runner_event::*;

crates/report/src/reporter_event.rs

@@ -0,0 +1,4 @@
+//! A reporter event sent by the report aggregator to the various listeners.
+
+#[derive(Clone, Debug)]
+pub enum ReporterEvent {}

crates/report/src/runner_event.rs

@@ -0,0 +1,147 @@
+//! The types associated with the events sent by the runner to the reporter.
+
+use std::path::PathBuf;
+
+use revive_dt_format::corpus::Corpus;
+use revive_dt_format::metadata::Metadata;
+use tokio::sync::{broadcast, oneshot};
+
+use crate::ReporterEvent;
+
+macro_rules! keep_if_doc {
+    (#[doc = $doc:expr]) => {
+        #[doc = $doc]
+    };
+    ( $($_:tt)* ) => {};
+}
+
+/// Defines the runner-event which is sent from the test runners to the report aggregator.
+///
+/// This macro defines a number of things related to the reporting infrastructure and the interface
+/// used. First of all, it defines the enum of all of the possible events that the runners can send
+/// to the aggregator. For each one of the variants it defines a separate struct for it to allow the
+/// variant field in the enum to be put in a [`Box`].
+///
+/// In addition to the above, it defines [`From`] implementations for the various event types for
+/// the [`RunnerEvent`] enum essentially allowing for events such as [`CorpusFileDiscoveryEvent`] to
+/// be converted into a [`RunnerEvent`].
+///
+/// In addition to the above, it also defines the [`RunnerEventReporter`] which is a wrapper around
+/// an [`UnboundedSender`] allowing for events to be sent to the report aggregator.
+///
+/// With the above description, we can see that this macro defines almost all of the interface of
+/// the reporting infrastructure, from the enum itself, to its associated types, and also to the
+/// reporter that's used to report events to the aggregator.
+///
+/// [`UnboundedSender`]: tokio::sync::mpsc::UnboundedSender
+macro_rules! define_event {
+    (
+        $(#[$enum_meta: meta])*
+        $vis: vis enum $ident: ident {
+            $(
+                $(#[$variant_meta: meta])*
+                $variant_ident: ident {
+                    $(
+                        $(#[$field_meta: meta])*
+                        $field_ident: ident: $field_ty: ty
+                    ),* $(,)?
+                }
+            ),* $(,)?
+        }
+    ) => {
+        paste::paste! {
+            $(#[$enum_meta])*
+            $vis enum $ident {
+                $(
+                    $(#[$variant_meta])*
+                    $variant_ident(Box<[<$variant_ident Event>]>)
+                ),*
+            }
+
+            $(
+                $(#[$variant_meta])*
+                $vis struct [<$variant_ident Event>] {
+                    $(
+                        $(#[$field_meta])*
+                        $vis $field_ident: $field_ty
+                    ),*
+                }
+            )*
+
+            $(
+                impl From<[<$variant_ident Event>]> for $ident {
+                    fn from(value: [<$variant_ident Event>]) -> Self {
+                        Self::$variant_ident(Box::new(value))
+                    }
+                }
+            )*
+
+            /// Provides a way to report events to the aggregator.
+            ///
+            /// Under the hood, this is a wrapper around an [`UnboundedSender`] which abstracts away
+            /// the fact that channels are used and that implements high-level methods for reporting
+            /// various events to the aggregator.
+            #[derive(Clone, Debug)]
+            pub struct [< $ident Reporter >]($vis tokio::sync::mpsc::UnboundedSender<$ident>);
+
+            impl From<tokio::sync::mpsc::UnboundedSender<$ident>> for [< $ident Reporter >] {
+                fn from(value: tokio::sync::mpsc::UnboundedSender<$ident>) -> Self {
+                    Self(value)
+                }
+            }
+
+            impl [< $ident Reporter >] {
+                fn report(&self, event: impl Into<$ident>) -> anyhow::Result<()> {
+                    self.0.send(event.into()).map_err(Into::into)
+                }
+
+                $(
+                    keep_if_doc!($(#[$variant_meta])*);
+                    pub fn [< report_ $variant_ident:snake _event >](&self, $($field_ident: impl Into<$field_ty>),*) -> anyhow::Result<()> {
+                        self.report([< $variant_ident Event >] {
+                            $($field_ident: $field_ident.into()),*
+                        })
+                    }
+                )*
+            }
+        }
+    };
+}
+
+define_event! {
+    /// An event type that's sent by the test runners/drivers to the report aggregator.
+    pub(crate) enum RunnerEvent {
+        /// An event emitted by the reporter when it wishes to listen to events emitted by the
+        /// aggregator.
+        SubscribeToEvents {
+            /// The channel that the aggregator is to send the receive side of the channel on.
+            tx: oneshot::Sender<broadcast::Receiver<ReporterEvent>>
+        },
+        /// An event emitted by runners when they've discovered a corpus file.
+        CorpusFileDiscovery {
+            /// The contents of the corpus file.
+            corpus: Corpus
+        },
+        /// An event emitted by runners when they've discovered a metadata file.
+        MetadataFileDiscovery {
+            /// The path of the metadata file discovered.
+            path: PathBuf,
+            /// The content of the metadata file.
+            metadata: Metadata
+        },
+        /// An event emitted by the runners when the execution is completed and the aggregator can
+        /// stop.
+        ExecutionCompleted {}
+    }
+}
+
+/// An extension to the [`Reporter`] implemented by the macro.
+impl RunnerEventReporter {
+    pub async fn subscribe(&self) -> anyhow::Result<broadcast::Receiver<ReporterEvent>> {
+        let (tx, rx) = oneshot::channel::<broadcast::Receiver<ReporterEvent>>();
+        self.report_subscribe_to_events_event(tx)?;
+        rx.await.map_err(Into::into)
+    }
+}
+
+pub type Reporter = RunnerEventReporter;