commit 849c40b5f5071617db0c7bbaa1d3438dd616420d · pyrox.dev/nixpkgs

+68 -10
nixos/modules/services/misc/klipper.nix
···

       35
       35
        
               description = lib.mdDoc "Path of the API socket to create.";

     

       36
       36
        
             };

     

       37
       37
        
       

     

       38
       38
       +
             mutableConfig = mkOption {

     

       39
       39
       +
               type = types.bool;

     

       40
       40
       +
               default = false;

     

       41
       41
       +
               example = true;

     

       42
       42
       +
               description = lib.mdDoc ''

     

       43
       43
       +
                 Whether to copy the config to a mutable directory instead of using the one directly from the nix store.

     

       44
       44
       +
                 This will only copy the config if the file at `services.klipper.mutableConfigPath` doesn't exist.

     

       45
       45
       +
               '';

     

       46
       46
       +
             };

     

       47
       47
       +
       

     

       48
       48
       +
             mutableConfigFolder = mkOption {

     

       49
       49
       +
               type = types.path;

     

       50
       50
       +
               default = "/var/lib/klipper";

     

       51
       51
       +
               description = lib.mdDoc "Path to mutable Klipper config file.";

     

       52
       52
       +
             };

     

       53
       53
       +
       

     

       54
       54
       +
             configFile = mkOption {

     

       55
       55
       +
               type = types.nullOr types.path;

     

       56
       56
       +
               default = null;

     

       57
       57
       +
               description = lib.mdDoc ''

     

       58
       58
       +
                 Path to default Klipper config.

     

       59
       59
       +
               '';

     

       60
       60
       +
             };

     

       61
       61
       +
       

     

       38
       62
        
             octoprintIntegration = mkOption {

     

       39
       63
        
               type = types.bool;

     

       40
       64
        
               default = false;

     
···

       62
       86
        
             };

     

       63
       87
        
       

     

       64
       88
        
             settings = mkOption {

     

       65
       65
       -
               type = format.type;

     

       66
       66
       -
               default = { };

     

       89
       89
       +
               type = types.nullOr format.type;

     

       90
       90
       +
               default = null;

     

       67
       91
        
               description = lib.mdDoc ''

     

       68
       92
        
                 Configuration for Klipper. See the [documentation](https://www.klipper3d.org/Overview.html#configuration-and-tuning-guides)

     

       69
       93
        
                 for supported values.

     
···

       80
       104
        
                       building of firmware and addition of klipper-flash tools for manual flashing.

     

       81
       105
        
                       This will add `klipper-flash-$mcu` scripts to your environment which can be called to flash the firmware.

     

       82
       106
        
                     '');

     

       107
       107
       +
                     serial = mkOption {

     

       108
       108
       +
                       type = types.nullOr path;

     

       109
       109
       +
                       description = lib.mdDoc "Path to serial port this printer is connected to. Leave `null` to derive it from `service.klipper.settings`.";

     

       110
       110
       +
                     };

     

       83
       111
        
                     configFile = mkOption {

     

       84
       112
        
                       type = path;

     

       85
       113
        
                       description = lib.mdDoc "Path to firmware config which is generated using `klipper-genconf`";

     
···

       95
       123
        
           assertions = [

     

       96
       124
        
             {

     

       97
       125
        
               assertion = cfg.octoprintIntegration -> config.services.octoprint.enable;

     

       98
       98
       -
               message = "Option klipper.octoprintIntegration requires Octoprint to be enabled on this system. Please enable services.octoprint to use it.";

     

       126
       126
       +
               message = "Option services.klipper.octoprintIntegration requires Octoprint to be enabled on this system. Please enable services.octoprint to use it.";

     

       99
       127
        
             }

     

       100
       128
        
             {

     

       101
       129
        
               assertion = cfg.user != null -> cfg.group != null;

     

       102
       102
       -
               message = "Option klipper.group is not set when a user is specified.";

     

       130
       130
       +
               message = "Option services.klipper.group is not set when services.klipper.user is specified.";

     

       103
       131
        
             }

     

       104
       132
        
             {

     

       105
       105
       -
               assertion = foldl (a: b: a && b) true (mapAttrsToList (mcu: _: mcu != null -> (hasAttrByPath [ "${mcu}" "serial" ] cfg.settings)) cfg.firmwares);

     

       106
       106
       -
               message = "Option klipper.settings.$mcu.serial must be set when klipper.firmware.$mcu is specified";

     

       133
       133
       +
               assertion = cfg.settings != null -> foldl (a: b: a && b) true (mapAttrsToList (mcu: _: mcu != null -> (hasAttrByPath [ "${mcu}" "serial" ] cfg.settings)) cfg.firmwares);

     

       134
       134
       +
               message = "Option services.klipper.settings.$mcu.serial must be set when settings.klipper.firmware.$mcu is specified";

     

       135
       135
       +
             }

     

       136
       136
       +
             {

     

       137
       137
       +
               assertion = (cfg.configFile != null) != (cfg.settings != null);

     

       138
       138
       +
               message = "You need to either specify services.klipper.settings or services.klipper.defaultConfig.";

     

       107
       139
        
             }

     

       108
       140
        
           ];

     

       109
       141
        
       

     

       110
       110
       -
           environment.etc."klipper.cfg".source = format.generate "klipper.cfg" cfg.settings;

     

       142
       142
       +
           environment.etc = mkIf (!cfg.mutableConfig) {

     

       143
       143
       +
             "klipper.cfg".source = if cfg.settings != null then format.generate "klipper.cfg" cfg.settings else cfg.configFile;

     

       144
       144
       +
           };

     

       111
       145
        
       

     

       112
       146
        
           services.klipper = mkIf cfg.octoprintIntegration {

     

       113
       147
        
             user = config.services.octoprint.user;

     
···

       118
       152
        
             let

     

       119
       153
        
               klippyArgs = "--input-tty=${cfg.inputTTY}"

     

       120
       154
        
                 + optionalString (cfg.apiSocket != null) " --api-server=${cfg.apiSocket}";

     

       155
       155
       +
               printerConfigPath =

     

       156
       156
       +
                 if cfg.mutableConfig

     

       157
       157
       +
                 then cfg.mutableConfigFolder + "/printer.cfg"

     

       158
       158
       +
                 else "/etc/klipper.cfg";

     

       159
       159
       +
               printerConfigFile =

     

       160
       160
       +
                 if cfg.settings != null

     

       161
       161
       +
                 then format.generate "klipper.cfg" cfg.settings

     

       162
       162
       +
                 else cfg.configFile;

     

       121
       163
        
             in

     

       122
       164
        
             {

     

       123
       165
        
               description = "Klipper 3D Printer Firmware";

     

       124
       166
        
               wantedBy = [ "multi-user.target" ];

     

       125
       167
        
               after = [ "network.target" ];

     

       168
       168
       +
               preStart = ''

     

       169
       169
       +
                 mkdir -p ${cfg.mutableConfigFolder}

     

       170
       170
       +
                 ${lib.optionalString (cfg.mutableConfig) ''

     

       171
       171
       +
                   [ -e ${printerConfigPath} ] || {

     

       172
       172
       +
                     cp ${printerConfigFile} ${printerConfigPath}

     

       173
       173
       +
                     chmod +w ${printerConfigPath}

     

       174
       174
       +
                   }

     

       175
       175
       +
                 ''}

     

       176
       176
       +
                 mkdir -p ${cfg.mutableConfigFolder}/gcodes

     

       177
       177
       +
               '';

     

       126
       178
        
       

     

       127
       179
        
               serviceConfig = {

     

       128
       128
       -
                 ExecStart = "${cfg.package}/lib/klipper/klippy.py ${klippyArgs} /etc/klipper.cfg";

     

       180
       180
       +
                 ExecStart = "${cfg.package}/lib/klipper/klippy.py ${klippyArgs} ${printerConfigPath}";

     

       129
       181
        
                 RuntimeDirectory = "klipper";

     

       182
       182
       +
                 StateDirectory = "klipper";

     

       130
       183
        
                 SupplementaryGroups = [ "dialout" ];

     

       131
       184
        
                 WorkingDirectory = "${cfg.package}/lib";

     

       132
       185
        
                 OOMScoreAdjust = "-999";

     
···

       134
       187
        
                 CPUSchedulingPriority = 99;

     

       135
       188
        
                 IOSchedulingClass = "realtime";

     

       136
       189
        
                 IOSchedulingPriority = 0;

     

       190
       190
       +
                 UMask = "0002";

     

       137
       191
        
               } // (if cfg.user != null then {

     

       138
       192
        
                 Group = cfg.group;

     

       139
       193
        
                 User = cfg.user;

     
···

       146
       200
        
           environment.systemPackages =

     

       147
       201
        
             with pkgs;

     

       148
       202
        
             let

     

       203
       203
       +
               default = a: b: if a != null then a else b;

     

       149
       204
        
               firmwares = filterAttrs (n: v: v!= null) (mapAttrs

     

       150
       150
       -
                 (mcu: { enable, configFile }: if enable then pkgs.klipper-firmware.override {

     

       205
       205
       +
                 (mcu: { enable, configFile, serial }: if enable then pkgs.klipper-firmware.override {

     

       151
       206
        
                   mcu = lib.strings.sanitizeDerivationName mcu;

     

       152
       207
        
                   firmwareConfig = configFile;

     

       153
       208
        
                 } else null)

     
···

       156
       211
        
                 (mcu: firmware: pkgs.klipper-flash.override {

     

       157
       212
        
                   mcu = lib.strings.sanitizeDerivationName mcu;

     

       158
       213
        
                   klipper-firmware = firmware;

     

       159
       159
       -
                   flashDevice = cfg.settings."${mcu}".serial;

     

       214
       214
       +
                   flashDevice = default cfg.firmwares."${mcu}".serial cfg.settings."${mcu}".serial;

     

       160
       215
        
                   firmwareConfig = cfg.firmwares."${mcu}".configFile;

     

       161
       216
        
                 })

     

       162
       217
        
                 firmwares;

     

       163
       218
        
             in

     

       164
       219
        
             [ klipper-genconf ] ++ firmwareFlasher ++ attrValues firmwares;

     

       165
       220
        
         };

     

       221
       221
       +
         meta.maintainers = [

     

       222
       222
       +
           maintainers.cab404

     

       223
       223
       +
         ];

     

       166
       224
        
       }