Naming fix: Pipeline -> Flow

Signed-off-by: Didier Wenzek <didier.wenzek@free.fr>

Author: didier-wenzek

crates/core/tedge/src/cli/mapping/cli.rs

@@ -8,37 +8,37 @@ use anyhow::Context;
 use anyhow::Error;
 use std::path::PathBuf;
 use tedge_config::TEdgeConfig;
-use tedge_gen_mapper::pipeline::Message;
+use tedge_gen_mapper::flow::Message;
 use tedge_gen_mapper::MessageProcessor;
 
 #[derive(clap::Subcommand, Debug)]
 pub enum TEdgeMappingCli {
-    /// List pipelines and filters
+    /// List flows and filters
     List {
-        /// Path to pipeline and filter specs
+        /// Path to flow and filter specs
         ///
         /// Default to /etc/tedge/gen-mapper
         #[clap(long)]
         mapping_dir: Option<PathBuf>,
 
-        /// List pipelines processing messages published on this topic
+        /// List flows processing messages published on this topic
         ///
-        /// If none is provided, lists all the pipelines
+        /// If none is provided, lists all the flows
         #[clap(long)]
         topic: Option<String>,
     },
 
     /// Process message samples
     Test {
-        /// Path to pipeline and filter specs
+        /// Path to flow and filter specs
         ///
         /// Default to /etc/tedge/gen-mapper
         #[clap(long)]
         mapping_dir: Option<PathBuf>,
 
-        /// Path to the javascript filter or TOML pipeline definition
+        /// Path to the javascript filter or TOML flow definition
         ///
-        /// If none is provided, applies all the matching pipelines
+        /// If none is provided, applies all the matching flows
         #[clap(long)]
         filter: Option<PathBuf>,
 
@@ -98,25 +98,20 @@ impl TEdgeMappingCli {
         config.root_dir().join("gen-mapper").into()
     }
 
-    pub async fn load_pipelines(mapping_dir: &PathBuf) -> Result<MessageProcessor, Error> {
+    pub async fn load_flows(mapping_dir: &PathBuf) -> Result<MessageProcessor, Error> {
         MessageProcessor::try_new(mapping_dir)
             .await
-            .with_context(|| {
-                format!(
-                    "loading pipelines and filters from {}",
-                    mapping_dir.display()
-                )
-            })
+            .with_context(|| format!("loading flows and filters from {}", mapping_dir.display()))
     }
 
     pub async fn load_filter(
         mapping_dir: &PathBuf,
         path: &PathBuf,
     ) -> Result<MessageProcessor, Error> {
         if let Some("toml") = path.extension().and_then(|s| s.to_str()) {
-            MessageProcessor::try_new_single_pipeline(mapping_dir, path)
+            MessageProcessor::try_new_single_flow(mapping_dir, path)
                 .await
-                .with_context(|| format!("loading pipeline {pipeline}", pipeline = path.display()))
+                .with_context(|| format!("loading flow {flow}", flow = path.display()))
         } else {
             MessageProcessor::try_new_single_filter(mapping_dir, path)
                 .await

crates/core/tedge/src/cli/mapping/list.rs

@@ -4,7 +4,7 @@ use crate::log::MaybeFancy;
 use anyhow::Error;
 use std::path::PathBuf;
 use tedge_config::TEdgeConfig;
-use tedge_gen_mapper::pipeline::Pipeline;
+use tedge_gen_mapper::flow::Flow;
 
 pub struct ListCommand {
     pub mapping_dir: PathBuf,
@@ -14,33 +14,30 @@ pub struct ListCommand {
 #[async_trait::async_trait]
 impl Command for ListCommand {
     fn description(&self) -> String {
-        format!(
-            "list pipelines and filters in {:}",
-            self.mapping_dir.display()
-        )
+        format!("list flows and filters in {:}", self.mapping_dir.display())
     }
 
     async fn execute(&self, _config: TEdgeConfig) -> Result<(), MaybeFancy<Error>> {
-        let processor = TEdgeMappingCli::load_pipelines(&self.mapping_dir).await?;
+        let processor = TEdgeMappingCli::load_flows(&self.mapping_dir).await?;
 
         match &self.topic {
             Some(topic) => processor
-                .pipelines
+                .flows
                 .iter()
-                .filter(|(_, pipeline)| pipeline.topics().accept_topic_name(topic))
+                .filter(|(_, flow)| flow.topics().accept_topic_name(topic))
                 .for_each(Self::display),
 
-            None => processor.pipelines.iter().for_each(Self::display),
+            None => processor.flows.iter().for_each(Self::display),
         }
 
         Ok(())
     }
 }
 
 impl ListCommand {
-    fn display((pipeline_id, pipeline): (&String, &Pipeline)) {
-        println!("{pipeline_id}");
-        for stage in pipeline.stages.iter() {
+    fn display((flow_id, flow): (&String, &Flow)) {
+        println!("{flow_id}");
+        for stage in flow.stages.iter() {
             println!("\t{}", stage.filter.path.display());
         }
     }

crates/core/tedge/src/cli/mapping/test.rs

@@ -4,7 +4,7 @@ use crate::log::MaybeFancy;
 use anyhow::Error;
 use std::path::PathBuf;
 use tedge_config::TEdgeConfig;
-use tedge_gen_mapper::pipeline::*;
+use tedge_gen_mapper::flow::*;
 use tedge_gen_mapper::MessageProcessor;
 use tokio::io::AsyncBufReadExt;
 use tokio::io::BufReader;
@@ -21,14 +21,14 @@ pub struct TestCommand {
 impl Command for TestCommand {
     fn description(&self) -> String {
         format!(
-            "process message samples using pipelines and filters in {:}",
+            "process message samples using flows and filters in {:}",
             self.mapping_dir.display()
         )
     }
 
     async fn execute(&self, _config: TEdgeConfig) -> Result<(), MaybeFancy<Error>> {
         let mut processor = match &self.filter {
-            None => TEdgeMappingCli::load_pipelines(&self.mapping_dir).await?,
+            None => TEdgeMappingCli::load_flows(&self.mapping_dir).await?,
             Some(filter) => TEdgeMappingCli::load_filter(&self.mapping_dir, filter).await?,
         };
         if let Some(message) = &self.message {