ref: renamed connection functions

Author: raphael-goetz

.github/workflows/build.yml

@@ -21,7 +21,7 @@ jobs:
         run: PATH=${{ runner.temp }}/proto/bin:$PATH cargo build
         env:
           RUST_BACKTRACE: 'full'
-      - name: Test De/Serialization from/to json
+      - name: Run Tests
         run: PATH=${{ runner.temp }}/proto/bin:$PATH cargo test --features all
         env:
           RUST_BACKTRACE: 'full'

src/flow_queue/connection.rs

@@ -6,15 +6,15 @@ pub type FlowQueue = Arc<Mutex<Box<Connection>>>;
 
 pub type FlowChannel = Arc<Mutex<Box<Channel>>>;
 
-pub async fn connect(uri: &str) -> Connection {
-    match Connection::connect(uri, ConnectionProperties::default()).await {
+async fn build_connection(rabbitmq_url: &str) -> Connection {
+    match Connection::connect(rabbitmq_url, ConnectionProperties::default()).await {
         Ok(env) => env,
-        Err(error) => panic!("Cannot connect to redis instance! Reason: {:?}", error),
+        Err(error) => panic!("Cannot connect to FlowQueue (RabbitMQ) instance! Reason: {:?}", error),
     }
 }
 
-pub async fn get_flow_channel(uri: &str) -> FlowChannel {
-    let connection = connect(uri).await;
+pub async fn create_flow_channel_connection(uri: &str) -> FlowChannel {
+    let connection = build_connection(uri).await;
 
     match connection.create_channel().await {
         Ok(channel) => Arc::new(Mutex::new(Box::new(channel))),
@@ -24,18 +24,18 @@ pub async fn get_flow_channel(uri: &str) -> FlowChannel {
 
 #[cfg(test)]
 mod tests {
-    use crate::flow_queue::connection::connect;
     use testcontainers::core::{IntoContainerPort, WaitFor};
     use testcontainers::runners::AsyncRunner;
     use testcontainers::GenericImage;
+    use crate::flow_queue::connection::build_connection;
     use crate::rabbitmq_container_test;
 
     rabbitmq_container_test!(test_rabbitmq_startup, (|url: String| async move {
         println!("RabbitMQ started with the url: {}", url);
     }));  
 
     rabbitmq_container_test!(test_rabbitmq_connection, (|url: String| async move {
-        connect(&*url).await;
+        build_connection(&*url).await;
     }));
 
 }

src/flow_store/connection.rs

@@ -1,12 +1,27 @@
-use redis::Client;
+use std::sync::Arc;
+use redis::aio::MultiplexedConnection;
+use redis::{Client, RedisResult};
+use tokio::sync::Mutex;
 
-pub fn build_connection(redis_url: String) -> Client {
+pub type FlowStore = Arc<Mutex<Box<MultiplexedConnection>>>;
+
+fn build_connection(redis_url: String) -> Client {
     match Client::open(redis_url) {
         Ok(client) => client,
-        Err(con_error) => panic!("{}", con_error),
+        Err(con_error) => panic!("Cannot create FlowStore (Redis) connection! Reason: {}", con_error),
     }
 }
 
+pub async fn create_flow_store_connection(url: String) -> FlowStore {
+    let client = match build_connection(url).get_multiplexed_async_connection().await  {
+        Ok(connection) => connection,
+        Err(error) => panic!("Cannot create FlowStore (Redis) connection! Reason: {}", error),
+    };
+    
+    Arc::new(Mutex::new(Box::new(client)))
+}
+
+
 #[cfg(test)]
 mod tests {
     use testcontainers::core::IntoContainerPort;

src/flow_store/service.rs

@@ -1,12 +1,8 @@
 use async_trait::async_trait;
 use log::{debug, error};
-use redis::aio::MultiplexedConnection;
 use redis::{AsyncCommands, RedisError};
-use std::sync::Arc;
-use tokio::sync::Mutex;
 use tucana::sagittarius::{Flow, Flows};
-
-pub type FlowStore = Arc<Mutex<MultiplexedConnection>>;
+use crate::flow_store::connection::FlowStore;
 
 #[derive(Debug)]
 pub struct FlowStoreError {