main.rs 15.2 KB
Newer Older
1
2
#![cfg_attr(feature = "strict", deny(warnings))]

Robert Czechowski's avatar
Robert Czechowski committed
3
4
5
6
7
8
9
#[macro_use]
extern crate iron;
#[macro_use]
extern crate router;
#[macro_use]
extern crate serde_derive;

Robert Czechowski's avatar
Robert Czechowski committed
10
extern crate handlebars_iron;
Robert Czechowski's avatar
Robert Czechowski committed
11
12
extern crate iron_sessionstorage;
extern crate mount;
13
extern crate params;
Robert Czechowski's avatar
Robert Czechowski committed
14
extern crate persistent;
15
extern crate postgres;
Robert Czechowski's avatar
Robert Czechowski committed
16
extern crate rand;
17
extern crate reqwest;
Robert Czechowski's avatar
Robert Czechowski committed
18
19
extern crate rusqlite;
extern crate serde_json;
20
extern crate serde_yaml;
Robert Czechowski's avatar
Robert Czechowski committed
21
22
23
24
extern crate staticfile;
extern crate structopt;
extern crate time;
extern crate urlencoded;
25
26
27
28
29

use rusqlite::Connection;

mod db_apply_migrations;
mod db_conn;
30
mod db_conn_postgres;
31
mod db_conn_sqlite;
32
33
34
mod db_objects;

use db_conn::{MedalConnection, MedalObject};
Robert Czechowski's avatar
Robert Czechowski committed
35
use functions::SetPassword; // TODO: Refactor, so we don't need to take this from there!
36
37
38

use db_objects::*;

39
mod configreader_yaml;
Robert Czechowski's avatar
Robert Czechowski committed
40
mod webfw_iron;
Robert Czechowski's avatar
Robert Czechowski committed
41
42
43
44
45
46

use webfw_iron::start_server;

mod functions;

use std::fs;
Robert Czechowski's avatar
Robert Czechowski committed
47
use std::path;
Robert Czechowski's avatar
Robert Czechowski committed
48

Robert Czechowski's avatar
Robert Czechowski committed
49
use std::path::{Path, PathBuf};
50
51
use structopt::StructOpt;

52
53
54
mod oauth_provider;

#[derive(Serialize, Deserialize, Clone, Default, Debug)]
55
pub struct Config {
56
57
58
    host: Option<String>,
    port: Option<u16>,
    self_url: Option<String>,
59
    oauth_providers: Option<Vec<oauth_provider::OauthProvider>>,
60
    database_file: Option<PathBuf>,
61
    database_url: Option<String>,
62
    template: Option<String>,
63
    no_contest_scan: Option<bool>,
64
65
}

66
fn read_config_from_file(file: &Path) -> Config {
67
    use std::io::Read;
Daniel Brüning's avatar
Daniel Brüning committed
68

69
    println!("Reading configuration file '{}'", file.to_str().unwrap_or("<Encoding error>"));
Daniel Brüning's avatar
Daniel Brüning committed
70

Robert Czechowski's avatar
Robert Czechowski committed
71
    let mut config: Config = if let Ok(mut file) = fs::File::open(file) {
72
73
74
75
        let mut contents = String::new();
        file.read_to_string(&mut contents).unwrap();
        serde_json::from_str(&contents).unwrap()
    } else {
76
        println!("Configuration file '{}' not found.", file.to_str().unwrap_or("<Encoding error>"));
77
        Default::default()
78
79
    };

80
81
82
83
84
85
86
    if let Some(ref oap) = config.oauth_providers {
        println!("OAuth providers:");
        for oap in oap {
            println!("  * {}", oap.provider_id);
        }
    }

Robert Czechowski's avatar
Robert Czechowski committed
87
88
89
90
91
92
93
94
95
    if config.host.is_none() {
        config.host = Some("[::]".to_string())
    }
    if config.port.is_none() {
        config.port = Some(8080)
    }
    if config.self_url.is_none() {
        config.self_url = Some("http://localhost:8080".to_string())
    }
96
97
98
    if config.template.is_none() {
        config.template = Some("default".to_string())
    }
99
100
101
    if config.no_contest_scan.is_none() {
        config.no_contest_scan = Some(false)
    }
102

103
    println!("OAuth providers will be told to redirect to {}", config.self_url.as_ref().unwrap());
104

105
    config
106
}
107

