maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(web/bubblegum): nix CGI programming framework

Browse source 
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>
This commit is contained in:
sterni 2021-02-21 12:57:40 +01:00
parent 68f3ac64c4
commit 93a746aaaa
9 changed files with 586 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

134
web/bubblegum/examples/blog.nix Normal file
View file

@ -0,0 +1,134 @@
{ depot, ... }:
let
inherit (depot)
lib
;
inherit (depot.users.sterni.nix)
url
fun
string
;
inherit (depot.web.bubblegum)
pathInfo
scriptName
respond
absolutePath
;
# substituted using substituteAll in default.nix
blogdir = "@blogdir@";
# blogdir = toString ./posts; # for local testing
parseDate = post:
let
matched = builtins.match "/?([0-9]+)-([0-9]+)-([0-9]+)-.+" post;
in
if matched == null
then [ 0 0 0 ]
else builtins.map builtins.fromJSON matched;
parseTitle = post:
let
matched = builtins.match "/?[0-9]+-[0-9]+-[0-9]+-(.+).html" post;
in
if matched == null
then "no title"
else builtins.head matched;
dateAtLeast = a: b:
builtins.all fun.id
(lib.zipListsWith (partA: partB: partA >= partB) a b);
byPostDate = a: b:
dateAtLeast (parseDate a) (parseDate b);
posts = builtins.sort byPostDate
(builtins.attrNames
(lib.filterAttrs (_: v: v == "regular")
(builtins.readDir blogdir)));
generic = { title, inner, ... }: ''
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>${title}</title>
<style>a:link, a:visited { color: blue; }</style>
</head>
<body>
${inner}
</body>
</html>
'';
index = posts: ''
<main>
<h1>blog posts</h1>
<ul>
'' + lib.concatMapStrings (post: ''
<li>
<a href="${absolutePath (url.encode {} post)}">${parseTitle post}</a>
</li>
'') posts + ''
</ul>
</main>
'';
formatDate =
let
# Assume we never deal with years < 1000
formatDigit = d: string.fit {
char = "0"; width = 2;
} (toString d);
in lib.concatMapStringsSep "-" formatDigit;
post = title: post: ''
<main>
<h1>${title}</h1>
<div id="content">
${builtins.readFile (blogdir + "/" + post)}
</div>
</main>
<footer>
<p>Posted on ${formatDate (parseDate post)}</p>
<nav><a href="${scriptName}">index</a></nav>
</footer>
'';
validatePathInfo = pathInfo:
let
chars = string.toChars pathInfo;
in builtins.length chars > 1
&& !(builtins.elem "/" (builtins.tail chars));
response =
if pathInfo == "/"
then {
title = "blog";
status = "OK";
inner = index posts;
}
else if !(validatePathInfo pathInfo)
then {
title = "Bad Request";
status = "Bad Request";
inner = "No slashes in post names 😡";
}
# CGI should already url.decode for us
else if builtins.pathExists (blogdir + "/" + pathInfo)
then rec {
title = parseTitle pathInfo;
status = "OK";
inner = post title pathInfo;
} else {
title = "Not Found";
status = "Not Found";
inner = "<h1>404 — not found</h1>";
};
in
respond response.status {
"Content-type" = "text/html";
} (generic response)

61
web/bubblegum/examples/default.nix Normal file
View file

@ -0,0 +1,61 @@
{ depot, pkgs, lib, ... }:
let
scripts = [
./hello.nix
./derivation-svg.nix
(substituteAll {
src = ./blog.nix;
# by making this a plain string this
# can be something outside the nix store!
blogdir = ./posts;
})
];
inherit (depot.nix)
writeExecline
runExecline
getBins
;
inherit (depot.web.bubblegum)
writeCGI
;
inherit (pkgs)
runCommandLocal
substituteAll
;
bins = (getBins pkgs.thttpd [ "thttpd" ])
// (getBins pkgs.coreutils [ "printf" "cp" "mkdir" ]);
webRoot =
let
copyScripts = lib.concatMap
(path: let
cgi = writeCGI {
# assume we are on NixOS since thttpd doesn't set PATH.
# using third_party.nix is tricky because not everyone
# has a tvix daemon running.
binPath = "/run/current-system/sw/bin";
} path;
in [
"if" [ bins.cp cgi "\${out}/${cgi.name}" ]
]) scripts;
in runExecline.local "webroot" {} ([
"importas" "out" "out"
"if" [ bins.mkdir "-p" "$out" ]
] ++ copyScripts);
port = 9000;
in
writeExecline "serve-examples" {} [
"foreground" [
bins.printf "%s\n" "Running on http://localhost:${toString port}"
]
"${bins.thttpd}" "-D" "-p" (toString port) "-l" "/dev/stderr"
"-c" "*.nix" "-d" webRoot
]

11
web/bubblegum/examples/derivation-svg.nix Normal file
View file

@ -0,0 +1,11 @@
# Warning: this is *very* slow on the first request
{ depot, ... }:
let
inherit (depot.web.bubblegum)
respond
;
in
respond "OK" {
Content-type = "image/svg+xml";
} (builtins.readFile "${depot.tvix.docs.svg}/component-flow.svg")

80
web/bubblegum/examples/hello.nix Normal file
View file

@ -0,0 +1,80 @@
{ depot, ... }:
let
inherit (depot)
lib
;
inherit (depot.web.bubblegum)
pathInfo
respond
absolutePath
;
routes = {
"/" = {
status = "OK";
title = "index";
content = ''
Hello World!
'';
};
"/clock" = {
status = "OK";
title = "clock";
content = ''
It is ${toString builtins.currentTime}s since 1970-01-01 00:00 UTC.
'';
};
"/coffee" = {
status = "I'm a teapot";
title = "coffee";
content = ''
No coffee, I'm afraid
'';
};
};
notFound = {
status = "Not Found";
title = "404";
content = ''
This page doesn't exist.
'';
};
navigation =
lib.concatStrings (lib.mapAttrsToList
(p: v: "<li><a href=\"${absolutePath p}\">${v.title}</a></li>")
routes);
template = { title, content, ... }: ''
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>${title}</title>
<style>a:link, a:visited { color: blue; }</style>
</head>
<body>
<hgroup>
<h1><code>//web/bubblegum</code></h1>
<h2>example app</h2>
</hgroup>
<header>
<nav>
<ul>${navigation}</ul>
</nav>
</header>
<main>
<p>${content}</p>
</main>
</body>
'';
response = routes."${pathInfo}" or notFound;
in
respond response.status {
"Content-type" = "text/html";
} (template response)

3
web/bubblegum/examples/posts/2021-04-01-hello.html Normal file
View file

@ -0,0 +1,3 @@
<p>
This is it, the peak of cursed.
</p>

7
web/bubblegum/examples/posts/2021-04-02-a second post.html Normal file
View file

@ -0,0 +1,7 @@
<p>
<ul>
<li>✅ sorting</li>
<li>✅ url encoding (admire the spaces!)</li>
<li>✅ classic Nix regex based parsing</li>
</ul>
</p>