93a746aaaa
So here is what has been keeping me up at night: At some point I
realized that nix actually made a somewhat passable language for CGI
programming:
* That `builtins.getEnv` exists as one of the impurities of Nix is
perfect as environment variables are the main way of communication
from the web server to the CGI application.
* We can actually read from the filesystem via builtins.readDir and
builtins.readFile with bearable overhead if we avoid importing the
used paths into the nix store.
* Templating and routing are convenient to implement via indented strings
and attribute sets respectively.
Of course there are obvious limitation:
* The overhead of derivations is probably much to great for them to be
useful via IfD.
* Even without derivations, nix evaluation is very slow to the point
were a trivial application takes between 100ms and 400ms to produce a
response.
* We can't really cause effects other than producing a response which
makes it not viable for a lot of applications. There are some ways
around this:
* With a custom interpreter we could have streaming and multiplexed
I/O (using lazy lists emulated via attrsets) to cause such effects,
but it would probably perform terribly.
* We can use builtins.fetchurl to call other HTTP-based microservices,
but only in very limited constraints, i. e. only GET, no headers,
and only if the tarball ttl is set to 0 in the global nix.conf.
* Terrible error handling capabilities because builtins.tryEval actually
doesn't catch a lot of errors.
To prove that it actually works, there are some demo applications,
which I invite you to run and potentially break horribly:
nix-build -A web.bubblegum.examples && ./result
# navigate to http://localhost:9000
The setup uses thttpd and executes the nix CGI scripts using
users.sterni.nint which automatically passed `depot`, so they can
import the cgi library.
Change-Id: I3a22a749612211627e5f8301c31ec2e7a872812c
Reviewed-on: https://cl.tvl.fyi/c/depot/+/2746
Tested-by: BuildkiteCI
Reviewed-by: tazjin <mail@tazj.in>
68 lines
2 KiB
Markdown
68 lines
2 KiB
Markdown
# //web/bubblegum
|
|
|
|
`bubblegum` is a CGI programming library for the Nix expression language.
|
|
It provides a few helpers to make writing CGI scripts which are executable
|
|
using [//users/sterni/nint](../../users/sterni/nint/README.md) convenient.
|
|
|
|
An example nix.cgi script looks like this (don't worry about the shebang
|
|
too much, you can use `web.bubblegum.writeCGI` to set this up without
|
|
thinking twice):
|
|
|
|
```nix
|
|
#!/usr/bin/env nint --arg depot '(import /path/to/depot {})'
|
|
{ depot, ... }:
|
|
|
|
let
|
|
inherit (depot.web.bubblegum)
|
|
respond
|
|
;
|
|
in
|
|
|
|
respond "OK" {
|
|
"Content-type" = "text/html";
|
|
# further headers…
|
|
} ''
|
|
<!doctype html>
|
|
<html>
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<title>hello world</title>
|
|
</head>
|
|
<body>
|
|
hello world!
|
|
</body>
|
|
</html>
|
|
''
|
|
```
|
|
|
|
As you can see, the core component of `bubblegum` is the `respond`
|
|
function which takes three arguments:
|
|
|
|
* The response status as the textual representation which is also
|
|
returned to the client in the HTTP protocol, e. g. `"OK"`,
|
|
`"Not Found"`, `"Bad Request"`, …
|
|
|
|
* An attribute set mapping header names to header values to be sent.
|
|
|
|
* The response body as a string.
|
|
|
|
Additionally it exposes a few helpers for working with the CGI
|
|
environment like `pathInfo` which is a wrapper around
|
|
`builtins.getEnv "PATH_INFO"`. The documentation for all exposed
|
|
helpers is inlined in [default.nix](./default.nix) (you should be
|
|
able to use `nixdoc` to render it).
|
|
|
|
For deployment purposes it is recommended to use `writeCGI` which
|
|
takes a nix CGI script in the form of a derivation, path or string
|
|
and builds an executable nix CGI script which has the correct shebang
|
|
set and is automatically passed a version of depot from the nix store,
|
|
so the script has access to the `bubblegum` library.
|
|
|
|
For example nix CGI scripts and a working deployment using `thttpd`
|
|
see the [examples directory](./examples). You can also start a local
|
|
server running the examples like this:
|
|
|
|
```
|
|
$ nix-build -A web.bubblegum.examples && ./result
|
|
# navigate to http://localhost:9000
|
|
```
|