chores: update mainstream to v0.1.0-86

Author: xiaokang00010

hoshi-lang

@@ -25,7 +25,7 @@ alias AfterRequestHook = func(response.Response) : lang.Result<response.Response
 
 struct ApplicationConfig {
     host: str.Str,
-    port: short,
+    datafield port: short,
     route: route.RouteTree,
     before_requests: vec.Vec<BeforeRequestHook>,
     after_requests: vec.Vec<AfterRequestHook>,
@@ -110,6 +110,9 @@ impl Application {
         this.config.add_route(path, handler)
     },
     serve() : ResultCode {
+        if (this.backend.init() == false) {
+            return ResultCode.SOCKET_CREATION_FAIL
+        }
         let sock = socket.socket()
         if (sock.is_err()) {
             return ResultCode.SOCKET_CREATION_FAIL

src/kiana/application.hoshi

@@ -14,8 +14,8 @@ impl LegacyBackend {
 }
 
 impl LegacyBackend : taskBackend.TaskBackend {
-    init() : none {
-        return
+    init() : bool {
+        return true
     },
     new_task(sock: socket.AbstractSocket, resp : func() : response.Response) : none {
         resp().write_to(sock)

src/kiana/backends/legacy.hoshi

@@ -0,0 +1,125 @@
+use taskBackend "kiana/taskBackend"
+use request "kiana/request"
+use response "kiana/response"
+use socket "net/socket"
+use threading "threading"
+use vec "vec"
+use lang "builtin"
+
+struct PoolTask {
+    sock: socket.AbstractSocket,
+    resp_func: func() : response.Response,
+    constructor(sock: socket.AbstractSocket, resp_func: func() : response.Response)
+}
+
+impl PoolTask {
+    constructor(sock: socket.AbstractSocket, resp_func: func() : response.Response) {
+        this.sock = sock
+        this.resp_func = resp_func
+    }
+}
+
+struct TaskPoolBackend {
+    thread_count: int,
+    tasks: vec.Vec<PoolTask>,
+    head: int,
+    mutex: threading.Mutex,
+    condition: threading.Condition,
+    workers: vec.Vec<threading.Thread>,
+    stop_flag: bool,
+    constructor(),
+    constructor(thread_count: int),
+    worker_loop() : none
+}
+
+impl TaskPoolBackend {
+    constructor() {
+        this.thread_count = threading.hardware_concurrency()
+        this.tasks = vec.Vec<PoolTask>()
+        this.head = 0
+        this.mutex = threading.Mutex()
+        this.condition = threading.Condition(this.mutex)
+        this.workers = vec.Vec<threading.Thread>()
+        this.stop_flag = false
+    },
+    constructor(thread_count: int) {
+        this.thread_count = thread_count
+        this.tasks = vec.Vec<PoolTask>()
+        this.head = 0
+        this.mutex = threading.Mutex()
+        this.condition = threading.Condition(this.mutex)
+        this.workers = vec.Vec<threading.Thread>()
+        this.stop_flag = false
+    },
+    worker_loop() : none {
+        while (true) {
+            let task_opt : PoolTask = null
+            
+            this.mutex.lock()
+            while (this.stop_flag == false && this.head == this.tasks.length) {
+                this.condition.wait()
+            }
+
+            if (this.stop_flag && this.head == this.tasks.length) {
+                this.mutex.unlock()
+                return
+            }
+
+            task_opt = this.tasks[this.head]
+            this.head += 1
+            
+            if (this.head == this.tasks.length) {
+                this.tasks.length = 0
+                this.head = 0
+            }
+            
+            this.mutex.unlock()
+
+            // Execute task
+            if (task_opt != null) {
+                task_opt.resp_func().write_to(task_opt.sock)
+                task_opt.sock.close()
+            }
+        }
+    }
+}
+
+impl TaskPoolBackend : taskBackend.TaskBackend {
+    init() : bool {
+        for (let i = 0; i < this.thread_count; i += 1) {
+            let thread = threading.Thread(func[this]() : none {
+                this.this.worker_loop()
+            })
+            if (thread.start().is_err()) {
+                return false
+            }
+            this.workers.push(thread)
+        }
+        return true
+    },
+
+    new_task(sock: socket.AbstractSocket, resp : func() : response.Response) : none {
+        this.mutex.lock()
+        this.tasks.push(PoolTask(sock, resp))
+        this.condition.signal()
+        this.mutex.unlock()
+    },
+
+    stop() : none {
+        this.mutex.lock()
+        this.stop_flag = true
+        this.condition.signal() // Might need notify_all if kiana supported it, but signal in a loop/multiple times
+        this.mutex.unlock()
+        
+        // Signal everyone
+        for (let i = 0; i < this.workers.length; i += 1) {
+            this.mutex.lock()
+            this.condition.signal()
+            this.mutex.unlock()
+        }
+
+        for (let i = 0; i < this.workers.length; i += 1) {
+            this.workers[i].join()
+        }
+    }
+}

src/kiana/backends/taskpool.hoshi

@@ -15,8 +15,8 @@ impl ThreadingBackend {
 }
 
 impl ThreadingBackend : taskBackend.TaskBackend {
-    init() : none {
-        return
+    init() : bool {
+        return true
     },
     new_task(sock: socket.AbstractSocket, resp : func() : response.Response) : none {
         threading.Thread(func [sock, resp] () : none {

src/kiana/backends/thread.hoshi

@@ -32,7 +32,7 @@ struct RouteTree {
     node_type: RouteTreeNodeType,
     matching_pattern: str.Str,
     handler: RouteHandler,
-    is_end: bool,
+    datafield is_end: bool,
     full_path: str.Str,
 
     constructor(pattern: str.Str, node_type: RouteTreeNodeType),

src/kiana/route.hoshi

@@ -3,5 +3,5 @@ use hashMap "hashMap"
 
 struct Session {
     data: hashMap.HashMap<str.Str, str.Str>,
-    expires: int
+    datafield expires: int
 }

src/kiana/session.hoshi

@@ -18,7 +18,7 @@ interface Logger {
 }
 
 struct ConsoleLogger {
-    level: Severity,
+    datafield level: Severity,
     constructor(level: Severity)
 }
 

src/logger.hoshi

@@ -9,8 +9,8 @@ use lang "builtin"
 
 struct Cookie {
     sections: hashMap.HashMap<str.Str, str.Str>,
-    section_secure: bool,
-    section_http_only: bool,
+    datafield section_secure: bool,
+    datafield section_http_only: bool,
     constructor(),
     constructor(sections: hashMap.HashMap<str.Str, str.Str>),
     put(key: str.Str, value: str.Str) : Cookie,
@@ -135,8 +135,8 @@ struct CookieSection {
     path: str.Str,
     expires: time.Date,
     max_age: time.Duration,
-    secure: bool,
-    http_only: bool,
+    datafield secure: bool,
+    datafield http_only: bool,
     constructor(),
     constructor(key: str.Str, value: str.Str, domain: str.Str, path: str.Str, expires: time.Date, max_age: time.Duration, secure: bool, http_only: bool),
     expires(e: time.Date) : CookieSection,

src/net/cookie.hoshi

@@ -214,11 +214,11 @@ struct RequestReader {
     socket: socket.AbstractSocket,
     cached_recv: io.ArrayBuffer,
     headers: hashMap.HashMap<str.Str, str.Str>,
-    is_chunked: bool,
-    content_length: int,
-    read_pos: int,
-    chunk_remaining: int,
-    is_eof_flag: bool,
+    datafield is_chunked: bool,
+    datafield content_length: int,
+    datafield read_pos: int,
+    datafield chunk_remaining: int,
+    datafield is_eof_flag: bool,
     constructor(socket: socket.AbstractSocket, cached_recv: io.ArrayBuffer, headers: hashMap.HashMap<str.Str, str.Str>),
     recv_next_raw() : lang.Result<io.ArrayBuffer, HTTPNetworkError>,
     read(size: int) : file.ReadBufferView,