nixos/modules/services/network-filesystems/xtreemfs.nix

   1 { config, lib, pkgs, ... }:
   2 let
   3
   4   cfg = config.services.xtreemfs;
   5
   6   xtreemfs = pkgs.xtreemfs;
   7
   8   home = cfg.homeDir;
   9
  10   startupScript = class: configPath: pkgs.writeScript "xtreemfs-osd.sh" ''
  11     #! ${pkgs.runtimeShell}
  12     JAVA_HOME="${pkgs.jdk}"
  13     JAVADIR="${xtreemfs}/share/java"
  14     JAVA_CALL="$JAVA_HOME/bin/java -ea -cp $JAVADIR/XtreemFS.jar:$JAVADIR/BabuDB.jar:$JAVADIR/Flease.jar:$JAVADIR/protobuf-java-2.5.0.jar:$JAVADIR/Foundation.jar:$JAVADIR/jdmkrt.jar:$JAVADIR/jdmktk.jar:$JAVADIR/commons-codec-1.3.jar"
  15     $JAVA_CALL ${class} ${configPath}
  16   '';
  17
  18   dirReplicationConfig = pkgs.writeText "xtreemfs-dir-replication-plugin.properties" ''
  19     babudb.repl.backupDir = ${home}/server-repl-dir
  20     plugin.jar = ${xtreemfs}/share/java/BabuDB_replication_plugin.jar
  21     babudb.repl.dependency.0 = ${xtreemfs}/share/java/Flease.jar
  22
  23     ${cfg.dir.replication.extraConfig}
  24   '';
  25
  26   dirConfig = pkgs.writeText "xtreemfs-dir-config.properties" ''
  27     uuid = ${cfg.dir.uuid}
  28     listen.port = ${toString cfg.dir.port}
  29     ${lib.optionalString (cfg.dir.address != "") "listen.address = ${cfg.dir.address}"}
  30     http_port = ${toString cfg.dir.httpPort}
  31     babudb.baseDir = ${home}/dir/database
  32     babudb.logDir = ${home}/dir/db-log
  33     babudb.sync = ${if cfg.dir.replication.enable then "FDATASYNC" else cfg.dir.syncMode}
  34
  35     ${lib.optionalString cfg.dir.replication.enable "babudb.plugin.0 = ${dirReplicationConfig}"}
  36
  37     ${cfg.dir.extraConfig}
  38   '';
  39
  40   mrcReplicationConfig = pkgs.writeText "xtreemfs-mrc-replication-plugin.properties" ''
  41     babudb.repl.backupDir = ${home}/server-repl-mrc
  42     plugin.jar = ${xtreemfs}/share/java/BabuDB_replication_plugin.jar
  43     babudb.repl.dependency.0 = ${xtreemfs}/share/java/Flease.jar
  44
  45     ${cfg.mrc.replication.extraConfig}
  46   '';
  47
  48   mrcConfig = pkgs.writeText "xtreemfs-mrc-config.properties" ''
  49     uuid = ${cfg.mrc.uuid}
  50     listen.port = ${toString cfg.mrc.port}
  51     ${lib.optionalString (cfg.mrc.address != "") "listen.address = ${cfg.mrc.address}"}
  52     http_port = ${toString cfg.mrc.httpPort}
  53     babudb.baseDir = ${home}/mrc/database
  54     babudb.logDir = ${home}/mrc/db-log
  55     babudb.sync = ${if cfg.mrc.replication.enable then "FDATASYNC" else cfg.mrc.syncMode}
  56
  57     ${lib.optionalString cfg.mrc.replication.enable "babudb.plugin.0 = ${mrcReplicationConfig}"}
  58
  59     ${cfg.mrc.extraConfig}
  60   '';
  61
  62   osdConfig = pkgs.writeText "xtreemfs-osd-config.properties" ''
  63     uuid = ${cfg.osd.uuid}
  64     listen.port = ${toString cfg.osd.port}
  65     ${lib.optionalString (cfg.osd.address != "") "listen.address = ${cfg.osd.address}"}
  66     http_port = ${toString cfg.osd.httpPort}
  67     object_dir = ${home}/osd/
  68
  69     ${cfg.osd.extraConfig}
  70   '';
  71
  72   optionalDir = lib.optionals cfg.dir.enable ["xtreemfs-dir.service"];
  73
  74   systemdOptionalDependencies = {
  75     after = [ "network.target" ] ++ optionalDir;
  76     wantedBy = [ "multi-user.target" ] ++ optionalDir;
  77   };
  78
  79 in
  80
  81 {
  82
  83   ###### interface
  84
  85   options = {
  86
  87     services.xtreemfs = {
  88
  89       enable = lib.mkEnableOption "XtreemFS";
  90
  91       homeDir = lib.mkOption {
  92         type = lib.types.path;
  93         default = "/var/lib/xtreemfs";
  94         description = ''
  95           XtreemFS home dir for the xtreemfs user.
  96         '';
  97       };
  98
  99       dir = {
 100         enable = lib.mkOption {
 101           type = lib.types.bool;
 102           default = true;
 103           description = ''
 104             Whether to enable XtreemFS DIR service.
 105           '';
 106         };
 107
 108         uuid = lib.mkOption {
 109           example = "eacb6bab-f444-4ebf-a06a-3f72d7465e40";
 110           type = lib.types.str;
 111           description = ''
 112             Must be set to a unique identifier, preferably a UUID according to
 113             RFC 4122. UUIDs can be generated with `uuidgen` command, found in
 114             the `util-linux` package.
 115           '';
 116         };
 117         port = lib.mkOption {
 118           default = 32638;
 119           type = lib.types.port;
 120           description = ''
 121             The port to listen on for incoming connections (TCP).
 122           '';
 123         };
 124         address = lib.mkOption {
 125           type = lib.types.str;
 126           example = "127.0.0.1";
 127           default = "";
 128           description = ''
 129             If specified, it defines the interface to listen on. If not
 130             specified, the service will listen on all interfaces (any).
 131           '';
 132         };
 133         httpPort = lib.mkOption {
 134           default = 30638;
 135           type = lib.types.port;
 136           description = ''
 137             Specifies the listen port for the HTTP service that returns the
 138             status page.
 139           '';
 140         };
 141         syncMode = lib.mkOption {
 142           type = lib.types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "FSYNC" ];
 143           default = "FSYNC";
 144           example = "FDATASYNC";
 145           description = ''
 146             The sync mode influences how operations are committed to the disk
 147             log before the operation is acknowledged to the caller.
 148
 149             -ASYNC mode the writes to the disk log are buffered in memory by the operating system. This is the fastest mode but will lead to data loss in case of a crash, kernel panic or power failure.
 150             -SYNC_WRITE_METADATA opens the file with O_SYNC, the system will not buffer any writes. The operation will be acknowledged when data has been safely written to disk. This mode is slow but offers maximum data safety. However, BabuDB cannot influence the disk drive caches, this depends on the OS and hard disk model.
 151             -SYNC_WRITE similar to SYNC_WRITE_METADATA but opens file with O_DSYNC which means that only the data is commit to disk. This can lead to some data loss depending on the implementation of the underlying file system. Linux does not implement this mode.
 152             -FDATASYNC is similar to SYNC_WRITE but opens the file in asynchronous mode and calls fdatasync() after writing the data to disk.
 153             -FSYNC is similar to SYNC_WRITE_METADATA but opens the file in asynchronous mode and calls fsync() after writing the data to disk.
 154
 155             For best throughput use ASYNC, for maximum data safety use FSYNC.
 156
 157             (If xtreemfs.dir.replication.enable is true then FDATASYNC is forced)
 158           '';
 159         };
 160         extraConfig = lib.mkOption {
 161           type = lib.types.lines;
 162           default = "";
 163           example = ''
 164             # specify whether SSL is required
 165             ssl.enabled = true
 166             ssl.service_creds.pw = passphrase
 167             ssl.service_creds.container = pkcs12
 168             ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/dir.p12
 169             ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/trusted.jks
 170             ssl.trusted_certs.pw = jks_passphrase
 171             ssl.trusted_certs.container = jks
 172           '';
 173           description = ''
 174             Configuration of XtreemFS DIR service.
 175             WARNING: configuration is saved as plaintext inside nix store.
 176             For more options: https://www.xtreemfs.org/xtfs-guide-1.5.1/index.html
 177           '';
 178         };
 179         replication = {
 180           enable = lib.mkEnableOption "XtreemFS DIR replication plugin";
 181           extraConfig = lib.mkOption {
 182             type = lib.types.lines;
 183             example = ''
 184               # participants of the replication including this replica
 185               babudb.repl.participant.0 = 192.168.0.10
 186               babudb.repl.participant.0.port = 35676
 187               babudb.repl.participant.1 = 192.168.0.11
 188               babudb.repl.participant.1.port = 35676
 189               babudb.repl.participant.2 = 192.168.0.12
 190               babudb.repl.participant.2.port = 35676
 191
 192               # number of servers that at least have to be up to date
 193               # To have a fault-tolerant system, this value has to be set to the
 194               # majority of nodes i.e., if you have three replicas, set this to 2
 195               # Please note that a setup with two nodes provides no fault-tolerance.
 196               babudb.repl.sync.n = 2
 197
 198               # specify whether SSL is required
 199               babudb.ssl.enabled = true
 200
 201               babudb.ssl.protocol = tlsv12
 202
 203               # server credentials for SSL handshakes
 204               babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12
 205               babudb.ssl.service_creds.pw = passphrase
 206               babudb.ssl.service_creds.container = pkcs12
 207
 208               # trusted certificates for SSL handshakes
 209               babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/trusted.jks
 210               babudb.ssl.trusted_certs.pw = jks_passphrase
 211               babudb.ssl.trusted_certs.container = jks
 212
 213               babudb.ssl.authenticationWithoutEncryption = false
 214             '';
 215             description = ''
 216               Configuration of XtreemFS DIR replication plugin.
 217               WARNING: configuration is saved as plaintext inside nix store.
 218               For more options: https://www.xtreemfs.org/xtfs-guide-1.5.1/index.html
 219             '';
 220           };
 221         };
 222       };
 223
 224       mrc = {
 225         enable = lib.mkOption {
 226           type = lib.types.bool;
 227           default = true;
 228           description = ''
 229             Whether to enable XtreemFS MRC service.
 230           '';
 231         };
 232
 233         uuid = lib.mkOption {
 234           example = "eacb6bab-f444-4ebf-a06a-3f72d7465e41";
 235           type = lib.types.str;
 236           description = ''
 237             Must be set to a unique identifier, preferably a UUID according to
 238             RFC 4122. UUIDs can be generated with `uuidgen` command, found in
 239             the `util-linux` package.
 240           '';
 241         };
 242         port = lib.mkOption {
 243           default = 32636;
 244           type = lib.types.port;
 245           description = ''
 246             The port to listen on for incoming connections (TCP).
 247           '';
 248         };
 249         address = lib.mkOption {
 250           example = "127.0.0.1";
 251           type = lib.types.str;
 252           default = "";
 253           description = ''
 254             If specified, it defines the interface to listen on. If not
 255             specified, the service will listen on all interfaces (any).
 256           '';
 257         };
 258         httpPort = lib.mkOption {
 259           default = 30636;
 260           type = lib.types.port;
 261           description = ''
 262             Specifies the listen port for the HTTP service that returns the
 263             status page.
 264           '';
 265         };
 266         syncMode = lib.mkOption {
 267           default = "FSYNC";
 268           type = lib.types.enum [ "ASYNC" "SYNC_WRITE_METADATA" "SYNC_WRITE" "FDATASYNC" "FSYNC" ];
 269           example = "FDATASYNC";
 270           description = ''
 271             The sync mode influences how operations are committed to the disk
 272             log before the operation is acknowledged to the caller.
 273
 274             -ASYNC mode the writes to the disk log are buffered in memory by the operating system. This is the fastest mode but will lead to data loss in case of a crash, kernel panic or power failure.
 275             -SYNC_WRITE_METADATA opens the file with O_SYNC, the system will not buffer any writes. The operation will be acknowledged when data has been safely written to disk. This mode is slow but offers maximum data safety. However, BabuDB cannot influence the disk drive caches, this depends on the OS and hard disk model.
 276             -SYNC_WRITE similar to SYNC_WRITE_METADATA but opens file with O_DSYNC which means that only the data is commit to disk. This can lead to some data loss depending on the implementation of the underlying file system. Linux does not implement this mode.
 277             -FDATASYNC is similar to SYNC_WRITE but opens the file in asynchronous mode and calls fdatasync() after writing the data to disk.
 278             -FSYNC is similar to SYNC_WRITE_METADATA but opens the file in asynchronous mode and calls fsync() after writing the data to disk.
 279
 280             For best throughput use ASYNC, for maximum data safety use FSYNC.
 281
 282             (If xtreemfs.mrc.replication.enable is true then FDATASYNC is forced)
 283           '';
 284         };
 285         extraConfig = lib.mkOption {
 286           type = lib.types.lines;
 287           example = ''
 288             osd_check_interval = 300
 289             no_atime = true
 290             local_clock_renewal = 0
 291             remote_time_sync = 30000
 292             authentication_provider = org.xtreemfs.common.auth.NullAuthProvider
 293
 294             # shared secret between the MRC and all OSDs
 295             capability_secret = iNG8UuQJrJ6XVDTe
 296
 297             dir_service.host = 192.168.0.10
 298             dir_service.port = 32638
 299
 300             # if replication is enabled
 301             dir_service.1.host = 192.168.0.11
 302             dir_service.1.port = 32638
 303             dir_service.2.host = 192.168.0.12
 304             dir_service.2.port = 32638
 305
 306             # specify whether SSL is required
 307             ssl.enabled = true
 308             ssl.protocol = tlsv12
 309             ssl.service_creds.pw = passphrase
 310             ssl.service_creds.container = pkcs12
 311             ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/mrc.p12
 312             ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/trusted.jks
 313             ssl.trusted_certs.pw = jks_passphrase
 314             ssl.trusted_certs.container = jks
 315           '';
 316           description = ''
 317             Configuration of XtreemFS MRC service.
 318             WARNING: configuration is saved as plaintext inside nix store.
 319             For more options: https://www.xtreemfs.org/xtfs-guide-1.5.1/index.html
 320           '';
 321         };
 322         replication = {
 323           enable = lib.mkEnableOption "XtreemFS MRC replication plugin";
 324           extraConfig = lib.mkOption {
 325             type = lib.types.lines;
 326             example = ''
 327               # participants of the replication including this replica
 328               babudb.repl.participant.0 = 192.168.0.10
 329               babudb.repl.participant.0.port = 35678
 330               babudb.repl.participant.1 = 192.168.0.11
 331               babudb.repl.participant.1.port = 35678
 332               babudb.repl.participant.2 = 192.168.0.12
 333               babudb.repl.participant.2.port = 35678
 334
 335               # number of servers that at least have to be up to date
 336               # To have a fault-tolerant system, this value has to be set to the
 337               # majority of nodes i.e., if you have three replicas, set this to 2
 338               # Please note that a setup with two nodes provides no fault-tolerance.
 339               babudb.repl.sync.n = 2
 340
 341               # specify whether SSL is required
 342               babudb.ssl.enabled = true
 343
 344               babudb.ssl.protocol = tlsv12
 345
 346               # server credentials for SSL handshakes
 347               babudb.ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12
 348               babudb.ssl.service_creds.pw = passphrase
 349               babudb.ssl.service_creds.container = pkcs12
 350
 351               # trusted certificates for SSL handshakes
 352               babudb.ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/trusted.jks
 353               babudb.ssl.trusted_certs.pw = jks_passphrase
 354               babudb.ssl.trusted_certs.container = jks
 355
 356               babudb.ssl.authenticationWithoutEncryption = false
 357             '';
 358             description = ''
 359               Configuration of XtreemFS MRC replication plugin.
 360               WARNING: configuration is saved as plaintext inside nix store.
 361               For more options: https://www.xtreemfs.org/xtfs-guide-1.5.1/index.html
 362             '';
 363           };
 364         };
 365       };
 366
 367       osd = {
 368         enable = lib.mkOption {
 369           type = lib.types.bool;
 370           default = true;
 371           description = ''
 372             Whether to enable XtreemFS OSD service.
 373           '';
 374         };
 375
 376         uuid = lib.mkOption {
 377           example = "eacb6bab-f444-4ebf-a06a-3f72d7465e42";
 378           type = lib.types.str;
 379           description = ''
 380             Must be set to a unique identifier, preferably a UUID according to
 381             RFC 4122. UUIDs can be generated with `uuidgen` command, found in
 382             the `util-linux` package.
 383           '';
 384         };
 385         port = lib.mkOption {
 386           default = 32640;
 387           type = lib.types.port;
 388           description = ''
 389             The port to listen on for incoming connections (TCP and UDP).
 390           '';
 391         };
 392         address = lib.mkOption {
 393           example = "127.0.0.1";
 394           type = lib.types.str;
 395           default = "";
 396           description = ''
 397             If specified, it defines the interface to listen on. If not
 398             specified, the service will listen on all interfaces (any).
 399           '';
 400         };
 401         httpPort = lib.mkOption {
 402           default = 30640;
 403           type = lib.types.port;
 404           description = ''
 405             Specifies the listen port for the HTTP service that returns the
 406             status page.
 407           '';
 408         };
 409         extraConfig = lib.mkOption {
 410           type = lib.types.lines;
 411           example = ''
 412             local_clock_renewal = 0
 413             remote_time_sync = 30000
 414             report_free_space = true
 415             capability_secret = iNG8UuQJrJ6XVDTe
 416
 417             dir_service.host = 192.168.0.10
 418             dir_service.port = 32638
 419
 420             # if replication is used
 421             dir_service.1.host = 192.168.0.11
 422             dir_service.1.port = 32638
 423             dir_service.2.host = 192.168.0.12
 424             dir_service.2.port = 32638
 425
 426             # specify whether SSL is required
 427             ssl.enabled = true
 428             ssl.service_creds.pw = passphrase
 429             ssl.service_creds.container = pkcs12
 430             ssl.service_creds = /etc/xos/xtreemfs/truststore/certs/osd.p12
 431             ssl.trusted_certs = /etc/xos/xtreemfs/truststore/certs/trusted.jks
 432             ssl.trusted_certs.pw = jks_passphrase
 433             ssl.trusted_certs.container = jks
 434           '';
 435           description = ''
 436             Configuration of XtreemFS OSD service.
 437             WARNING: configuration is saved as plaintext inside nix store.
 438             For more options: https://www.xtreemfs.org/xtfs-guide-1.5.1/index.html
 439           '';
 440         };
 441       };
 442     };
 443
 444   };
 445
 446
 447   ###### implementation
 448
 449   config = lib.mkIf cfg.enable {
 450
 451     environment.systemPackages = [ xtreemfs ];
 452
 453     users.users.xtreemfs =
 454       { uid = config.ids.uids.xtreemfs;
 455         description = "XtreemFS user";
 456         createHome = true;
 457         home = home;
 458       };
 459
 460     users.groups.xtreemfs =
 461       { gid = config.ids.gids.xtreemfs;
 462       };
 463
 464     systemd.services.xtreemfs-dir = lib.mkIf cfg.dir.enable {
 465       description = "XtreemFS-DIR Server";
 466       after = [ "network.target" ];
 467       wantedBy = [ "multi-user.target" ];
 468       serviceConfig = {
 469         User = "xtreemfs";
 470         ExecStart = "${startupScript "org.xtreemfs.dir.DIR" dirConfig}";
 471       };
 472     };
 473
 474     systemd.services.xtreemfs-mrc = lib.mkIf cfg.mrc.enable ({
 475       description = "XtreemFS-MRC Server";
 476       serviceConfig = {
 477         User = "xtreemfs";
 478         ExecStart = "${startupScript "org.xtreemfs.mrc.MRC" mrcConfig}";
 479       };
 480     } // systemdOptionalDependencies);
 481
 482     systemd.services.xtreemfs-osd = lib.mkIf cfg.osd.enable ({
 483       description = "XtreemFS-OSD Server";
 484       serviceConfig = {
 485         User = "xtreemfs";
 486         ExecStart = "${startupScript "org.xtreemfs.osd.OSD" osdConfig}";
 487       };
 488     } // systemdOptionalDependencies);
 489
 490   };
 491
 492 }