watchso 0.1.0

Hot reload Solana programs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use std::{
    path::{Path, PathBuf},
    sync::Arc,
};

use async_trait::async_trait;
use watchso::{
    command::WCommand,
    error::WatchError,
    framework::{Framework, WatchableFramework},
    framework_utils::{get_program_name_path_hashmap, ProjectMap},
};

#[derive(Default)]
pub struct Anchor {
    /// Starting directory path
    origin: Arc<PathBuf>,
    /// Map of program names and paths
    project_map: ProjectMap,
}

impl Anchor {
    pub fn new<P: AsRef<Path>>(origin: P) -> Self {
        Self {
            origin: Arc::new(origin.as_ref().to_path_buf()),
            ..Default::default()
        }
    }
}

/// Default implementation works.
impl WatchableFramework for Anchor {}

#[async_trait]
impl Framework for Anchor {
    fn origin(&self) -> &Path {
        self.origin.as_path()
    }

    async fn check_toolset(&self) -> miette::Result<()> {
        const ANCHOR: &str = "anchor";
        if !WCommand::exists(ANCHOR).await {
            Err(WatchError::CommandNotFound(ANCHOR))?
        }

        Ok(())
    }

    async fn map_program_names(&self) -> miette::Result<()> {
        for (name, path) in get_program_name_path_hashmap(self.origin()).await? {
            self.project_map.set_program_path(name, path).await;
        }

        Ok(())
    }

    async fn get_program_path(&self, path: &Path) -> Option<PathBuf> {
        self.project_map.get_program_path(path).await
    }

    async fn build(&self, program_path: &Path) -> WCommand {
        // Changing the current directory to the program's path makes Anchor build only the
        // modified program in the workspace.
        let mut command = WCommand::new("anchor build");
        command.current_dir(program_path);
        command
    }

    async fn deploy(&self, elf_path: &Path) -> WCommand {
        // Anchor still deploys all of the programs in the workspace even after changing the
        // current dir to the program's dir and it is using program dirname as program name
        // instead of manifest's package name. Thus, we get the program name from the dirname
        // and only deploy the modified program.
        self.get_program_path(elf_path)
            .await
            .as_ref()
            .and_then(|path| path.file_name())
            .and_then(|name| name.to_str())
            .map(|name| WCommand::new(format!("anchor deploy -p {name}")))
            .unwrap_or(WCommand::new("anchor deploy"))
    }
}