consistent_hasher 0.1.5

An implementation of consistent hashing, a technique commonly used in distributed systems to map keys (such as data items or requests) to nodes (e.g., servers or storage units) in a way that minimizes disruptions when nodes are added or removed.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

// use std::io;
// use consistent_hasher::CircularBTreeMap;

// fn main() {
//     let mut x: CircularBTreeMap<usize> = CircularBTreeMap::new();

//     loop {

//         let mut input = String::new();
//         io::stdin().read_line(&mut input).expect("Failed to read line");

//         // Trim whitespace and check if the user wants to quit
//         let input = input.trim();
//         if input == "q" {
//             break;
//         }

//         // Parse input and perform insertions
//         if let Some(stripped) = input.strip_prefix("n ") {
//             if let Ok(num) = stripped.trim().parse::<usize>() {
                
//                 println!("Inserted node: {:?}", x.insert_node(num));
//             } else {
//                 println!("Invalid number for insert_node.");
//             }
//         } else if let Some(stripped) = input.strip_prefix("d ") {
//             if let Ok(num) = stripped.trim().parse::<usize>() {
                
//                 println!("Deleted node: {:?}", x.delete_node(&num));
//             } else {
//                 println!("Invalid number for insert_node.");
//             }
//         }

//         else {
//             println!("Invalid input. Please enter a number or 'n + number'.");
//         }

//         // Print the tree after each insertion
//         x.print();
//         println!();
//     }

//     // Display final tree details
//     println!("Final tree nodes count: {} ", x.nodes_count());
// }

use std::io;
use consistent_hasher::{Identifier, LDB}; // Ensure `Transaction` is in scope
use std::time::Instant;
struct X {
    pub x: usize,
}

impl X {
    pub fn new(x: usize) -> Self {
        Self { x }
    }
}

impl Identifier for X {
    fn identify(&self) -> usize {
        self.x
    }
}

fn main() {
    // let time = Instant::now();
     let mut db = LDB::new(7,4); // Adjust parameters as needed
    // for i in 0..10000
    // {
    //     let _=db.add_node(X::new(i));
    // }
    // println!("time-elapsed: {:?}",time.elapsed());
    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Failed to read line");

        let input = input.trim();
        if input == "q" {
            break;
        }

        if let Some(stripped) = input.strip_prefix("n ") {
            if let Ok(num) = stripped.trim().parse::<usize>() {
                let result = db.add_node(X::new(num)); // Adding node
                match result {
                    Ok(Some(transactions)) => {
                        println!("Added node {}. Transactions: ", num);
                        for (i, transaction) in transactions.iter().enumerate() {
                            println!("Transaction {}: {}", i + 1, transaction);
                        }
                    }
                    Ok(None) => println!("Node {} already exists.", num),
                    Err(e) => println!("Error: {:?}", e),
                }
            } else {
                println!("Invalid node number.");
            }
        } else if let Some(stripped) = input.strip_prefix("d ") {
            if let Ok(num) = stripped.trim().parse::<usize>() {
                let result = db.delete_node(X::new(num)); // Deleting node
                match result {
                    Ok(Some(transactions)) => {
                        println!("Deleted node {}. Transactions: ", num, );
                        for (i, transaction) in transactions.iter().enumerate() {
                            println!("Transaction {}: {}", i + 1, transaction);
                        }
                    }
                    Ok(None) => (),
                    Err(e) => println!("Error: {:?}", e),
                }
            } else {
                println!("Invalid node number.");
            }
        }  else if let Some(stripped) = input.strip_prefix("vi ") {
            if let Ok(num) = stripped.trim().parse::<usize>() {
                let result = db.set_virtual_instances(num); // Setting virtual instances
                match result {
                    Some(transactions) => {
                        for (i, transaction) in transactions.iter().enumerate() {
                            println!("Transaction {}: {}", i + 1, transaction);
                        }
                    }
                   None => println!("No change in virtual instances or invalid count."),

                }
            } else {
                println!("Invalid number of virtual instances.");
            }}
            else if let Some(stripped) = input.strip_prefix("s ") {
                if let Ok(num) = stripped.trim().parse::<String>(){
                    let result = db.key(&num); // Setting virtual instances
                    match result {
                        Ok((x,y)) => {
                           
                                println!("go to :{x} with hash:{y}");

                        }
                       Err(e) => println!("Error:{}",e.to_string()),
    
                    }
                } else {
                    println!("Invalid number of virtual instances.");
                }}
                
         else {
            println!("Invalid command. Commands are:");
            println!(" - n <node number>   : Add node");
            println!(" - d <node number>   : Delete node");
            println!(" - vi <count>        : Set virtual instances");
        }

        db.print();
    }

    println!("Final state:");
    db.print();
}