trace.rs (4335B)
1 use std::path::Path; 2 use std::fs::{ 3 File, 4 // OpenOptions, 5 }; 6 use std::io::Write; 7 8 use hex; 9 10 use log::{debug}; 11 12 use crate::record::{ 13 RequestResult, 14 RequestResultType, 15 }; 16 17 18 pub fn trace_request(p: &Path, res: &RequestResult, store_identity: bool) { 19 if res.typ != RequestResultType::Changed { 20 return; 21 } 22 let mut rf = String::new(); 23 match &res.v { 24 Some(v) => { 25 rf.push_str(v); 26 }, 27 None => { 28 }, 29 }; 30 if rf.len() == 0 { 31 return; 32 } 33 //let mut content = String::new(); 34 let mut content: Vec<u8> = vec!(); 35 let mut identity = String::new(); 36 match &res.a { 37 Some(auth) => { 38 if auth.active() && store_identity { 39 content = auth.identity.clone(); 40 identity = hex::encode(&content); 41 } 42 }, 43 None => { 44 }, 45 } 46 debug!("have identity: {}", identity); 47 let fp = p.join(&rf); 48 let mut f = File::create(fp).unwrap(); 49 _ = f.write(content.as_ref()); 50 51 // useless update because we can always resolve mutable to immutable from data dir 52 // if content.len() != 0 { 53 // let rf_content_hex = res.s.as_ref().unwrap(); 54 // let rf_content = hex::decode(rf_content_hex).unwrap(); 55 // //let rf_content = s.clone(); 56 // let fp = p.join(&identity); 57 // 58 // let mut f = OpenOptions::new() 59 // .write(true) 60 // .append(true) 61 // .create(true) 62 // .open(fp) 63 // .unwrap(); 64 // 65 // let rf_bin = hex::decode(rf).unwrap(); 66 // f.write(rf_bin.as_ref()); 67 // f.write(rf_content.as_ref()); 68 // } 69 } 70 71 #[cfg(test)] 72 mod tests { 73 use std::path::Path; 74 use std::fs::File; 75 76 use tempfile::tempdir; 77 78 use log::{debug}; 79 80 use crate::record::{ 81 RequestResult, 82 RequestResultType, 83 }; 84 use crate::auth::{ 85 AuthResult, 86 }; 87 88 use super::trace_request; 89 90 #[test] 91 fn test_trace_immutable() { 92 let d = tempdir().unwrap(); 93 let p = d.path(); 94 let url = String::from("deadbeef"); 95 let mut r = RequestResult::new(RequestResultType::Changed); 96 r = r.with_content(url); 97 trace_request(&p, &r, false); 98 let fp = p.join(&r.v.unwrap()); 99 let f = File::open(fp).unwrap(); 100 let meta = f.metadata().unwrap(); 101 assert_eq!(meta.len(), 0); 102 } 103 104 #[test] 105 fn test_trace_typchk() { 106 let d = tempdir().unwrap(); 107 let p = d.path(); 108 let url = String::from("deadbeef"); 109 let mut r = RequestResult::new(RequestResultType::Found); 110 r = r.with_content(url); 111 trace_request(&p, &r, false); 112 let fp = p.join(&r.v.unwrap()); 113 let f = File::open(fp); 114 match f { 115 Ok(v) => { 116 panic!("should not have file {:?}", v); 117 }, 118 Err(e) => { 119 }, 120 } 121 } 122 123 #[test] 124 #[ignore] 125 fn test_trace_auth_inactive() { 126 let d = tempdir().unwrap(); 127 let p = d.path(); 128 let url = String::from("deadbeef"); 129 let a = AuthResult{ 130 identity: vec!(), 131 error: false, 132 }; 133 let mut r = RequestResult::new(RequestResultType::Changed); 134 r = r.with_content(url); 135 r = r.with_auth(a); 136 trace_request(&p, &r, false); 137 let fp = p.join(&r.v.unwrap()); 138 let f = File::open(fp); 139 match f { 140 Ok(v) => { 141 panic!("should not have file {:?}", v); 142 }, 143 Err(e) => { 144 }, 145 } 146 } 147 148 #[test] 149 fn test_trace_mutable() { 150 let d = tempdir().unwrap(); 151 let p = d.path(); 152 let url = String::from("deadbeef"); 153 let id_b = b"moradi"; 154 let a = AuthResult{ 155 identity: id_b.to_vec(), 156 error: false, 157 }; 158 let mut r = RequestResult::new(RequestResultType::Changed); 159 r = r.with_content(url); 160 r = r.with_auth(a); 161 trace_request(&p, &r, true); 162 let fp = p.join(r.v.unwrap()); 163 let f = File::open(fp).unwrap(); 164 let meta = f.metadata().unwrap(); 165 //let id_l = (id_b.len() * 2) as u64; 166 let id_l = id_b.len() as u64; 167 let r_l = meta.len(); 168 assert_eq!(r_l, id_l); 169 } 170 }