mongodb 0.1.7

An experimental MongoDB driver written by MongoDB interns.
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

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

use json::server_selection::reader::SuiteContainer;
use rustc_serialize::json::Json;
use std::sync::{Arc, RwLock};

pub fn run_suite(file: &str) {
    let json = Json::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()));
    
    let mut topology_description = TopologyDescription::new();    
    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);

        {
            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)
    };

    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);
        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.iter() {
        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.iter() {
        assert!(suitable_hosts.contains(&server.host));
    }
}