access_log.ion

// Access log analyzer: scan log lines for HTTP status codes, classify them,
// and count server errors on a background thread while the main thread parses.

import "stdlib/fmt.ion" as fmt;
import "stdlib/io.ion" as io;

enum HttpClass {
    Success;
    ClientError;
    ServerError;
}

fn line_at(index: int) -> String {
    if index == 0 {
        return String::from("GET /health 200 OK");
    } else if index == 1 {
        return String::from("POST /login 401 Unauthorized");
    } else if index == 2 {
        return String::from("GET /missing 404 Not Found");
    } else if index == 3 {
        return String::from("GET /down 503 Service Unavailable");
    } else {
        return String::from("malformed line with no status");
    }
}

fn parse_status_from_line(line: String) -> int {
    let mut last: int = 0;
    let mut current: int = 0;
    let mut in_run: bool = false;
    for ch in line {
        if ch >= 48 && ch <= 57 {
            if !in_run {
                current = 0;
                in_run = true;
            }
            current = current * 10 + ((ch as int) - 48);
        } else {
            if in_run {
                last = current;
                in_run = false;
            }
        }
    }
    if in_run {
        last = current;
    }
    return last;
}

// Parse the last digit run from a log line at the given index.
fn parse_line_at(index: int) -> int {
    let line: String = line_at(index);
    return parse_status_from_line(line);
}

fn scan_logs(code_tx: Sender<int>, expected: int) -> int {
    let mut auth_failures: int = 0;
    let mut parsed: int = 0;
    let log_indices: [int; 5] = [0, 1, 2, 3, 4];

    for index in log_indices {
        let code: int = parse_line_at(index);
        if code == 0 {
            continue;
        }
        if parsed >= expected {
            break;
        }

        let mut kind: HttpClass = HttpClass::ClientError;
        if code >= 200 && code < 300 {
            kind = HttpClass::Success;
        } else if code >= 400 && code < 500 {
            kind = HttpClass::ClientError;
        } else if code >= 500 && code < 600 {
            kind = HttpClass::ServerError;
        }

        match kind {
            HttpClass::ClientError if code == 401 => {
                auth_failures += 1;
            }
            HttpClass::ClientError => {}
            HttpClass::ServerError => {}
            HttpClass::Success => {}
        };
        send(&code_tx, code);
        parsed += 1;
    }

    return auth_failures;
}

fn valid_log_count() -> int {
    return 4;
}

fn main() -> int {
    let (code_tx, code_rx): (Sender<int>, Receiver<int>) = channel<int>();
    let (done_tx, done_rx): (Sender<int>, Receiver<int>) = channel<int>();

    spawn {
        let mut rx: Receiver<int> = code_rx;
        let mut server_errors: int = 0;
        let mut received: int = 0;
        loop {
            if received >= valid_log_count() {
                break;
            }
            let code: int = recv(&mut rx);
            if code >= 500 {
                server_errors += 1;
            }
            received += 1;
        }
        send(&done_tx, server_errors);
    };

    let auth_failures: int = scan_logs(code_tx, valid_log_count());

    let mut done_rx_mut: Receiver<int> = done_rx;
    let server_errors: int = recv(&mut done_rx_mut);

    if server_errors != 1 {
        return 1;
    }
    if auth_failures != 1 {
        return 2;
    }

    let server_line: String = fmt::int_to_string(server_errors);
    io::println(server_line);
    let auth_line: String = fmt::int_to_string(auth_failures);
    io::println(auth_line);
    return 0;
}