rust_hdfs/
lib.rs

1#![allow(non_upper_case_globals)]
2#![allow(non_camel_case_types)]
3#![allow(non_snake_case)]
4
5include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
6
7extern crate libc;
8extern crate rand;
9
10pub mod hdfs_fs;
11pub use hdfs_fs::*;
12
13#[cfg(test)]
14mod tests {
15
16    use std::ffi::CString;
17	use std::io::{Write, BufReader, prelude::*};
18	use rand::{thread_rng, Rng};
19	use rand::distributions::Alphanumeric;
20
21
22    use libc::c_void;
23    use super::*;
24
25
26	#[test]
27	fn hdfs_raw_write(){
28		unsafe{
29			let name_node = CString::new("default").unwrap();
30			let fs = hdfsConnect(name_node.as_ptr(), 0);
31
32			let random_str: String = thread_rng().sample_iter(&Alphanumeric).take(10).collect();
33			let write_path = ["/", random_str.as_str()].concat();
34			let write_path = CString::new(write_path).unwrap();
35
36			let write_file = hdfsOpenFile(fs, write_path.as_ptr(), (O_WRONLY |O_CREAT) as i32, 0, 0, 0);
37
38			let buffer = String::from("HHHHHello worldddddd\n");
39			let buffer_ptr = buffer.as_ptr() as *const c_void;
40
41			let written_bytes = hdfsWrite(fs, write_file, buffer_ptr, buffer.len() as i32);
42			let result = hdfsFlush(fs, write_file);
43			
44			assert_eq!(written_bytes, buffer.len() as i32);
45			assert_eq!(result, 0);
46
47			hdfsCloseFile(fs, write_file);
48			hdfsDisconnect(fs);
49		}
50	}
51
52
53	#[test] 
54	fn test_hdfs_fs_write() {
55		let random_str = get_ramdon_string();
56		let path = ["/", random_str.as_str()].concat();
57
58		let mut hdfs_file = HdfsFile::create(path.as_str()).unwrap();	
59
60		let buffer = String::from("HHHHHello worldddddd\n");
61		let written_bytes = hdfs_file.write(buffer.as_bytes()).unwrap();
62		hdfs_file.flush().unwrap();
63
64		assert_eq!(written_bytes, buffer.len());
65
66		hdfs_file.delete().unwrap();
67		hdfs_file.close();
68	}
69
70	#[test] 
71	fn test_hdfs_fs_read(){
72		let random_str = get_ramdon_string();
73		let path = ["/", random_str.as_str()].concat();
74		let mut hdfs_writer = HdfsFile::create(path.as_str()).unwrap();	
75
76		let buffer = String::from("HHHHHello\nworldddddd\n");
77		hdfs_writer.write(buffer.as_bytes()).unwrap();
78		hdfs_writer.flush().unwrap();
79		hdfs_writer.close();
80
81		let hdfs_reader = HdfsFile::open(path.as_str()).unwrap();
82		let reader = BufReader::new(hdfs_reader);
83		println!("outputing file:");
84		for line in reader.lines() {
85			println!("{}", line.unwrap());
86		}
87	}
88
89	#[test] 
90	fn test_hdfs_fs_read_dir() {
91		let path = String::from("/");
92		let entries = read_dir(path);
93
94		for entry in entries {
95			println!("{}",entry.path.to_string_lossy());
96			// let reader = BufReader::new(entry);
97			// for line in reader.lines() {
98			// 	println!("{}", line.unwrap());
99			// }
100		}
101	}
102
103	fn get_ramdon_string() -> String {
104		thread_rng().sample_iter(&Alphanumeric).take(10).collect()
105	}
106}