A beautiful commit.

hw8/task1/Cargo.toml

 authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
 
 [dependencies]
+sha2 = "0.7.0"
+clap = "2.28"
+time = "0.1"
+sys-info = "*"

hw8/task1/src/lib.rs

-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
+extern crate sha2;
+#[cfg(feature = "SHA2")]
+use self::sha2::Sha256;
+
+
+pub struct Sha256;
+
+pub trait Hasher {
+    type Output: HashResult;
+    fn hash(input: &[u8]) -> Self::Output;
+}
+
+pub trait HashResult {
+    /// Get the output in hex notation.
+    fn hex(&self) -> String;
+    /// Size of the output in bytes.
+    fn size() -> usize;
+}
+
+
+impl Hasher for Sha256 {
+    type Output = [u8; 32];
+
+    fn hash(input: &[u8]) -> Self::Output {
+        use self::sha2::*;
+        let mut tmp = Sha256::new();
+        tmp.input(input);
+        let r = tmp.result().as_slice().to_vec();
+        [
+            r[0],
+            r[1],
+            r[2],
+            r[3],
+            r[4],
+            r[5],
+            r[6],
+            r[7],
+            r[8],
+            r[9],
+            r[10],
+            r[11],
+            r[12],
+            r[13],
+            r[14],
+            r[15],
+            r[16],
+            r[17],
+            r[18],
+            r[19],
+            r[20],
+            r[21],
+            r[22],
+            r[23],
+            r[24],
+            r[25],
+            r[26],
+            r[27],
+            r[28],
+            r[29],
+            r[30],
+            r[31],
+        ]
+    }
+}
+
+impl HashResult for [u8; 32] {
+    fn hex(&self) -> String {
+        const HEX: [char; 16] = [
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f',
+        ];
+        let mut tmp = String::with_capacity(32 * 2);
+        for byte in self.iter() {
+            tmp.push(HEX[*byte as usize / 16]);
+            tmp.push(HEX[*byte as usize % 16]);
+        }
+        tmp
+    }
+
+    fn size() -> usize {
+        32
+    }
+}
+
+
+pub struct Solution {
+    pub number: usize,
+    pub hash: String,
+}
+
+pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option<Solution> {
+    let sol = base * number;
+    let input = sol.to_string();
+    let bytes = input.as_bytes();
+
+    let hash = Sha256::hash(bytes).hex();
+
+    if hash.ends_with(difficulty) {
+        return Some(Solution{ number: number, hash: hash,});
     }
+
+    None
 }
+

hw8/task1/src/main.rs

+extern crate clap;
+extern crate time;
+extern crate task1;
+extern crate sys_info;
+
+use std::sync::mpsc::channel;
+use time::get_time;
+use clap::{Arg, App, SubCommand};
+use std::{process, thread};
+use task1::verify_product;
+use std::sync::Arc;
+
+pub fn main() {
+    let matches = create_app().get_matches();
+    let base = matches.value_of("base").unwrap_or("1");
+    let diff = Arc::new(matches.value_of("difficulty").unwrap_or("1").to_string());
+    let cpus = sys_info::cpu_num().unwrap_or(1).to_string();
+    let threads = matches.value_of("threads").unwrap_or(&cpus);
+    let mut time_measurement = false;
+
+    if diff.chars().any(|c| !c.is_digit(16)) {
+        println!("Difficulty is not hexadecimal.");
+        process::exit(1)
+    }
+
+    if let Some(ref sub_command) = matches.subcommand {
+        if sub_command.name.eq("timings") {
+            time_measurement = true;
+        }
+    }
+
+    if true {
+        println!("--------------------------------------------");
+        println!(
+            "Container:    : \"{}\"",
+            sys_info::hostname().unwrap_or("-".to_string())
+        );
+        println!("Physical CPUs : {}", sys_info::cpu_num().unwrap_or(0));
+        println!("Logical CPUs  : {}", sys_info::cpu_num().unwrap_or(0));
+        println!("CPU Speed     : {}", sys_info::cpu_speed().unwrap_or(0));
+        println!("Load Average  : {:?}", sys_info::loadavg().unwrap());
+        println!("Processes     : {}", sys_info::proc_total().unwrap_or(0));
+        println!("--------------------------------------------");
+    }
+
+    match (base.parse::<usize>(), threads.parse::<usize>()) {
+        (Ok(b), Ok(t)) => {
+            println!("Using base: {}", b);
+            println!("Using difficulty: {}", diff);
+            println!("Please wait...");
+            let start = get_time();
+            let max = <usize>::max_value();
+            let mut children = vec![];
+
+            let (tx, rx) = channel();
+
+            for i in 0..t {
+                let d = diff.clone();
+                let tx = tx.clone();
+
+                children.push(thread::spawn(move || {
+                    let from = max / t * i;
+                    let to = max / t * (i + 1);
+                    println!("{} - {} | Thread {} | Difficulty is: {}", from, to, i, d);
+
+                    for n in from..to {
+                        if let Some(x) = verify_product(b, n, &d) {
+                            let end = get_time();
+                            println!("Number: {} --> hash: {}", x.number, x.hash);
+                            if time_measurement {
+                                let diff = end - start;
+                                let s = diff.num_seconds();
+                                let ms = diff.num_milliseconds();
+                                let us = diff.num_microseconds().unwrap_or(ms * 1000);
+                                println!("(Duration {}s / {}ms / {}us)", s, ms, us);
+                            }
+                            tx.send("Finished").unwrap();
+                        }
+                    }
+
+                }));
+            }
+
+            match rx.recv() {
+                Ok(msg) => {
+                    println!("{}", msg);
+                }
+                Err(_) => {}
+            }
+
+            /*
+            for child in children {
+                let _ = child.join();
+            } 
+            */
+        }
+        (_, Err(_)) => {
+            println!("Number of threads is not integer.");
+            process::exit(1)
+        }
+        (Err(_), _) => {
+            println!("Base is not integer.");
+            process::exit(1)
+        }
+    };
+}
+
+fn create_app<'a, 'b>() -> App<'a, 'b> {
+    App::new("Hash256")
+        .version("1.0")
+        .author("Lorenz Bung & Joshua Rutschmann")
+        .about(
+            "Calculates the Hashvalue of the given base, number and difficulty.",
+        )
+        .arg(
+            Arg::with_name("base")
+                .value_name("base")
+                .help("The base of the hash to be calculated on.")
+                .takes_value(true)
+                .required(true),
+        )
+        .arg(
+            Arg::with_name("difficulty")
+                .value_name("difficulty")
+                .help("The difficulty of the calculated hash.")
+                .takes_value(true)
+                .required(true),
+        )
+        .arg(
+            Arg::with_name("threads")
+                .value_name("threads")
+                .help(
+                    "Sets the number of the threads to use (default = number of cpus)",
+                )
+                .takes_value(true)
+                .required(false),
+        )
+        .subcommand(
+            SubCommand::with_name("timings")
+                .about("controls timing features")
+                .version("1.0")
+                .author("Lorenz Bung & Joshua Rutschmann"),
+        )
+}

hw8/task1/src/unit_test.rs

+#[test]
+fn test_hash() {
+    assert_eq!(
+        Sha256::hash("test".as_bytes()).hex(),
+        "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
+    );
+}