Initial project import
This commit is contained in:
Agila Forge Importer committed
commit
23f2d29e32
11957 files changed
+1754577
No files matched your search
@@ -0,0 +1,366 @@
|
||||
module picoev
|
||||
|
||||
import net
|
||||
import pico_http_parser
|
||||
import time
|
||||
|
||||
// maximum size of the event queue.
|
||||
pub const max_queue = 4096
|
||||
|
||||
// event for incoming data ready to be read on a socket.
|
||||
pub const picoev_read = 1
|
||||
|
||||
// event for socket ready for writing.
|
||||
pub const picoev_write = 2
|
||||
|
||||
// event indicating a timeout has occurred.
|
||||
pub const picoev_timeout = 4
|
||||
|
||||
// flag for adding a file descriptor to the event loop.
|
||||
pub const picoev_add = 0x40000000
|
||||
|
||||
// flag for removing a file descriptor from the event loop.
|
||||
pub const picoev_del = 0x20000000
|
||||
|
||||
// event read/write.
|
||||
pub const picoev_readwrite = 3
|
||||
|
||||
// Target is a data representation of everything that needs to be associated with a single file descriptor (connection).
|
||||
pub struct Target {
|
||||
pub mut:
|
||||
fd int // file descriptor
|
||||
loop_id int = -1
|
||||
events u32
|
||||
cb fn (int, int, voidptr) = unsafe { nil }
|
||||
// used internally by the kqueue implementation
|
||||
backend int
|
||||
}
|
||||
|
||||
// Config configures the Picoev instance with server settings and callbacks.
|
||||
pub struct Config {
|
||||
pub:
|
||||
port int = 8080
|
||||
cb fn (voidptr, pico_http_parser.Request, mut pico_http_parser.Response) = unsafe { nil }
|
||||
err_cb fn (voidptr, pico_http_parser.Request, mut pico_http_parser.Response, IError) = default_error_callback
|
||||
raw_cb fn (mut Picoev, int, int) = unsafe { nil }
|
||||
user_data voidptr = unsafe { nil }
|
||||
timeout_secs int = 8
|
||||
max_headers int = 100
|
||||
max_read int = 4096
|
||||
max_write int = 8192
|
||||
family net.AddrFamily = .ip6
|
||||
host string
|
||||
}
|
||||
|
||||
// Core structure for managing the event loop and connections.
|
||||
// Contains event loop, file descriptor table, timeouts, buffers, and configuration.
|
||||
@[heap]
|
||||
pub struct Picoev {
|
||||
cb fn (voidptr, pico_http_parser.Request, mut pico_http_parser.Response) = unsafe { nil }
|
||||
error_callback fn (voidptr, pico_http_parser.Request, mut pico_http_parser.Response, IError) = default_error_callback
|
||||
raw_callback fn (mut Picoev, int, int) = unsafe { nil }
|
||||
|
||||
timeout_secs int
|
||||
max_headers int = 100
|
||||
max_read int = 4096
|
||||
max_write int = 8192
|
||||
mut:
|
||||
loop &LoopType = unsafe { nil }
|
||||
file_descriptors [4096]&Target // TODO: use max_fds here, instead of the hardcoded size, when the compiler allows it
|
||||
timeouts map[int]i64
|
||||
num_loops int
|
||||
|
||||
buf &u8 = unsafe { nil }
|
||||
idx [max_fds]int
|
||||
out &u8 = unsafe { nil }
|
||||
|
||||
date string
|
||||
pub:
|
||||
user_data voidptr = unsafe { nil }
|
||||
}
|
||||
|
||||
// init fills the `file_descriptors` array.
|
||||
pub fn (mut pv Picoev) init() {
|
||||
// assert max_fds > 0
|
||||
pv.num_loops = 0
|
||||
for i in 0 .. max_fds {
|
||||
pv.file_descriptors[i] = &Target{}
|
||||
}
|
||||
}
|
||||
|
||||
// add a file descriptor to the event loop.
|
||||
@[direct_array_access]
|
||||
pub fn (mut pv Picoev) add(fd int, events int, timeout int, callback voidptr) int {
|
||||
if pv == unsafe { nil } || fd < 0 || fd >= max_fds {
|
||||
return -1 // Invalid arguments
|
||||
}
|
||||
mut target := pv.file_descriptors[fd]
|
||||
target.fd = fd
|
||||
target.cb = callback
|
||||
target.loop_id = pv.loop.id
|
||||
target.events = 0
|
||||
if pv.update_events(fd, events | picoev_add) != 0 {
|
||||
if pv.delete(fd) != 0 {
|
||||
elog('Error during del')
|
||||
}
|
||||
return -1
|
||||
}
|
||||
pv.set_timeout(fd, timeout)
|
||||
return 0
|
||||
}
|
||||
|
||||
// remove a file descriptor from the event loop.
|
||||
@[direct_array_access]
|
||||
pub fn (mut pv Picoev) delete(fd int) int {
|
||||
if fd < 0 || fd >= max_fds {
|
||||
return -1 // Invalid fd
|
||||
}
|
||||
mut target := pv.file_descriptors[fd]
|
||||
trace_fd('remove ${fd}')
|
||||
if pv.update_events(fd, picoev_del) != 0 {
|
||||
elog('Error during update_events. event: `picoev.picoev_del`')
|
||||
return -1
|
||||
}
|
||||
pv.set_timeout(fd, 0)
|
||||
target.loop_id = -1
|
||||
target.fd = 0
|
||||
target.cb = unsafe { nil } // Clear callback to prevent accidental invocations
|
||||
return 0
|
||||
}
|
||||
|
||||
fn (mut pv Picoev) loop_once(max_wait_in_sec int) int {
|
||||
pv.loop.now = get_time()
|
||||
if pv.poll_once(max_wait_in_sec) != 0 {
|
||||
$if !windows {
|
||||
if C.errno == net.error_eintr {
|
||||
// Signal-driven wakeups are transient. The caller should keep serving,
|
||||
// instead of spinning on a logged "error" until the signal source stops.
|
||||
return 0
|
||||
}
|
||||
}
|
||||
elog('Error during poll_once')
|
||||
return -1
|
||||
}
|
||||
if max_wait_in_sec == 0 {
|
||||
// If no waiting, skip timeout handling for potential performance optimization
|
||||
return 0
|
||||
}
|
||||
// Update loop start time again if waiting occurred
|
||||
pv.loop.now = get_time()
|
||||
pv.handle_timeout()
|
||||
return 0
|
||||
}
|
||||
|
||||
// set_timeout sets the timeout in seconds for a file descriptor. If a timeout occurs
|
||||
// the file descriptors target callback is called with a timeout event.
|
||||
@[direct_array_access; inline]
|
||||
fn (mut pv Picoev) set_timeout(fd int, secs int) {
|
||||
assert fd < max_fds
|
||||
if secs == 0 {
|
||||
pv.timeouts.delete(fd)
|
||||
} else {
|
||||
pv.timeouts[fd] = pv.loop.now + secs
|
||||
}
|
||||
}
|
||||
|
||||
// handle_timeout loops over all file descriptors and removes them from the loop
|
||||
// if they are timed out. Also the file descriptors target callback is called with a
|
||||
// timeout event.
|
||||
@[direct_array_access; inline]
|
||||
fn (mut pv Picoev) handle_timeout() {
|
||||
mut to_remove := []int{}
|
||||
for fd, timeout in pv.timeouts {
|
||||
if timeout <= pv.loop.now {
|
||||
to_remove << fd
|
||||
}
|
||||
}
|
||||
for fd in to_remove {
|
||||
target := pv.file_descriptors[fd]
|
||||
assert target.loop_id == pv.loop.id
|
||||
pv.timeouts.delete(fd)
|
||||
unsafe { target.cb(fd, picoev_timeout, &pv) }
|
||||
}
|
||||
}
|
||||
|
||||
// accept_callback accepts a new connection from `listen_fd` and adds it to the event loop.
|
||||
fn accept_callback(listen_fd int, _events int, cb_arg voidptr) {
|
||||
mut pv := unsafe { &Picoev(cb_arg) }
|
||||
accepted_fd := accept(listen_fd)
|
||||
if accepted_fd == -1 {
|
||||
if fatal_socket_error(accepted_fd) == false {
|
||||
return
|
||||
}
|
||||
elog('Error during accept')
|
||||
return
|
||||
}
|
||||
if accepted_fd >= max_fds {
|
||||
// should never happen
|
||||
elog('Error during accept, accepted_fd >= max_fd')
|
||||
close_socket(accepted_fd)
|
||||
return
|
||||
}
|
||||
trace_fd('accept ${accepted_fd}')
|
||||
setup_sock(accepted_fd) or {
|
||||
elog('setup_sock failed, fd: ${accepted_fd}, listen_fd: ${listen_fd}, err: ${err.code()}')
|
||||
pv.error_callback(pv.user_data, pico_http_parser.Request{}, mut
|
||||
&pico_http_parser.Response{}, err)
|
||||
close_socket(accepted_fd) // Close fd on failure
|
||||
return
|
||||
}
|
||||
pv.add(accepted_fd, picoev_read, pv.timeout_secs, raw_callback)
|
||||
}
|
||||
|
||||
// close_conn closes the socket `fd` and removes it from the loop.
|
||||
@[inline]
|
||||
pub fn (mut pv Picoev) close_conn(fd int) {
|
||||
if pv.delete(fd) != 0 {
|
||||
elog('Error during del')
|
||||
}
|
||||
close_socket(fd)
|
||||
}
|
||||
|
||||
// raw_callback handles raw events (read, write, timeout) for a file descriptor.
|
||||
@[direct_array_access]
|
||||
fn raw_callback(fd int, events int, context voidptr) {
|
||||
mut pv := unsafe { &Picoev(context) }
|
||||
defer {
|
||||
pv.idx[fd] = 0
|
||||
}
|
||||
if events & picoev_timeout != 0 {
|
||||
trace_fd('timeout ${fd}')
|
||||
if !isnil(pv.raw_callback) {
|
||||
pv.raw_callback(mut pv, fd, events)
|
||||
return
|
||||
}
|
||||
pv.close_conn(fd)
|
||||
return
|
||||
} else if events & picoev_read != 0 {
|
||||
pv.set_timeout(fd, pv.timeout_secs)
|
||||
if !isnil(pv.raw_callback) {
|
||||
pv.raw_callback(mut pv, fd, events)
|
||||
return
|
||||
}
|
||||
mut request_buffer := pv.buf
|
||||
unsafe {
|
||||
request_buffer += fd * pv.max_read // pointer magic
|
||||
}
|
||||
mut req := pico_http_parser.Request{}
|
||||
// Response init
|
||||
mut response_buffer := pv.out
|
||||
unsafe {
|
||||
response_buffer += fd * pv.max_write // pointer magic
|
||||
}
|
||||
mut res := pico_http_parser.Response{
|
||||
fd: fd
|
||||
buf_start: response_buffer
|
||||
buf: response_buffer
|
||||
date: pv.date.str
|
||||
}
|
||||
for {
|
||||
// Request parsing loop
|
||||
r := req_read(fd, request_buffer, pv.max_read, pv.idx[fd]) // Get data from socket
|
||||
if r == 0 {
|
||||
// connection closed by peer
|
||||
pv.close_conn(fd)
|
||||
return
|
||||
} else if r == -1 {
|
||||
if fatal_socket_error(fd) == false {
|
||||
return
|
||||
}
|
||||
elog('Error during req_read')
|
||||
// fatal error
|
||||
pv.close_conn(fd)
|
||||
return
|
||||
}
|
||||
pv.idx[fd] += r
|
||||
mut s := unsafe { tos(request_buffer, pv.idx[fd]) }
|
||||
pret := req.parse_request(s) or {
|
||||
// Parse error
|
||||
pv.error_callback(pv.user_data, req, mut &res, err)
|
||||
return
|
||||
}
|
||||
if pret > 0 { // Success
|
||||
break
|
||||
}
|
||||
assert pret == -2
|
||||
// request is incomplete, continue the loop
|
||||
if pv.idx[fd] == sizeof(request_buffer) {
|
||||
pv.error_callback(pv.user_data, req, mut &res, error('RequestIsTooLongError'))
|
||||
return
|
||||
}
|
||||
}
|
||||
// Callback (should call .end() itself)
|
||||
pv.cb(pv.user_data, req, mut &res)
|
||||
} else if events & picoev_write != 0 {
|
||||
pv.set_timeout(fd, pv.timeout_secs)
|
||||
if !isnil(pv.raw_callback) {
|
||||
pv.raw_callback(mut pv, fd, events)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn default_error_callback(_data voidptr, _req pico_http_parser.Request, mut res pico_http_parser.Response, error IError) {
|
||||
elog('picoev: ${error}')
|
||||
res.end()
|
||||
}
|
||||
|
||||
// new creates a `Picoev` struct and initializes the main loop.
|
||||
pub fn new(config Config) !&Picoev {
|
||||
listening_socket_fd := listen(config) or {
|
||||
elog('Error during listen: ${err}')
|
||||
return err
|
||||
}
|
||||
mut pv := &Picoev{
|
||||
num_loops: 1
|
||||
cb: config.cb
|
||||
error_callback: config.err_cb
|
||||
raw_callback: config.raw_cb
|
||||
user_data: config.user_data
|
||||
timeout_secs: config.timeout_secs
|
||||
max_headers: config.max_headers
|
||||
max_read: config.max_read
|
||||
max_write: config.max_write
|
||||
}
|
||||
if isnil(pv.raw_callback) {
|
||||
pv.buf = unsafe { malloc_noscan(max_fds * config.max_read + 1) }
|
||||
pv.out = unsafe { malloc_noscan(max_fds * config.max_write + 1) }
|
||||
}
|
||||
// epoll on linux
|
||||
// kqueue on macos and bsd
|
||||
// select on windows and others
|
||||
$if linux || termux {
|
||||
pv.loop = create_epoll_loop(0) or { panic(err) }
|
||||
} $else $if freebsd || macos || openbsd {
|
||||
pv.loop = create_kqueue_loop(0) or { panic(err) }
|
||||
} $else {
|
||||
pv.loop = create_select_loop(0) or { panic(err) }
|
||||
}
|
||||
if pv.loop == unsafe { nil } {
|
||||
elog('Failed to create loop')
|
||||
close_socket(listening_socket_fd)
|
||||
return unsafe { nil }
|
||||
}
|
||||
pv.init()
|
||||
pv.add(listening_socket_fd, picoev_read, 0, accept_callback)
|
||||
return pv
|
||||
}
|
||||
|
||||
// serve starts the event loop for accepting new connections.
|
||||
// See also picoev.new().
|
||||
pub fn (mut pv Picoev) serve() {
|
||||
spawn update_date_string(mut pv)
|
||||
for {
|
||||
pv.loop_once(1)
|
||||
}
|
||||
}
|
||||
|
||||
// update_date updates the date field of the Picoev instance every second for HTTP headers.
|
||||
fn update_date_string(mut pv Picoev) {
|
||||
for {
|
||||
// get GMT (UTC) time for the HTTP Date header
|
||||
gmt := time.utc()
|
||||
pv.date = gmt.http_header_string()
|
||||
time.sleep(time.second)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user