firefly-compiler 0.4.6 → 0.4.8

package/webserver/WebServer.ff

@@ -0,0 +1,608 @@
+class WebRequest[T](
+    internalJsApp: JsValue
+    internalJsContext: JsValue
+    internalMethod: String
+    internalPath: String
+    internalQuery: String
+    internalHeaders: StringMap[String]
+    internalJsResponse: JsValue
+    internalResponse: T
+    internalResponseHeaders: StringMap[String]
+    internalResponseChunks: Stack[JsValue]
+    mutable internalResponseStatus: String
+    mutable internalCloseConnection: Bool
+    mutable internalResolveFlush: JsValue
+    mutable internalContentSize: Int
+    mutable internalResponded: Bool
+)
+
+capability WebResponse {}
+
+data MultipartField {}
+
+capability WebSocketConnection {}
+
+listen(
+    system: NodeSystem
+    host: String
+    port: Int
+    handler: WebRequest[WebResponse] => Unit
+): Unit
+    target node async """
+        import * as uws from 'uWebSockets.js'
+        ff_core_Task.Task_throwIfAborted($task);
+        await new Promise((resolveServer, rejectServer) => {
+            const app = uws.App();
+            const handleRequest = (res, req, context) => {
+                let abortedByUws = false;
+                const method = req.getMethod();
+                const path = req.getUrl();
+                const query = req.getQuery() || '';
+                const headers = new Map();
+                req.forEach((key, value) => headers.set(key, value));
+                const chunks = internalStack_();
+                const task = ff_core_Task.Task_spawn($task, async task => {
+                    try {
+                        ff_core_Task.Task_throwIfAborted(task);
+                        const webRequest = WebRequest(
+                            app, context, 
+                            method, path, query, headers, 
+                            res, null, 
+                            new Map(), internalStack_(), 
+                            "200 OK", false, null, -1, false
+                        );
+                        await handler_(webRequest, task);
+                        ff_core_Task.Task_throwIfAborted(task);
+                        if(context == null && !webRequest.internalResponded_ && webRequest.internalContentSize_ >= 0) {
+                            await WebRequest_flush$(webRequest, task);
+                            ff_core_Task.Task_throwIfAborted(task);
+                        }
+                        if(context == null && !webRequest.internalResponded_) await new Promise((resolve, reject) => {
+                            res.cork(() => {
+                                try {
+                                    ff_core_Task.Task_throwIfAborted(task);
+                                    if(!webRequest.internalResolveFlush_) {
+                                        res.writeStatus(webRequest.internalResponseStatus_);
+                                        webRequest.internalResponseHeaders_.forEach((value, key) => res.writeHeader(key, value));
+                                    }
+                                    const chunk = internalChunksToChunk_(webRequest.internalResponseChunks_);
+                                    res.end(chunk, webRequest.internalCloseConnection_);
+                                    resolve();
+                                } catch(e) {
+                                    reject(e);
+                                }
+                            });
+                        });
+                    } catch(e) {
+                        if(!abortedByUws) console.error(e);
+                        if(!abortedByUws && context == null) res.cork(() => {
+                            if(!abortedByUws) res.writeStatus("500 Internal Server Error");
+                            if(!abortedByUws) res.end();
+                        });
+                    }
+                });
+                res.onAborted(() => {
+                    abortedByUws = true; 
+                    ff_core_Task.Task_abort(task);
+                });
+            }
+            app.any('/*', handleRequest);
+            app.ws("/*", {
+                compression: 0,
+                maxPayloadLength: 16 * 1024 * 1024,
+                idleTimeout: 10,
+                upgrade: handleRequest,
+                open: ws => ws.getUserData().onOpen(ws),
+                message: (ws, m, b) => ws.getUserData().onMessage(m, b),
+                close: ws => ws.getUserData().onClose(),
+            });
+            app.listen(host_, port_, listenSocket => {
+                if(listenSocket) {
+                    const abort = () => {
+                        $task.controller.signal.removeEventListener('abort', abort);
+                        uws.us_listen_socket_close(listenSocket);
+                    }
+                    $task.controller.signal.addEventListener('abort', abort);
+                } else {
+                    rejectServer();
+                }
+            });
+        });
+    """
+
+nodeMain(system: NodeSystem) {
+    listen(system, "localhost", 8080) {request =>
+        if(request.readPath() != "/") {request.writeStatus("404 Not Found")} else:
+        request.writeHeader("IsExample", request.readQuery("foo").else {"None"})
+        request.writeContentSize(10 * 500000 * "Hello ".size() + "world!".size())
+        1.to(10).each {_ => request.writeText(1.to(500000).map {_ => "Hello "}.join())}
+        request.flush()
+        request.writeText("world!")
+    }
+}
+
+extend self[T]: WebRequest[T] {
+
+    readMethod(): String {
+        self.internalMethod
+    }
+
+    readPath(): String {
+        self.internalPath
+    }
+
+    readRawQueryString(): String {
+        self.internalQuery
+    }
+
+    readQuery(name: String): Option[String]
+        target node sync """
+            if(self_.internalQuery_.length === 0) return ff_core_Option.None();
+            const ps = self_.internalQuery_.split('&');
+            const n = name_ + '=';
+            const r = ps.find(p => p === name_ || p.startsWith(n));
+            if(r == null) return ff_core_Option.None();
+            return ff_core_Option.Some(decodeURIComponent(r.slice(name_.length + 1)));
+        """
+    
+    readHeader(lowerCaseName: String): Option[String] {
+        self.internalHeaders.get(lowerCaseName)
+    }
+    
+    eachHeader(body: (String, String) => Unit) {
+        self.internalHeaders.each {body(_, _)}
+    }
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    writeStatus(codeAndMessage: String) {
+        self.internalResponseStatus = codeAndMessage
+    }
+    
+    writeHeader(name: String, value: String) {
+        self.internalResponseHeaders.set(name, value)
+    }
+    
+    writeContentSize(contentSize: Int) {
+        if(contentSize >= 0) {
+            self.internalContentSize = contentSize
+        }
+    }
+
+    writeText(data: String) {
+        self.internalResponseChunks.push(internalTextChunk(data))
+    }
+
+    writeBuffer(data: Buffer) {
+        self.internalResponseChunks.push(internalBufferChunk(data))
+    }
+    
+    writeStream(data: Stream[Buffer]) {
+        data.each {self.writeBuffer(_)}
+    }
+
+}
+
+extend self[T]: WebRequest[T] {
+
+    publishBuffer(topic: String, message: Buffer) // Should this be corked?
+        target js sync """
+            self_.internalJsApp_.publish(topic_, message_.buffer, true);
+        """
+    
+    publishText(topic: String, message: String) // Should this be corked?
+        target js sync """
+            self_.internalJsApp_.publish(topic_, message_, false);
+        """
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    closeConnection() {
+        self.internalCloseConnection = True
+    }
+    
+    readRemoteAddress(): String
+        target js sync """
+            return new TextDecoder().decode(self_.internalJsResponse_.getRemoteAddressAsText())
+        """
+
+    readProxiedRemoteAddress(): String
+        target js sync """
+            return new TextDecoder().decode(self_.internalJsResponse_.getProxiedRemoteAddressAsText())
+        """
+
+}
+
+extend self: WebRequest[WebResponse] {
+
+    flush()
+        target js async """
+            if(!self_.internalResolveFlush_) {
+                self_.internalResolveFlush_ = () => {};
+                self_.internalJsResponse_.cork(() => {
+                    self_.internalJsResponse_.writeStatus(self_.internalResponseStatus_);
+                    self_.internalResponseHeaders_.forEach((value, key) =>
+                        self_.internalJsResponse_.writeHeader(key, value)
+                    );
+                    self_.internalJsResponse_.onWritable(() => {
+                        self_.internalResolveFlush_();
+                        return true;
+                    });
+                });
+            }
+            while(self_.internalResponseChunks_.array.length !== 0) {
+                await new Promise((resolve, reject) => {
+                    self_.internalJsResponse_.cork(() => {
+                        let backpressure = false;
+                        let i = 0;
+                        for(i = 0; i < self_.internalResponseChunks_.array.length && !backpressure; i++) {
+                            let chunk = self_.internalResponseChunks_.array[i];
+                            if(chunk && (chunk.byteLength || chunk.length)) {
+                                if(typeof chunk !== 'string') {
+                                    chunk = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+                                } else if(self_.internalContentSize_ >= 0) {
+                                    chunk = new TextEncoder().encode(chunk);
+                                }
+                                if(self_.internalContentSize_ >= 0) {
+                                    const lastOffset = self_.internalJsResponse_.getWriteOffset();
+                                    const [ok, responded] = self_.internalJsResponse_.tryEnd(chunk, self_.internalContentSize_);
+                                    if(responded) self_.internalResponded_ = true;
+                                    if(!ok) {
+                                        const written = self_.internalJsResponse_.getWriteOffset() - lastOffset;
+                                        backpressure = true;
+                                        self_.internalResponseChunks_.array[i] = 
+                                            new Uint8Array(chunk.buffer, chunk.byteOffset + written, chunk.byteLength - written);
+                                        i -= 1;
+                                    }
+                                } else {
+                                    backpressure = !self_.internalJsResponse_.write(chunk);
+                                }
+                            }
+                        }
+                        if(i > 0) self_.internalResponseChunks_.array.splice(0, i);
+                        if(!backpressure) {
+                            resolve();
+                        } else {
+                            self_.internalResolveFlush_ = resolve;
+                        }
+                    });
+                });
+            }
+        """
+
+    flushText(data: String) {
+        self.writeText(data)
+        self.flush()
+    }
+
+    flushBuffer(data: Buffer) {
+        self.writeBuffer(data)
+        self.flush()
+    }
+
+    flushStream(data: Stream[Buffer]) {
+        data.each {self.flushBuffer(_)}
+    }
+
+}
+
+extend self: WebRequest[WebResponse] {
+    
+    readText(encoding: String = "utf8"): String {
+        self.readStream(1073741823).toString(encoding)
+    }
+    
+    readBuffer(): Buffer {
+        self.readStream(1073741823).toBuffer()
+    }
+    
+    readStream(maxPendingBytes: Int = 65536): Stream[Buffer]
+        target js async """
+            const front = [];
+            const back = [];
+            let pendingBytes = 0
+            let closed = false;
+            let callResolve = null;
+            let callReject = null;
+            self_.internalJsResponse_.onData((chunk, isLast) => {
+                if(closed) return;
+                if(isLast) closed = true; 
+                else chunk = cunk.slice();
+                pendingBytes += chunk.byteLength;
+                back.push(new DataView(chunk));
+                if(pendingBytes >= maxPendingBytes_) self_.internalJsResponse_.pause();
+                if(callResolve) callResolve();
+            });
+            const abort = () => {
+                $task.controller.signal.removeEventListener('abort', abort);
+                if(callReject) callReject();
+            }
+            $task.controller.signal.addEventListener('abort', abort);
+            return ff_core_Stream.Stream(
+                async () => {
+                    while(true) {
+                        ff_core_Task.Task_throwIfAborted($task);
+                        if(front.length === 0) {
+                            while(back.length !== 0) front.push(back.pop());
+                        }
+                        if(front.length !== 0) {
+                            const chunk = front.pop();
+                            const paused = pendingBytes >= maxPendingBytes_;
+                            pendingBytes -= chunk.byteLength;
+                            if(!closed && paused && pendingBytes < maxPendingBytes_) self_.internalJsResponse_.unpause();
+                            return ff_core_Option.Some(chunk);
+                        } else if(closed) {
+                            return ff_core_Option.None();
+                        } else {
+                            await new Promise((resolve, reject) => {
+                                callResolve = resolve;
+                                callReject = reject;
+                            });
+                            callResolve = null;
+                            callReject = null;
+                        }
+                    }
+                },
+                async () => {
+                    closed = true;
+                    ff_core_Task.Task_throwIfAborted($task);
+                    if(callResolve) callResolve();
+                }
+            )
+        """
+    
+}
+
+extend self[T]: WebRequest[T] {
+    
+    needsWebSocket(): Bool
+        target js sync """
+            return self_.internalJsContext_ != null;
+        """
+    
+}
+
+extend self: WebRequest[WebResponse] {
+    
+    openWebSocket(): WebSocketConnection
+        target js async """
+            ff_core_Task.Task_throwIfAborted($task);
+            const userData = {};
+            const wrapper = {front: [], back: [], listeners: [], task: $task};
+            const promise = new Promise((resolve, reject) => {
+                const abort = () => {wrapper.webSocket = null; reject()};
+                userData.onOpen = ws => {wrapper.webSocket = ws; resolve(wrapper)};
+                userData.onClose = () => {
+                    $task.controller.signal.removeEventListener('abort', abort);
+                    abort();
+                    for(let i = 0; i < wrapper.listeners.length; i++) wrapper.listeners[i]();
+                    wrapper.listeners.length = 0;
+                };
+                userData.onMessage = (message, isBinary) => {
+                    wrapper.back.push(isBinary ? new DataView(message) : new TextDecoder().decode(message));
+                    for(let i = 0; i < wrapper.listeners.length; i++) wrapper.listeners[i]();
+                    wrapper.listeners.length = 0;
+                };
+                $task.controller.signal.addEventListener('abort', abort);
+            });
+            self_.internalJsResponse_.cork(() => {
+                ff_core_Task.Task_throwIfAborted($task);
+                self_.internalJsResponse_.upgrade(
+                    userData, 
+                    self_.internalHeaders_.get('sec-websocket-key'),
+                    self_.internalHeaders_.get('sec-websocket-protocol'),
+                    self_.internalHeaders_.get('sec-websocket-extensions'),
+                    self_.internalJsContext_
+                )
+            });
+            return await promise;
+        """
+
+}
+
+extend self: WebSocketConnection {
+    
+    readText(encoding: String = "utf8"): Option[String] {
+        self.readAny {_} {_.toString(encoding)}
+    }
+
+    readBuffer(): Option[Buffer] {
+        self.readAny {_.toBuffer()} {_}
+    }
+    
+    readAny[T](fromText: String => T, fromBuffer: Buffer => T): Option[T]
+        target node async """
+            ff_core_Task.Task_throwIfAborted($task);
+            while(self_.front.length === 0) {
+                while(self_.back.length !== 0) {
+                    self_.front.push(self_.back.pop());
+                }
+                if(self_.front.length !== 0) break;
+                if(self_.webSocket == null) return ff_core_Option.None();
+                let abort = null;
+                try {
+                    await new Promise((resolve, reject) => {
+                        self_.listeners.push(resolve);
+                        if($task !== self_.task) {
+                            abort = () => {
+                                self_.listeners = self_.listeners.filter(l => l != resolve);
+                                reject();
+                            };
+                            $task.controller.signal.addEventListener('abort', abort);
+                        }
+                    });
+                } finally {
+                    if($task !== self_.task) {
+                        $task.controller.signal.removeEventListener('abort', abort);
+                    }
+                }
+            }
+            const data = self_.front.pop();
+            if(typeof data === 'string') return ff_core_Option.Some(await fromText_(data));
+            return ff_core_Option.Some(await fromBuffer_(data));
+        """
+        
+    readStream(): Stream[Buffer] {
+        Stream {self.readBuffer()} {self.close()}
+    }
+    
+    writeBuffer(message: Buffer)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.send(message_.buffer, true) !== 2, $task);
+        """
+    
+    writeText(message: String)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.send(message_, false) !== 2, $task);
+        """
+    
+    publishBuffer(topic: String, message: Buffer)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.publish(topic_, message_.buffer, true), $task);
+        """
+    
+    publishText(topic: String, message: String)
+        target node async """
+            await internalSend_$(self_, () => self_.webSocket.publish(topic_, message_, false), $task);
+        """
+
+    subscribe(topic: String)
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            self_.webSocket.subscribe(topic_);
+        """
+
+    unsubscribe(topic: String)
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            self_.webSocket.unsubscribe(topic_);
+        """
+
+    isSubscribedTo(topic: String): Bool
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            return self_.webSocket.isSubscribed(topic_);
+        """
+        
+    subscriptions(): Array[String]
+        target node async """
+            if(self_.webSocket == null) throw new Error("WebSocket is closed");
+            return self_.webSocket.getTopics();
+        """
+
+    close(): Unit
+        target node async """
+            if(self_.webSocket != null) {
+                self_.webSocket.close();
+                self_.webSocket = null;
+            }
+        """
+
+}
+
+internalSend[T](self: WebSocketConnection, send: () => Bool): JsValue
+    target node async """
+        let abort = null;
+        try {
+            await new Promise((resolve, reject) => {
+                if(self_.webSocket == null) new Error("WebSocket is closed");
+                else self_.webSocket.cork(() => {
+                    if($task !== self_.task) {
+                        abort = () => {
+                            self_.listeners = self_.listeners.filter(l => l != resolve);
+                            reject();
+                        };
+                        $task.controller.signal.addEventListener('abort', abort);
+                    }
+                    if(self_.webSocket == null) {
+                        reject(new Error("WebSocket is closed"));
+                    } else if(!send_()) {
+                        reject(new Error("Dropped message due to backpressure"));
+                    } else {
+                        resolve();
+                    }
+                })
+            });
+        } finally {
+            if($task !== self_.task) {
+                $task.controller.signal.removeEventListener('abort', abort);
+            }
+        }
+    """
+
+internalStack[T](): Stack[T] {
+    Stack.make()
+}
+
+internalTextChunk(data: String): JsValue
+    target js sync """
+        return data_;
+    """
+    
+internalBufferChunk(data: Buffer): JsValue
+    target js sync """
+        return data_;
+    """
+
+internalChunksToChunk(chunks: Stack[JsValue]): JsValue
+    target js sync """
+        const chunks = chunks_.array;
+        if(chunks.length === 0) return;
+        const firstIsString = typeof chunks[0] === 'string';
+        if(firstIsString && chunks.length === 1) return chunks[0];
+        if(firstIsString && chunks.every(c => typeof c === 'string')) {
+            let result = chunks[0];
+            for(let i = 1; i < chunks.length; i++) {
+                result += chunks[i];
+            }
+            return result;
+        }
+        let totalLength = 0;
+        for(let i = 0; i < chunks.length; i++) {
+            if(typeof chunks[i] === 'string') chunks[i] = new TextEncoder().encode(chunks[i]);
+            totalLength += chunks[i].byteLength;
+        }
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for(let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const uint8Array = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+            result.set(uint8Array, offset);
+            offset += chunk.byteLength;
+        }
+        return result;
+    """
+
+parseMultipartFields(data: Buffer, contentType: String): Option[Array[MultipartField]]
+    target js sync """
+        const parts = getParts(data_, contentType_);
+        return parts == null ? ff_core_Option.None() : ff_core_Option.Some(parts);
+    """
+
+extend self: MultipartField {
+    
+    data(): Buffer
+        target js sync """
+            return new DataView(self_.data);
+        """
+
+    name(): String
+        target js sync """
+            return self_.name;
+        """
+
+    type(): Option[String]
+        target js sync """
+            return self_.type == null ? ff_core_Option.None() : ff_core_Option.Some(self_.type);
+        """
+
+    filename(): Option[String]
+        target js sync """
+            return self_.filename == null ? ff_core_Option.None() : ff_core_Option.Some(self_.filename);
+        """
+
+}