108
109
110
111
112
113
114
115
116
117
#[derive(StructOpt, Debug)]
#[structopt()]
struct Opt {
    /// Config file to use (default: 'config.json')
    #[structopt(short = "c", long = "config", default_value = "config.json", parse(from_os_str))]
    configfile: PathBuf,

    /// Database file to use (default: from config file or 'medal.db')
    #[structopt(short = "d", long = "database", parse(from_os_str))]
    databasefile: Option<PathBuf>,
118

119
120
121
122
    /// Database file to use (default: from config file or 'medal.db')
    #[structopt(short = "D", long = "databaseurl")]
    databaseurl: Option<String>,

123
124
125
    /// Port to listen on (default: from config file or 8080)
    #[structopt(short = "p", long = "port")]
    port: Option<u16>,
126
127
128
129

    /// Reset password of admin user (user_id=1)
    #[structopt(short = "a", long = "reset-admin-pw")]
    resetadminpw: bool,
130
131
132
133
134
135
136
137

    /// Run medal without scanning for contests
    #[structopt(short = "S", long = "no-contest-scan")]
    nocontestscan: bool,

    /// Scan for contests without starting medal
    #[structopt(short = "s", long = "only-contest-scan")]
    onlycontestscan: bool,
138
139
}

Robert Czechowski's avatar
Robert Czechowski committed
140
fn read_contest(p: &path::PathBuf) -> Option<Contest> {
141
142
    use std::fs::File;
    use std::io::Read;
143

144
145
146
    let mut file = File::open(p).unwrap();
    let mut contents = String::new();
    file.read_to_string(&mut contents).unwrap();
147

Robert Czechowski's avatar
Robert Czechowski committed
148
149
150
    configreader_yaml::parse_yaml(&contents,
                                  p.file_name().to_owned()?.to_str()?,
                                  &format!("{}/", p.parent().unwrap().to_str()?))
Robert Czechowski's avatar
Robert Czechowski committed
151
152
153
154
}

fn get_all_contest_info(task_dir: &str) -> Vec<Contest> {
    fn walk_me_recursively(p: &path::PathBuf, contests: &mut Vec<Contest>) {
155
156
        if let Ok(paths) = fs::read_dir(p) {
            for path in paths {
Robert Czechowski's avatar
Robert Czechowski committed
157
158
                let p = path.unwrap().path();
                walk_me_recursively(&p, contests);
159
            }
Robert Czechowski's avatar
Robert Czechowski committed
160
        }
161

162
        if p.file_name().unwrap().to_string_lossy().to_string().ends_with(".yaml") {
163
            read_contest(p).map(|contest| contests.push(contest));
164
        };
Robert Czechowski's avatar
Robert Czechowski committed
165
166
167
168
169
    };

    let mut contests = Vec::new();
    match fs::read_dir(task_dir) {
        Err(why) => println!("Error opening tasks directory! {:?}", why.kind()),
Robert Czechowski's avatar
Robert Czechowski committed
170
171
172
173
174
        Ok(paths) => {
            for path in paths {
                walk_me_recursively(&path.unwrap().path(), &mut contests);
            }
        }
Robert Czechowski's avatar
Robert Czechowski committed
175
176
177
178
179
    };

    contests
}

180
181
182
183
fn refresh_all_contests<C>(conn: &mut C)
    where C: MedalConnection,
          db_objects::Contest: db_conn::MedalObject<C>
{
Robert Czechowski's avatar
Robert Czechowski committed
184
185
186
187
188
189
190
    let v = get_all_contest_info("tasks/");

    for mut contest_info in v {
        contest_info.save(conn);
    }
}

