indradb 3.0.3

A graph database server
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

extern crate clap;

mod cli;

use std::error::Error;
use std::net::ToSocketAddrs;
use std::path::Path;
use std::sync::Arc;

use crate::cli::CliDatastoreArgs;

use indradb_proto as proto;
use tokio::net::TcpListener;

async fn run_server<D>(datastore: D, listener: TcpListener, plugin_path: &Option<String>) -> Result<(), Box<dyn Error>>
where
    D: indradb::Datastore + Send + Sync + 'static,
{
    let binding = listener.local_addr()?;
    println!("grpc://{}", binding);

    if let Some(plugin_path) = plugin_path {
        unsafe {
            proto::run_server_with_plugins(Arc::new(datastore), listener, plugin_path).await?;
        }
    } else {
        proto::run_server(Arc::new(datastore), listener).await?;
    }

    Ok(())
}

#[tokio::main]
pub async fn main() -> Result<(), Box<dyn Error>> {
    let args = cli::parse_cli_args();

    let addr = args.addr.to_socket_addrs()?.next().unwrap();
    let listener = TcpListener::bind(addr).await?;

    match args.datastore_args {
        CliDatastoreArgs::Rocksdb {
            path,
            max_open_files,
            repair,
        } => {
            if repair {
                indradb::RocksdbDatastore::repair(&path, Some(max_open_files))
                    .expect("Expected to be able to repair the RocksDB datastore");
                println!("repair successful");
                return Ok(());
            }

            let datastore = indradb::RocksdbDatastore::new(&path, Some(max_open_files))
                .expect("Expected to be able to create the RocksDB datastore");
            run_server(datastore, listener, &args.plugin_path).await
        }
        CliDatastoreArgs::Memory { path } => {
            let datastore = match path {
                None => indradb::MemoryDatastore::default(),
                Some(path) if Path::new(path.as_os_str()).exists() => indradb::MemoryDatastore::read(path)?,
                Some(path) => indradb::MemoryDatastore::create(path)?,
            };
            run_server(datastore, listener, &args.plugin_path).await
        }
    }
}