| | 1 | { config, lib, name, ... }: |
| | 2 | with lib; |
| | 3 | with types; |
| | 4 | with lists; |
| | 5 | let |
| | 6 | ldapOptions = { |
| | 7 | base = mkOption { description = "Base of the LDAP tree"; type = str; }; |
| | 8 | host = mkOption { description = "Host to access LDAP"; type = str; }; |
| | 9 | root_dn = mkOption { description = "DN of the root user"; type = str; }; |
| | 10 | root_pw = mkOption { description = "Hashed password of the root user"; type = str; }; |
| | 11 | replication_dn = mkOption { description = "DN of the user allowed to replicate the LDAP directory"; type = str; }; |
| | 12 | replication_pw = mkOption { description = "Password of the user allowed to replicate the LDAP directory"; type = str; }; |
| | 13 | }; |
| | 14 | mkLdapOptions = name: more: mkOption { |
| | 15 | description = "${name} LDAP configuration"; |
| | 16 | type = submodule { |
| | 17 | options = ldapOptions // { |
| | 18 | dn = mkOption { description = "DN of the ${name} user"; type = str; }; |
| | 19 | password = mkOption { description = "password of the ${name} user"; type = str; }; |
| | 20 | filter = mkOption { description = "Filter for ${name} users"; type = str; default = ""; }; |
| | 21 | } // more; |
| | 22 | }; |
| | 23 | }; |
| | 24 | mysqlOptions = { |
| | 25 | host = mkOption { description = "Host to access Mysql"; type = str; }; |
| | 26 | remoteHost = mkOption { description = "Host to access Mysql from outside"; type = str; }; |
| | 27 | port = mkOption { description = "Port to access Mysql"; type = str; }; |
| | 28 | socket = mkOption { description = "Socket to access Mysql"; type = path; }; |
| | 29 | systemUsers = mkOption { |
| | 30 | description = "Attrs of user-passwords allowed to access mysql"; |
| | 31 | type = attrsOf str; |
| | 32 | }; |
| | 33 | pam = mkOption { |
| | 34 | description = "PAM configuration for mysql"; |
| | 35 | type = submodule { |
| | 36 | options = { |
| | 37 | dn = mkOption { description = "DN to connect as to check users"; type = str; }; |
| | 38 | password = mkOption { description = "DN password to connect as to check users"; type = str; }; |
| | 39 | filter = mkOption { description = "filter to match users"; type = str; }; |
| | 40 | }; |
| | 41 | }; |
| | 42 | }; |
| | 43 | }; |
| | 44 | mkMysqlOptions = name: more: mkOption { |
| | 45 | description = "${name} mysql configuration"; |
| | 46 | type = submodule { |
| | 47 | options = mysqlOptions // { |
| | 48 | database = mkOption { description = "${name} database"; type = str; }; |
| | 49 | user = mkOption { description = "${name} user"; type = str; }; |
| | 50 | password = mkOption { description = "mysql password of the ${name} user"; type = str; }; |
| | 51 | } // more; |
| | 52 | }; |
| | 53 | }; |
| | 54 | psqlOptions = { |
| | 55 | host = mkOption { description = "Host to access Postgresql"; type = str; }; |
| | 56 | port = mkOption { description = "Port to access Postgresql"; type = str; }; |
| | 57 | socket = mkOption { description = "Socket to access Postgresql"; type = path; }; |
| | 58 | pam = mkOption { |
| | 59 | description = "PAM configuration for psql"; |
| | 60 | type = submodule { |
| | 61 | options = { |
| | 62 | dn = mkOption { description = "DN to connect as to check users"; type = str; }; |
| | 63 | password = mkOption { description = "DN password to connect as to check users"; type = str; }; |
| | 64 | filter = mkOption { description = "filter to match users"; type = str; }; |
| | 65 | }; |
| | 66 | }; |
| | 67 | }; |
| | 68 | }; |
| | 69 | mkPsqlOptions = name: mkOption { |
| | 70 | description = "${name} psql configuration"; |
| | 71 | type = submodule { |
| | 72 | options = psqlOptions // { |
| | 73 | database = mkOption { description = "${name} database"; type = str; }; |
| | 74 | schema = mkOption { description = "${name} schema"; type = nullOr str; default = null; }; |
| | 75 | user = mkOption { description = "${name} user"; type = str; }; |
| | 76 | password = mkOption { description = "psql password of the ${name} user"; type = str; }; |
| | 77 | }; |
| | 78 | }; |
| | 79 | }; |
| | 80 | redisOptions = { |
| | 81 | host = mkOption { description = "Host to access Redis"; type = str; }; |
| | 82 | port = mkOption { description = "Port to access Redis"; type = str; }; |
| | 83 | socket = mkOption { description = "Socket to access Redis"; type = path; }; |
| | 84 | dbs = mkOption { |
| | 85 | description = "Attrs of db number. Each number should be unique to avoid collision!"; |
| | 86 | type = attrsOf str; |
| | 87 | }; |
| | 88 | spiped_key = mkOption { |
| | 89 | type = str; |
| | 90 | description = '' |
| | 91 | Key to use with spiped to make a secure channel to replication |
| | 92 | ''; |
| | 93 | }; |
| | 94 | predixy = mkOption { |
| | 95 | description = "Predixy configuration. Unused yet"; |
| | 96 | type = submodule { |
| | 97 | options = { |
| | 98 | read = mkOption { type = str; description = "Read password"; }; |
| | 99 | }; |
| | 100 | }; |
| | 101 | }; |
| | 102 | }; |
| | 103 | mkRedisOptions = name: mkOption { |
| | 104 | description = "${name} redis configuration"; |
| | 105 | type = submodule { |
| | 106 | options = redisOptions // { |
| | 107 | db = mkOption { description = "${name} database"; type = str; }; |
| | 108 | }; |
| | 109 | }; |
| | 110 | }; |
| | 111 | hostEnv = submodule { |
| | 112 | options = { |
| | 113 | fqdn = mkOption { |
| | 114 | description = "Host FQDN"; |
| | 115 | type = str; |
| | 116 | }; |
| | 117 | users = mkOption { |
| | 118 | type = unspecified; |
| | 119 | default = pkgs: []; |
| | 120 | description = '' |
| | 121 | Sublist of users from realUsers. Function that takes pkgs as |
| | 122 | argument and gives an array as a result |
| | 123 | ''; |
| | 124 | }; |
| | 125 | emails = mkOption { |
| | 126 | default = []; |
| | 127 | description = "List of e-mails that the server can be a sender of"; |
| | 128 | type = listOf str; |
| | 129 | }; |
| | 130 | ldap = mkOption { |
| | 131 | description = '' |
| | 132 | LDAP credentials for the host |
| | 133 | ''; |
| | 134 | type = submodule { |
| | 135 | options = { |
| | 136 | password = mkOption { type = str; description = "Password for the LDAP connection"; }; |
| | 137 | dn = mkOption { type = str; description = "DN for the LDAP connection"; }; |
| | 138 | }; |
| | 139 | }; |
| | 140 | }; |
| | 141 | mx = mkOption { |
| | 142 | description = "subdomain and priority for MX server"; |
| | 143 | default = { enable = false; }; |
| | 144 | type = submodule { |
| | 145 | options = { |
| | 146 | enable = mkEnableOption "Enable MX"; |
| | 147 | subdomain = mkOption { type = nullOr str; description = "Subdomain name (mx-*)"; }; |
| | 148 | priority = mkOption { type = nullOr str; description = "Priority"; }; |
| | 149 | }; |
| | 150 | }; |
| | 151 | }; |
| | 152 | ips = mkOption { |
| | 153 | description = '' |
| | 154 | attrs of ip4/ip6 grouped by section |
| | 155 | ''; |
| | 156 | type = attrsOf (submodule { |
| | 157 | options = { |
| | 158 | ip4 = mkOption { |
| | 159 | type = str; |
| | 160 | description = '' |
| | 161 | ip4 address of the host |
| | 162 | ''; |
| | 163 | }; |
| | 164 | ip6 = mkOption { |
| | 165 | type = listOf str; |
| | 166 | default = []; |
| | 167 | description = '' |
| | 168 | ip6 addresses of the host |
| | 169 | ''; |
| | 170 | }; |
| | 171 | }; |
| | 172 | }); |
| | 173 | }; |
| | 174 | }; |
| | 175 | }; |
| | 176 | in |
| | 177 | { |
| | 178 | options.myEnv = { |
| | 179 | servers = mkOption { |
| | 180 | description = '' |
| | 181 | Attrs of servers information in the cluster (not necessarily handled by nixops) |
| | 182 | ''; |
| | 183 | default = {}; |
| | 184 | type = attrsOf hostEnv; |
| | 185 | }; |
| | 186 | hetznerCloud = mkOption { |
| | 187 | description = '' |
| | 188 | Hetzner Cloud credential information |
| | 189 | ''; |
| | 190 | type = submodule { |
| | 191 | options = { |
| | 192 | authToken = mkOption { |
| | 193 | type = str; |
| | 194 | description = '' |
| | 195 | The API auth token. |
| | 196 | ''; |
| | 197 | }; |
| | 198 | }; |
| | 199 | }; |
| | 200 | }; |
| | 201 | hetzner = mkOption { |
| | 202 | description = '' |
| | 203 | Hetzner credential information |
| | 204 | ''; |
| | 205 | type = submodule { |
| | 206 | options = { |
| | 207 | user = mkOption { type = str; description = "User"; }; |
| | 208 | pass = mkOption { type = str; description = "Password"; }; |
| | 209 | }; |
| | 210 | }; |
| | 211 | }; |
| | 212 | sshd = mkOption { |
| | 213 | description = '' |
| | 214 | sshd service credential information |
| | 215 | ''; |
| | 216 | type = submodule { |
| | 217 | options = { |
| | 218 | ldap = mkOption { |
| | 219 | description = '' |
| | 220 | LDAP credentials for cn=ssh,ou=services,dc=immae,dc=eu dn |
| | 221 | ''; |
| | 222 | type = submodule { |
| | 223 | options = { |
| | 224 | password = mkOption { description = "Password"; type = str; }; |
| | 225 | }; |
| | 226 | }; |
| | 227 | }; |
| | 228 | }; |
| | 229 | }; |
| | 230 | }; |
| | 231 | ports = mkOption { |
| | 232 | description = '' |
| | 233 | non-standard reserved ports. Must be unique! |
| | 234 | ''; |
| | 235 | type = attrsOf port; |
| | 236 | default = {}; |
| | 237 | apply = let |
| | 238 | noDupl = x: builtins.length (builtins.attrValues x) == builtins.length (unique (builtins.attrValues x)); |
| | 239 | in |
| | 240 | x: if isAttrs x && noDupl x then x else throw "Non unique values for ports"; |
| | 241 | }; |
| | 242 | httpd = mkOption { |
| | 243 | description = '' |
| | 244 | httpd service credential information |
| | 245 | ''; |
| | 246 | type = submodule { |
| | 247 | options = { |
| | 248 | ldap = mkOption { |
| | 249 | description = '' |
| | 250 | LDAP credentials for cn=httpd,ou=services,dc=immae,dc=eu dn |
| | 251 | ''; |
| | 252 | type = submodule { |
| | 253 | options = { |
| | 254 | password = mkOption { description = "Password"; type = str; }; |
| | 255 | }; |
| | 256 | }; |
| | 257 | }; |
| | 258 | }; |
| | 259 | }; |
| | 260 | }; |
| | 261 | ldap = mkOption { |
| | 262 | description = '' |
| | 263 | LDAP server configuration |
| | 264 | ''; |
| | 265 | type = submodule { |
| | 266 | options = ldapOptions; |
| | 267 | }; |
| | 268 | }; |
| | 269 | databases = mkOption { |
| | 270 | description = "Databases configuration"; |
| | 271 | type = submodule { |
| | 272 | options = { |
| | 273 | mysql = mkOption { |
| | 274 | type = submodule { options = mysqlOptions; }; |
| | 275 | description = "Mysql configuration"; |
| | 276 | }; |
| | 277 | redis = mkOption { |
| | 278 | type = submodule { options = redisOptions; }; |
| | 279 | description = "Redis configuration"; |
| | 280 | }; |
| | 281 | postgresql = mkOption { |
| | 282 | type = submodule { options = psqlOptions; }; |
| | 283 | description = "Postgresql configuration"; |
| | 284 | }; |
| | 285 | }; |
| | 286 | }; |
| | 287 | }; |
| | 288 | jabber = mkOption { |
| | 289 | description = "Jabber configuration"; |
| | 290 | type = submodule { |
| | 291 | options = { |
| | 292 | postfix_user_filter = mkOption { type = str; description = "Postfix filter to get xmpp users"; }; |
| | 293 | ldap = mkLdapOptions "Jabber" {}; |
| | 294 | postgresql = mkPsqlOptions "Jabber"; |
| | 295 | }; |
| | 296 | }; |
| | 297 | }; |
| | 298 | realUsers = mkOption { |
| | 299 | description = '' |
| | 300 | Attrset of function taking pkgs as argument. |
| | 301 | Real users settings, should provide a subattr of users.users.<name> |
| | 302 | with at least: name, (hashed)Password, shell |
| | 303 | ''; |
| | 304 | type = attrsOf unspecified; |
| | 305 | }; |
| | 306 | users = mkOption { |
| | 307 | description = "System and regular users uid/gid"; |
| | 308 | type = attrsOf (submodule { |
| | 309 | options = { |
| | 310 | uid = mkOption { |
| | 311 | description = "user uid"; |
| | 312 | type = int; |
| | 313 | }; |
| | 314 | gid = mkOption { |
| | 315 | description = "user gid"; |
| | 316 | type = int; |
| | 317 | }; |
| | 318 | }; |
| | 319 | }); |
| | 320 | }; |
| | 321 | dns = mkOption { |
| | 322 | description = "DNS configuration"; |
| | 323 | type = submodule { |
| | 324 | options = { |
| | 325 | soa = mkOption { |
| | 326 | description = "SOA information"; |
| | 327 | type = submodule { |
| | 328 | options = { |
| | 329 | serial = mkOption { |
| | 330 | description = "Serial number. Should be incremented at each change and unique"; |
| | 331 | type = str; |
| | 332 | }; |
| | 333 | refresh = mkOption { |
| | 334 | description = "Refresh time"; |
| | 335 | type = str; |
| | 336 | }; |
| | 337 | retry = mkOption { |
| | 338 | description = "Retry time"; |
| | 339 | type = str; |
| | 340 | }; |
| | 341 | expire = mkOption { |
| | 342 | description = "Expire time"; |
| | 343 | type = str; |
| | 344 | }; |
| | 345 | ttl = mkOption { |
| | 346 | description = "Default TTL time"; |
| | 347 | type = str; |
| | 348 | }; |
| | 349 | email = mkOption { |
| | 350 | description = "hostmaster e-mail"; |
| | 351 | type = str; |
| | 352 | }; |
| | 353 | primary = mkOption { |
| | 354 | description = "Primary NS"; |
| | 355 | type = str; |
| | 356 | }; |
| | 357 | }; |
| | 358 | }; |
| | 359 | }; |
| | 360 | ns = mkOption { |
| | 361 | description = "Attrs of NS servers group"; |
| | 362 | example = { |
| | 363 | foo = { |
| | 364 | "ns1.foo.com" = [ "198.51.100.10" "2001:db8:abcd::1" ]; |
| | 365 | "ns2.foo.com" = [ "198.51.100.15" "2001:db8:1234::1" ]; |
| | 366 | }; |
| | 367 | }; |
| | 368 | type = attrsOf (attrsOf (listOf str)); |
| | 369 | }; |
| | 370 | slaveZones = mkOption { |
| | 371 | description = "List of slave zones"; |
| | 372 | type = listOf (submodule { |
| | 373 | options = { |
| | 374 | name = mkOption { type = str; description = "zone name"; }; |
| | 375 | masters = mkOption { |
| | 376 | description = "NS master groups of this zone"; |
| | 377 | type = listOf str; |
| | 378 | }; |
| | 379 | }; |
| | 380 | }); |
| | 381 | }; |
| | 382 | masterZones = mkOption { |
| | 383 | description = "List of master zones"; |
| | 384 | type = listOf (submodule { |
| | 385 | options = { |
| | 386 | name = mkOption { type = str; description = "zone name"; }; |
| | 387 | slaves = mkOption { |
| | 388 | description = "NS slave groups of this zone"; |
| | 389 | type = listOf str; |
| | 390 | }; |
| | 391 | ns = mkOption { |
| | 392 | description = "groups names that should have their NS entries listed here"; |
| | 393 | type = listOf str; |
| | 394 | }; |
| | 395 | extra = mkOption { |
| | 396 | description = "Extra zone configuration for bind"; |
| | 397 | example = '' |
| | 398 | notify yes; |
| | 399 | ''; |
| | 400 | type = lines; |
| | 401 | }; |
| | 402 | entries = mkOption { type = lines; description = "Regular entries of the NS zone"; }; |
| | 403 | withEmail = mkOption { |
| | 404 | description = "List of domains that should have mail entries (MX, dkim, SPF, ...)"; |
| | 405 | default = []; |
| | 406 | type = listOf (submodule { |
| | 407 | options = { |
| | 408 | domain = mkOption { type = str; description = "Which subdomain is concerned"; }; |
| | 409 | send = mkOption { type = bool; description = "Whether there can be e-mails originating from the subdomain"; }; |
| | 410 | receive = mkOption { type = bool; description = "Whether there can be e-mails arriving to the subdomain"; }; |
| | 411 | }; |
| | 412 | }); |
| | 413 | }; |
| | 414 | }; |
| | 415 | }); |
| | 416 | }; |
| | 417 | }; |
| | 418 | }; |
| | 419 | }; |
| | 420 | backup = mkOption { |
| | 421 | description = '' |
| | 422 | Remote backup with duplicity |
| | 423 | ''; |
| | 424 | type = submodule { |
| | 425 | options = { |
| | 426 | password = mkOption { type = str; description = "Password for encrypting files"; }; |
| | 427 | remote = mkOption { type = str; description = "Remote url access"; }; |
| | 428 | accessKeyId = mkOption { type = str; description = "Remote access-key"; }; |
| | 429 | secretAccessKey = mkOption { type = str; description = "Remote access secret"; }; |
| | 430 | }; |
| | 431 | }; |
| | 432 | }; |
| | 433 | rsync_backup = mkOption { |
| | 434 | description ='' |
| | 435 | Rsync backup configuration from controlled host |
| | 436 | ''; |
| | 437 | type = submodule { |
| | 438 | options = { |
| | 439 | ssh_key = mkOption { |
| | 440 | description = "SSH key information"; |
| | 441 | type = submodule { |
| | 442 | options = { |
| | 443 | public = mkOption { type = str; description = "Public part of the key"; }; |
| | 444 | private = mkOption { type = lines; description = "Private part of the key"; }; |
| | 445 | }; |
| | 446 | }; |
| | 447 | }; |
| | 448 | profiles = mkOption { |
| | 449 | description = "Attrs of profiles to backup"; |
| | 450 | type = attrsOf (submodule { |
| | 451 | options = { |
| | 452 | keep = mkOption { type = int; description = "Number of backups to keep"; }; |
| | 453 | login = mkOption { type = str; description = "Login to connect to host"; }; |
| | 454 | port = mkOption { type = str; default = "22"; description = "Port to connect to host"; }; |
| | 455 | host = mkOption { type = str; description = "Host to connect to"; }; |
| | 456 | host_key = mkOption { type = str; description = "Host key"; }; |
| | 457 | host_key_type = mkOption { type = str; description = "Host key type"; }; |
| | 458 | parts = mkOption { |
| | 459 | description = "Parts to backup for this host"; |
| | 460 | type = attrsOf (submodule { |
| | 461 | options = { |
| | 462 | remote_folder = mkOption { type = path; description = "Remote folder to backup";}; |
| | 463 | exclude_from = mkOption { |
| | 464 | type = listOf path; |
| | 465 | default = []; |
| | 466 | description = "List of folders/files to exclude from the backup"; |
| | 467 | }; |
| | 468 | files_from = mkOption { |
| | 469 | type = listOf path; |
| | 470 | default = []; |
| | 471 | description = "List of folders/files to backup in the base folder"; |
| | 472 | }; |
| | 473 | args = mkOption { |
| | 474 | type = nullOr str; |
| | 475 | default = null; |
| | 476 | description = "Extra arguments to pass to rsync"; |
| | 477 | }; |
| | 478 | }; |
| | 479 | }); |
| | 480 | }; |
| | 481 | }; |
| | 482 | }); |
| | 483 | }; |
| | 484 | }; |
| | 485 | }; |
| | 486 | }; |
| | 487 | monitoring = mkOption { |
| | 488 | description = "Monitoring configuration"; |
| | 489 | type = submodule { |
| | 490 | options = { |
| | 491 | status_url = mkOption { type = str; description = "URL to push status to"; }; |
| | 492 | status_token = mkOption { type = str; description = "Token for the status url"; }; |
| | 493 | http_user_password = mkOption { type = str; description = "HTTP credentials to check services behind wall"; }; |
| | 494 | email = mkOption { type = str; description = "Admin E-mail"; }; |
| | 495 | ssh_public_key = mkOption { type = str; description = "SSH public key"; }; |
| | 496 | ssh_secret_key = mkOption { type = str; description = "SSH secret key"; }; |
| | 497 | imap_login = mkOption { type = str; description = "IMAP login"; }; |
| | 498 | imap_password = mkOption { type = str; description = "IMAP password"; }; |
| | 499 | eriomem_keys = mkOption { type = listOf (listOf str); description = "Eriomem keys"; default = []; }; |
| | 500 | ovh_sms = mkOption { |
| | 501 | description = "OVH credentials for sms script"; |
| | 502 | type = submodule { |
| | 503 | options = { |
| | 504 | endpoint = mkOption { type = str; default = "ovh-eu"; description = "OVH endpoint"; }; |
| | 505 | application_key = mkOption { type = str; description = "Application key"; }; |
| | 506 | application_secret = mkOption { type = str; description = "Application secret"; }; |
| | 507 | consumer_key = mkOption { type = str; description = "Consumer key"; }; |
| | 508 | account = mkOption { type = str; description = "Account"; }; |
| | 509 | }; |
| | 510 | }; |
| | 511 | }; |
| | 512 | nrdp_tokens = mkOption { type = listOf str; description = "Tokens allowed to push status update"; }; |
| | 513 | slack_url = mkOption { type = str; description = "Slack webhook url to push status update"; }; |
| | 514 | slack_channel = mkOption { type = str; description = "Slack channel to push status update"; }; |
| | 515 | contacts = mkOption { type = attrsOf unspecified; description = "Contact dicts to fill naemon objects"; }; |
| | 516 | email_check = mkOption { |
| | 517 | description = "Emails services to check"; |
| | 518 | type = attrsOf (submodule { |
| | 519 | options = { |
| | 520 | local = mkOption { type = bool; default = false; description = "Use local configuration"; }; |
| | 521 | port = mkOption { type = nullOr str; default = null; description = "Port to connect to ssh"; }; |
| | 522 | login = mkOption { type = nullOr str; default = null; description = "Login to connect to ssh"; }; |
| | 523 | targets = mkOption { type = listOf str; description = "Hosts to send E-mails to"; }; |
| | 524 | mail_address = mkOption { type = nullOr str; default = null; description = "E-mail recipient part to send e-mail to"; }; |
| | 525 | mail_domain = mkOption { type = nullOr str; default = null; description = "E-mail domain part to send e-mail to"; }; |
| | 526 | }; |
| | 527 | }); |
| | 528 | }; |
| | 529 | }; |
| | 530 | }; |
| | 531 | }; |
| | 532 | mpd = mkOption { |
| | 533 | description = "MPD configuration"; |
| | 534 | type = submodule { |
| | 535 | options = { |
| | 536 | folder = mkOption { type = str; description = "Folder to serve from the MPD instance"; }; |
| | 537 | password = mkOption { type = str; description = "Password to connect to the MPD instance"; }; |
| | 538 | host = mkOption { type = str; description = "Host to connect to the MPD instance"; }; |
| | 539 | port = mkOption { type = str; description = "Port to connect to the MPD instance"; }; |
| | 540 | }; |
| | 541 | }; |
| | 542 | }; |
| | 543 | ftp = mkOption { |
| | 544 | description = "FTP configuration"; |
| | 545 | type = submodule { |
| | 546 | options = { |
| | 547 | ldap = mkLdapOptions "FTP" {}; |
| | 548 | }; |
| | 549 | }; |
| | 550 | }; |
| | 551 | vpn = mkOption { |
| | 552 | description = "VPN configuration"; |
| | 553 | type = attrsOf (submodule { |
| | 554 | options = { |
| | 555 | prefix = mkOption { type = str; description = "ipv6 prefix for the vpn subnet"; }; |
| | 556 | privateKey = mkOption { type = str; description = "Private key for the host"; }; |
| | 557 | publicKey = mkOption { type = str; description = "Public key for the host"; }; |
| | 558 | }; |
| | 559 | }); |
| | 560 | }; |
| | 561 | mail = mkOption { |
| | 562 | description = "Mail configuration"; |
| | 563 | type = submodule { |
| | 564 | options = { |
| | 565 | dmarc = mkOption { |
| | 566 | description = "DMARC configuration"; |
| | 567 | type = submodule { |
| | 568 | options = { |
| | 569 | ignore_hosts = mkOption { |
| | 570 | type = lines; |
| | 571 | description = '' |
| | 572 | Hosts to ignore when checking for dmarc |
| | 573 | ''; |
| | 574 | }; |
| | 575 | }; |
| | 576 | }; |
| | 577 | }; |
| | 578 | dkim = mkOption { |
| | 579 | description = "DKIM configuration"; |
| | 580 | type = attrsOf (submodule { |
| | 581 | options = { |
| | 582 | public = mkOption { |
| | 583 | type = str; |
| | 584 | example = '' |
| | 585 | ( "v=DKIM1; k=rsa; " |
| | 586 | "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC3w1a2aMxWw9+hdcmbqX4UevcVqr204y0K73Wdc7MPZiOOlUJQYsMNSYR1Y/SC7jmPKeitpcJCpQgn/cveJZbuikjjPLsDReHyFEYmC278ZLRTELHx6f1IXM8WE08JIRT69CfZiMi1rVcOh9qRT4F93PyjCauU8Y5hJjtg9ThsWwIDAQAB" ) |
| | 587 | ''; |
| | 588 | description = "Public entry to put in DNS TXT field"; |
| | 589 | }; |
| | 590 | private = mkOption { type = str; description = "Private key"; }; |
| | 591 | }; |
| | 592 | }); |
| | 593 | }; |
| | 594 | postfix = mkOption { |
| | 595 | description = "Postfix configuration"; |
| | 596 | type = submodule { |
| | 597 | options = { |
| | 598 | additional_mailbox_domains = mkOption { |
| | 599 | description = '' |
| | 600 | List of domains that are used as mailbox final destination, in addition to those defined in the DNS records |
| | 601 | ''; |
| | 602 | type = listOf str; |
| | 603 | }; |
| | 604 | mysql = mkMysqlOptions "Postfix" { |
| | 605 | password_encrypt = mkOption { type = str; description = "Key to encrypt relay password in database"; }; |
| | 606 | }; |
| | 607 | backup_domains = mkOption { |
| | 608 | description = '' |
| | 609 | Domains that are accepted for relay as backup domain |
| | 610 | ''; |
| | 611 | type = attrsOf (submodule { |
| | 612 | options = { |
| | 613 | domains = mkOption { type = listOf str; description = "Domains list"; }; |
| | 614 | relay_restrictions = mkOption { |
| | 615 | type = lines; |
| | 616 | description = '' |
| | 617 | Restrictions for relaying the e-mails from the domains |
| | 618 | ''; |
| | 619 | }; |
| | 620 | recipient_maps = mkOption { |
| | 621 | description = '' |
| | 622 | Recipient map to accept relay for. |
| | 623 | Must be specified for domain, the rules apply to everyone! |
| | 624 | ''; |
| | 625 | type = listOf (submodule { |
| | 626 | options = { |
| | 627 | type = mkOption { |
| | 628 | type = enum [ "hash" ]; |
| | 629 | description = "Map type"; |
| | 630 | }; |
| | 631 | content = mkOption { |
| | 632 | type = str; |
| | 633 | description = "Map content"; |
| | 634 | }; |
| | 635 | }; |
| | 636 | }); |
| | 637 | }; |
| | 638 | }; |
| | 639 | }); |
| | 640 | }; |
| | 641 | }; |
| | 642 | }; |
| | 643 | }; |
| | 644 | dovecot = mkOption { |
| | 645 | description = "Dovecot configuration"; |
| | 646 | type = submodule { |
| | 647 | options = { |
| | 648 | ldap = mkLdapOptions "Dovecot" { |
| | 649 | pass_attrs = mkOption { type = str; description = "Password attribute in LDAP"; }; |
| | 650 | user_attrs = mkOption { type = str; description = "User attribute mapping in LDAP"; }; |
| | 651 | iterate_attrs = mkOption { type = str; description = "User attribute mapping for listing in LDAP"; }; |
| | 652 | iterate_filter = mkOption { type = str; description = "User attribute filter for listing in LDAP"; }; |
| | 653 | postfix_mailbox_filter = mkOption { type = str; description = "Postfix filter to get mailboxes"; }; |
| | 654 | }; |
| | 655 | }; |
| | 656 | }; |
| | 657 | }; |
| | 658 | rspamd = mkOption { |
| | 659 | description = "rspamd configuration"; |
| | 660 | type = submodule { |
| | 661 | options = { |
| | 662 | redis = mkRedisOptions "Redis"; |
| | 663 | read_password_hashed = mkOption { type = str; description = "Hashed read password for rspamd"; }; |
| | 664 | write_password_hashed = mkOption { type = str; description = "Hashed write password for rspamd"; }; |
| | 665 | read_password = mkOption { |
| | 666 | type = str; |
| | 667 | description = "Read password for rspamd. Unused"; |
| | 668 | apply = x: ""; |
| | 669 | }; |
| | 670 | write_password = mkOption { |
| | 671 | type = str; |
| | 672 | description = "Write password for rspamd. Unused"; |
| | 673 | apply = x: ""; |
| | 674 | }; |
| | 675 | }; |
| | 676 | }; |
| | 677 | }; |
| | 678 | scripts = mkOption { |
| | 679 | description = "Mail script recipients"; |
| | 680 | type = attrsOf (submodule { |
| | 681 | options = { |
| | 682 | external = mkEnableOption "Create a script_<name>@mail.immae.eu external address"; |
| | 683 | src = mkOption { |
| | 684 | description = '' |
| | 685 | git source to fetch the script from. |
| | 686 | It must have a default.nix file as its root accepting a scriptEnv parameter |
| | 687 | ''; |
| | 688 | type = submodule { |
| | 689 | options = { |
| | 690 | url = mkOption { type = str; description = "git url to fetch"; }; |
| | 691 | rev = mkOption { type = str; description = "git reference to fetch"; }; |
| | 692 | }; |
| | 693 | }; |
| | 694 | }; |
| | 695 | env = mkOption { |
| | 696 | description = "Variables to pass to the script"; |
| | 697 | type = unspecified; |
| | 698 | }; |
| | 699 | }; |
| | 700 | }); |
| | 701 | }; |
| | 702 | sympa = mkOption { |
| | 703 | description = "Sympa configuration"; |
| | 704 | type = submodule { |
| | 705 | options = { |
| | 706 | listmasters = mkOption { |
| | 707 | type = listOf str; |
| | 708 | description = "Listmasters"; |
| | 709 | }; |
| | 710 | postgresql = mkPsqlOptions "Sympa"; |
| | 711 | data_sources = mkOption { |
| | 712 | type = attrsOf str; |
| | 713 | default = {}; |
| | 714 | description = "Data sources to make available to sympa"; |
| | 715 | }; |
| | 716 | scenari = mkOption { |
| | 717 | type = attrsOf str; |
| | 718 | default = {}; |
| | 719 | description = "Scenari to make available to sympa"; |
| | 720 | }; |
| | 721 | }; |
| | 722 | }; |
| | 723 | }; |
| | 724 | }; |
| | 725 | }; |
| | 726 | }; |
| | 727 | buildbot = mkOption { |
| | 728 | description = "Buildbot configuration"; |
| | 729 | type = submodule { |
| | 730 | options = { |
| | 731 | user = mkOption { |
| | 732 | description = "Buildbot user"; |
| | 733 | type = submodule { |
| | 734 | options = { |
| | 735 | uid = mkOption { |
| | 736 | description = "user uid"; |
| | 737 | type = int; |
| | 738 | }; |
| | 739 | gid = mkOption { |
| | 740 | description = "user gid"; |
| | 741 | type = int; |
| | 742 | }; |
| | 743 | }; |
| | 744 | }; |
| | 745 | }; |
| | 746 | ldap = mkOption { |
| | 747 | description = "Ldap configuration for buildbot"; |
| | 748 | type = submodule { |
| | 749 | options = { |
| | 750 | password = mkOption { type = str; description = "Buildbot password"; }; |
| | 751 | }; |
| | 752 | }; |
| | 753 | }; |
| | 754 | projects = mkOption { |
| | 755 | description = "Projects to make a buildbot for"; |
| | 756 | type = attrsOf (submodule { |
| | 757 | options = { |
| | 758 | name = mkOption { type = str; description = "Project name"; }; |
| | 759 | packages = mkOption { |
| | 760 | type = unspecified; |
| | 761 | example = literalExample '' |
| | 762 | pkgs: [ pkgs.bash pkgs.git pkgs.gzip pkgs.openssh ]; |
| | 763 | ''; |
| | 764 | description = '' |
| | 765 | Function. |
| | 766 | Builds packages list to make available to buildbot project. |
| | 767 | Takes pkgs as argument. |
| | 768 | ''; |
| | 769 | }; |
| | 770 | pythonPackages = mkOption { |
| | 771 | type = unspecified; |
| | 772 | example = literalExample '' |
| | 773 | p: pkgs: [ pkgs.python3Packages.pip ]; |
| | 774 | ''; |
| | 775 | description = '' |
| | 776 | Function. |
| | 777 | Builds python packages list to make available to buildbot project. |
| | 778 | Takes buildbot python module as first argument and pkgs as second argument in order to augment the python modules list. |
| | 779 | ''; |
| | 780 | }; |
| | 781 | pythonPathHome = mkOption { type = bool; description = "Whether to add project’s python home to python path"; }; |
| | 782 | secrets = mkOption { |
| | 783 | type = attrsOf str; |
| | 784 | description = "Secrets for the project to dump as files"; |
| | 785 | }; |
| | 786 | environment = mkOption { |
| | 787 | type = attrsOf str; |
| | 788 | description = '' |
| | 789 | Environment variables for the project. |
| | 790 | BUILDBOT_ is prefixed to the variable names |
| | 791 | ''; |
| | 792 | }; |
| | 793 | activationScript = mkOption { |
| | 794 | type = lines; |
| | 795 | description = '' |
| | 796 | Activation script to run during deployment |
| | 797 | ''; |
| | 798 | }; |
| | 799 | builderPaths = mkOption { |
| | 800 | type = attrsOf unspecified; |
| | 801 | default = {}; |
| | 802 | description = '' |
| | 803 | Attrs of functions to make accessible specifically per builder. |
| | 804 | Takes pkgs as argument and should return a single path containing binaries. |
| | 805 | This path will be accessible as BUILDBOT_PATH_<attrskey> |
| | 806 | ''; |
| | 807 | }; |
| | 808 | webhookTokens = mkOption { |
| | 809 | type = nullOr (listOf str); |
| | 810 | default = null; |
| | 811 | description = '' |
| | 812 | List of tokens allowed to push to project’s change_hook/base endpoint |
| | 813 | ''; |
| | 814 | }; |
| | 815 | }; |
| | 816 | }); |
| | 817 | }; |
| | 818 | }; |
| | 819 | }; |
| | 820 | }; |
| | 821 | tools = mkOption { |
| | 822 | description = "Tools configurations"; |
| | 823 | type = submodule { |
| | 824 | options = { |
| | 825 | contact = mkOption { type = str; description = "Contact e-mail address"; }; |
| | 826 | davical = mkOption { |
| | 827 | description = "Davical configuration"; |
| | 828 | type = submodule { |
| | 829 | options = { |
| | 830 | postgresql = mkPsqlOptions "Davical"; |
| | 831 | ldap = mkLdapOptions "Davical" {}; |
| | 832 | }; |
| | 833 | }; |
| | 834 | }; |
| | 835 | diaspora = mkOption { |
| | 836 | description = "Diaspora configuration"; |
| | 837 | type = submodule { |
| | 838 | options = { |
| | 839 | postgresql = mkPsqlOptions "Diaspora"; |
| | 840 | redis = mkRedisOptions "Diaspora"; |
| | 841 | ldap = mkLdapOptions "Diaspora" {}; |
| | 842 | secret_token = mkOption { type = str; description = "Secret token"; }; |
| | 843 | }; |
| | 844 | }; |
| | 845 | }; |
| | 846 | dmarc_reports = mkOption { |
| | 847 | description = "DMARC reports configuration"; |
| | 848 | type = submodule { |
| | 849 | options = { |
| | 850 | mysql = mkMysqlOptions "DMARC" {}; |
| | 851 | anonymous_key = mkOption { type = str; description = "Anonymous hashing key"; }; |
| | 852 | }; |
| | 853 | }; |
| | 854 | }; |
| | 855 | etherpad-lite = mkOption { |
| | 856 | description = "Etherpad configuration"; |
| | 857 | type = submodule { |
| | 858 | options = { |
| | 859 | postgresql = mkPsqlOptions "Etherpad"; |
| | 860 | ldap = mkLdapOptions "Etherpad" { |
| | 861 | group_filter = mkOption { type = str; description = "Filter for groups"; }; |
| | 862 | }; |
| | 863 | adminPassword = mkOption { type = str; description = "Admin password for mypads / admin"; }; |
| | 864 | session_key = mkOption { type = str; description = "Session key"; }; |
| | 865 | api_key = mkOption { type = str; description = "API key"; }; |
| | 866 | redirects = mkOption { type = str; description = "Redirects for apache"; }; |
| | 867 | }; |
| | 868 | }; |
| | 869 | }; |
| | 870 | gitolite = mkOption { |
| | 871 | description = "Gitolite configuration"; |
| | 872 | type = submodule { |
| | 873 | options = { |
| | 874 | ldap = mkLdapOptions "Gitolite" {}; |
| | 875 | }; |
| | 876 | }; |
| | 877 | }; |
| | 878 | kanboard = mkOption { |
| | 879 | description = "Kanboard configuration"; |
| | 880 | type = submodule { |
| | 881 | options = { |
| | 882 | postgresql = mkPsqlOptions "Kanboard"; |
| | 883 | ldap = mkLdapOptions "Kanboard" { |
| | 884 | admin_dn = mkOption { type = str; description = "Admin DN"; }; |
| | 885 | }; |
| | 886 | }; |
| | 887 | }; |
| | 888 | }; |
| | 889 | mantisbt = mkOption { |
| | 890 | description = "Mantisbt configuration"; |
| | 891 | type = submodule { |
| | 892 | options = { |
| | 893 | postgresql = mkPsqlOptions "Mantisbt"; |
| | 894 | ldap = mkLdapOptions "Mantisbt" {}; |
| | 895 | master_salt = mkOption { type = str; description = "Master salt for password hash"; }; |
| | 896 | }; |
| | 897 | }; |
| | 898 | }; |
| | 899 | mastodon = mkOption { |
| | 900 | description = "Mastodon configuration"; |
| | 901 | type = submodule { |
| | 902 | options = { |
| | 903 | postgresql = mkPsqlOptions "Mastodon"; |
| | 904 | redis = mkRedisOptions "Mastodon"; |
| | 905 | ldap = mkLdapOptions "Mastodon" {}; |
| | 906 | paperclip_secret = mkOption { type = str; description = "Paperclip secret"; }; |
| | 907 | otp_secret = mkOption { type = str; description = "OTP secret"; }; |
| | 908 | secret_key_base = mkOption { type = str; description = "Secret key base"; }; |
| | 909 | vapid = mkOption { |
| | 910 | description = "vapid key"; |
| | 911 | type = submodule { |
| | 912 | options = { |
| | 913 | private = mkOption { type = str; description = "Private key"; }; |
| | 914 | public = mkOption { type = str; description = "Public key"; }; |
| | 915 | }; |
| | 916 | }; |
| | 917 | }; |
| | 918 | }; |
| | 919 | }; |
| | 920 | }; |
| | 921 | mediagoblin = mkOption { |
| | 922 | description = "Mediagoblin configuration"; |
| | 923 | type = submodule { |
| | 924 | options = { |
| | 925 | postgresql = mkPsqlOptions "Mediagoblin"; |
| | 926 | redis = mkRedisOptions "Mediagoblin"; |
| | 927 | ldap = mkLdapOptions "Mediagoblin" {}; |
| | 928 | }; |
| | 929 | }; |
| | 930 | }; |
| | 931 | nextcloud = mkOption { |
| | 932 | description = "Nextcloud configuration"; |
| | 933 | type = submodule { |
| | 934 | options = { |
| | 935 | postgresql = mkPsqlOptions "Peertube"; |
| | 936 | redis = mkRedisOptions "Peertube"; |
| | 937 | password_salt = mkOption { type = str; description = "Password salt"; }; |
| | 938 | instance_id = mkOption { type = str; description = "Instance ID"; }; |
| | 939 | secret = mkOption { type = str; description = "App secret"; }; |
| | 940 | }; |
| | 941 | }; |
| | 942 | }; |
| | 943 | peertube = mkOption { |
| | 944 | description = "Peertube configuration"; |
| | 945 | type = submodule { |
| | 946 | options = { |
| | 947 | listenPort = mkOption { type = port; description = "Port to listen to"; }; |
| | 948 | postgresql = mkPsqlOptions "Peertube"; |
| | 949 | redis = mkRedisOptions "Peertube"; |
| | 950 | ldap = mkLdapOptions "Peertube" {}; |
| | 951 | }; |
| | 952 | }; |
| | 953 | }; |
| | 954 | syden_peertube = mkOption { |
| | 955 | description = "Peertube Syden configuration"; |
| | 956 | type = submodule { |
| | 957 | options = { |
| | 958 | listenPort = mkOption { type = port; description = "Port to listen to"; }; |
| | 959 | postgresql = mkPsqlOptions "Peertube"; |
| | 960 | redis = mkRedisOptions "Peertube"; |
| | 961 | }; |
| | 962 | }; |
| | 963 | }; |
| | 964 | phpldapadmin = mkOption { |
| | 965 | description = "phpLdapAdmin configuration"; |
| | 966 | type = submodule { |
| | 967 | options = { |
| | 968 | ldap = mkLdapOptions "phpldapadmin" {}; |
| | 969 | }; |
| | 970 | }; |
| | 971 | }; |
| | 972 | rompr = mkOption { |
| | 973 | description = "Rompr configuration"; |
| | 974 | type = submodule { |
| | 975 | options = { |
| | 976 | mpd = mkOption { |
| | 977 | description = "MPD configuration"; |
| | 978 | type = submodule { |
| | 979 | options = { |
| | 980 | host = mkOption { type = str; description = "Host for MPD"; }; |
| | 981 | port = mkOption { type = port; description = "Port to access MPD host"; }; |
| | 982 | }; |
| | 983 | }; |
| | 984 | }; |
| | 985 | }; |
| | 986 | }; |
| | 987 | }; |
| | 988 | roundcubemail = mkOption { |
| | 989 | description = "Roundcubemail configuration"; |
| | 990 | type = submodule { |
| | 991 | options = { |
| | 992 | postgresql = mkPsqlOptions "TT-RSS"; |
| | 993 | secret = mkOption { type = str; description = "Secret"; }; |
| | 994 | }; |
| | 995 | }; |
| | 996 | }; |
| | 997 | shaarli = mkOption { |
| | 998 | description = "Shaarli configuration"; |
| | 999 | type = submodule { |
| | 1000 | options = { |
| | 1001 | ldap = mkLdapOptions "Shaarli" {}; |
| | 1002 | }; |
| | 1003 | }; |
| | 1004 | }; |
| | 1005 | task = mkOption { |
| | 1006 | description = "Taskwarrior configuration"; |
| | 1007 | type = submodule { |
| | 1008 | options = { |
| | 1009 | ldap = mkLdapOptions "Taskwarrior" {}; |
| | 1010 | taskwarrior-web = mkOption { |
| | 1011 | description = "taskwarrior-web profiles"; |
| | 1012 | type = attrsOf (submodule { |
| | 1013 | options = { |
| | 1014 | uid = mkOption { |
| | 1015 | type = listOf str; |
| | 1016 | description = "List of ldap uids having access to this profile"; |
| | 1017 | }; |
| | 1018 | org = mkOption { type = str; description = "Taskd organisation"; }; |
| | 1019 | key = mkOption { type = str; description = "Taskd key"; }; |
| | 1020 | date = mkOption { type = str; description = "Preferred date format"; }; |
| | 1021 | }; |
| | 1022 | }); |
| | 1023 | }; |
| | 1024 | }; |
| | 1025 | }; |
| | 1026 | }; |
| | 1027 | ttrss = mkOption { |
| | 1028 | description = "TT-RSS configuration"; |
| | 1029 | type = submodule { |
| | 1030 | options = { |
| | 1031 | postgresql = mkPsqlOptions "TT-RSS"; |
| | 1032 | ldap = mkLdapOptions "TT-RSS" {}; |
| | 1033 | }; |
| | 1034 | }; |
| | 1035 | }; |
| | 1036 | wallabag = mkOption { |
| | 1037 | description = "Wallabag configuration"; |
| | 1038 | type = submodule { |
| | 1039 | options = { |
| | 1040 | postgresql = mkPsqlOptions "Wallabag"; |
| | 1041 | ldap = mkLdapOptions "Wallabag" { |
| | 1042 | admin_filter = mkOption { type = str; description = "Admin users filter"; }; |
| | 1043 | }; |
| | 1044 | redis = mkRedisOptions "Wallabag"; |
| | 1045 | secret = mkOption { type = str; description = "App secret"; }; |
| | 1046 | }; |
| | 1047 | }; |
| | 1048 | }; |
| | 1049 | webhooks = mkOption { |
| | 1050 | type = attrsOf str; |
| | 1051 | description = "Mapping 'name'.php => script for webhooks"; |
| | 1052 | }; |
| | 1053 | ympd = mkOption { |
| | 1054 | description = "Ympd configuration"; |
| | 1055 | type = submodule { |
| | 1056 | options = { |
| | 1057 | listenPort = mkOption { type = port; description = "Port to listen to"; }; |
| | 1058 | mpd = mkOption { |
| | 1059 | description = "MPD configuration"; |
| | 1060 | type = submodule { |
| | 1061 | options = { |
| | 1062 | password = mkOption { type = str; description = "Password to access MPD host"; }; |
| | 1063 | host = mkOption { type = str; description = "Host for MPD"; }; |
| | 1064 | port = mkOption { type = port; description = "Port to access MPD host"; }; |
| | 1065 | }; |
| | 1066 | }; |
| | 1067 | }; |
| | 1068 | }; |
| | 1069 | }; |
| | 1070 | }; |
| | 1071 | yourls = mkOption { |
| | 1072 | description = "Yourls configuration"; |
| | 1073 | type = submodule { |
| | 1074 | options = { |
| | 1075 | mysql = mkMysqlOptions "Yourls" {}; |
| | 1076 | ldap = mkLdapOptions "Yourls" {}; |
| | 1077 | cookieKey = mkOption { type = str; description = "Cookie key"; }; |
| | 1078 | }; |
| | 1079 | }; |
| | 1080 | }; |
| | 1081 | }; |
| | 1082 | }; |
| | 1083 | }; |
| | 1084 | websites = mkOption { |
| | 1085 | description = "Websites configurations"; |
| | 1086 | type = submodule { |
| | 1087 | options = { |
| | 1088 | immae = mkOption { |
| | 1089 | description = "Immae configuration by environment"; |
| | 1090 | type = submodule { |
| | 1091 | options = { |
| | 1092 | temp = mkOption { |
| | 1093 | description = "Temp configuration"; |
| | 1094 | type = submodule { |
| | 1095 | options = { |
| | 1096 | ldap = mkLdapOptions "Immae temp" { |
| | 1097 | filter = mkOption { type = str; description = "Filter for user access"; }; |
| | 1098 | }; |
| | 1099 | }; |
| | 1100 | }; |
| | 1101 | }; |
| | 1102 | }; |
| | 1103 | }; |
| | 1104 | }; |
| | 1105 | isabelle = mkOption { |
| | 1106 | description = "Isabelle configurations by environment"; |
| | 1107 | type = |
| | 1108 | let |
| | 1109 | atenSubmodule = mkOption { |
| | 1110 | description = "environment configuration"; |
| | 1111 | type = submodule { |
| | 1112 | options = { |
| | 1113 | environment = mkOption { type = str; description = "Symfony environment"; }; |
| | 1114 | secret = mkOption { type = str; description = "Symfony App secret"; }; |
| | 1115 | postgresql = mkPsqlOptions "Aten"; |
| | 1116 | }; |
| | 1117 | }; |
| | 1118 | }; |
| | 1119 | in |
| | 1120 | submodule { |
| | 1121 | options = { |
| | 1122 | aten_production = atenSubmodule; |
| | 1123 | aten_integration = atenSubmodule; |
| | 1124 | iridologie = mkOption { |
| | 1125 | description = "environment configuration"; |
| | 1126 | type = submodule { |
| | 1127 | options = { |
| | 1128 | environment = mkOption { type = str; description = "SPIP environment"; }; |
| | 1129 | mysql = mkMysqlOptions "Iridologie" {}; |
| | 1130 | ldap = mkLdapOptions "Iridologie" {}; |
| | 1131 | }; |
| | 1132 | }; |
| | 1133 | }; |
| | 1134 | }; |
| | 1135 | }; |
| | 1136 | }; |
| | 1137 | chloe = mkOption { |
| | 1138 | description = "Chloe configurations by environment"; |
| | 1139 | type = |
| | 1140 | let |
| | 1141 | chloeSubmodule = mkOption { |
| | 1142 | description = "environment configuration"; |
| | 1143 | type = submodule { |
| | 1144 | options = { |
| | 1145 | environment = mkOption { type = str; description = "SPIP environment"; }; |
| | 1146 | mysql = mkMysqlOptions "Chloe" {}; |
| | 1147 | ldap = mkLdapOptions "Chloe" {}; |
| | 1148 | }; |
| | 1149 | }; |
| | 1150 | }; |
| | 1151 | in |
| | 1152 | submodule { |
| | 1153 | options = { |
| | 1154 | production = chloeSubmodule; |
| | 1155 | integration = chloeSubmodule; |
| | 1156 | }; |
| | 1157 | }; |
| | 1158 | }; |
| | 1159 | connexionswing = mkOption { |
| | 1160 | description = "Connexionswing configurations by environment"; |
| | 1161 | type = |
| | 1162 | let |
| | 1163 | csSubmodule = mkOption { |
| | 1164 | description = "environment configuration"; |
| | 1165 | type = submodule { |
| | 1166 | options = { |
| | 1167 | environment = mkOption { type = str; description = "Symfony environment"; }; |
| | 1168 | mysql = mkMysqlOptions "Connexionswing" {}; |
| | 1169 | secret = mkOption { type = str; description = "Symfony App secret"; }; |
| | 1170 | email = mkOption { type = str; description = "Symfony email notification"; }; |
| | 1171 | }; |
| | 1172 | }; |
| | 1173 | }; |
| | 1174 | in |
| | 1175 | submodule { |
| | 1176 | options = { |
| | 1177 | production = csSubmodule; |
| | 1178 | integration = csSubmodule; |
| | 1179 | }; |
| | 1180 | }; |
| | 1181 | }; |
| | 1182 | jerome = mkOption { |
| | 1183 | description = "Naturaloutil configuration"; |
| | 1184 | type = submodule { |
| | 1185 | options = { |
| | 1186 | mysql = mkMysqlOptions "Naturaloutil" {}; |
| | 1187 | server_admin = mkOption { type = str; description = "Server admin e-mail"; }; |
| | 1188 | }; |
| | 1189 | }; |
| | 1190 | }; |
| | 1191 | telio_tortay = mkOption { |
| | 1192 | description = "Telio Tortay configuration"; |
| | 1193 | type = submodule { |
| | 1194 | options = { |
| | 1195 | server_admin = mkOption { type = str; description = "Server admin e-mail"; }; |
| | 1196 | }; |
| | 1197 | }; |
| | 1198 | }; |
| | 1199 | ludivine = mkOption { |
| | 1200 | description = "Ludivinecassal configurations by environment"; |
| | 1201 | type = |
| | 1202 | let |
| | 1203 | lcSubmodule = mkOption { |
| | 1204 | description = "environment configuration"; |
| | 1205 | type = submodule { |
| | 1206 | options = { |
| | 1207 | environment = mkOption { type = str; description = "Symfony environment"; }; |
| | 1208 | mysql = mkMysqlOptions "LudivineCassal" {}; |
| | 1209 | ldap = mkLdapOptions "LudivineCassal" {}; |
| | 1210 | secret = mkOption { type = str; description = "Symfony App secret"; }; |
| | 1211 | }; |
| | 1212 | }; |
| | 1213 | }; |
| | 1214 | in |
| | 1215 | submodule { |
| | 1216 | options = { |
| | 1217 | production = lcSubmodule; |
| | 1218 | integration = lcSubmodule; |
| | 1219 | }; |
| | 1220 | }; |
| | 1221 | }; |
| | 1222 | emilia = mkOption { |
| | 1223 | description = "Emilia configuration"; |
| | 1224 | type = submodule { |
| | 1225 | options = { |
| | 1226 | postgresql = mkPsqlOptions "Emilia"; |
| | 1227 | }; |
| | 1228 | }; |
| | 1229 | }; |
| | 1230 | florian = mkOption { |
| | 1231 | description = "Florian configuration"; |
| | 1232 | type = submodule { |
| | 1233 | options = { |
| | 1234 | server_admin = mkOption { type = str; description = "Server admin e-mail"; }; |
| | 1235 | }; |
| | 1236 | }; |
| | 1237 | }; |
| | 1238 | nassime = mkOption { |
| | 1239 | description = "Nassime configuration"; |
| | 1240 | type = submodule { |
| | 1241 | options = { |
| | 1242 | server_admin = mkOption { type = str; description = "Server admin e-mail"; }; |
| | 1243 | }; |
| | 1244 | }; |
| | 1245 | }; |
| | 1246 | piedsjaloux = mkOption { |
| | 1247 | description = "Piedsjaloux configurations by environment"; |
| | 1248 | type = |
| | 1249 | let |
| | 1250 | pjSubmodule = mkOption { |
| | 1251 | description = "environment configuration"; |
| | 1252 | type = submodule { |
| | 1253 | options = { |
| | 1254 | environment = mkOption { type = str; description = "Symfony environment"; }; |
| | 1255 | mysql = mkMysqlOptions "Piedsjaloux" {}; |
| | 1256 | secret = mkOption { type = str; description = "Symfony App secret"; }; |
| | 1257 | }; |
| | 1258 | }; |
| | 1259 | }; |
| | 1260 | in |
| | 1261 | submodule { |
| | 1262 | options = { |
| | 1263 | production = pjSubmodule; |
| | 1264 | integration = pjSubmodule; |
| | 1265 | }; |
| | 1266 | }; |
| | 1267 | }; |
| | 1268 | richie = mkOption { |
| | 1269 | description = "Europe Richie configurations by environment"; |
| | 1270 | type = submodule { |
| | 1271 | options = { |
| | 1272 | mysql = mkMysqlOptions "Richie" {}; |
| | 1273 | smtp_mailer = mkOption { |
| | 1274 | description = "SMTP mailer configuration"; |
| | 1275 | type = submodule { |
| | 1276 | options = { |
| | 1277 | user = mkOption { type = str; description = "Username"; }; |
| | 1278 | password = mkOption { type = str; description = "Password"; }; |
| | 1279 | }; |
| | 1280 | }; |
| | 1281 | }; |
| | 1282 | }; |
| | 1283 | }; |
| | 1284 | }; |
| | 1285 | tellesflorian = mkOption { |
| | 1286 | description = "Tellesflorian configurations by environment"; |
| | 1287 | type = |
| | 1288 | let |
| | 1289 | tfSubmodule = mkOption { |
| | 1290 | description = "environment configuration"; |
| | 1291 | type = submodule { |
| | 1292 | options = { |
| | 1293 | environment = mkOption { type = str; description = "Symfony environment"; }; |
| | 1294 | mysql = mkMysqlOptions "Tellesflorian" {}; |
| | 1295 | secret = mkOption { type = str; description = "Symfony App secret"; }; |
| | 1296 | invite_passwords = mkOption { type = str; description = "Password basic auth"; }; |
| | 1297 | }; |
| | 1298 | }; |
| | 1299 | }; |
| | 1300 | in |
| | 1301 | submodule { |
| | 1302 | options = { |
| | 1303 | integration = tfSubmodule; |
| | 1304 | }; |
| | 1305 | }; |
| | 1306 | }; |
| | 1307 | }; |
| | 1308 | }; |
| | 1309 | }; |
| | 1310 | |
| | 1311 | privateFiles = mkOption { |
| | 1312 | type = path; |
| | 1313 | description = '' |
| | 1314 | Path to secret files to make available during build |
| | 1315 | ''; |
| | 1316 | }; |
| | 1317 | }; |
| | 1318 | options.hostEnv = mkOption { |
| | 1319 | readOnly = true; |
| | 1320 | type = hostEnv; |
| | 1321 | default = config.myEnv.servers."${name}"; |
| | 1322 | description = "Host environment"; |
| | 1323 | }; |
| | 1324 | } |
projects / perso / Immae / Config / Nix.git / blame_incremental