Add optional post-build hook

Author: losman0s

cli/src/config.rs

@@ -274,6 +274,7 @@ pub struct Config {
     pub provider: ProviderConfig,
     pub programs: ProgramsConfig,
     pub scripts: ScriptsConfig,
+    pub hooks: Option<HooksConfig>,
     pub workspace: WorkspaceConfig,
     // Separate entry next to test_config because
     // "anchor localnet" only has access to the Anchor.toml,
@@ -309,6 +310,16 @@ pub struct ProviderConfig {
 
 pub type ScriptsConfig = BTreeMap<String, String>;
 
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct HooksConfig {
+    pub pre_build: Option<String>,
+    pub post_build: Option<String>,
+    pub pre_test: Option<String>,
+    pub post_test: Option<String>,
+    pub pre_deploy: Option<String>,
+    pub post_deploy: Option<String>,
+}
+
 pub type ProgramsConfig = BTreeMap<Cluster, BTreeMap<String, ProgramDeployment>>;
 
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
@@ -413,6 +424,7 @@ struct _Config {
     provider: Provider,
     workspace: Option<WorkspaceConfig>,
     scripts: Option<ScriptsConfig>,
+    hooks: Option<HooksConfig>,
     test: Option<_TestValidator>,
 }
 
@@ -446,6 +458,7 @@ impl ToString for Config {
                 true => None,
                 false => Some(self.scripts.clone()),
             },
+            hooks: self.hooks.clone(),
             programs,
             workspace: (!self.workspace.members.is_empty() || !self.workspace.exclude.is_empty())
                 .then(|| self.workspace.clone()),
@@ -471,6 +484,7 @@ impl FromStr for Config {
                 wallet: shellexpand::tilde(&cfg.provider.wallet).parse()?,
             },
             scripts: cfg.scripts.unwrap_or_default(),
+            hooks: cfg.hooks,
             test_validator: cfg.test.map(Into::into),
             test_config: None,
             programs: cfg.programs.map_or(Ok(BTreeMap::new()), deser_programs)?,

cli/src/lib.rs

@@ -771,6 +771,9 @@ pub fn build(
     }
 
     let cfg = Config::discover(cfg_override)?.expect("Not in workspace.");
+
+    try_run_hook(&cfg, HookType::PreBuild)?;
+
     let build_config = BuildConfig {
         verifiable,
         solana_version: solana_version.or_else(|| cfg.solana_version.clone()),
@@ -841,6 +844,8 @@ pub fn build(
 
     set_workspace_dir_or_exit();
 
+    try_run_hook(&cfg, HookType::PostBuild)?;
+
     Ok(())
 }
 
@@ -1892,6 +1897,9 @@ fn test(
         if (!is_localnet || skip_local_validator) && !skip_deploy {
             deploy(cfg_override, None, None)?;
         }
+
+        try_run_hook(cfg, HookType::PreTest)?;
+
         let mut is_first_suite = true;
         if cfg.scripts.get("test").is_some() {
             is_first_suite = false;
@@ -1936,6 +1944,9 @@ fn test(
                 )?;
             }
         }
+
+        try_run_hook(cfg, HookType::PostTest)?;
+
         Ok(())
     })
 }
@@ -2401,6 +2412,8 @@ fn deploy(
         let url = cluster_url(cfg, &cfg.test_validator);
         let keypair = cfg.provider.wallet.to_string();
 
+        try_run_hook(cfg, HookType::PreDeploy)?;
+
         // Deploy the programs.
         println!("Deploying workspace: {}", url);
         println!("Upgrade authority: {}", keypair);
@@ -2462,6 +2475,8 @@ fn deploy(
 
         println!("Deploy success");
 
+        try_run_hook(cfg, HookType::PostDeploy)?;
+
         Ok(())
     })
 }
@@ -2811,27 +2826,59 @@ fn shell(cfg_override: &ConfigOverride) -> Result<()> {
 
 fn run(cfg_override: &ConfigOverride, script: String) -> Result<()> {
     with_workspace(cfg_override, |cfg| {
-        let url = cluster_url(cfg, &cfg.test_validator);
         let script = cfg
             .scripts
             .get(&script)
             .ok_or_else(|| anyhow!("Unable to find script"))?;
-        let exit = std::process::Command::new("bash")
-            .arg("-c")
-            .arg(&script)
-            .env("ANCHOR_PROVIDER_URL", url)
-            .env("ANCHOR_WALLET", cfg.provider.wallet.to_string())
-            .stdout(Stdio::inherit())
-            .stderr(Stdio::inherit())
-            .output()
-            .unwrap();
-        if !exit.status.success() {
-            std::process::exit(exit.status.code().unwrap_or(1));
-        }
+        run_bash_cmd(cfg, script)?;
         Ok(())
     })
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum HookType {
+    PreBuild,
+    PostBuild,
+    PreTest,
+    PostTest,
+    PreDeploy,
+    PostDeploy,
+}
+
+fn try_run_hook(cfg: &WithPath<Config>, hook_type: HookType) -> Result<()> {
+    if let Some(hooks) = &cfg.hooks {
+        let cmd = match hook_type {
+            HookType::PreBuild => &hooks.pre_build,
+            HookType::PostBuild => &hooks.post_build,
+            HookType::PreTest => &hooks.pre_test,
+            HookType::PostTest => &hooks.post_test,
+            HookType::PreDeploy => &hooks.pre_deploy,
+            HookType::PostDeploy => &hooks.post_deploy,
+        };
+        if let Some(cmd) = &cmd {
+            run_bash_cmd(cfg, cmd)?;
+        };
+    };
+    Ok(())
+}
+
+fn run_bash_cmd(cfg: &Config, cmd: &String) -> Result<()> {
+    let url = cluster_url(cfg, &cfg.test_validator);
+    let exit = std::process::Command::new("bash")
+        .arg("-c")
+        .arg(cmd)
+        .env("ANCHOR_PROVIDER_URL", url)
+        .env("ANCHOR_WALLET", cfg.provider.wallet.to_string())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .output()
+        .unwrap();
+    if !exit.status.success() {
+        std::process::exit(exit.status.code().unwrap_or(1));
+    }
+    Ok(())
+}
+
 fn login(_cfg_override: &ConfigOverride, token: String) -> Result<()> {
     let dir = shellexpand::tilde("~/.config/anchor");
     if !Path::new(&dir.to_string()).exists() {