Struct Config 

pub struct Config {

    pub db_path: Option<PathBuf>,
    pub secret: [u8; 32],
    pub group_ids: Vec<GroupId>,
    pub permission: bool,
    pub only_stable_data: bool,
    pub p2p_peer: Peer,
    pub p2p_allowlist: Vec<Peer>,
    pub p2p_blocklist: Vec<IpAddr>,
    pub p2p_allow_peer_list: Vec<PeerId>,
    pub p2p_block_peer_list: Vec<PeerId>,
    pub rpc_http: Option<SocketAddr>,
    pub rpc_ws: Option<SocketAddr>,
    pub rpc_channel: Option<ChannelAddr>,
    pub rpc_index: Option<PathBuf>,
}

load config from config file.

Fields

db_path: Option<PathBuf>

secret: [u8; 32]

group_ids: Vec<GroupId>

permission: bool

only_stable_data: bool

p2p_peer: Peer

p2p_allowlist: Vec<Peer>

p2p_blocklist: Vec<IpAddr>

p2p_allow_peer_list: Vec<PeerId>

p2p_block_peer_list: Vec<PeerId>

rpc_http: Option<SocketAddr>

rpc_ws: Option<SocketAddr>

rpc_channel: Option<ChannelAddr>

rpc_index: Option<PathBuf>

Implementations

impl Config

pub fn split(self) -> ([u8; 32], Vec<GroupId>, P2pConfig, RpcConfig)

Examples found in repository

examples/stop.rs (line 7)

async fn main() {
    let config = Config::load(PathBuf::from("./")).await;
    let (_secret, ids, p2p_config, _rpc_config) = config.split();
    let (send_send, send_recv) = new_send_channel();
    let (recv_send, mut recv_recv) = new_receive_channel();

    let peer_id = start_main(ids, p2p_config, recv_send, send_recv, None, None)
        .await
        .unwrap();
    println!("Example: peer id: {:?}", peer_id);

    println!("Network will stop after 5s...");
    tokio::time::sleep(Duration::from_secs(5)).await;

    let _ = send_send
        .send(SendMessage::Network(NetworkType::NetworkStop))
        .await;

    while let Some(_) = recv_recv.recv().await {
        //
    }

    println!("Network is stopped.");
}

impl Config

pub fn with_addr(p2p_addr: SocketAddr, rpc_http: SocketAddr) -> Self

pub fn default() -> Self

pub async fn load(path: PathBuf) -> Self

Examples found in repository

examples/app_with_config_file.rs (line 8)

async fn main() {
    // use crate root directory's config.toml
    let dir_path = PathBuf::from(".");
    let config = Config::load(dir_path).await;

    let (peer_addr, _send, mut out_recv) = start_with_config(config).await.unwrap();
    println!("Example: peer id: {}", peer_addr.short_show());

    while let Some(message) = out_recv.recv().await {
        match message {
            _ => {}
        }
    }
}

examples/stop.rs (line 6)

async fn main() {
    let config = Config::load(PathBuf::from("./")).await;
    let (_secret, ids, p2p_config, _rpc_config) = config.split();
    let (send_send, send_recv) = new_send_channel();
    let (recv_send, mut recv_recv) = new_receive_channel();

    let peer_id = start_main(ids, p2p_config, recv_send, send_recv, None, None)
        .await
        .unwrap();
    println!("Example: peer id: {:?}", peer_id);

    println!("Network will stop after 5s...");
    tokio::time::sleep(Duration::from_secs(5)).await;

    let _ = send_send
        .send(SendMessage::Network(NetworkType::NetworkStop))
        .await;

    while let Some(_) = recv_recv.recv().await {
        //
    }

    println!("Network is stopped.");
}

pub async fn load_save(path: PathBuf, config: Config) -> Result<Self>

pub async fn load_custom<S: SeSerialize + SeDeserializeOwned>( path: PathBuf, ) -> Option<S>

pub async fn append_custom(path: PathBuf, s: &str) -> Result<()>