netutils.ecs

package netutils

import network.*, regex, curl

# Internal Functions

var request_line_reg = regex.build("^([^ ]*) ([^? ]*)(\\?([^ ]*))? HTTP/([^ ]*)$")
var request_header_reg = regex.build("^([^:]*): ?(.*)$")

namespace state_codes
    constant code_200 = "200 OK"
    constant code_400 = "400 Bad Request"
    constant code_403 = "403 Forbidden"
    constant code_404 = "404 Not Found"
    constant code_500 = "500 Internal Server Error"
    constant code_503 = "503 Service Unavailable"
end

var wday_map = {
    "Mon", "Tues", "Wed", "Thur", "Fri", "Sat", "Sun"
}

var mon_map = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
}

function time_padding(obj, width)
    var time = to_string(obj)
    var last = width - time.size
    if last <= 0
        return time
    end
    var str = new string
    foreach it in range(last) do str += "0"
    return str + time
end

function compose_http_time()
    var tm = runtime.utc_time()
    return "Date: " +
        wday_map[tm.wday - 1] + ", " +
        tm.mday + " " + mon_map[tm.mon] + " " + to_string(1900 + tm.year) + " " +
        time_padding(tm.hour, 2) + ":" + time_padding(tm.min, 2) + ":" + time_padding(tm.sec, 2) + " GMT"
end

class http_session
    var url = null
    var args = null
    var sock = null
    var host = null
    var method = null
    var version = null
    var connection = null
    var content_length = null
    function construct(socket, request_header : array)
        sock = socket
        var request_line = request_header.front
        request_header.pop_front()
        var match = request_line_reg.match(request_line)
        if !match.empty()
            method = match.str(1)
            url = match.str(2)
            args = match.str(4)
            version = match.str(5)
        end
        foreach line in request_header
            var match = request_header_reg.match(line)
            if !match.empty()
                switch match.str(1)
                    case "Host"
                        host = match.str(2)
                    end
                    case "Connection"
                        connection = match.str(2)
                    end
                    case "Content-Length"
                        content_length = match.str(2).to_number()
                    end
                end
            end
        end
    end
    function send_response(code, data, type)
        sock.send("HTTP/" + version + " " + code + "\r\n")
        sock.send(compose_http_time() + "\r\n")
        sock.send("Connection: " + connection)
        sock.send("Content-Length: " + data.size + "\r\n")
        sock.send("Content-Type: " + type + "\r\n")
        sock.send("\r\n")
        sock.send(data)
    end
end

# Logs

var log_stream = null

function log(msg)
    if log_stream != null
        log_stream.println("[" + compose_http_time() + "]: " + msg)
    end
end

# Coroutines

struct worker_type
    var co = null
    var server = null
end

function wait_sock(sock, size)
    while sock.available() < size
        runtime.yield()
    end
end

function worker_main(self)
    constant buffer_size = 256
    loop
        # Accept new connection
        while self->server->ac_lock
            runtime.yield()
        end
        self->server->ac_lock = true
        var sock = new tcp.socket
        runtime.await_s(sock.accept, {self->server->ac})
        self->server->ac_lock = false
        runtime.yield()
        # Process request
        var header = new array
        var buffer = new string
        loop
            wait_sock(sock, 1)
            var str = sock.receive(buffer_size)
            var skip_cntl_n = false
            var end_of_header = 0
            foreach ch in str
                if end_of_header == 2
                    buffer += ch
                    continue
                end
                if skip_cntl_n
                    skip_cntl_n = false
                    if ch == '\n'
                        header.push_back(buffer)
                        buffer = new string
                        ++end_of_header
                        continue
                    end
                    log("Data transmission error: expected \\n after \\r.")
                end
                if ch == '\r'
                    skip_cntl_n = true
                    continue
                end
                end_of_header = 0
                buffer += ch
            end
        until end_of_header == 2
        # Construct session
        var session = new http_session{sock, header}
        log("Received: Method = " + session.method + ", URL = " + session.url + ", Host = " + session.host)
        # Receive POST data
        var data = null
        if session.method == "POST"
            data = buffer
            if session.content_length > buffer.size
                var last_length = session.content_length - buffer.size
                while last_length > buffer_size
                    wait_sock(sock, buffer_size)
                    data += sock.receive(buffer_size)
                    last_length -= buffer_size
                end
                wait_sock(sock, last_length)
                data += sock.receive(last_length)
            end
        else
            data = session.args
        end
        # Calling function
        link url_map = self->server->url_map
        if url_map.exist(session.url)
            url_map[session.url](session, data)
        else
            url_map["404"](session, data)
        end
        sock.close()
        runtime.yield()
    end
end

function read_file(path)
    var ifs = iostream.ifstream(path)
    var data = new string
    loop
        var ch = ifs.get()
        if ifs.good() && !ifs.eof()
            data += ch
        else
            break
        end
    end
    return move(data)
end

# Public Interfaces

var proxy = null, timeout_ms = null, low_speed_limit = null

function http_get(url)
    var buff = new iostream.char_buff
    var session = curl.make_session_os(buff.get_ostream())
    session.set_url(url)
    session.allow_redirect(true)
    if proxy != null
        session.set_proxy(proxy)
    end
    session.set_ssl_verify_host(false)
    session.set_ssl_verify_peer(false)
    if timeout_ms != null
        session.set_connect_timeout_ms(timeout_ms)
        session.set_accept_timeout_ms(timeout_ms)
        session.set_low_speed_time(timeout_ms)
    end
    if low_speed_limit != null
        session.set_low_speed_limit(low_speed_limit)
    end
    if session.perform()
        return buff.get_string()
    else
        return null
    end
end

function http_post(url, post_fields)
    var buff = new iostream.char_buff
    var session = curl.make_session_os(buff.get_ostream())
    session.set_url(url)
    session.allow_redirect(true)
    if proxy != null
        session.set_proxy(proxy)
    end
    session.set_http_post(true)
    session.set_http_post_fields(post_fields)
    session.set_ssl_verify_host(false)
    session.set_ssl_verify_peer(false)
    if timeout_ms != null
        session.set_connect_timeout_ms(timeout_ms)
        session.set_accept_timeout_ms(timeout_ms)
        session.set_low_speed_time(timeout_ms)
    end
    if low_speed_limit != null
        session.set_low_speed_limit(low_speed_limit)
    end
    if session.perform()
        return buff.get_string()
    else
        return null
    end
end

class http_server
    var ac = null
    var ac_lock = false
    var url_map = new hash_map
    var worker_list = new array
    var worker_count = 10
    function initialize()
        url_map.insert("404", [](session, post_data){
            var response_data = "<html><head><meta charset=\"UTF-8\"></head><body><p>404 Not Found: " + session.url + "</p></body></html>"
            session.send_response(state_codes.code_404, response_data, "text/html")
        })
    end
    function bind_page(url, path, state_code)
        var response_data = read_file(path)
        url_map.insert(url, [response_data, state_code](session, post_data){
            session.send_response(state_code, response_data, "text/html")
        })
    end
    function bind_func(url, func : function)
        url_map.insert(url, func)
    end
    function listen(port : integer)
        ac = tcp.acceptor(tcp.endpoint_v4(port))
    end
    function run()
        # Init workers
        foreach it in range(worker_count)
            var worker = gcnew worker_type
            worker->server = &this
            worker->co = runtime.create_co_s(worker_main, {worker})
            runtime.resume(worker->co)
            worker_list.push_back(worker)
        end
        loop
            foreach worker in worker_list
                runtime.resume(worker->co)
            end
        end
    end
end