git.iko.soy/obelisk
on ae@ova-attribute help sign in
obelisk/default.nix
388 lines 17 kB history raw
1{ system ? builtins.currentSystem
2, profiling ? false
3, iosSdkVersion ? "10.2"
4, config ? {}
5, reflex-platform-func ? import ./dep/reflex-platform
6}:
7let
8 reflex-platform = getReflexPlatform { inherit system; };
9 inherit (reflex-platform) hackGet nixpkgs;
10 pkgs = nixpkgs;
12 inherit (import dep/gitignore.nix { inherit (nixpkgs) lib; }) gitignoreSource;
14 getReflexPlatform = { system, enableLibraryProfiling ? profiling }: reflex-platform-func {
15 inherit iosSdkVersion config system enableLibraryProfiling;
17 nixpkgsOverlays = [
18 (import ./nixpkgs-overlays)
19 ];
21 haskellOverlays = [
22 (import ./haskell-overlays/misc-deps.nix { inherit hackGet; })
23 pkgs.obeliskExecutableConfig.haskellOverlay
24 (import ./haskell-overlays/obelisk.nix)
25 (import ./haskell-overlays/tighten-ob-exes.nix)
26 ];
27 };
29 # The haskell environment used to build Obelisk itself, e.g. the 'ob' command
30 ghcObelisk = reflex-platform.ghc;
32 # Development environments for obelisk packages.
33 ghcObeliskEnvs = pkgs.lib.mapAttrs (n: v: reflex-platform.workOn ghcObelisk v) ghcObelisk;
35 inherit (import ./lib/asset/assets.nix { inherit nixpkgs; }) mkAssets;
37 haskellLib = pkgs.haskell.lib;
39in rec {
40 inherit reflex-platform;
41 inherit (reflex-platform) nixpkgs pinBuildInputs;
42 inherit (nixpkgs) lib;
43 pathGit = ./.; # Used in CI by the migration graph hash algorithm to correctly ignore files.
44 path = reflex-platform.filterGit ./.;
45 obelisk = ghcObelisk;
46 obeliskEnvs = pkgs.lib.filterAttrs (k: _: pkgs.lib.strings.hasPrefix "obelisk-" k) ghcObeliskEnvs;
47 command = ghcObelisk.obelisk-command;
48 shell = pinBuildInputs "obelisk-shell" ([command] ++ command.commandRuntimeDeps);
50 selftest = pkgs.writeScript "selftest" ''
51 #!${pkgs.runtimeShell}
52 set -euo pipefail
54 PATH="${command}/bin:$PATH"
55 cd ${./.}
56 "${ghcObelisk.obelisk-selftest}/bin/obelisk-selftest" +RTS -N -RTS "$@"
57 '';
58 skeleton = pkgs.runCommand "skeleton" {
59 dir = builtins.filterSource (path: type: builtins.trace path (baseNameOf path != ".obelisk")) ./skeleton;
60 } ''
61 ln -s "$dir" "$out"
62 '';
63 nullIfAbsent = p: if lib.pathExists p then p else null;
64 #TODO: Avoid copying files within the nix store. Right now, obelisk-asset-manifest-generate copies files into a big blob so that the android/ios static assets can be imported from there; instead, we should get everything lined up right before turning it into an APK, so that copies, if necessary, only exist temporarily.
65 processAssets = { src, packageName ? "obelisk-generated-static", moduleName ? "Obelisk.Generated.Static" }: pkgs.runCommand "asset-manifest" {
66 inherit src;
67 outputs = [ "out" "haskellManifest" "symlinked" ];
68 nativeBuildInputs = [ ghcObelisk.obelisk-asset-manifest ];
69 } ''
70 set -euo pipefail
71 touch "$out"
72 mkdir -p "$symlinked"
73 obelisk-asset-manifest-generate "$src" "$haskellManifest" ${packageName} ${moduleName} "$symlinked"
74 '';
76 compressedJs = frontend: optimizationLevel: pkgs.runCommand "compressedJs" {} ''
77 mkdir $out
78 cd $out
79 # TODO profiling + static shouldn't break and need an ad-hoc workaround like that
80 ln -s "${haskellLib.justStaticExecutables frontend}/bin/frontend.jsexe/all.js" all.unminified.js
81 ${if optimizationLevel == null then ''
82 ln -s all.unminified.js all.js
83 '' else ''
84 ${pkgs.closurecompiler}/bin/closure-compiler --externs "${reflex-platform.ghcjsExternsJs}" -O ${optimizationLevel} --jscomp_warning=checkVars --create_source_map="all.js.map" --source_map_format=V3 --js_output_file="all.js" all.unminified.js
85 echo "//# sourceMappingURL=all.js.map" >> all.js
86 ''}
87 '';
89 serverModules = {
90 mkBaseEc2 = { nixosPkgs, ... }: {...}: {
91 imports = [
92 (nixosPkgs.path + /nixos/modules/virtualisation/amazon-image.nix)
93 ];
94 ec2.hvm = true;
95 };
97 mkDefaultNetworking = { adminEmail, enableHttps, hostName, routeHost, ... }: {...}: {
98 networking = {
99 inherit hostName;
100 firewall.allowedTCPPorts = if enableHttps then [ 80 443 ] else [ 80 ];
101 };
103 # `amazon-image.nix` already sets these but if the user provides their own module then
104 # forgetting these can cause them to lose access to the server!
105 # https://github.com/NixOS/nixpkgs/blob/fab05f17d15e4e125def4fd4e708d205b41d8d74/nixos/modules/virtualisation/amazon-image.nix#L133-L136
106 services.openssh.enable = true;
107 services.openssh.permitRootLogin = "prohibit-password";
109 security.acme.certs = if enableHttps then {
110 "${routeHost}".email = adminEmail;
111 } else {};
112 };
114 mkObeliskApp =
115 { exe
116 , routeHost
117 , enableHttps
118 , name ? "backend"
119 , user ? name
120 , group ? user
121 , baseUrl ? "/"
122 , internalPort ? 8000
123 , backendArgs ? "--port=${toString internalPort}"
124 , ...
125 }: {...}: {
126 services.nginx = {
127 enable = true;
128 virtualHosts."${routeHost}" = {
129 enableACME = enableHttps;
130 forceSSL = enableHttps;
131 locations.${baseUrl} = {
132 proxyPass = "http://127.0.0.1:" + toString internalPort;
133 proxyWebsockets = true;
134 };
135 };
136 };
137 systemd.services.${name} = {
138 wantedBy = [ "multi-user.target" ];
139 after = [ "network.target" ];
140 restartIfChanged = true;
141 path = [ pkgs.gnutar ];
142 script = ''
143 ln -sft . '${exe}'/*
144 mkdir -p log
145 exec ./backend ${backendArgs} </dev/null
146 '';
147 serviceConfig = {
148 User = user;
149 KillMode = "process";
150 WorkingDirectory = "~";
151 Restart = "always";
152 RestartSec = 5;
153 };
154 };
155 users = {
156 users.${user} = {
157 description = "${user} service";
158 home = "/var/lib/${user}";
159 createHome = true;
160 isSystemUser = true;
161 group = group;
162 };
163 groups.${group} = {};
164 };
165 };
166 };
168 inherit mkAssets;
170 serverExe = { backend, frontend, assets, optimizationLevel, version, bundledConfig }:
171 pkgs.runCommand "serverExe" {} ''
172 mkdir $out
173 set -eux
174 ln -s "${if profiling then backend else haskellLib.justStaticExecutables backend}"/bin/* $out/
175 ln -s "${mkAssets assets}" $out/static.assets
176 ln -s ${mkAssets (compressedJs frontend optimizationLevel)} $out/frontend.jsexe.assets
177 ${pkgs.lib.optionalString (bundledConfig != null) "ln -s ${bundledConfig} $out/config"}
178 echo ${version} > $out/version
179 '';
181 mkNixOS = imports: import (pkgs.path + /nixos) {
182 system = "x86_64-linux";
183 configuration = { inherit imports; };
184 };
186 serverImports = args: [
187 (serverModules.mkDefaultNetworking args)
188 (serverModules.mkObeliskApp args)
189 ];
191 server = { exe, hostName, adminEmail, routeHost, enableHttps, version, module ? serverModules.mkBaseEc2 }@args:
192 mkNixOS (serverImports args ++ [
193 (module { inherit exe hostName adminEmail routeHost enableHttps version; nixosPkgs = pkgs; })
194 ]);
196 mkVM = { exe, hostName, adminEmail, routeHost, enableHttps, version, module }@args:
197 mkNixOS (serverImports args ++ [
198 (pkgs.path + /nixos/modules/virtualisation/virtualbox-image.nix)
199 (module { inherit exe hostName adminEmail routeHost enableHttps version; nixosPkgs = pkgs; })
200 ]);
202 # An Obelisk project is a reflex-platform project with a predefined layout and role for each component
203 project = base': projectDefinition:
204 let
205 projectOut = { system, enableLibraryProfiling ? profiling }: let reflexPlatformProject = (getReflexPlatform { inherit system enableLibraryProfiling; }).project; in reflexPlatformProject (args@{ nixpkgs, ... }:
206 let
207 inherit (lib.strings) hasPrefix;
208 mkProject =
209 { android ? null #TODO: Better error when missing
210 , ios ? null #TODO: Better error when missing
211 , packages ? {}
212 , overrides ? _: _: {}
213 , staticFiles ? null
214 , tools ? _: []
215 , shellToolOverrides ? _: _: {}
216 , withHoogle ? false # Setting this to `true` makes shell reloading far slower
217 , __closureCompilerOptimizationLevel ? "ADVANCED" # Set this to `null` to skip the closure-compiler step
218 , __withGhcide ? false
219 }:
220 let
221 allConfig = nixpkgs.lib.makeExtensible (self: {
222 base = base';
223 inherit args;
224 userSettings = {
225 inherit android ios packages overrides tools shellToolOverrides withHoogle __closureCompilerOptimizationLevel __withGhcide;
226 staticFiles = if staticFiles == null then self.base + /static else staticFiles;
227 };
228 frontendName = "frontend";
229 backendName = "backend";
230 commonName = "common";
231 staticName = "obelisk-generated-static";
232 staticFilesImpure = let fs = self.userSettings.staticFiles; in if lib.isDerivation fs then fs else toString fs;
233 processedStatic = processAssets { src = self.userSettings.staticFiles; };
234 # The packages whose names and roles are defined by this package
235 predefinedPackages = lib.filterAttrs (_: x: x != null) {
236 ${self.frontendName} = nullIfAbsent (self.base + "/frontend");
237 ${self.commonName} = nullIfAbsent (self.base + "/common");
238 ${self.backendName} = nullIfAbsent (self.base + "/backend");
239 };
240 shellPackages = {};
241 combinedPackages = self.predefinedPackages // self.userSettings.packages // self.shellPackages;
242 projectOverrides = self': super': {
243 ${self.staticName} = haskellLib.dontHaddock (self'.callCabal2nix self.staticName self.processedStatic.haskellManifest {});
244 ${self.backendName} = haskellLib.addBuildDepend super'.${self.backendName} self'.obelisk-run;
245 };
246 totalOverrides = lib.composeExtensions self.projectOverrides self.userSettings.overrides;
247 privateConfigDirs = ["config/backend"];
248 injectableConfig = builtins.filterSource (path: _:
249 !(lib.lists.any (x: hasPrefix (toString self.base + "/" + toString x) (toString path)) self.privateConfigDirs)
250 );
251 __androidWithConfig = configPath: {
252 ${if self.userSettings.android == null then null else self.frontendName} = {
253 executableName = "frontend";
254 ${if builtins.pathExists self.userSettings.staticFiles then "assets" else null} =
255 nixpkgs.obeliskExecutableConfig.platforms.android.inject
256 (self.injectableConfig configPath)
257 self.processedStatic.symlinked;
258 } // self.userSettings.android;
259 };
260 __iosWithConfig = configPath: {
261 ${if self.userSettings.ios == null then null else self.frontendName} = {
262 executableName = "frontend";
263 ${if builtins.pathExists self.userSettings.staticFiles then "staticSrc" else null} =
264 nixpkgs.obeliskExecutableConfig.platforms.ios.inject
265 (self.injectableConfig configPath)
266 self.processedStatic.symlinked;
267 } // self.userSettings.ios;
268 };
270 shells-ghc = builtins.attrNames (self.predefinedPackages // self.shellPackages);
272 shells-ghcjs = [
273 self.frontendName
274 self.commonName
275 ];
277 shells-ghcSavedSplices = [
278 self.commonName
279 self.frontendName
280 ];
282 shellToolOverrides = lib.composeExtensions
283 self.userSettings.shellToolOverrides
284 (if self.userSettings.__withGhcide
285 then (import ./haskell-overlays/ghcide.nix)
286 else (_: _: {})
287 );
289 project = reflexPlatformProject ({...}: self.projectConfig);
290 projectConfig = {
291 inherit (self) shellToolOverrides;
292 inherit (self.userSettings) tools withHoogle;
293 overrides = self.totalOverrides;
294 packages = self.combinedPackages;
295 shells = {
296 ${if self.userSettings.android == null && self.userSettings.ios == null then null else "ghcSavedSplices"} =
297 lib.filter (x: lib.hasAttr x self.combinedPackages) self.shells-ghcSavedSplices;
298 ghc = lib.filter (x: lib.hasAttr x self.combinedPackages) self.shells-ghc;
299 ghcjs = lib.filter (x: lib.hasAttr x self.combinedPackages) self.shells-ghcjs;
300 };
301 android = self.__androidWithConfig (self.base + "/config");
302 ios = self.__iosWithConfig (self.base + "/config");
304 passthru = {
305 __unstable__.self = allConfig;
306 inherit (self)
307 staticFilesImpure processedStatic
308 __iosWithConfig __androidWithConfig
309 ;
310 inherit (self.userSettings)
311 android ios overrides packages shellToolOverrides staticFiles tools withHoogle
312 __closureCompilerOptimizationLevel
313 ;
314 };
315 };
316 });
317 in allConfig;
318 in (mkProject (projectDefinition args)).projectConfig);
319 mainProjectOut = projectOut { inherit system; };
320 serverOn = { projectInst, bundledConfig ? null, version } : serverExe {
321 inherit bundledConfig version;
322 inherit (projectInst.ghc) backend;
323 inherit (mainProjectOut.ghcjs) frontend;
324 assets = projectInst.passthru.staticFiles;
325 optimizationLevel = projectInst.passthru.__closureCompilerOptimizationLevel;
326 };
327 linuxExe = version: serverOn {
328 inherit version;
329 projectInst = projectOut { system = "x86_64-linux"; };
330 };
331 ovaExe = version: serverOn {
332 inherit version;
333 projectInst = projectOut { system = "x86_64-linux"; };
334 bundledConfig = base' + /config;
335 };
336 dummyVersion = "Version number is only available for deployments";
337 vm = args@{ hostName, adminEmail, routeHost, enableHttps, version, module ? (_:_:{}) }:
338 mkVM (args // { inherit module; exe = ovaExe version; });
340 in mainProjectOut // {
341 __unstable__ = {
342 inherit vm;
343 ova = args@{ hostName, adminEmail, routeHost, enableHttps, version, module ? (_: _: {}) }:
344 (vm args).config.system.build.virtualBoxOVA;
345 profiledObRun = let
346 profiled = projectOut { inherit system; enableLibraryProfiling = true; };
347 exeSource = builtins.toFile "ob-run.hs" ''
348 module Main where
350 import Control.Exception
351 import Reflex.Profiled
352 import System.Environment
354 import qualified Obelisk.Run
355 import qualified Frontend
356 import qualified Backend
358 main :: IO ()
359 main = do
360 args <- getArgs
361 let port = read $ args !! 0
362 assets = args !! 1
363 profileFile = (args !! 2) <> ".rprof"
364 Obelisk.Run.run port (Obelisk.Run.runServeAsset assets) Backend.backend Frontend.frontend `finally` writeProfilingData profileFile
365 '';
366 in nixpkgs.runCommand "ob-run" {
367 buildInputs = [ (profiled.ghc.ghcWithPackages (p: [ p.backend p.frontend])) ];
368 } ''
369 cp ${exeSource} $PWD/ob-run.hs
370 mkdir -p $out/bin/
371 ghc -x hs -prof -fno-prof-auto -threaded ob-run.hs -o $out/bin/ob-run
372 '';
373 };
375 linuxExeConfigurable = linuxExe;
376 linuxExe = linuxExe dummyVersion;
377 exe = serverOn {
378 projectInst = mainProjectOut;
379 version = dummyVersion;
380 };
381 server = args@{ hostName, adminEmail, routeHost, enableHttps, version, module ? serverModules.mkBaseEc2 }:
382 server (args // { exe = linuxExe version; });
383 obelisk = import (base' + "/.obelisk/impl") {};
384 };
385 haskellPackageSets = {
386 inherit (reflex-platform) ghc ghcjs;
387 };