191
192
fn add_admin_user<C>(conn: &mut C, resetpw: bool)
    where C: MedalConnection {
193
194
195
    let mut admin = match conn.get_user_by_id(1) {
        None => {
            print!("New Database. Creating new admin user with credentials 'admin':");
196
            conn.new_session("")
Robert Czechowski's avatar
Robert Czechowski committed
197
        }
198
199
        Some(user) => {
            if !resetpw {
Robert Czechowski's avatar
Robert Czechowski committed
200
                return;
201
            }
202
203
204
205
206
            print!("Request to reset admin password. Set credentials 'admin':");
            user
        }
    };

Robert Czechowski's avatar
Robert Czechowski committed
207
    use rand::{distributions::Alphanumeric, thread_rng, Rng};
208
209

    let password: String = thread_rng().sample_iter(&Alphanumeric)
Robert Czechowski's avatar
Robert Czechowski committed
210
211
212
213
214
215
                                       .filter(|x| {
                                           let x = *x;
                                           !(x == 'l' || x == 'I' || x == '1' || x == 'O' || x == 'o' || x == '0')
                                       })
                                       .take(8)
                                       .collect();
216
217
218
219
    print!("'{}' …", &password);

    admin.username = Some("admin".into());
    match admin.set_password(&password) {
220
        None => println!(" FAILED! (Password hashing error)"),
221
222
        _ => {
            conn.save_session(admin);
223
            println!(" Done");
224
        }
225
226
227
    }
}

228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
fn prepare_and_start_server<C>(mut conn: C, config: Config, onlycontestscan: bool, resetadminpw: bool)
    where C: MedalConnection + std::marker::Send + 'static,
          db_objects::Contest: db_conn::MedalObject<C>
{
    println!("connected!");

    println!("applying migrations …");
    db_apply_migrations::test(&mut conn);

    if onlycontestscan || config.no_contest_scan == Some(false) {
        println!("scanning for contests …");
        refresh_all_contests(&mut conn);
        println!("finished")
    }

    if !onlycontestscan {
        add_admin_user(&mut conn, resetadminpw);

        match start_server(conn, config) {
            Ok(_) => println!("Server started"),
            Err(_) => println!("Error on server start …"),
        };

        println!("Could not run server. Is the port already in use?");
    }
}

Robert Czechowski's avatar
Robert Czechowski committed
255
fn main() {
256
    let opt = Opt::from_args();
257
    //println!("{:?}", opt); // Show in different debug level?
Daniel Brüning's avatar
Daniel Brüning committed
258

259
260
    let mut config = read_config_from_file(&opt.configfile);

Robert Czechowski's avatar
Robert Czechowski committed
261
262
263
    if opt.databasefile.is_some() {
        config.database_file = opt.databasefile;
    }
264
265
266
    if opt.databaseurl.is_some() {
        config.database_url = opt.databaseurl;
    }
Robert Czechowski's avatar
Robert Czechowski committed
267
268
269
    if opt.port.is_some() {
        config.port = opt.port;
    }
270
271
272
    if opt.nocontestscan {
        config.no_contest_scan = Some(true);
    }
273

274
275
276
    if config.database_url.is_some() {
        let conn =
            postgres::Connection::connect(config.database_url.clone().unwrap(), postgres::TlsMode::None).unwrap();
Robert Czechowski's avatar
Robert Czechowski committed
277

278
279
280
281
282
283
284
285
286
287
288
        prepare_and_start_server(conn, config, opt.onlycontestscan, opt.resetadminpw);
    } else {
        let conn = match config.database_file {
            Some(ref path) => {
                println!("Using database file {}", &path.to_str().unwrap_or("<unprintable filename>"));
                rusqlite::Connection::open(path).unwrap()
            }
            None => {
                println!("Using default database file ./medal.db");
                rusqlite::Connection::open(&Path::new("medal.db")).unwrap()
            }
289
        };
Robert Czechowski's avatar
Robert Czechowski committed
290

291
        prepare_and_start_server(conn, config, opt.onlycontestscan, opt.resetadminpw);
292
    }
293
}
294
295
296
297

