aboutsummaryrefslogtreecommitdiffstats
path: root/license-generator/src/main.rs
blob: 43a9d776f158329c3fcd2bd2326b82b28a29cc55 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
extern crate fastcgi;

#[macro_use]
extern crate log;
extern crate mysql;
extern crate simplelog;

extern crate license_generator;

use std::env;
use std::fs::OpenOptions;
use std::io::{Read, Write};

use simplelog::{Config, LevelFilter, WriteLogger};

use license_generator::database;
use license_generator::errors::*;
use license_generator::params;
use license_generator::purchaser::Purchaser;

fn main() -> Result<()> {
    let log_file_path = env::var("LOG_FILE")
        .chain_err(|| "LOG_FILE environment variable not found")?;

    let log_file = OpenOptions::new()
        .append(true)
        .create(true)
        .open(log_file_path)?;

    WriteLogger::init(LevelFilter::Info, Config::default(), log_file)?;

    let mut cx = match database::get_database_connection()
        .chain_err(|| "failed to create a database connection")
    {
        Ok(cx) => cx,
        Err(e) => {
            error!("{}", e);
            return Err(e);
        },
    };

    let test_purchaser = Purchaser::new("Shiki", "shiki@example.com");
    match test_purchaser.insert(&mut cx) {
        Ok(_) => (),
        Err(e) => error!("{}", e),
    }

    fastcgi::run(|mut req| {
        write!(&mut req.stdout(), "Content-Type: text/plain\n\nHello, world!")
            .unwrap_or(());

        let mut params = String::new();
        for (key, val) in req.params() {
            params.push_str(format!("{}: {}\n", key, val).as_str());
        }

        write!(&mut req.stdout(), "\n\n{}", params)
            .unwrap_or(());

        let mut stdin = String::new();
        req.stdin().read_to_string(&mut stdin).unwrap();

        write!(&mut req.stdout(), "\n\nstdin: {}\n", stdin)
            .unwrap_or(());

        let p = params::parse(&stdin);
        write!(&mut req.stdout(), "\n{:?}\n", p)
            .unwrap_or(());
    });

    Ok(())
}