lesscode/
lib.rs

1pub mod error;
2pub mod connect_info;
3
4use mongodb::{Client as MongoClient, options::ClientOptions as MongoClientOptions};
5use mysql::{Pool as MysqlPool};
6use connect_info::ConnectInfo;
7use error::UnsupportedTypeError;
8use neo4rs::Graph;
9use std::sync::Arc;
10use redis::Client as RedisClient;
11use postgres::{Client as PostgresClient, NoTls as PostgresNoTls};
12
13
14pub enum ConnectPool {
15    MysqlPool(MysqlPool),
16    MongoPool(MongoClient),
17    Neo4jPool(Arc<Graph>),
18    RedisPool(RedisClient),
19    PostgresPool(PostgresClient),
20    Error(UnsupportedTypeError),
21}
22
23pub async fn get_pool(connect_info: &ConnectInfo) -> ConnectPool {
24    if connect_info.dialect == "mysql" {
25        let url = format!("mysql://{}:{}@{}:{}/{}",
26                          connect_info.user,
27                          connect_info.password,
28                          connect_info.host,
29                          connect_info.port,
30                          connect_info.db);
31        let pool = MysqlPool::new(url.as_str()).unwrap();
32        return ConnectPool::MysqlPool(pool);
33    } else if connect_info.dialect == "mongo" {
34        let mut url = format!("mongodb://{}:{}@{}:{}", connect_info.user,
35                              connect_info.password, connect_info.host, connect_info.port);
36        let mut auth_type = "Password";
37        match connect_info.params.get("auth_type") {
38            Some(value) => {
39                auth_type = value;
40            }
41            _ => {
42                auth_type = "Password";
43            }
44        }
45        match auth_type {
46            "Password" => url = format!("{}/?authSource=admin", url),
47            "LDAP" => url = format!("{}/?authMechanism=PLAIN", url),
48            "X509" => url = format!("{}/?authMechanism=MONGODB-X509", url),
49            _ => url = url
50        }
51        let mut client_options = MongoClientOptions::parse(url).await.unwrap();
52        client_options.app_name = Some("My App".to_string());
53        let client = MongoClient::with_options(client_options).unwrap();
54
55        return ConnectPool::MongoPool(client);
56    } else if connect_info.dialect == "neo4j" {
57        let uri = format!("{}:{}", connect_info.host, connect_info.port);
58        let graph = Arc::new(Graph::new(uri, connect_info.user.as_str(), connect_info.password.as_str()).await.unwrap());
59        return ConnectPool::Neo4jPool(graph);
60    } else if connect_info.dialect == "redis" {
61        let url = format!("redis://:{}@{}:{}/{}", connect_info.password, connect_info.host, connect_info.port, connect_info.db);
62        let client = redis::Client::open(url).unwrap();
63        return ConnectPool::RedisPool(client);
64    } else if connect_info.dialect == "postgres" {
65        let url = format!("postgres://{}:{}@{}:{}/{}", connect_info.user, connect_info.password, connect_info.host, connect_info.port, connect_info.db);
66        let client = PostgresClient::connect(url.as_str(), PostgresNoTls).unwrap();
67        return ConnectPool::PostgresPool(client);
68    } else {
69        return ConnectPool::Error(UnsupportedTypeError {
70            code: String::from("4001"),
71            message: String::from("unsupported database tye"),
72        });
73    }
74}