mongodb 0.2.8

A native MongoDB driver developed under MongoDB labs.
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

use mongodb::{Client, ThreadedClient};
use mongodb::common::ReadMode;
use mongodb::connstring::ConnectionString;
use mongodb::stream::StreamConnector;
use mongodb::topology::{TopologyDescription, TopologyType};
use mongodb::topology::server::Server;

use json::server_selection::reader::SuiteContainer;
use serde_json::Value;
use std::sync::{Arc, RwLock};

pub fn run_suite(file: &str) {
    let json = Value::from_file(file).unwrap();
    let suite = json.get_suite().unwrap();

    let dummy_config = ConnectionString::new("i-dont-exist", 27017);
    let dummy_client = Client::with_config(dummy_config, None, None).unwrap();
    let dummy_top_arc = Arc::new(RwLock::new(TopologyDescription::new(StreamConnector::default())));

    let mut topology_description = TopologyDescription::new(StreamConnector::default());
    topology_description.topology_type = suite.topology_description.ttype;

    for suite_server in suite.topology_description.servers {
        let server = Server::new(dummy_client.clone(),
                                 suite_server.host.clone(),
                                 dummy_top_arc.clone(),
                                 false,
                                 StreamConnector::default());

        {
            let mut description = server.description.write().unwrap();
            description.round_trip_time = Some(suite_server.rtt);
            description.tags = suite_server.tags;
            description.server_type = suite_server.stype;
        }

        topology_description.servers.insert(suite_server.host, server);
    }

    let (mut suitable_hosts, _) = if suite.write {
        topology_description.choose_write_hosts()
    } else {
        topology_description.choose_hosts(&suite.read_preference).unwrap()
    };

    if suite.topology_description.ttype != TopologyType::Sharded &&
       suite.topology_description.ttype != TopologyType::Single {
        topology_description.filter_hosts(&mut suitable_hosts, &suite.read_preference);
    }

    if suitable_hosts.is_empty() && !suite.write &&
       suite.read_preference.mode == ReadMode::SecondaryPreferred {
        let mut read_pref = suite.read_preference.clone();
        read_pref.mode = ReadMode::PrimaryPreferred;
        let (mut hosts, _) = topology_description.choose_hosts(&read_pref).unwrap();
        if suite.topology_description.ttype != TopologyType::Sharded &&
           suite.topology_description.ttype != TopologyType::Single {
            topology_description.filter_hosts(&mut hosts, &read_pref);
        }
        suitable_hosts.extend(hosts);
    }

    assert_eq!(suite.suitable_servers.len(), suitable_hosts.len());
    for server in &suite.suitable_servers {
        assert!(suitable_hosts.contains(&server.host));
    }

    topology_description.filter_latency_hosts(&mut suitable_hosts);
    assert_eq!(suite.in_latency_window.len(), suitable_hosts.len());
    for server in &suite.in_latency_window {
        assert!(suitable_hosts.contains(&server.host));
    }
}