Initial implememntation of seeding - not very optimal yet with 2 functions

Author: simzzz

docs/config/ganache.toml

@@ -47,6 +47,8 @@ admins = [
     '0x80690751969B234697e9059e04ed72195c3507fa'
 ]
 
+seed_db = true
+
 [platform]
 # This should be changed for tests and use the wiremock url
 url = "https://platform.adex.network"

docs/config/prod.toml

@@ -28,6 +28,8 @@ validators_whitelist = []
 # Galya (for analytics)
 admins = ['0x5d6A3F1AD7b124ecDFDf4841D9bB246eD5fBF04c']
 
+seed_db = false
+
 [platform]
 # This should be changed for tests and use the wiremock url
 url = "https://platform.adex.network"

primitives/src/config.rs

@@ -182,6 +182,7 @@ pub struct Config {
     pub chains: HashMap<String, ChainInfo>,
     pub platform: PlatformConfig,
     pub limits: Limits,
+    pub seed_db: bool,
 }
 
 impl Config {

sentry/Cargo.toml

@@ -79,10 +79,9 @@ woothee = "0.13"
 reqwest = { version = "0.11", features = ["json", "cookies"] }
 
 [dev-dependencies]
-pretty_assertions = "1"
-
 primitives = { version = "0.2", path = "../primitives", features = ["postgres", "test-util"] }
 adapter = { version = "0.2", path = "../adapter", features = ["test-util"] }
+pretty_assertions = "1"
 
 # we only require `hyper` for `hyper::body::to_bytes` function
 hyper = { version = "0.14", default-features = false }

sentry/src/application.rs

@@ -9,7 +9,7 @@ use axum::{
     http::{Method, StatusCode},
     middleware,
     routing::get,
-    Extension, Router,
+    Extension, Json, Router,
 };
 use axum_server::{tls_rustls::RustlsConfig, Handle};
 use once_cell::sync::Lazy;
@@ -19,14 +19,19 @@ use slog::{error, info, Logger};
 use tower::ServiceBuilder;
 use tower_http::cors::CorsLayer;
 
-use adapter::{client::Locked, Adapter};
-use primitives::{config::Environment, ValidatorId};
+use adapter::{client::Locked, Adapter, Dummy, Ethereum};
+use primitives::{
+    config::Environment, sentry::campaign_create::CreateCampaign, test_util::CAMPAIGNS,
+    unified_num::FromWhole, Campaign, ChainOf, Deposit, UnifiedNum, ValidatorId,
+};
 
 use crate::{
     db::{CampaignRemaining, DbPool},
     middleware::auth::authenticate,
     platform::PlatformApi,
     routes::{
+        campaign::create_campaign,
+        channel::{channel_dummy_deposit, ChannelDummyDeposit},
         get_cfg,
         routers::{analytics_router, campaigns_router, channels_router, units_for_slot_router},
     },
@@ -307,6 +312,136 @@ async fn shutdown_signal(logger: Logger, handle: Handle) {
     info!(&logger, "Received Ctrl+C signal. Shutting down..")
 }
 
+pub async fn seed_dummy(app: Application<Dummy>) -> Result<(), Box<dyn std::error::Error>> {
+    // create campaign
+    // Chain 1337
+    let campaign_1 = CAMPAIGNS[0].clone();
+    // Chain 1337
+    let campaign_2 = CAMPAIGNS[1].clone();
+    // Chain 1
+    let campaign_3 = CAMPAIGNS[2].clone();
+
+    async fn create_seed_campaign(
+        app: Application<Dummy>,
+        campaign: &ChainOf<Campaign>,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let campaign_to_create = CreateCampaign::from_campaign(campaign.context.clone());
+        let auth = Auth {
+            era: 0,
+            uid: ValidatorId::from(campaign_to_create.creator),
+            chain: campaign.chain.clone(),
+        };
+        let _result = create_campaign(
+            Json(campaign_to_create),
+            Extension(auth),
+            Extension(Arc::new(app)),
+        )
+        .await
+        .expect("Should create seed campaigns");
+
+        Ok(())
+    }
+
+    async fn dummy_deposit(
+        app: Application<Dummy>,
+        campaign: &ChainOf<Campaign>,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let channel = campaign.context.channel;
+        let auth = Auth {
+            era: 0,
+            uid: ValidatorId::from(campaign.context.creator),
+            chain: campaign.chain.clone(),
+        };
+
+        let request = ChannelDummyDeposit {
+            channel,
+            deposit: Deposit {
+                total: UnifiedNum::from_whole(1_000_000),
+            },
+        };
+
+        let result =
+            channel_dummy_deposit(Extension(Arc::new(app)), Extension(auth), Json(request)).await;
+
+        assert!(result.is_ok());
+
+        Ok(())
+    }
+    // chain 1337
+    dummy_deposit(app.clone(), &campaign_1).await?;
+    // chain 1337
+    dummy_deposit(app.clone(), &campaign_2).await?;
+    // chain 1
+    dummy_deposit(app.clone(), &campaign_3).await?;
+
+    create_seed_campaign(app.clone(), &campaign_1).await?;
+    create_seed_campaign(app.clone(), &campaign_2).await?;
+    create_seed_campaign(app.clone(), &campaign_3).await?;
+    Ok(())
+}
+
+pub async fn seed_ethereum(app: Application<Ethereum>) -> Result<(), Box<dyn std::error::Error>> {
+    // create campaign
+    // Chain 1337
+    let campaign_1 = CAMPAIGNS[0].clone();
+    // Chain 1337
+    let campaign_2 = CAMPAIGNS[1].clone();
+    // Chain 1
+    let campaign_3 = CAMPAIGNS[2].clone();
+
+    async fn create_seed_campaign(
+        app: Application<Ethereum>,
+        campaign: &ChainOf<Campaign>,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let campaign_to_create = CreateCampaign::from_campaign(campaign.context.clone());
+        let auth = Auth {
+            era: 0,
+            uid: ValidatorId::from(campaign_to_create.creator),
+            chain: campaign.chain.clone(),
+        };
+        let _result = create_campaign(
+            Json(campaign_to_create),
+            Extension(auth),
+            Extension(Arc::new(app)),
+        )
+        .await
+        .expect("Should create seed campaigns");
+        Ok(())
+    }
+    async fn deposit(
+        app: Application<Ethereum>,
+        campaign: &ChainOf<Campaign>,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let channel = campaign.context.channel;
+        let auth = Auth {
+            era: 0,
+            uid: ValidatorId::from(campaign.context.creator),
+            chain: campaign.chain.clone(),
+        };
+        let request = ChannelDummyDeposit {
+            channel,
+            deposit: Deposit {
+                total: UnifiedNum::from_whole(1_000_000),
+            },
+        };
+        let result =
+            channel_dummy_deposit(Extension(Arc::new(app)), Extension(auth), Json(request)).await;
+        assert!(result.is_ok());
+        Ok(())
+    }
+    // chain 1337
+    deposit(app.clone(), &campaign_1).await?;
+    // chain 1337
+    deposit(app.clone(), &campaign_2).await?;
+    // chain 1
+    deposit(app.clone(), &campaign_3).await?;
+
+    create_seed_campaign(app.clone(), &campaign_1).await?;
+    create_seed_campaign(app.clone(), &campaign_2).await?;
+    create_seed_campaign(app.clone(), &campaign_3).await?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod test {
     use serde_json::json;

sentry/src/main.rs

@@ -13,7 +13,7 @@ use primitives::{
     util::logging::new_logger, ValidatorId,
 };
 use sentry::{
-    application::EnableTls,
+    application::{seed_dummy, seed_ethereum, EnableTls},
     db::{postgres_connection, redis_connection, setup_migrations, CampaignRemaining},
     platform::PlatformApi,
     Application,
@@ -150,32 +150,47 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     )
     .expect("Failed to build PlatformApi");
 
+    // Like dummy adapter route
     match adapter {
         AdapterTypes::Ethereum(adapter) => {
-            Application::new(
+            let app = Application::new(
                 *adapter,
-                config,
+                config.clone(),
                 logger,
-                redis,
+                redis.clone(),
                 postgres,
                 campaign_remaining,
                 platform_api,
-            )
-            .run(enable_tls)
-            .await
+            );
+
+            if config.seed_db {
+                redis::cmd("FLUSHDB")
+                    .query_async::<_, String>(&mut redis.clone())
+                    .await?;
+                seed_ethereum(app.clone()).await?;
+            }
+
+            app.run(enable_tls).await
         }
         AdapterTypes::Dummy(adapter) => {
-            Application::new(
+            let app = Application::new(
                 *adapter,
-                config,
+                config.clone(),
                 logger,
-                redis,
+                redis.clone(),
                 postgres,
                 campaign_remaining,
                 platform_api,
-            )
-            .run(enable_tls)
-            .await
+            );
+
+            if config.seed_db {
+                redis::cmd("FLUSHDB")
+                    .query_async::<_, String>(&mut redis.clone())
+                    .await?;
+                seed_dummy(app.clone()).await?;
+            }
+
+            app.run(enable_tls).await
         }
     };