firefly-compiler 0.4.31 → 0.4.32

package/httpserver/HttpServer.ff

@@ -1,184 +0,0 @@
-capability HttpRequest {}
-capability HttpResponse {}
-
-listen(system: NodeSystem, host: String, port: Int, handler: (HttpRequest, HttpResponse) => Unit): Unit
-    target node async """
-        import * as http from 'http'
-        ff_core_Task.Task_throwIfAborted($task)
-        const server = http.createServer(async (req, res) => {
-            try {
-                const channel = ff_core_Task.Task_channel($task)
-                ff_core_Task.Task_spawn($task, async task => {
-                    try {
-                        await handler_(req, res, task)
-                    } finally {
-                        await ff_core_Channel.Channel_write$(channel, null, task)
-                    }
-                })
-                await ff_core_Channel.Channel_read$(channel, $task)
-                if(!res.headersSent) res.writeHead(200, 'OK')
-            } finally {
-                if(!res.headersSent) res.writeHead(500, 'Internal Server Error')
-                if(!res.writableEnded) res.end()
-            }
-        })
-        await new Promise((resolve, reject) => {
-            server.listen(port_, host_, error => {if(error != null) reject(error); else resolve()})
-        })
-        await new Promise((resolve, reject) => {
-            const abort = () => {
-                $task.controller.signal.removeEventListener('abort', abort)
-                const reason = $task.controller.signal.reason
-                $task.controller = new AbortController()
-                server.close(() => reject(reason))
-            }
-            $task.controller.signal.addEventListener('abort', abort)
-        })
-    """
-
-
-extend self: HttpRequest {
-
-    method(): String
-        target node async "return self_.method"
-
-    path(): String
-        target node async """
-            let i = self_.url.indexOf('?')
-            return i === -1 ? self_.url : self_.url.slice(0, i)
-        """
-
-    parameters(): Option[String]
-        target node async """
-            let i = self_.url.indexOf('?')
-            return i === -1 ? ff_core_Option.None() : ff_core_Option.Some(self_.url.slice(i + 1))
-        """
-
-    parameter(name: String): Option[String]
-        target node async """
-            let i = self_.url.indexOf('?')
-            if(i === -1) return ff_core_Option.None()
-            let ps = self_.url.slice(i + 1).split('&')
-            let n = name_ + '='
-            let r = ps.find(p => p === name_ || p.startsWith(n))
-            if(r == null) return ff_core_Option.None()
-            return ff_core_Option.Some(r.slice(name_.length + 1))
-        """
-
-    header(name: String): Option[String]
-        target node async """
-            let header = self_.headers[name_.toLowerCase()]
-            if(header == null || header.length == 0) ff_core_Option.None()
-            return ff_core_Option.Some(Array.isArray(header) ? header[0] : header)
-        """
-
-    encoding(): Option[String]
-        target node async """
-            return self_.readableEncoding ? ff_core_Option.Some(self_.readableEncoding) : ff_core_Option.None()
-        """
-
-    readText(encoding: Option[String] = None): String {
-        self.readStream().toString(encoding.else {self.encoding().else {"utf8"}})
-    }
-
-    readBuffer(): Buffer {
-        self.readStream().toBuffer()
-    }
-
-    readStream(): Stream[Buffer]
-        target node async """
-            import * as http from 'http'
-            let task = null
-            let readable = self_
-            let doResolve = null
-            let doReject = null
-            let seenError = null
-            const abort = () => {
-                if(task != null) {
-                    task.controller.signal.removeEventListener('abort', abort)
-                    readable.destroy()
-                }
-            }
-            function open($task) {
-                ff_core_Task.Task_throwIfAborted($task)
-                if(self_.streamWorkaround != null) throw new Error("Can't open HttpRequest body stream twice")
-                task = $task
-                self_.streamWorkaround = true
-                readable.on('readable', () => {
-                    if(doResolve != null) doResolve()
-                })
-                readable.on('error', error => {
-                    task.controller.signal.removeEventListener('abort', abort)
-                    seenError = error
-                    if(doReject != null) doReject(error)
-                })
-                readable.on('close', () => {
-                    task.controller.signal.removeEventListener('abort', abort)
-                    if(doResolve != null) doResolve()
-                })
-                $task.controller.signal.addEventListener('abort', abort)
-            }
-            return ff_core_Stream.Stream(async function go($task) {
-                if(task == null) open($task)
-                let buffer = readable.read()
-                if(buffer != null) return ff_core_Option.Some(buffer)
-                if(seenError != null) throw seenError
-                if(readable.destroyed) return ff_core_Option.None()
-                let promise = new Promise((resolve, reject) => {
-                    doResolve = () => {doResolve = null; doReject = null; resolve()}
-                    doReject = error => {doResolve = null; doReject = null; reject(error)}
-                }).then(() => go($task))
-                return await promise
-            }, abort)
-        """
-
-}
-
-extend self: HttpResponse {
-
-    setHeader(name: String, values: List[String]): Unit
-        target node async "self_.setHeader(name_, ff_core_List.List_toArray(values_))"
-
-    writeStatus(code: Int, message: Option[String]): Unit
-        target node async "self_.writeHead(code_, message_.value_)"
-
-    write(buffer: Buffer): Unit
-        target node async """
-            import * as http from 'http'
-            ff_core_Task.Task_throwIfAborted($task)
-            if(!self_.write(Buffer.from(buffer_.buffer))) {
-                let reject = null;
-                await new Promise((resolve, reject) => {
-                    const abort = () => {
-                        $task.controller.signal.removeEventListener('abort', abort)
-                        reject($task.controller.signal.reason)
-                    }
-                    $task.controller.signal.addEventListener('abort', abort)
-                    self_.once('drain', () => {
-                        $task.controller.signal.removeEventListener('abort', abort)
-                        resolve()
-                    })
-                })
-            }
-        """
-
-    writeText(text: String, encoding: String = "utf8"): Unit
-        target node async """
-            import * as http from 'http'
-            ff_core_Task.Task_throwIfAborted($task)
-            if(!self_.write(text_, encoding_)) {
-                await new Promise((resolve, reject) => {
-                    const abort = () => {
-                        $task.controller.signal.removeEventListener('abort', abort)
-                        reject($task.controller.signal.reason)
-                    }
-                    $task.controller.signal.addEventListener('abort', abort)
-                    self_.once('drain', () => {
-                        $task.controller.signal.removeEventListener('abort', abort)
-                        resolve()
-                    })
-                })
-            }
-        """
-
-}