#[cfg(test)]
mod tests {
    use super::*;
298
    use std::io::Read;
299

Robert Czechowski's avatar
Robert Czechowski committed
300
301
    fn start_server_and_fn<F>(port: u16, set_user: Option<(String, String)>, f: F)
        where F: FnOnce() {
302
        use std::sync::mpsc::channel;
Robert Czechowski's avatar
Robert Czechowski committed
303
        use std::{thread, time};
304
305
306
307
308
309
310
        let (start_tx, start_rx) = channel();
        let (stop_tx, stop_rx) = channel();

        thread::spawn(move || {
            let mut conn = Connection::open_in_memory().unwrap();
            db_apply_migrations::test(&mut conn);

311
            if let Some(user) = set_user {
312
                let mut test_user = conn.new_session("");
313
                test_user.username = Some(user.0);
314
315
316
                match test_user.set_password(&user.1) {
                    None => panic!("Set Password did not work correctly.)"),
                    _ => conn.save_session(test_user),
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
                }
            }

            let mut config = read_config_from_file(Path::new("thisfileshoudnotexist"));
            config.port = Some(port);
            let srvr = start_server(conn, config);

            start_tx.send(()).unwrap();

            stop_rx.recv().unwrap();

            srvr.unwrap().close().unwrap();
        });

        // wait for server to start:
        start_rx.recv().unwrap();
        thread::sleep(time::Duration::from_millis(100));
        f();
        stop_tx.send(()).unwrap();
    }

338
    fn login_for_tests(port: u16, client: &reqwest::Client, username: &str, password: &str) -> reqwest::Response {
339
        let params = [("username", username), ("password", password)];
Robert Czechowski's avatar
Robert Czechowski committed
340
        let resp = client.post(&format!("http://localhost:{}/login", port)).form(&params).send().unwrap();
341
        resp
342
343
    }

344
345
346
347
348
349
350
    fn check_status(resp: &reqwest::Response, expected_status: reqwest::StatusCode) {
        let status = resp.status();
        if status != &expected_status {
            panic!("Status is not (as expexted) {}. Status: {}", expected_status, status)
        };
    }

351
352
    #[test]
    fn start_server_and_check_request() {
Robert Czechowski's avatar
Robert Czechowski committed
353
        start_server_and_fn(8080, None, || {
354
            let mut resp = reqwest::get("http://localhost:8080").unwrap();
355
            check_status(&resp, reqwest::StatusCode::Ok);
356
            let mut content = String::new();
357
            resp.read_to_string(&mut content).unwrap();
358
            assert!(content.contains("Jugendwettbewerb Informatik</h1>"));
359
360
361
            assert!(!content.contains("Error"));

            let mut resp = reqwest::get("http://localhost:8080/contest").unwrap();
362
            check_status(&resp, reqwest::StatusCode::Ok);
363
            let mut content = String::new();
364
            resp.read_to_string(&mut content).unwrap();
365
366
367
368
            assert!(content.contains("<h1>Wettbewerbe</h1>"));
            assert!(!content.contains("Error"));
        })
    }
Daniel Brüning's avatar
Daniel Brüning committed
369

370
371
    #[test]
    fn check_login_wrong_credentials() {
Robert Czechowski's avatar
Robert Czechowski committed
372
        start_server_and_fn(8081, None, || {
373
            let client = reqwest::Client::new().unwrap();
374
375
            let mut resp = login_for_tests(8081, &client, "nonexistingusername", "wrongpassword");
            check_status(&resp, reqwest::StatusCode::Ok);
376
            let mut content = String::new();
377
            resp.read_to_string(&mut content).unwrap();
378
379
            assert!(content.contains("<h1>Login</h1>"));
            assert!(content.contains("Login fehlgeschlagen."));
380
            assert!(!content.contains("Error"));
381
        })
382
    }
383
384
385

