|
26
|
1 use super::user;
|
|
|
2
|
|
19
|
3 use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
|
|
|
4 use quick_xml::{Reader, Writer};
|
|
|
5 use rand::Rng;
|
|
20
|
6 use std::fs;
|
|
19
|
7 use std::fs::File;
|
|
20
|
8 use std::io::{BufReader, BufWriter, Error};
|
|
19
|
9 use std::path::Path;
|
|
|
10 use uuid::Uuid;
|
|
|
11
|
|
|
12 const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
|
|
|
13 abcdefghijklmnopqrstuvwxyz\
|
|
20
|
14 0123456789)(*^%$#@!~";
|
|
19
|
15
|
|
|
16 const PASSWORD_LEN: usize = 30;
|
|
|
17
|
|
|
18 const DOMAIN_XMLNS_QEMU: (&str, &str) =
|
|
|
19 ("xmlns:qemu", "http://libvirt.org/schemas/domain/qemu/1.0");
|
|
|
20
|
|
29
|
21 const IE_VIRSH_TEMPLATE_VM_NAME: &str = "ie-virsh-template";
|
|
|
22 const VNC_XML_TAG: &str = "graphics";
|
|
19
|
23
|
|
29
|
24 const ROOT_START_TAG: &str = "domain";
|
|
19
|
25
|
|
29
|
26 const QEMU_COMMAND_LINE_TAG: &str = "qemu:commandline";
|
|
|
27 const QEMU_ARG_TAG: &str = "qemu:arg";
|
|
19
|
28
|
|
20
|
29 const TEMPLATE_XML_FILE: &str = "/etc/libvirt/template.xml";
|
|
|
30
|
|
|
31 const LIBVIRT_XML_DIR: &str = "/etc/libvirt/qemu";
|
|
|
32 const QCOW2_PATH: &str = "/mnt/ie-virsh";
|
|
|
33
|
|
|
34 pub struct GenerateVMArg {
|
|
26
|
35 vm_name: String,
|
|
|
36 qcow2_path: String,
|
|
|
37 xml_path: String,
|
|
|
38 vnc_password: String,
|
|
33
|
39 debug_tcp_port: Option<u64>,
|
|
|
40 backing_file: Option<String>,
|
|
26
|
41 }
|
|
|
42
|
|
|
43 pub fn dump_vnc_passwd(user: user::UserDetail, _vm_name: &str) -> Result<String, Error> {
|
|
|
44 let user_pass = user.getpass();
|
|
|
45 let mut reader = Reader::from_reader(BufReader::new(File::open(get_xml_dir(&user_pass))?));
|
|
|
46 let mut buf = Vec::new();
|
|
|
47 loop {
|
|
|
48 match reader.read_event(&mut buf) {
|
|
|
49 Ok(Event::Eof) => break,
|
|
29
|
50 Ok(Event::Empty(ref e)) if e.name() == VNC_XML_TAG.as_bytes() => {}
|
|
26
|
51 Ok(_) => {}
|
|
|
52 Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
|
|
|
53 }
|
|
|
54 }
|
|
|
55 Ok(String::from("ok"))
|
|
|
56 }
|
|
|
57
|
|
|
58 fn get_xml_dir(user_path: &str) -> String {
|
|
|
59 format!("{}/{}", LIBVIRT_XML_DIR, user_path)
|
|
20
|
60 }
|
|
|
61
|
|
|
62 impl GenerateVMArg {
|
|
33
|
63 pub fn new(
|
|
|
64 user_name: &str,
|
|
|
65 vm_name: &str,
|
|
|
66 debug_tcp_port: Option<u64>,
|
|
|
67 backing_file: Option<String>,
|
|
|
68 ) -> GenerateVMArg {
|
|
20
|
69 let year = user_name.chars().skip(1).take(2).collect::<String>();
|
|
|
70 let affilication = if year.parse::<u8>().is_ok() {
|
|
|
71 // /etc/libvirt/qemu/e19/e195729
|
|
|
72 user_name.chars().take(3).collect::<String>()
|
|
|
73 } else {
|
|
|
74 "teacher".to_string()
|
|
|
75 };
|
|
|
76
|
|
|
77 let xml_dir = format!("{}/{}/{}", LIBVIRT_XML_DIR, affilication, user_name);
|
|
26
|
78 let xml_path = format!("{}/{}.xml", xml_dir, vm_name);
|
|
20
|
79
|
|
|
80 if !Path::new(&xml_dir).exists() {
|
|
|
81 fs::create_dir_all(xml_dir).ok();
|
|
|
82 }
|
|
|
83
|
|
|
84 let qcow2_dir = format!("{}/{}/{}", QCOW2_PATH, affilication, user_name);
|
|
|
85
|
|
26
|
86 let qcow2_path = format!("{}/{}.qcow2", qcow2_dir, vm_name);
|
|
19
|
87
|
|
20
|
88 if !Path::new(&qcow2_dir).exists() {
|
|
|
89 fs::create_dir_all(qcow2_dir).ok();
|
|
|
90 }
|
|
|
91
|
|
|
92 let pw = generate_pw();
|
|
|
93
|
|
|
94 GenerateVMArg {
|
|
26
|
95 vm_name: vm_name.to_string(),
|
|
|
96 qcow2_path,
|
|
|
97 xml_path,
|
|
|
98 vnc_password: pw,
|
|
33
|
99 debug_tcp_port,
|
|
|
100 backing_file,
|
|
20
|
101 }
|
|
|
102 }
|
|
19
|
103
|
|
21
|
104 pub fn generate(self) -> Result<String, Error> {
|
|
20
|
105 let mut reader = Reader::from_reader(BufReader::new(File::open(TEMPLATE_XML_FILE)?));
|
|
19
|
106
|
|
26
|
107 println!("generate xml :{}", self.xml_path);
|
|
|
108 let mut writer = Writer::new(BufWriter::new(File::create(self.xml_path.clone()).unwrap()));
|
|
20
|
109 let mut buf = Vec::new();
|
|
|
110 loop {
|
|
|
111 match reader.read_event(&mut buf) {
|
|
|
112 Ok(Event::Start(ref e)) if e.name() == b"uuid" => {
|
|
|
113 writer
|
|
|
114 .write_event(Event::Start(e.clone()))
|
|
|
115 .expect("faild write event");
|
|
|
116 reader
|
|
|
117 .read_event(&mut Vec::new())
|
|
|
118 .expect("faild read event");
|
|
|
119 let vm_uuid = Uuid::new_v4().to_string();
|
|
|
120 let elem = BytesText::from_plain_str(&vm_uuid);
|
|
|
121 writer.write_event(Event::Text(elem)).unwrap();
|
|
19
|
122 }
|
|
|
123
|
|
29
|
124 Ok(Event::Start(ref e))
|
|
33
|
125 if (e.name() == ROOT_START_TAG.as_bytes() && self.debug_tcp_port.is_some()) =>
|
|
29
|
126 {
|
|
20
|
127 let mut elem = e.clone();
|
|
|
128 elem.push_attribute(DOMAIN_XMLNS_QEMU);
|
|
|
129 writer.write_event(Event::Start(elem)).unwrap();
|
|
|
130
|
|
29
|
131 let qemu_command_line_start =
|
|
|
132 BytesStart::borrowed_name(QEMU_COMMAND_LINE_TAG.as_bytes());
|
|
20
|
133 writer
|
|
|
134 .write_event(Event::Start(qemu_command_line_start))
|
|
|
135 .unwrap();
|
|
19
|
136
|
|
26
|
137 for value in ["-S", "-gdb"].iter() {
|
|
29
|
138 let mut qemu_elem = BytesStart::borrowed_name(QEMU_ARG_TAG.as_bytes());
|
|
20
|
139 let v: &str = &value;
|
|
|
140 qemu_elem.push_attribute(("value", v));
|
|
|
141 writer.write_event(Event::Empty(qemu_elem)).unwrap();
|
|
|
142 }
|
|
19
|
143
|
|
29
|
144 let mut qemu_elem = BytesStart::borrowed_name(QEMU_ARG_TAG.as_bytes());
|
|
33
|
145 let gdb_port: &str = &format!("tcp::{}", self.debug_tcp_port.unwrap());
|
|
26
|
146 qemu_elem.push_attribute(("value", gdb_port));
|
|
|
147 writer.write_event(Event::Empty(qemu_elem)).unwrap();
|
|
|
148
|
|
29
|
149 let qemu_command_line_end =
|
|
|
150 BytesEnd::borrowed(QEMU_COMMAND_LINE_TAG.as_bytes());
|
|
20
|
151 writer
|
|
|
152 .write_event(Event::End(qemu_command_line_end))
|
|
|
153 .unwrap();
|
|
19
|
154 }
|
|
20
|
155
|
|
29
|
156 Ok(Event::Empty(ref e)) if e.name() == VNC_XML_TAG.as_bytes() => {
|
|
20
|
157 let mut elem = e.clone();
|
|
26
|
158 let pw: &str = &self.vnc_password;
|
|
20
|
159 elem.push_attribute(("passwd", pw));
|
|
|
160 writer.write_event(Event::Empty(elem)).ok();
|
|
|
161 }
|
|
19
|
162
|
|
33
|
163 Ok(Event::End(ref e)) if ((e.name() == b"disk") && self.backing_file.is_some()) => {
|
|
|
164 let mut backing_store_start = BytesStart::borrowed_name(b"backingStore");
|
|
|
165 backing_store_start.push_attribute(("type", "file"));
|
|
|
166 backing_store_start.push_attribute(("index", "3"));
|
|
|
167 writer
|
|
|
168 .write_event(Event::Empty(backing_store_start))
|
|
|
169 .unwrap();
|
|
|
170
|
|
|
171 let mut format_elem = BytesStart::borrowed_name(b"format");
|
|
|
172 format_elem.push_attribute(("type", "qcow2"));
|
|
|
173 writer.write_event(Event::Empty(format_elem)).unwrap();
|
|
|
174
|
|
|
175 let mut backing_sorce = BytesStart::borrowed_name(b"sorce");
|
|
|
176 let backing_file: &str = &self.backing_file.clone().unwrap();
|
|
|
177 backing_sorce.push_attribute(("file", backing_file));
|
|
|
178 writer.write_event(Event::Empty(backing_sorce)).unwrap();
|
|
|
179
|
|
|
180 let backing_store_end = BytesEnd::borrowed(b"backingStore");
|
|
|
181 writer.write_event(Event::End(backing_store_end)).unwrap();
|
|
|
182 }
|
|
|
183
|
|
20
|
184 Ok(Event::Empty(ref e)) if (e.name() == b"source") => {
|
|
|
185 let mut elem = e.clone();
|
|
|
186 let is_qcow_file = elem
|
|
|
187 .attributes()
|
|
|
188 .find(|attr| attr.as_ref().unwrap().key == b"file");
|
|
|
189 if is_qcow_file.is_some() {
|
|
|
190 elem.clear_attributes();
|
|
26
|
191 let qcow2_path: &str = &self.qcow2_path;
|
|
20
|
192 elem.push_attribute(("file", qcow2_path));
|
|
|
193 }
|
|
|
194 writer.write_event(Event::Empty(elem)).ok();
|
|
|
195 }
|
|
|
196
|
|
29
|
197 Ok(Event::Text(ref e)) if e.escaped() == IE_VIRSH_TEMPLATE_VM_NAME.as_bytes() => {
|
|
26
|
198 let elem = BytesText::from_plain_str(&self.vm_name);
|
|
20
|
199 writer.write_event(Event::Text(elem)).unwrap();
|
|
|
200 }
|
|
|
201 Ok(Event::Eof) => break,
|
|
|
202 // you can use either `e` or `&e` if you don't want to move the event
|
|
|
203 Ok(e) => assert!(writer.write_event(&e).is_ok()),
|
|
|
204 Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
|
|
19
|
205 }
|
|
20
|
206 buf.clear();
|
|
19
|
207 }
|
|
26
|
208 println!("generate xml : {}", self.xml_path);
|
|
|
209 println!("vnc password : {}", self.vnc_password);
|
|
|
210 Ok(self.xml_path)
|
|
19
|
211 }
|
|
|
212 }
|
|
|
213
|
|
|
214 fn generate_pw() -> String {
|
|
|
215 let mut rng = rand::thread_rng();
|
|
|
216
|
|
|
217 (0..PASSWORD_LEN)
|
|
|
218 .map(|_| {
|
|
|
219 let idx = rng.gen_range(0, CHARSET.len());
|
|
|
220 CHARSET[idx] as char
|
|
|
221 })
|
|
|
222 .collect()
|
|
|
223 }
|