    #[test]
    fn start_server_and_check_login() {
Robert Czechowski's avatar
Robert Czechowski committed
386
        start_server_and_fn(8082, Some(("testusr".to_string(), "testpw".to_string())), || {
387
            let mut client = reqwest::Client::new().unwrap();
Robert Czechowski's avatar
Robert Czechowski committed
388
            client.redirect(reqwest::RedirectPolicy::custom(|attempt| attempt.stop()));
389
390
391
            let mut resp = login_for_tests(8082, &client, "testusr", "testpw");
            check_status(&resp, reqwest::StatusCode::Found);

392
            let mut content = String::new();
393
            resp.read_to_string(&mut content).unwrap();
394
395
396
            assert!(!content.contains("Error"));

            let header = resp.headers();
397
398
            let set_cookie = header.get::<reqwest::header::SetCookie>();
            match set_cookie {
399
                None => panic!("No setCookie."),
Robert Czechowski's avatar
Robert Czechowski committed
400
401
                Some(cookie) => {
                    if cookie.len() == 1 {
402
                        let new_cookie = reqwest::header::Cookie(cookie.to_vec());
Robert Czechowski's avatar
Robert Czechowski committed
403
                        let mut new_resp = client.get("http://localhost:8082").header(new_cookie).send().unwrap();
404
405
406
407
408
409
                        check_status(&new_resp, reqwest::StatusCode::Ok);

                        let mut new_content = String::new();
                        new_resp.read_to_string(&mut new_content).unwrap();
                        assert!(!content.contains("Error"));
                        assert!(new_content.contains("Eingeloggt als <em>testusr</em>"));
410
                        assert!(new_content.contains("Jugendwettbewerb Informatik</h1>"));
411
412
                    } else {
                        panic!("More than one setCookie.");
Robert Czechowski's avatar
Robert Czechowski committed
413
414
                    }
                }
415
416
417
418
            };
        })
    }

419
420
    #[test]
    fn start_server_and_check_logout() {
Robert Czechowski's avatar
Robert Czechowski committed
421
        start_server_and_fn(8083, Some(("testusr".to_string(), "testpw".to_string())), || {
422
            let mut client = reqwest::Client::new().unwrap();
Robert Czechowski's avatar
Robert Czechowski committed
423
            client.redirect(reqwest::RedirectPolicy::custom(|attempt| attempt.stop()));
424
            let resp = login_for_tests(8083, &client, "testusr", "testpw");
425
            check_status(&resp, reqwest::StatusCode::Found);
426
427

            let header = resp.headers();
428
429
            let set_cookie = header.get::<reqwest::header::SetCookie>();
            match set_cookie {
430
                None => panic!("No setCookie."),
Robert Czechowski's avatar
Robert Czechowski committed
431
432
433
434
435
436
437
438
439
440
441
                Some(cookie) => {
                    if cookie.len() == 1 {
                        let new_cookie = reqwest::header::Cookie(cookie.to_vec());
                        let mut new_resp =
                            client.get("http://localhost:8082/logout").header(new_cookie.clone()).send().unwrap();
                        check_status(&new_resp, reqwest::StatusCode::Found);
                        new_resp = client.get("http://localhost:8082").header(new_cookie).send().unwrap();
                        check_status(&new_resp, reqwest::StatusCode::Ok);

                        let mut new_content = String::new();
                        new_resp.read_to_string(&mut new_content).unwrap();
442
443
444
445
                        assert!(new_content.contains("Benutzername"));
                        assert!(new_content.contains("Passwort"));
                        assert!(new_content.contains("Gruppencode / Teilnahmecode"));
                        assert!(new_content.contains("Jugendwettbewerb Informatik</h1>"));
446
447
                    } else {
                        panic!("More than one setCookie.");
Robert Czechowski's avatar
Robert Czechowski committed
448
449
                    }
                }
450
451
452
453
            };
        })
    }

454
}