commit 65cddb74d7408da1c2dd19782bd1ae997e2f3a82 · pyrox.dev/nixpkgs

nixos/doc/manual/release-notes/rl-2105.xml

···

       788
       788
        
            and use Maturin as their build tool.

     

       789
       789
        
           </para>

     

       790
       790
        
          </listitem>

     

       791
       791
       +
          <listitem>

     

       792
       792
       +
           <para>

     

       793
       793
       +
            Kubernetes has <link xlink:href="https://kubernetes.io/blog/2020/12/02/dont-panic-kubernetes-and-docker/">deprecated docker</link> as container runtime.

     

       794
       794
       +
            As a consequence, the Kubernetes module now has support for configuration of custom remote container runtimes and enables containerd by default.

     

       795
       795
       +
            Note that containerd is more strict regarding container image OCI-compliance.

     

       796
       796
       +
            As an example, images with CMD or ENTRYPOINT defined as strings (not lists) will fail on containerd, while working fine on docker.

     

       797
       797
       +
            Please test your setup and container images with containerd prior to upgrading.

     

       798
       798
       +
           </para>

     

       799
       799
       +
          </listitem>

     

       791
       800
        
         </itemizedlist>

     

       792
       801
        
        </section>

     

       793
       802
        
       </section>

nixos/modules/module-list.nix

···

       1053
       1053
        
         ./testing/service-runner.nix

     

       1054
       1054
        
         ./virtualisation/anbox.nix

     

       1055
       1055
        
         ./virtualisation/container-config.nix

     

       1056
       1056
       +
         ./virtualisation/containerd.nix

     

       1056
       1057
        
         ./virtualisation/containers.nix

     

       1057
       1058
        
         ./virtualisation/nixos-containers.nix

     

       1058
       1059
        
         ./virtualisation/oci-containers.nix

+3 -4

nixos/modules/services/cluster/kubernetes/addons/dns.nix

···

       3
       3
        
       with lib;

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         version = "1.6.4";

     

       6
       6
       +
         version = "1.7.1";

     

       7
       7
        
         cfg = config.services.kubernetes.addons.dns;

     

       8
       8
        
         ports = {

     

       9
       9
        
           dns = 10053;

     
···

       55
       55
        
             type = types.attrs;

     

       56
       56
        
             default = {

     

       57
       57
        
               imageName = "coredns/coredns";

     

       58
       58
       -
               imageDigest = "sha256:493ee88e1a92abebac67cbd4b5658b4730e0f33512461442d8d9214ea6734a9b";

     

       58
       58
       +
               imageDigest = "sha256:4a6e0769130686518325b21b0c1d0688b54e7c79244d48e1b15634e98e40c6ef";

     

       59
       59
        
               finalImageTag = version;

     

       60
       60
       -
               sha256 = "0fm9zdjavpf5hni8g7fkdd3csjbhd7n7py7llxjc66sbii087028";

     

       60
       60
       +
               sha256 = "02r440xcdsgi137k5lmmvp0z5w5fmk8g9mysq5pnysq1wl8sj6mw";

     

       61
       61
        
             };

     

       62
       62
        
           };

     

       63
       63
        
         };

     
···

       156
       156
        
                   health :${toString ports.health}

     

       157
       157
        
                   kubernetes ${cfg.clusterDomain} in-addr.arpa ip6.arpa {

     

       158
       158
        
                     pods insecure

     

       159
       159
       -
                     upstream

     

       160
       159
        
                     fallthrough in-addr.arpa ip6.arpa

     

       161
       160
        
                   }

     

       162
       161
        
                   prometheus :${toString ports.metrics}

+35 -7

nixos/modules/services/cluster/kubernetes/apiserver.nix

···

       238
       238
        
             type = int;

     

       239
       239
        
           };

     

       240
       240
        
       

     

       241
       241
       +
           apiAudiences = mkOption {

     

       242
       242
       +
             description = ''

     

       243
       243
       +
               Kubernetes apiserver ServiceAccount issuer.

     

       244
       244
       +
             '';

     

       245
       245
       +
             default = "api,https://kubernetes.default.svc";

     

       246
       246
       +
             type = str;

     

       247
       247
       +
           };

     

       248
       248
       +
       

     

       249
       249
       +
           serviceAccountIssuer = mkOption {

     

       250
       250
       +
             description = ''

     

       251
       251
       +
               Kubernetes apiserver ServiceAccount issuer.

     

       252
       252
       +
             '';

     

       253
       253
       +
             default = "https://kubernetes.default.svc";

     

       254
       254
       +
             type = str;

     

       255
       255
       +
           };

     

       256
       256
       +
       

     

       257
       257
       +
           serviceAccountSigningKeyFile = mkOption {

     

       258
       258
       +
             description = ''

     

       259
       259
       +
               Path to the file that contains the current private key of the service

     

       260
       260
       +
               account token issuer. The issuer will sign issued ID tokens with this

     

       261
       261
       +
               private key.

     

       262
       262
       +
             '';

     

       263
       263
       +
             type = path;

     

       264
       264
       +
           };

     

       265
       265
       +
       

     

       241
       266
        
           serviceAccountKeyFile = mkOption {

     

       242
       267
        
             description = ''

     

       243
       243
       -
               Kubernetes apiserver PEM-encoded x509 RSA private or public key file,

     

       244
       244
       -
               used to verify ServiceAccount tokens. By default tls private key file

     

       245
       245
       -
               is used.

     

       268
       268
       +
               File containing PEM-encoded x509 RSA or ECDSA private or public keys,

     

       269
       269
       +
               used to verify ServiceAccount tokens. The specified file can contain

     

       270
       270
       +
               multiple keys, and the flag can be specified multiple times with

     

       271
       271
       +
               different files. If unspecified, --tls-private-key-file is used.

     

       272
       272
       +
               Must be specified when --service-account-signing-key is provided

     

       246
       273
        
             '';

     

       247
       247
       -
             default = null;

     

       248
       248
       -
             type = nullOr path;

     

       274
       274
       +
             type = path;

     

       249
       275
        
           };

     

       250
       276
        
       

     

       251
       277
        
           serviceClusterIpRange = mkOption {

     
···

       357
       383
        
                     ${optionalString (cfg.runtimeConfig != "")

     

       358
       384
        
                       "--runtime-config=${cfg.runtimeConfig}"} \

     

       359
       385
        
                     --secure-port=${toString cfg.securePort} \

     

       360
       360
       -
                     ${optionalString (cfg.serviceAccountKeyFile!=null)

     

       361
       361
       -
                       "--service-account-key-file=${cfg.serviceAccountKeyFile}"} \

     

       386
       386
       +
                     --api-audiences=${toString cfg.apiAudiences} \

     

       387
       387
       +
                     --service-account-issuer=${toString cfg.serviceAccountIssuer} \

     

       388
       388
       +
                     --service-account-signing-key-file=${cfg.serviceAccountSigningKeyFile} \

     

       389
       389
       +
                     --service-account-key-file=${cfg.serviceAccountKeyFile} \

     

       362
       390
        
                     --service-cluster-ip-range=${cfg.serviceClusterIpRange} \

     

       363
       391
        
                     --storage-backend=${cfg.storageBackend} \

     

       364
       392
        
                     ${optionalString (cfg.tlsCertFile != null)

+25 -8

nixos/modules/services/cluster/kubernetes/default.nix

···

       5
       5
        
       let

     

       6
       6
        
         cfg = config.services.kubernetes;

     

       7
       7
        
       

     

       8
       8
       +
         defaultContainerdConfigFile = pkgs.writeText "containerd.toml" ''

     

       9
       9
       +
           version = 2

     

       10
       10
       +
           root = "/var/lib/containerd/daemon"

     

       11
       11
       +
           state = "/var/run/containerd/daemon"

     

       12
       12
       +
           oom_score = 0

     

       13
       13
       +
       

     

       14
       14
       +
           [grpc]

     

       15
       15
       +
             address = "/var/run/containerd/containerd.sock"

     

       16
       16
       +
       

     

       17
       17
       +
           [plugins."io.containerd.grpc.v1.cri"]

     

       18
       18
       +
             sandbox_image = "pause:latest"

     

       19
       19
       +
       

     

       20
       20
       +
           [plugins."io.containerd.grpc.v1.cri".cni]

     

       21
       21
       +
             bin_dir = "/opt/cni/bin"

     

       22
       22
       +
             max_conf_num = 0

     

       23
       23
       +
       

     

       24
       24
       +
           [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]

     

       25
       25
       +
             runtime_type = "io.containerd.runc.v2"

     

       26
       26
       +
       

     

       27
       27
       +
           [plugins."io.containerd.grpc.v1.cri".containerd.runtimes."io.containerd.runc.v2".options]

     

       28
       28
       +
             SystemdCgroup = true

     

       29
       29
       +
         '';

     

       30
       30
       +
       

     

       8
       31
        
         mkKubeConfig = name: conf: pkgs.writeText "${name}-kubeconfig" (builtins.toJSON {

     

       9
       32
        
           apiVersion = "v1";

     

       10
       33
        
           kind = "Config";

     
···

       222
       245
        
           })

     

       223
       246
        
       

     

       224
       247
        
           (mkIf cfg.kubelet.enable {

     

       225
       225
       -
             virtualisation.docker = {

     

       248
       248
       +
             virtualisation.containerd = {

     

       226
       249
        
               enable = mkDefault true;

     

       227
       227
       -
       

     

       228
       228
       -
               # kubernetes needs access to logs

     

       229
       229
       -
               logDriver = mkDefault "json-file";

     

       230
       230
       -
       

     

       231
       231
       -
               # iptables must be disabled for kubernetes

     

       232
       232
       -
               extraOptions = "--iptables=false --ip-masq=false";

     

       250
       250
       +
               configFile = mkDefault defaultContainerdConfigFile;

     

       233
       251
        
             };

     

       234
       252
        
           })

     

       235
       253
        
       

     
···

       269
       287
        
             users.users.kubernetes = {

     

       270
       288
        
               uid = config.ids.uids.kubernetes;

     

       271
       289
        
               description = "Kubernetes user";

     

       272
       272
       -
               extraGroups = [ "docker" ];

     

       273
       290
        
               group = "kubernetes";

     

       274
       291
        
               home = cfg.dataDir;

     

       275
       292
        
               createHome = true;

+2 -38

nixos/modules/services/cluster/kubernetes/flannel.nix

···

       8
       8
        
       

     

       9
       9
        
         # we want flannel to use kubernetes itself as configuration backend, not direct etcd

     

       10
       10
        
         storageBackend = "kubernetes";

     

       11
       11
       -
       

     

       12
       12
       -
         # needed for flannel to pass options to docker

     

       13
       13
       -
         mkDockerOpts = pkgs.runCommand "mk-docker-opts" {

     

       14
       14
       -
           buildInputs = [ pkgs.makeWrapper ];

     

       15
       15
       -
         } ''

     

       16
       16
       -
           mkdir -p $out

     

       17
       17
       -
       

     

       18
       18
       -
           # bashInteractive needed for `compgen`

     

       19
       19
       -
           makeWrapper ${pkgs.bashInteractive}/bin/bash $out/mk-docker-opts --add-flags "${pkgs.kubernetes}/bin/mk-docker-opts.sh"

     

       20
       20
       -
         '';

     

       21
       11
        
       in

     

       22
       12
        
       {

     

       23
       13
        
         ###### interface

     
···

       43
       33
        
               cniVersion = "0.3.1";

     

       44
       34
        
               delegate = {

     

       45
       35
        
                 isDefaultGateway = true;

     

       46
       46
       -
                 bridge = "docker0";

     

       36
       36
       +
                 bridge = "mynet";

     

       47
       37
        
               };

     

       48
       38
        
             }];

     

       49
       39
        
           };

     

       50
       40
        
       

     

       51
       51
       -
           systemd.services.mk-docker-opts = {

     

       52
       52
       -
             description = "Pre-Docker Actions";

     

       53
       53
       -
             path = with pkgs; [ gawk gnugrep ];

     

       54
       54
       -
             script = ''

     

       55
       55
       -
               ${mkDockerOpts}/mk-docker-opts -d /run/flannel/docker

     

       56
       56
       -
               systemctl restart docker

     

       57
       57
       -
             '';

     

       58
       58
       -
             serviceConfig.Type = "oneshot";

     

       59
       59
       -
           };

     

       60
       60
       -
       

     

       61
       61
       -
           systemd.paths.flannel-subnet-env = {

     

       62
       62
       -
             wantedBy = [ "flannel.service" ];

     

       63
       63
       -
             pathConfig = {

     

       64
       64
       -
               PathModified = "/run/flannel/subnet.env";

     

       65
       65
       -
               Unit = "mk-docker-opts.service";

     

       66
       66
       -
             };

     

       67
       67
       -
           };

     

       68
       68
       -
       

     

       69
       69
       -
           systemd.services.docker = {

     

       70
       70
       -
             environment.DOCKER_OPTS = "-b none";

     

       71
       71
       -
             serviceConfig.EnvironmentFile = "-/run/flannel/docker";

     

       72
       72
       -
           };

     

       73
       73
       -
       

     

       74
       74
       -
           # read environment variables generated by mk-docker-opts

     

       75
       75
       -
           virtualisation.docker.extraOptions = "$DOCKER_OPTS";

     

       76
       76
       -
       

     

       77
       41
        
           networking = {

     

       78
       42
        
             firewall.allowedUDPPorts = [

     

       79
       43
        
               8285  # flannel udp

     

       80
       44
        
               8472  # flannel vxlan

     

       81
       45
        
             ];

     

       82
       82
       -
             dhcpcd.denyInterfaces = [ "docker*" "flannel*" ];

     

       46
       46
       +
             dhcpcd.denyInterfaces = [ "mynet*" "flannel*" ];

     

       83
       47
        
           };

     

       84
       48
        
       

     

       85
       49
        
           services.kubernetes.pki.certs = {

+33 -6

nixos/modules/services/cluster/kubernetes/kubelet.nix

···

       23
       23
        
           name = "pause";

     

       24
       24
        
           tag = "latest";

     

       25
       25
        
           contents = top.package.pause;

     

       26
       26
       -
           config.Cmd = "/bin/pause";

     

       26
       26
       +
           config.Cmd = ["/bin/pause"];

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         kubeconfig = top.lib.mkKubeConfig "kubelet" cfg.kubeconfig;

     
···

       125
       125
        
             };

     

       126
       126
        
           };

     

       127
       127
        
       

     

       128
       128
       +
           containerRuntime = mkOption {

     

       129
       129
       +
             description = "Which container runtime type to use";

     

       130
       130
       +
             type = enum ["docker" "remote"];

     

       131
       131
       +
             default = "remote";

     

       132
       132
       +
           };

     

       133
       133
       +
       

     

       134
       134
       +
           containerRuntimeEndpoint = mkOption {

     

       135
       135
       +
             description = "Endpoint at which to find the container runtime api interface/socket";

     

       136
       136
       +
             type = str;

     

       137
       137
       +
             default = "unix:///var/run/containerd/containerd.sock";

     

       138
       138
       +
           };

     

       139
       139
       +
       

     

       128
       140
        
           enable = mkEnableOption "Kubernetes kubelet.";

     

       129
       141
        
       

     

       130
       142
        
           extraOpts = mkOption {

     
···

       235
       247
        
         ###### implementation

     

       236
       248
        
         config = mkMerge [

     

       237
       249
        
           (mkIf cfg.enable {

     

       250
       250
       +
       

     

       251
       251
       +
             environment.etc."cni/net.d".source = cniConfig;

     

       252
       252
       +
       

     

       238
       253
        
             services.kubernetes.kubelet.seedDockerImages = [infraContainer];

     

       239
       254
        
       

     

       255
       255
       +
             boot.kernel.sysctl = {

     

       256
       256
       +
               "net.bridge.bridge-nf-call-iptables"  = 1;

     

       257
       257
       +
               "net.ipv4.ip_forward"                 = 1;

     

       258
       258
       +
               "net.bridge.bridge-nf-call-ip6tables" = 1;

     

       259
       259
       +
             };

     

       260
       260
       +
       

     

       240
       261
        
             systemd.services.kubelet = {

     

       241
       262
        
               description = "Kubernetes Kubelet Service";

     

       242
       263
        
               wantedBy = [ "kubernetes.target" ];

     

       243
       243
       -
               after = [ "network.target" "docker.service" "kube-apiserver.service" ];

     

       264
       264
       +
               after = [ "containerd.service" "network.target" "kube-apiserver.service" ];

     

       244
       265
        
               path = with pkgs; [

     

       245
       266
        
                 gitMinimal

     

       246
       267
        
                 openssh

     

       247
       247
       -
                 docker

     

       248
       268
        
                 util-linux

     

       249
       269
        
                 iproute

     

       250
       270
        
                 ethtool

     
···

       254
       274
        
               ] ++ lib.optional config.boot.zfs.enabled config.boot.zfs.package ++ top.path;

     

       255
       275
        
               preStart = ''

     

       256
       276
        
                 ${concatMapStrings (img: ''

     

       257
       257
       -
                   echo "Seeding docker image: ${img}"

     

       258
       258
       -
                   docker load <${img}

     

       277
       277
       +
                   echo "Seeding container image: ${img}"

     

       278
       278
       +
                   ${if (lib.hasSuffix "gz" img) then

     

       279
       279
       +
                     ''${pkgs.gzip}/bin/zcat "${img}" | ${pkgs.containerd}/bin/ctr -n k8s.io image import -''

     

       280
       280
       +
                   else

     

       281
       281
       +
                     ''${pkgs.coreutils}/bin/cat "${img}" | ${pkgs.containerd}/bin/ctr -n k8s.io image import -''

     

       282
       282
       +
                   }

     

       259
       283
        
                 '') cfg.seedDockerImages}

     

       260
       284
        
       

     

       261
       285
        
                 rm /opt/cni/bin/* || true

     
···

       306
       330
        
                   ${optionalString (cfg.tlsKeyFile != null)

     

       307
       331
        
                     "--tls-private-key-file=${cfg.tlsKeyFile}"} \

     

       308
       332
        
                   ${optionalString (cfg.verbosity != null) "--v=${toString cfg.verbosity}"} \

     

       333
       333
       +
                   --container-runtime=${cfg.containerRuntime} \

     

       334
       334
       +
                   --container-runtime-endpoint=${cfg.containerRuntimeEndpoint} \

     

       335
       335
       +
                   --cgroup-driver=systemd \

     

       309
       336
        
                   ${cfg.extraOpts}

     

       310
       337
        
                 '';

     

       311
       338
        
                 WorkingDirectory = top.dataDir;

     
···

       315
       342
        
             # Allways include cni plugins

     

       316
       343
        
             services.kubernetes.kubelet.cni.packages = [pkgs.cni-plugins];

     

       317
       344
        
       

     

       318
       318
       -
             boot.kernelModules = ["br_netfilter"];

     

       345
       345
       +
             boot.kernelModules = ["br_netfilter" "overlay"];

     

       319
       346
        
       

     

       320
       347
        
             services.kubernetes.kubelet.hostname = with config.networking;

     

       321
       348
        
               mkDefault (hostName + optionalString (domain != null) ".${domain}");

nixos/modules/services/cluster/kubernetes/pki.nix

···

       361
       361
        
                 tlsCertFile = mkDefault cert;

     

       362
       362
        
                 tlsKeyFile = mkDefault key;

     

       363
       363
        
                 serviceAccountKeyFile = mkDefault cfg.certs.serviceAccount.cert;

     

       364
       364
       +
                 serviceAccountSigningKeyFile = mkDefault cfg.certs.serviceAccount.key;

     

       364
       365
        
                 kubeletClientCaFile = mkDefault caCert;

     

       365
       366
        
                 kubeletClientCertFile = mkDefault cfg.certs.apiserverKubeletClient.cert;

     

       366
       367
        
                 kubeletClientKeyFile = mkDefault cfg.certs.apiserverKubeletClient.key;

+2 -4

nixos/modules/services/networking/flannel.nix

···

       162
       162
        
               NODE_NAME = cfg.nodeName;

     

       163
       163
        
             };

     

       164
       164
        
             path = [ pkgs.iptables ];

     

       165
       165
       -
             preStart = ''

     

       166
       166
       -
               mkdir -p /run/flannel

     

       167
       167
       -
               touch /run/flannel/docker

     

       168
       168
       -
             '' + optionalString (cfg.storageBackend == "etcd") ''

     

       165
       165
       +
             preStart = optionalString (cfg.storageBackend == "etcd") ''

     

       169
       166
        
               echo "setting network configuration"

     

       170
       167
        
               until ${pkgs.etcdctl}/bin/etcdctl set /coreos.com/network/config '${builtins.toJSON networkConfig}'

     

       171
       168
        
               do

     
···

       177
       174
        
               ExecStart = "${cfg.package}/bin/flannel";

     

       178
       175
        
               Restart = "always";

     

       179
       176
        
               RestartSec = "10s";

     

       177
       177
       +
               RuntimeDirectory = "flannel";

     

       180
       178
        
             };

     

       181
       179
        
           };

     

       182
       180

+60

nixos/modules/virtualisation/containerd.nix

···

       1
       1
       +
       { pkgs, lib, config, ... }:

     

       2
       2
       +
       let

     

       3
       3
       +
         cfg = config.virtualisation.containerd;

     

       4
       4
       +
         containerdConfigChecked = pkgs.runCommand "containerd-config-checked.toml" { nativeBuildInputs = [pkgs.containerd]; } ''

     

       5
       5
       +
           containerd -c ${cfg.configFile} config dump >/dev/null

     

       6
       6
       +
           ln -s ${cfg.configFile} $out

     

       7
       7
       +
         '';

     

       8
       8
       +
       in

     

       9
       9
       +
       {

     

       10
       10
       +
       

     

       11
       11
       +
         options.virtualisation.containerd = with lib.types; {

     

       12
       12
       +
           enable = lib.mkEnableOption "containerd container runtime";

     

       13
       13
       +
       

     

       14
       14
       +
           configFile = lib.mkOption {

     

       15
       15
       +
             default = null;

     

       16
       16
       +
             description = "path to containerd config file";

     

       17
       17
       +
             type = nullOr path;

     

       18
       18
       +
           };

     

       19
       19
       +
       

     

       20
       20
       +
           args = lib.mkOption {

     

       21
       21
       +
             default = {};

     

       22
       22
       +
             description = "extra args to append to the containerd cmdline";

     

       23
       23
       +
             type = attrsOf str;

     

       24
       24
       +
           };

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         config = lib.mkIf cfg.enable {

     

       28
       28
       +
           virtualisation.containerd.args.config = lib.mkIf (cfg.configFile != null) (toString containerdConfigChecked);

     

       29
       29
       +
       

     

       30
       30
       +
           environment.systemPackages = [pkgs.containerd];

     

       31
       31
       +
       

     

       32
       32
       +
           systemd.services.containerd = {

     

       33
       33
       +
             description = "containerd - container runtime";

     

       34
       34
       +
             wantedBy = [ "multi-user.target" ];

     

       35
       35
       +
             after = [ "network.target" ];

     

       36
       36
       +
             path = with pkgs; [

     

       37
       37
       +
               containerd

     

       38
       38
       +
               runc

     

       39
       39
       +
               iptables

     

       40
       40
       +
             ];

     

       41
       41
       +
             serviceConfig = {

     

       42
       42
       +
               ExecStart = ''${pkgs.containerd}/bin/containerd ${lib.concatStringsSep " " (lib.cli.toGNUCommandLine {} cfg.args)}'';

     

       43
       43
       +
               Delegate = "yes";

     

       44
       44
       +
               KillMode = "process";

     

       45
       45
       +
               Type = "notify";

     

       46
       46
       +
               Restart = "always";

     

       47
       47
       +
               RestartSec = "5";

     

       48
       48
       +
               StartLimitBurst = "8";

     

       49
       49
       +
               StartLimitIntervalSec = "120s";

     

       50
       50
       +
       

     

       51
       51
       +
               # "limits" defined below are adopted from upstream: https://github.com/containerd/containerd/blob/master/containerd.service

     

       52
       52
       +
               LimitNPROC = "infinity";

     

       53
       53
       +
               LimitCORE = "infinity";

     

       54
       54
       +
               LimitNOFILE = "infinity";

     

       55
       55
       +
               TasksMax = "infinity";

     

       56
       56
       +
               OOMScoreAdjust = "-999";

     

       57
       57
       +
             };

     

       58
       58
       +
           };

     

       59
       59
       +
         };

     

       60
       60
       +
       }

+7 -8

nixos/tests/kubernetes/dns.nix

···

       34
       34
        
           name = "redis";

     

       35
       35
        
           tag = "latest";

     

       36
       36
        
           contents = [ pkgs.redis pkgs.bind.host ];

     

       37
       37
       -
           config.Entrypoint = "/bin/redis-server";

     

       37
       37
       +
           config.Entrypoint = ["/bin/redis-server"];

     

       38
       38
        
         };

     

       39
       39
        
       

     

       40
       40
        
         probePod = pkgs.writeText "probe-pod.json" (builtins.toJSON {

     
···

       55
       55
        
           name = "probe";

     

       56
       56
        
           tag = "latest";

     

       57
       57
        
           contents = [ pkgs.bind.host pkgs.busybox ];

     

       58
       58
       -
           config.Entrypoint = "/bin/tail";

     

       58
       58
       +
           config.Entrypoint = ["/bin/tail"];

     

       59
       59
        
         };

     

       60
       60
        
       

     

       61
       61
       -
         extraConfiguration = { config, pkgs, ... }: {

     

       61
       61
       +
         extraConfiguration = { config, pkgs, lib, ... }: {

     

       62
       62
        
           environment.systemPackages = [ pkgs.bind.host ];

     

       63
       63
       -
           # virtualisation.docker.extraOptions = "--dns=${config.services.kubernetes.addons.dns.clusterIp}";

     

       64
       63
        
           services.dnsmasq.enable = true;

     

       65
       64
        
           services.dnsmasq.servers = [

     

       66
       65
        
             "/cluster.local/${config.services.kubernetes.addons.dns.clusterIp}#53"

     
···

       77
       76
        
             # prepare machine1 for test

     

       78
       77
        
             machine1.wait_until_succeeds("kubectl get node machine1.${domain} | grep -w Ready")

     

       79
       78
        
             machine1.wait_until_succeeds(

     

       80
       80
       -
                 "docker load < ${redisImage}"

     

       79
       79
       +
                 "${pkgs.gzip}/bin/zcat ${redisImage} | ${pkgs.containerd}/bin/ctr -n k8s.io image import -"

     

       81
       80
        
             )

     

       82
       81
        
             machine1.wait_until_succeeds(

     

       83
       82
        
                 "kubectl create -f ${redisPod}"

     
···

       86
       85
        
                 "kubectl create -f ${redisService}"

     

       87
       86
        
             )

     

       88
       87
        
             machine1.wait_until_succeeds(

     

       89
       89
       -
                 "docker load < ${probeImage}"

     

       88
       88
       +
                 "${pkgs.gzip}/bin/zcat ${probeImage} | ${pkgs.containerd}/bin/ctr -n k8s.io image import -"

     

       90
       89
        
             )

     

       91
       90
        
             machine1.wait_until_succeeds(

     

       92
       91
        
                 "kubectl create -f ${probePod}"

     
···

       118
       117
        
             # prepare machines for test

     

       119
       118
        
             machine1.wait_until_succeeds("kubectl get node machine2.${domain} | grep -w Ready")

     

       120
       119
        
             machine2.wait_until_succeeds(

     

       121
       121
       -
                 "docker load < ${redisImage}"

     

       120
       120
       +
                 "${pkgs.gzip}/bin/zcat ${redisImage} | ${pkgs.containerd}/bin/ctr -n k8s.io image import -"

     

       122
       121
        
             )

     

       123
       122
        
             machine1.wait_until_succeeds(

     

       124
       123
        
                 "kubectl create -f ${redisPod}"

     
···

       127
       126
        
                 "kubectl create -f ${redisService}"

     

       128
       127
        
             )

     

       129
       128
        
             machine2.wait_until_succeeds(

     

       130
       130
       -
                 "docker load < ${probeImage}"

     

       129
       129
       +
                 "${pkgs.gzip}/bin/zcat ${probeImage} | ${pkgs.containerd}/bin/ctr -n k8s.io image import -"

     

       131
       130
        
             )

     

       132
       131
        
             machine1.wait_until_succeeds(

     

       133
       132
        
                 "kubectl create -f ${probePod}"

+3 -3

nixos/tests/kubernetes/rbac.nix

···

       85
       85
        
           name = "kubectl";

     

       86
       86
        
           tag = "latest";

     

       87
       87
        
           contents = [ kubectl pkgs.busybox kubectlPod2 ];

     

       88
       88
       -
           config.Entrypoint = "/bin/sh";

     

       88
       88
       +
           config.Entrypoint = ["/bin/sh"];

     

       89
       89
        
         };

     

       90
       90
        
       

     

       91
       91
        
         base = {

     
···

       97
       97
        
             machine1.wait_until_succeeds("kubectl get node machine1.my.zyx | grep -w Ready")

     

       98
       98
        
       

     

       99
       99
        
             machine1.wait_until_succeeds(

     

       100
       100
       -
                 "docker load < ${kubectlImage}"

     

       100
       100
       +
                 "${pkgs.gzip}/bin/zcat ${kubectlImage} | ${pkgs.containerd}/bin/ctr -n k8s.io image import -"

     

       101
       101
        
             )

     

       102
       102
        
       

     

       103
       103
        
             machine1.wait_until_succeeds(

     
···

       134
       134
        
             machine1.wait_until_succeeds("kubectl get node machine2.my.zyx | grep -w Ready")

     

       135
       135
        
       

     

       136
       136
        
             machine2.wait_until_succeeds(

     

       137
       137
       -
                 "docker load < ${kubectlImage}"

     

       137
       137
       +
                 "${pkgs.gzip}/bin/zcat ${kubectlImage} | ${pkgs.containerd}/bin/ctr -n k8s.io image import -"

     

       138
       138
        
             )

     

       139
       139
        
       

     

       140
       140
        
             machine1.wait_until_succeeds(

+2 -2

pkgs/applications/blockchains/particl/particl-core.nix

···

       17
       17
        
       

     

       18
       18
        
       stdenv.mkDerivation rec {

     

       19
       19
        
         pname = "particl-core";

     

       20
       20
       -
         version = "0.19.2.3";

     

       20
       20
       +
         version = "0.19.2.5";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchurl {

     

       23
       23
        
           url = "https://github.com/particl/particl-core/archive/v${version}.tar.gz";

     

       24
       24
       -
           sha256 = "sha256-nAsQvYWUejSu/4MMIwZhlV5Gjza/Da4jcp6/01lppvg=";

     

       24
       24
       +
           sha256 = "sha256-uI4T8h6RvCikk8h/sZmGlj3Uj3Xhu0vDn/fPb6rLcSg=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         nativeBuildInputs = [ pkg-config autoreconfHook ];

+3 -6

pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix

···

       33
       33
        
       

     

       34
       34
        
       , gmp

     

       35
       35
        
       

     

       36
       36
       -
       # Pluggable transport dependencies

     

       37
       37
       -
       , python27

     

       38
       38
       -
       

     

       39
       36
        
       # Wrapper runtime

     

       40
       37
        
       , coreutils

     

       41
       38
        
       , glibcLocales

     
···

       91
       88
        
         fteLibPath = makeLibraryPath [ stdenv.cc.cc gmp ];

     

       92
       89
        
       

     

       93
       90
        
         # Upstream source

     

       94
       94
       -
         version = "10.0.12";

     

       91
       91
       +
         version = "10.0.13";

     

       95
       92
        
       

     

       96
       93
        
         lang = "en-US";

     

       97
       94
        
       

     

       98
       95
        
         srcs = {

     

       99
       96
        
           x86_64-linux = fetchurl {

     

       100
       97
        
             url = "https://dist.torproject.org/torbrowser/${version}/tor-browser-linux64-${version}_${lang}.tar.xz";

     

       101
       101
       -
             sha256 = "0i5g997kgn7n6ji7pxbyvkx33nqfi2s1val680fp5hh1zz31yvfv";

     

       98
       98
       +
             sha256 = "sha256-KxJKS/ymbkAg8LjMFz3BDSupPk5cNB1pFz9fFyRTndk=";

     

       102
       99
        
           };

     

       103
       100
        
       

     

       104
       101
        
           i686-linux = fetchurl {

     

       105
       102
        
             url = "https://dist.torproject.org/torbrowser/${version}/tor-browser-linux32-${version}_${lang}.tar.xz";

     

       106
       106
       -
             sha256 = "16915fvvq3d16v1bzclnb52sa6yyaalihk3gv93jcnph9vsz8ags";

     

       103
       103
       +
             sha256 = "sha256-4glc2qP6AdHtWc8zW+varG30rlAXpeFyKjqDPsmiVfI=";

     

       107
       104
        
           };

     

       108
       105
        
         };

     

       109
       106
        
       in

+13 -6

pkgs/applications/networking/cluster/kubernetes/default.nix

···

       20
       20
        
       

     

       21
       21
        
       stdenv.mkDerivation rec {

     

       22
       22
        
         pname = "kubernetes";

     

       23
       23
       -
         version = "1.19.5";

     

       23
       23
       +
         version = "1.20.4";

     

       24
       24
        
       

     

       25
       25
        
         src = fetchFromGitHub {

     

       26
       26
        
           owner = "kubernetes";

     

       27
       27
        
           repo = "kubernetes";

     

       28
       28
        
           rev = "v${version}";

     

       29
       29
       -
           sha256 = "15bv620fj4x731f2z2a9dcdss18rk379kc40g49bpqsdn42jjx2z";

     

       29
       29
       +
           sha256 = "0nni351ya688dphdkpyq94p3wjw2kigg85kmalwdpv5wpz1abl5g";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         nativeBuildInputs = [ removeReferencesTo makeWrapper which go rsync installShellFiles ];

     

       33
       33
        
       

     

       34
       34
        
         outputs = [ "out" "man" "pause" ];

     

       35
       35
        
       

     

       36
       36
       +
         patches = [ ./fixup-addonmanager-lib-path.patch ];

     

       37
       37
       +
       

     

       36
       38
        
         postPatch = ''

     

       37
       39
        
           # go env breaks the sandbox

     

       38
       40
        
           substituteInPlace "hack/lib/golang.sh" \

     
···

       53
       55
        
       

     

       54
       56
        
         postBuild = ''

     

       55
       57
        
           ./hack/update-generated-docs.sh

     

       56
       56
       -
           (cd build/pause && cc pause.c -o pause)

     

       58
       58
       +
           (cd build/pause/linux && cc pause.c -o pause)

     

       57
       59
        
         '';

     

       58
       60
        
       

     

       59
       61
        
         installPhase = ''

     
···

       61
       63
        
             install -D _output/local/go/bin/''${p##*/} -t $out/bin

     

       62
       64
        
           done

     

       63
       65
        
       

     

       64
       64
       -
           install -D build/pause/pause -t $pause/bin

     

       66
       66
       +
           install -D build/pause/linux/pause -t $pause/bin

     

       65
       67
        
           installManPage docs/man/man1/*.[1-9]

     

       66
       68
        
       

     

       67
       67
       -
           cp cluster/addons/addon-manager/kube-addons.sh $out/bin/kube-addons

     

       69
       69
       +
           # Unfortunately, kube-addons-main.sh only looks for the lib file in either the current working dir

     

       70
       70
       +
           # or in /opt. We have to patch this for now.

     

       71
       71
       +
           substitute cluster/addons/addon-manager/kube-addons-main.sh $out/bin/kube-addons \

     

       72
       72
       +
             --subst-var out

     

       73
       73
       +
       

     

       74
       74
       +
           chmod +x $out/bin/kube-addons

     

       68
       75
        
           patchShebangs $out/bin/kube-addons

     

       69
       76
        
           wrapProgram $out/bin/kube-addons --set "KUBECTL_BIN" "$out/bin/kubectl"

     

       70
       77
        
       

     

       71
       71
       -
           cp ${./mk-docker-opts.sh} $out/bin/mk-docker-opts.sh

     

       78
       78
       +
           cp cluster/addons/addon-manager/kube-addons.sh $out/bin/kube-addons-lib.sh

     

       72
       79
        
       

     

       73
       80
        
           for tool in kubeadm kubectl; do

     

       74
       81
        
             installShellCompletion --cmd $tool \

+23

pkgs/applications/networking/cluster/kubernetes/fixup-addonmanager-lib-path.patch

···

       1
       1
       +
       diff --git a/cluster/addons/addon-manager/kube-addons-main.sh b/cluster/addons/addon-manager/kube-addons-main.sh

     

       2
       2
       +
       index 849973470d1..e4fef30eaea 100755

     

       3
       3
       +
       --- a/cluster/addons/addon-manager/kube-addons-main.sh

     

       4
       4
       +
       +++ b/cluster/addons/addon-manager/kube-addons-main.sh

     

       5
       5
       +
       @@ -17,17 +17,7 @@

     

       6
       6
       +
        # Import required functions. The addon manager is installed to /opt in

     

       7
       7
       +
        # production use (see the Dockerfile)

     

       8
       8
       +
        # Disabling shellcheck following files as the full path would be required.

     

       9
       9
       +
       -if [ -f "kube-addons.sh" ]; then

     

       10
       10
       +
       -  # shellcheck disable=SC1091

     

       11
       11
       +
       -  source "kube-addons.sh"

     

       12
       12
       +
       -elif [ -f "/opt/kube-addons.sh" ]; then

     

       13
       13
       +
       -  # shellcheck disable=SC1091

     

       14
       14
       +
       -  source "/opt/kube-addons.sh"

     

       15
       15
       +
       -else

     

       16
       16
       +
       -  # If the required source is missing, we have to fail.

     

       17
       17
       +
       -  log ERR "== Could not find kube-addons.sh (not in working directory or /opt) at $(date -Is) =="

     

       18
       18
       +
       -  exit 1

     

       19
       19
       +
       -fi

     

       20
       20
       +
       +source "@out@/bin/kube-addons-lib.sh"

     

       21
       21
       +
        

     

       22
       22
       +
        # The business logic for whether a given object should be created

     

       23
       23
       +
        # was already enforced by salt, and /etc/kubernetes/addons is the

-113

pkgs/applications/networking/cluster/kubernetes/mk-docker-opts.sh

···

       1
       1
       -
       #!/usr/bin/env bash

     

       2
       2
       -
       

     

       3
       3
       -
       # Copyright 2014 The Kubernetes Authors.

     

       4
       4
       -
       #

     

       5
       5
       -
       # Licensed under the Apache License, Version 2.0 (the "License");

     

       6
       6
       -
       # you may not use this file except in compliance with the License.

     

       7
       7
       -
       # You may obtain a copy of the License at

     

       8
       8
       -
       #

     

       9
       9
       -
       #     http://www.apache.org/licenses/LICENSE-2.0

     

       10
       10
       -
       #

     

       11
       11
       -
       # Unless required by applicable law or agreed to in writing, software

     

       12
       12
       -
       # distributed under the License is distributed on an "AS IS" BASIS,

     

       13
       13
       -
       # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

     

       14
       14
       -
       # See the License for the specific language governing permissions and

     

       15
       15
       -
       # limitations under the License.

     

       16
       16
       -
       

     

       17
       17
       -
       # Generate Docker daemon options based on flannel env file.

     

       18
       18
       -
       

     

       19
       19
       -
       # exit on any error

     

       20
       20
       -
       set -e

     

       21
       21
       -
       

     

       22
       22
       -
       usage() {

     

       23
       23
       -
         echo "$0 [-f FLANNEL-ENV-FILE] [-d DOCKER-ENV-FILE] [-i] [-c] [-m] [-k COMBINED-KEY]

     

       24
       24
       -
       

     

       25
       25
       -
       Generate Docker daemon options based on flannel env file

     

       26
       26
       -
       OPTIONS:

     

       27
       27
       -
           -f  Path to flannel env file. Defaults to /run/flannel/subnet.env

     

       28
       28
       -
           -d  Path to Docker env file to write to. Defaults to /run/docker_opts.env

     

       29
       29
       -
           -i  Output each Docker option as individual var. e.g. DOCKER_OPT_MTU=1500

     

       30
       30
       -
           -c  Output combined Docker options into DOCKER_OPTS var

     

       31
       31
       -
           -k  Set the combined options key to this value (default DOCKER_OPTS=)

     

       32
       32
       -
           -m  Do not output --ip-masq (useful for older Docker version)

     

       33
       33
       -
       " >/dev/stderr

     

       34
       34
       -
         exit 1

     

       35
       35
       -
       }

     

       36
       36
       -
       

     

       37
       37
       -
       flannel_env="/run/flannel/subnet.env"

     

       38
       38
       -
       docker_env="/run/docker_opts.env"

     

       39
       39
       -
       combined_opts_key="DOCKER_OPTS"

     

       40
       40
       -
       indiv_opts=false

     

       41
       41
       -
       combined_opts=false

     

       42
       42
       -
       ipmasq=true

     

       43
       43
       -
       val=""

     

       44
       44
       -
       

     

       45
       45
       -
       while getopts "f:d:icmk:" opt; do

     

       46
       46
       -
         case $opt in

     

       47
       47
       -
           f)

     

       48
       48
       -
             flannel_env=$OPTARG

     

       49
       49
       -
             ;;

     

       50
       50
       -
           d)

     

       51
       51
       -
             docker_env=$OPTARG

     

       52
       52
       -
             ;;

     

       53
       53
       -
           i)

     

       54
       54
       -
             indiv_opts=true

     

       55
       55
       -
             ;;

     

       56
       56
       -
           c)

     

       57
       57
       -
             combined_opts=true

     

       58
       58
       -
             ;;

     

       59
       59
       -
           m)

     

       60
       60
       -
             ipmasq=false

     

       61
       61
       -
             ;;

     

       62
       62
       -
           k)

     

       63
       63
       -
             combined_opts_key=$OPTARG

     

       64
       64
       -
             ;;

     

       65
       65
       -
           \?)

     

       66
       66
       -
             usage

     

       67
       67
       -
             ;;

     

       68
       68
       -
         esac

     

       69
       69
       -
       done

     

       70
       70
       -
       

     

       71
       71
       -
       if [[ $indiv_opts = false ]] && [[ $combined_opts = false ]]; then

     

       72
       72
       -
         indiv_opts=true

     

       73
       73
       -
         combined_opts=true

     

       74
       74
       -
       fi

     

       75
       75
       -
       

     

       76
       76
       -
       if [[ -f "${flannel_env}" ]]; then

     

       77
       77
       -
         source "${flannel_env}"

     

       78
       78
       -
       fi

     

       79
       79
       -
       

     

       80
       80
       -
       if [[ -n "$FLANNEL_SUBNET" ]]; then

     

       81
       81
       -
         # shellcheck disable=SC2034  # Variable name referenced in OPT_LOOP below

     

       82
       82
       -
         DOCKER_OPT_BIP="--bip=$FLANNEL_SUBNET"

     

       83
       83
       -
       fi

     

       84
       84
       -
       

     

       85
       85
       -
       if [[ -n "$FLANNEL_MTU" ]]; then

     

       86
       86
       -
         # shellcheck disable=SC2034  # Variable name referenced in OPT_LOOP below

     

       87
       87
       -
         DOCKER_OPT_MTU="--mtu=$FLANNEL_MTU"

     

       88
       88
       -
       fi

     

       89
       89
       -
       

     

       90
       90
       -
       if [[ "$FLANNEL_IPMASQ" = true ]] && [[ $ipmasq = true ]]; then

     

       91
       91
       -
         # shellcheck disable=SC2034  # Variable name referenced in OPT_LOOP below

     

       92
       92
       -
         DOCKER_OPT_IPMASQ="--ip-masq=false"

     

       93
       93
       -
       fi

     

       94
       94
       -
       

     

       95
       95
       -
       eval docker_opts="\$${combined_opts_key}"

     

       96
       96
       -
       docker_opts+=" "

     

       97
       97
       -
       

     

       98
       98
       -
       echo -n "" >"${docker_env}"

     

       99
       99
       -
       

     

       100
       100
       -
       # OPT_LOOP

     

       101
       101
       -
       for opt in $(compgen -v DOCKER_OPT_); do

     

       102
       102
       -
         eval val=\$"${opt}"

     

       103
       103
       -
       

     

       104
       104
       -
         if [[ "$indiv_opts" = true ]]; then

     

       105
       105
       -
           echo "$opt=\"$val\"" >>"${docker_env}"

     

       106
       106
       -
         fi

     

       107
       107
       -
       

     

       108
       108
       -
         docker_opts+="$val "

     

       109
       109
       -
       done

     

       110
       110
       -
       

     

       111
       111
       -
       if [[ "$combined_opts" = true ]]; then

     

       112
       112
       -
         echo "${combined_opts_key}=\"${docker_opts}\"" >>"${docker_env}"

     

       113
       113
       -
       fi

+44

pkgs/applications/networking/cluster/ssm-agent/0001-Disable-NIC-tests-that-fail-in-the-Nix-sandbox.patch

···

       1
       1
       +
       From bea6307ec2a77d90d59c13940381d73ec0f05b70 Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: Graham Christensen <graham@grahamc.com>

     

       3
       3
       +
       Date: Mon, 1 Mar 2021 10:57:44 -0500

     

       4
       4
       +
       Subject: [PATCH] Disable NIC tests that fail in the Nix sandbox.

     

       5
       5
       +
       

     

       6
       6
       +
       ---

     

       7
       7
       +
        agent/managedInstances/fingerprint/fingerprint_integ_test.go | 2 ++

     

       8
       8
       +
        agent/ssm/service_test.go                                    | 1 +

     

       9
       9
       +
        2 files changed, 3 insertions(+)

     

       10
       10
       +
       

     

       11
       11
       +
       diff --git a/agent/managedInstances/fingerprint/fingerprint_integ_test.go b/agent/managedInstances/fingerprint/fingerprint_integ_test.go

     

       12
       12
       +
       index a1f969ff..631ea1f5 100644

     

       13
       13
       +
       --- a/agent/managedInstances/fingerprint/fingerprint_integ_test.go

     

       14
       14
       +
       +++ b/agent/managedInstances/fingerprint/fingerprint_integ_test.go

     

       15
       15
       +
       @@ -28,12 +28,14 @@ func TestHostnameInfo(t *testing.T) {

     

       16
       16
       +
        }

     

       17
       17
       +
        

     

       18
       18
       +
        func TestPrimaryIpInfo(t *testing.T) {

     

       19
       19
       +
       +	t.Skip("The Nix build sandbox has no non-loopback IPs, causing this test to fail.");

     

       20
       20
       +
        	ip, err := primaryIpInfo()

     

       21
       21
       +
        	assert.NoError(t, err, "expected no error fetching the primary ip")

     

       22
       22
       +
        	assert.NotEmpty(t, ip, "expected to fetch primary ip")

     

       23
       23
       +
        }

     

       24
       24
       +
        

     

       25
       25
       +
        func TestMacAddrInfo(t *testing.T) {

     

       26
       26
       +
       +	t.Skip("The Nix build sandbox has no non-loopback interfaces, causing this test to fail.");

     

       27
       27
       +
        	mac, err := macAddrInfo()

     

       28
       28
       +
        	assert.NoError(t, err, "expected no error fetching the mac addr")

     

       29
       29
       +
        	assert.NotEmpty(t, mac, "expected to fetch mac address")

     

       30
       30
       +
       diff --git a/agent/ssm/service_test.go b/agent/ssm/service_test.go

     

       31
       31
       +
       index f4b34f83..d8216dba 100644

     

       32
       32
       +
       --- a/agent/ssm/service_test.go

     

       33
       33
       +
       +++ b/agent/ssm/service_test.go

     

       34
       34
       +
       @@ -85,6 +85,7 @@ func (suite *SsmServiceTestSuite) TestUpdateEmptyInstanceInformation() {

     

       35
       35
       +
        // Test function for update instance information

     

       36
       36
       +
        // This function update the agent name, agent statuc, and agent version.

     

       37
       37
       +
        func (suite *SsmServiceTestSuite) TestUpdateInstanceInformation() {

     

       38
       38
       +
       +	suite.T().Skip("The Nix build sandbox has no interfaces for IP and MAC address reports.");

     

       39
       39
       +
        	// Give mock value to test UpdateInstanceInformation, assert the error is nil, assert the log.Debug function get called.

     

       40
       40
       +
        	response, err := suite.sdkService.UpdateInstanceInformation(suite.logMock, "2.2.3.2", "active", "Amazon-ssm-agent")

     

       41
       41
       +
        	assert.Nil(suite.T(), err, "Err should be nil")

     

       42
       42
       +
       -- 

     

       43
       43
       +
       2.29.2

     

       44
       44
       +

+46

pkgs/applications/networking/cluster/ssm-agent/0002-version-gen-don-t-use-unnecessary-constants.patch

···

       1
       1
       +
       From 473e3f8544915a35b3a45c548743978b34e5310e Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: Cole Helbling <cole.e.helbling@outlook.com>

     

       3
       3
       +
       Date: Tue, 2 Mar 2021 00:24:00 -0800

     

       4
       4
       +
       Subject: [PATCH] version-gen: don't use unnecessary constants

     

       5
       5
       +
       

     

       6
       6
       +
       This prevents the tool from being built with Nix, because this project

     

       7
       7
       +
       doesn't use Go modules (or something; I'm not really familiar with Go,

     

       8
       8
       +
       much less Go + Nix).

     

       9
       9
       +
       ---

     

       10
       10
       +
        agent/version/versiongenerator/version-gen.go | 6 ++----

     

       11
       11
       +
        1 file changed, 2 insertions(+), 4 deletions(-)

     

       12
       12
       +
       

     

       13
       13
       +
       diff --git a/agent/version/versiongenerator/version-gen.go b/agent/version/versiongenerator/version-gen.go

     

       14
       14
       +
       index d710effc..55c9a001 100644

     

       15
       15
       +
       --- a/agent/version/versiongenerator/version-gen.go

     

       16
       16
       +
       +++ b/agent/version/versiongenerator/version-gen.go

     

       17
       17
       +
       @@ -22,8 +22,6 @@ import (

     

       18
       18
       +
        	"path/filepath"

     

       19
       19
       +
        	"strings"

     

       20
       20
       +
        	"text/template"

     

       21
       21
       +
       -

     

       22
       22
       +
       -	"github.com/aws/amazon-ssm-agent/agent/appconfig"

     

       23
       23
       +
        )

     

       24
       24
       +
        

     

       25
       25
       +
        const versiongoTemplate = `// This is an autogenerated file and should not be edited.

     

       26
       26
       +
       @@ -59,7 +57,7 @@ func main() {

     

       27
       27
       +
        	versionStr := strings.TrimSpace(string(versionContent))

     

       28
       28
       +
        

     

       29
       29
       +
        	fmt.Printf("Agent Version: %v", versionStr)

     

       30
       30
       +
       -	if err := ioutil.WriteFile(filepath.Join("VERSION"), []byte(versionStr), appconfig.ReadWriteAccess); err != nil {

     

       31
       31
       +
       +	if err := ioutil.WriteFile(filepath.Join("VERSION"), []byte(versionStr), 0600); err != nil {

     

       32
       32
       +
        		log.Fatalf("Error writing to VERSION file. %v", err)

     

       33
       33
       +
        	}

     

       34
       34
       +
        

     

       35
       35
       +
       @@ -108,7 +106,7 @@ func main() {

     

       36
       36
       +
        

     

       37
       37
       +
        	releaseNoteOutFile := strings.Join(releaseNoteLines, "\n")

     

       38
       38
       +
        

     

       39
       39
       +
       -	if err = ioutil.WriteFile(filepath.Join(releaseNotesFile), []byte(releaseNoteOutFile), appconfig.ReadWriteAccess); err != nil {

     

       40
       40
       +
       +	if err = ioutil.WriteFile(filepath.Join(releaseNotesFile), []byte(releaseNoteOutFile), 0600); err != nil {

     

       41
       41
       +
        		log.Fatalf("Error writing to RELEASENOTES.md file. %v", err)

     

       42
       42
       +
        	}

     

       43
       43
       +
        

     

       44
       44
       +
       -- 

     

       45
       45
       +
       2.30.0

     

       46
       46
       +

+84 -37

pkgs/applications/networking/cluster/ssm-agent/default.nix

···

       1
       1
       -
       { lib, fetchFromGitHub, buildGoPackage, bash, makeWrapper }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , writeShellScriptBin

     

       3
       3
       +
       , buildGoPackage

     

       4
       4
       +
       , makeWrapper

     

       5
       5
       +
       , fetchFromGitHub

     

       6
       6
       +
       , coreutils

     

       7
       7
       +
       , nettools

     

       8
       8
       +
       , dmidecode

     

       9
       9
       +
       , util-linux

     

       10
       10
       +
       , bashInteractive

     

       11
       11
       +
       }:

     

       12
       12
       +
       

     

       13
       13
       +
       let

     

       14
       14
       +
         # Tests use lsb_release, so we mock it (the SSM agent used to not

     

       15
       15
       +
         # read from our /etc/os-release file, but now it does) because in

     

       16
       16
       +
         # reality, it won't (shouldn't) be used when active on a system with

     

       17
       17
       +
         # /etc/os-release. If it is, we fake the only two fields it cares about.

     

       18
       18
       +
         fake-lsb-release = writeShellScriptBin "lsb_release" ''

     

       19
       19
       +
           . /etc/os-release || true

     

       2
       20
        
       

     

       21
       21
       +
           case "$1" in

     

       22
       22
       +
             -i) echo "''${NAME:-unknown}";;

     

       23
       23
       +
             -r) echo "''${VERSION:-unknown}";;

     

       24
       24
       +
           esac

     

       25
       25
       +
         '';

     

       26
       26
       +
       in

     

       3
       27
        
       buildGoPackage rec {

     

       4
       4
       -
         pname   = "amazon-ssm-agent";

     

       5
       5
       -
         version = "2.3.1319.0";

     

       28
       28
       +
         pname = "amazon-ssm-agent";

     

       29
       29
       +
         version = "3.0.755.0";

     

       6
       30
        
       

     

       7
       31
        
         goPackagePath = "github.com/aws/${pname}";

     

       8
       8
       -
         subPackages   = [

     

       9
       9
       -
           "agent"

     

       10
       10
       -
           "agent/framework/processor/executer/outofproc/worker"

     

       11
       11
       -
           "agent/framework/processor/executer/outofproc/worker"

     

       12
       12
       -
           "agent/framework/processor/executer/outofproc/sessionworker"

     

       13
       13
       -
           "agent/session/logging"

     

       14
       14
       -
           "agent/cli-main"

     

       15
       15
       -
         ];

     

       16
       32
        
       

     

       17
       33
        
         nativeBuildInputs = [ makeWrapper ];

     

       18
       34
        
       

     

       19
       35
        
         src = fetchFromGitHub {

     

       20
       20
       -
           rev    = version;

     

       21
       21
       -
           owner  = "aws";

     

       22
       22
       -
           repo   = pname;

     

       23
       23
       -
           sha256 = "1yiyhj7ckqa32b1rnbwn7zx89rsj00m5imn1xlpsw002ywxsxbnv";

     

       36
       36
       +
           rev = version;

     

       37
       37
       +
           owner = "aws";

     

       38
       38
       +
           repo = "amazon-ssm-agent";

     

       39
       39
       +
           hash = "sha256-yVQJL1MJ1JlAndlrXfEbNLQihlbLhSoQXTKzJMRzhao=";

     

       24
       40
        
         };

     

       25
       41
        
       

     

       42
       42
       +
         patches = [

     

       43
       43
       +
           # Some tests use networking, so we skip them.

     

       44
       44
       +
           ./0001-Disable-NIC-tests-that-fail-in-the-Nix-sandbox.patch

     

       45
       45
       +
       

     

       46
       46
       +
           # They used constants from another package that I couldn't figure

     

       47
       47
       +
           # out how to resolve, so hardcoded the constants.

     

       48
       48
       +
           ./0002-version-gen-don-t-use-unnecessary-constants.patch

     

       49
       49
       +
         ];

     

       50
       50
       +
       

     

       51
       51
       +
         preConfigure = ''

     

       52
       52
       +
           rm -r ./Tools/src/goreportcard

     

       53
       53
       +
           printf "#!/bin/sh\ntrue" > ./Tools/src/checkstyle.sh

     

       54
       54
       +
       

     

       55
       55
       +
           substituteInPlace agent/platform/platform_unix.go \

     

       56
       56
       +
               --replace "/usr/bin/uname" "${coreutils}/bin/uname" \

     

       57
       57
       +
               --replace '"/bin", "hostname"' '"${nettools}/bin/hostname"' \

     

       58
       58
       +
               --replace '"lsb_release"' '"${fake-lsb-release}/bin/lsb_release"'

     

       59
       59
       +
       

     

       60
       60
       +
           substituteInPlace agent/managedInstances/fingerprint/hardwareInfo_unix.go \

     

       61
       61
       +
               --replace /usr/sbin/dmidecode ${dmidecode}/bin/dmidecode

     

       62
       62
       +
       

     

       63
       63
       +
           substituteInPlace agent/session/shell/shell_unix.go \

     

       64
       64
       +
               --replace '"script"' '"${util-linux}/bin/script"'

     

       65
       65
       +
       

     

       66
       66
       +
           echo "${version}" > VERSION

     

       67
       67
       +
         '';

     

       68
       68
       +
       

     

       26
       69
        
         preBuild = ''

     

       27
       27
       -
           mv go/src/${goPackagePath}/vendor strange-vendor

     

       28
       28
       -
           mv strange-vendor/src go/src/${goPackagePath}/vendor

     

       70
       70
       +
           cp -r go/src/${goPackagePath}/vendor/src go

     

       29
       71
        
       

     

       30
       30
       -
           cd go/src/${goPackagePath}

     

       31
       31
       -
           echo ${version} > VERSION

     

       72
       72
       +
           pushd go/src/${goPackagePath}

     

       32
       73
        
       

     

       33
       33
       -
           substituteInPlace agent/plugins/inventory/gatherers/application/dataProvider.go \

     

       34
       34
       -
             --replace '"github.com/aws/amazon-ssm-agent/agent/plugins/configurepackage/localpackages"' ""

     

       74
       74
       +
           # Note: if this step fails, please patch the code to fix it! Please only skip

     

       75
       75
       +
           # tests if it is not feasible for the test to pass in a sandbox.

     

       76
       76
       +
           make quick-integtest

     

       35
       77
        
       

     

       36
       36
       -
           go run agent/version/versiongenerator/version-gen.go

     

       37
       37
       -
           substituteInPlace agent/appconfig/constants_unix.go \

     

       38
       38
       -
             --replace /usr/bin/ssm-document-worker $bin/bin/ssm-document-worker \

     

       39
       39
       -
             --replace /usr/bin/ssm-session-worker $bin/bin/ssm-session-worker \

     

       40
       40
       -
             --replace /usr/bin/ssm-session-logger $bin/bin/ssm-session-logger

     

       41
       41
       -
           cd -

     

       78
       78
       +
           make pre-release

     

       79
       79
       +
           make pre-build

     

       80
       80
       +
       

     

       81
       81
       +
           popd

     

       42
       82
        
         '';

     

       43
       83
        
       

     

       44
       84
        
         postBuild = ''

     

       45
       45
       -
           mv go/bin/agent go/bin/amazon-ssm-agent

     

       46
       46
       -
           mv go/bin/worker go/bin/ssm-document-worker

     

       47
       47
       -
           mv go/bin/sessionworker go/bin/ssm-session-worker

     

       48
       48
       -
           mv go/bin/logging go/bin/ssm-session-logger

     

       49
       49
       -
           mv go/bin/cli-main go/bin/ssm-cli

     

       85
       85
       +
           pushd go/bin

     

       86
       86
       +
       

     

       87
       87
       +
           rm integration-cli versiongenerator generator

     

       88
       88
       +
       

     

       89
       89
       +
           mv core amazon-ssm-agent

     

       90
       90
       +
           mv agent ssm-agent-worker

     

       91
       91
       +
           mv cli-main ssm-cli

     

       92
       92
       +
           mv worker ssm-document-worker

     

       93
       93
       +
           mv logging ssm-session-logger

     

       94
       94
       +
           mv sessionworker ssm-session-worker

     

       95
       95
       +
       

     

       96
       96
       +
           popd

     

       50
       97
        
         '';

     

       51
       98
        
       

     

       52
       52
       -
         postInstall = ''

     

       53
       53
       -
           wrapProgram $out/bin/amazon-ssm-agent --prefix PATH : ${bash}/bin

     

       99
       99
       +
         postFixup = ''

     

       100
       100
       +
           wrapProgram $out/bin/amazon-ssm-agent --prefix PATH : ${bashInteractive}/bin

     

       54
       101
        
         '';

     

       55
       102
        
       

     

       56
       103
        
         meta = with lib; {

     

       57
       104
        
           description = "Agent to enable remote management of your Amazon EC2 instance configuration";

     

       58
       58
       -
           homepage    = "https://github.com/aws/amazon-ssm-agent";

     

       59
       59
       -
           license     = licenses.asl20;

     

       60
       60
       -
           platforms   = platforms.unix;

     

       105
       105
       +
           homepage = "https://github.com/aws/amazon-ssm-agent";

     

       106
       106
       +
           license = licenses.asl20;

     

       107
       107
       +
           platforms = platforms.unix;

     

       61
       108
        
           maintainers = with maintainers; [ copumpkin manveru ];

     

       62
       109
        
         };

     

       63
       110
        
       }

+1 -1

pkgs/applications/networking/instant-messengers/mirage/default.nix

···

       1
       1
        
       { lib, stdenv, mkDerivation, fetchFromGitHub

     

       2
       2
        
       , qmake, pkg-config, olm, wrapQtAppsHook

     

       3
       3
       -
       , qtbase, qtquickcontrols2, qtkeychain, qtmultimedia, qttools, qtgraphicaleffects

     

       3
       3
       +
       , qtbase, qtquickcontrols2, qtkeychain, qtmultimedia, qtgraphicaleffects

     

       4
       4
        
       , python3Packages, pyotherside, libXScrnSaver

     

       5
       5
        
       }:

     

       6
       6

+131

pkgs/applications/science/math/sage/patches/eclib-20210223-test-formatting.patch

···

       1
       1
       +
       diff --git a/src/sage/libs/eclib/interface.py b/src/sage/libs/eclib/interface.py

     

       2
       2
       +
       index e898456720..6b98c12328 100644

     

       3
       3
       +
       --- a/src/sage/libs/eclib/interface.py

     

       4
       4
       +
       +++ b/src/sage/libs/eclib/interface.py

     

       5
       5
       +
       @@ -758,78 +758,78 @@ class mwrank_MordellWeil(SageObject):

     

       6
       6
       +
        

     

       7
       7
       +
                sage: EQ = mwrank_MordellWeil(E, verbose=True)

     

       8
       8
       +
                sage: EQ.search(1)

     

       9
       9
       +
       -        P1 = [0:1:0]     is torsion point, order 1

     

       10
       10
       +
       -        P1 = [-3:0:1]     is generator number 1

     

       11
       11
       +
       -        saturating up to 20...Checking 2-saturation

     

       12
       12
       +
       +        P1 = [0:1:0]         is torsion point, order 1

     

       13
       13
       +
       +        P1 = [-3:0:1]         is generator number 1

     

       14
       14
       +
       +        saturating up to 20...Checking 2-saturation...

     

       15
       15
       +
                Points have successfully been 2-saturated (max q used = 7)

     

       16
       16
       +
       -        Checking 3-saturation

     

       17
       17
       +
       +        Checking 3-saturation...

     

       18
       18
       +
                Points have successfully been 3-saturated (max q used = 7)

     

       19
       19
       +
       -        Checking 5-saturation

     

       20
       20
       +
       +        Checking 5-saturation...

     

       21
       21
       +
                Points have successfully been 5-saturated (max q used = 23)

     

       22
       22
       +
       -        Checking 7-saturation

     

       23
       23
       +
       +        Checking 7-saturation...

     

       24
       24
       +
                Points have successfully been 7-saturated (max q used = 41)

     

       25
       25
       +
       -        Checking 11-saturation

     

       26
       26
       +
       +        Checking 11-saturation...

     

       27
       27
       +
                Points have successfully been 11-saturated (max q used = 17)

     

       28
       28
       +
       -        Checking 13-saturation

     

       29
       29
       +
       +        Checking 13-saturation...

     

       30
       30
       +
                Points have successfully been 13-saturated (max q used = 43)

     

       31
       31
       +
       -        Checking 17-saturation

     

       32
       32
       +
       +        Checking 17-saturation...

     

       33
       33
       +
                Points have successfully been 17-saturated (max q used = 31)

     

       34
       34
       +
       -        Checking 19-saturation

     

       35
       35
       +
       +        Checking 19-saturation...

     

       36
       36
       +
                Points have successfully been 19-saturated (max q used = 37)

     

       37
       37
       +
                done

     

       38
       38
       +
       -        P2 = [-2:3:1]     is generator number 2

     

       39
       39
       +
       -        saturating up to 20...Checking 2-saturation

     

       40
       40
       +
       +        P2 = [-2:3:1]         is generator number 2

     

       41
       41
       +
       +        saturating up to 20...Checking 2-saturation...

     

       42
       42
       +
                possible kernel vector = [1,1]

     

       43
       43
       +
                This point may be in 2E(Q): [14:-52:1]

     

       44
       44
       +
                ...and it is!

     

       45
       45
       +
                Replacing old generator #1 with new generator [1:-1:1]

     

       46
       46
       +
                Points have successfully been 2-saturated (max q used = 7)

     

       47
       47
       +
                Index gain = 2^1

     

       48
       48
       +
       -        Checking 3-saturation

     

       49
       49
       +
       +        Checking 3-saturation...

     

       50
       50
       +
                Points have successfully been 3-saturated (max q used = 13)

     

       51
       51
       +
       -        Checking 5-saturation

     

       52
       52
       +
       +        Checking 5-saturation...

     

       53
       53
       +
                Points have successfully been 5-saturated (max q used = 67)

     

       54
       54
       +
       -        Checking 7-saturation

     

       55
       55
       +
       +        Checking 7-saturation...

     

       56
       56
       +
                Points have successfully been 7-saturated (max q used = 53)

     

       57
       57
       +
       -        Checking 11-saturation

     

       58
       58
       +
       +        Checking 11-saturation...

     

       59
       59
       +
                Points have successfully been 11-saturated (max q used = 73)

     

       60
       60
       +
       -        Checking 13-saturation

     

       61
       61
       +
       +        Checking 13-saturation...

     

       62
       62
       +
                Points have successfully been 13-saturated (max q used = 103)

     

       63
       63
       +
       -        Checking 17-saturation

     

       64
       64
       +
       +        Checking 17-saturation...

     

       65
       65
       +
                Points have successfully been 17-saturated (max q used = 113)

     

       66
       66
       +
       -        Checking 19-saturation

     

       67
       67
       +
       +        Checking 19-saturation...

     

       68
       68
       +
                Points have successfully been 19-saturated (max q used = 47)

     

       69
       69
       +
                done (index = 2).

     

       70
       70
       +
                Gained index 2, new generators = [ [1:-1:1] [-2:3:1] ]

     

       71
       71
       +
       -        P3 = [-14:25:8]   is generator number 3

     

       72
       72
       +
       -        saturating up to 20...Checking 2-saturation

     

       73
       73
       +
       +        P3 = [-14:25:8]       is generator number 3

     

       74
       74
       +
       +        saturating up to 20...Checking 2-saturation...

     

       75
       75
       +
                Points have successfully been 2-saturated (max q used = 11)

     

       76
       76
       +
       -        Checking 3-saturation

     

       77
       77
       +
       +        Checking 3-saturation...

     

       78
       78
       +
                Points have successfully been 3-saturated (max q used = 13)

     

       79
       79
       +
       -        Checking 5-saturation

     

       80
       80
       +
       +        Checking 5-saturation...

     

       81
       81
       +
                Points have successfully been 5-saturated (max q used = 71)

     

       82
       82
       +
       -        Checking 7-saturation

     

       83
       83
       +
       +        Checking 7-saturation...

     

       84
       84
       +
                Points have successfully been 7-saturated (max q used = 101)

     

       85
       85
       +
       -        Checking 11-saturation

     

       86
       86
       +
       +        Checking 11-saturation...

     

       87
       87
       +
                Points have successfully been 11-saturated (max q used = 127)

     

       88
       88
       +
       -        Checking 13-saturation

     

       89
       89
       +
       +        Checking 13-saturation...

     

       90
       90
       +
                Points have successfully been 13-saturated (max q used = 151)

     

       91
       91
       +
       -        Checking 17-saturation

     

       92
       92
       +
       +        Checking 17-saturation...

     

       93
       93
       +
                Points have successfully been 17-saturated (max q used = 139)

     

       94
       94
       +
       -        Checking 19-saturation

     

       95
       95
       +
       +        Checking 19-saturation...

     

       96
       96
       +
                Points have successfully been 19-saturated (max q used = 179)

     

       97
       97
       +
                done (index = 1).

     

       98
       98
       +
       -        P4 = [-1:3:1]    = -1*P1 + -1*P2 + -1*P3 (mod torsion)

     

       99
       99
       +
       -        P4 = [0:2:1]     = 2*P1 + 0*P2 + 1*P3 (mod torsion)

     

       100
       100
       +
       -        P4 = [2:13:8]    = -3*P1 + 1*P2 + -1*P3 (mod torsion)

     

       101
       101
       +
       -        P4 = [1:0:1]     = -1*P1 + 0*P2 + 0*P3 (mod torsion)

     

       102
       102
       +
       -        P4 = [2:0:1]     = -1*P1 + 1*P2 + 0*P3 (mod torsion)

     

       103
       103
       +
       -        P4 = [18:7:8]    = -2*P1 + -1*P2 + -1*P3 (mod torsion)

     

       104
       104
       +
       -        P4 = [3:3:1]     = 1*P1 + 0*P2 + 1*P3 (mod torsion)

     

       105
       105
       +
       -        P4 = [4:6:1]     = 0*P1 + -1*P2 + -1*P3 (mod torsion)

     

       106
       106
       +
       -        P4 = [36:69:64]  = 1*P1 + -2*P2 + 0*P3 (mod torsion)

     

       107
       107
       +
       -        P4 = [68:-25:64]         = -2*P1 + -1*P2 + -2*P3 (mod torsion)

     

       108
       108
       +
       -        P4 = [12:35:27]  = 1*P1 + -1*P2 + -1*P3 (mod torsion)

     

       109
       109
       +
       +        P4 = [-1:3:1]        = -1*P1 + -1*P2 + -1*P3 (mod torsion)

     

       110
       110
       +
       +        P4 = [0:2:1]         = 2*P1 + 0*P2 + 1*P3 (mod torsion)

     

       111
       111
       +
       +        P4 = [2:13:8]        = -3*P1 + 1*P2 + -1*P3 (mod torsion)

     

       112
       112
       +
       +        P4 = [1:0:1]         = -1*P1 + 0*P2 + 0*P3 (mod torsion)

     

       113
       113
       +
       +        P4 = [2:0:1]         = -1*P1 + 1*P2 + 0*P3 (mod torsion)

     

       114
       114
       +
       +        P4 = [18:7:8]        = -2*P1 + -1*P2 + -1*P3 (mod torsion)

     

       115
       115
       +
       +        P4 = [3:3:1]         = 1*P1 + 0*P2 + 1*P3 (mod torsion)

     

       116
       116
       +
       +        P4 = [4:6:1]         = 0*P1 + -1*P2 + -1*P3 (mod torsion)

     

       117
       117
       +
       +        P4 = [36:69:64]      = 1*P1 + -2*P2 + 0*P3 (mod torsion)

     

       118
       118
       +
       +        P4 = [68:-25:64]     = -2*P1 + -1*P2 + -2*P3 (mod torsion)

     

       119
       119
       +
       +        P4 = [12:35:27]      = 1*P1 + -1*P2 + -1*P3 (mod torsion)

     

       120
       120
       +
                sage: EQ

     

       121
       121
       +
                Subgroup of Mordell-Weil group: [[1:-1:1], [-2:3:1], [-14:25:8]]

     

       122
       122
       +
        

     

       123
       123
       +
       @@ -1076,7 +1076,7 @@ class mwrank_MordellWeil(SageObject):

     

       124
       124
       +
                    sage: EQ.search(1)

     

       125
       125
       +
                    P1 = [0:1:0]         is torsion point, order 1

     

       126
       126
       +
                    P1 = [-3:0:1]         is generator number 1

     

       127
       127
       +
       -            saturating up to 20...Checking 2-saturation

     

       128
       128
       +
       +            saturating up to 20...Checking 2-saturation...

     

       129
       129
       +
                    ...

     

       130
       130
       +
                    P4 = [12:35:27]      = 1*P1 + -1*P2 + -1*P3 (mod torsion)

     

       131
       131
       +
                    sage: EQ

pkgs/applications/science/math/sage/sage-src.nix

···

       112
       112
        
       

     

       113
       113
        
           # workaround until we use sage's fork of threejs, which contains a "version" file

     

       114
       114
        
           ./patches/dont-grep-threejs-version-from-minified-js.patch

     

       115
       115
       +
       

     

       116
       116
       +
           # updated eclib output has punctuation changes and tidier whitespace

     

       117
       117
       +
           ./patches/eclib-20210223-test-formatting.patch

     

       115
       118
        
         ];

     

       116
       119
        
       

     

       117
       120
        
         patches = nixPatches ++ bugfixPatches ++ packageUpgradePatches;

+28 -77

pkgs/applications/video/kodi/default.nix

···

       1
       1
       -
       { stdenv, lib, fetchurl, fetchFromGitHub, autoconf, automake, libtool, makeWrapper, linuxHeaders

     

       1
       1
       +
       { stdenv, lib, fetchFromGitHub, autoconf, automake, libtool, makeWrapper

     

       2
       2
        
       , pkg-config, cmake, gnumake, yasm, python3Packages

     

       3
       3
        
       , libgcrypt, libgpgerror, libunistring

     

       4
       4
        
       , boost, avahi, lame

     
···

       57
       57
        
           sha256 = "097dg6a7v4ia85jx1pmlpwzdpqcqxlrmniqd005q73zvgj67zc2p";

     

       58
       58
        
         };

     

       59
       59
        
       

     

       60
       60
       -
         cmakeProto = fetchurl {

     

       61
       61
       -
           url = "https://raw.githubusercontent.com/pramsey/libght/ca9b1121c352ea10170636e170040e1af015bad1/cmake/modules/CheckPrototypeExists.cmake";

     

       62
       62
       -
           sha256  = "1zai82gm5x55n3xvdv7mns3ja6a2k81x9zz0nk42j6s2yb0fkjxh";

     

       63
       63
       -
         };

     

       64
       64
       -
       

     

       65
       65
       -
         cmakeProtoPatch = ''

     

       66
       66
       -
           # get rid of windows headers as they will otherwise be found first

     

       67
       67
       -
           rm -rf msvc

     

       68
       68
       -
       

     

       69
       69
       -
           cp ${cmakeProto} cmake/${cmakeProto.name}

     

       70
       70
       -
           # we need to enable support for C++ for check_prototype_exists to do its thing

     

       71
       71
       -
           substituteInPlace CMakeLists.txt --replace 'LANGUAGES C' 'LANGUAGES C CXX'

     

       72
       72
       -
           if [ -f cmake/CheckHeadersSTDC.cmake ]; then

     

       73
       73
       -
             sed -i cmake/CheckHeadersSTDC.cmake \

     

       74
       74
       -
               -e '7iinclude(CheckPrototypeExists)'

     

       75
       75
       -
           fi

     

       76
       76
       -
         '';

     

       77
       77
       -
       

     

       78
       78
       -
         kodiDependency = { name, version, rev, sha256, ... } @attrs:

     

       79
       79
       -
           let

     

       80
       80
       -
             attrs' = builtins.removeAttrs attrs ["name" "version" "rev" "sha256"];

     

       81
       81
       -
           in stdenv.mkDerivation ({

     

       82
       82
       -
             name = "kodi-${lib.toLower name}-${version}";

     

       83
       83
       -
             src = fetchFromGitHub {

     

       84
       84
       -
               owner = "xbmc";

     

       85
       85
       -
               repo  = name;

     

       86
       86
       -
               inherit rev sha256;

     

       87
       87
       -
             };

     

       88
       88
       -
           } // attrs');

     

       89
       89
       -
       

     

       90
       90
       -
         ffmpeg = kodiDependency rec {

     

       91
       91
       -
           name    = "FFmpeg";

     

       60
       60
       +
         ffmpeg = stdenv.mkDerivation rec {

     

       61
       61
       +
           pname = "kodi-ffmpeg";

     

       92
       62
        
           version = "4.3.1";

     

       93
       93
       -
           rev     = "${version}-${rel}-Beta1";

     

       94
       94
       -
           sha256  = "1c5rwlxn6xj501iw7masdv2p6wb9rkmd299lmlkx97sw1kvxvg2w";

     

       63
       63
       +
           src = fetchFromGitHub {

     

       64
       64
       +
             owner   = "xbmc";

     

       65
       65
       +
             repo    = "FFmpeg";

     

       66
       66
       +
             rev     = "${version}-${rel}-Beta1";

     

       67
       67
       +
             sha256  = "1c5rwlxn6xj501iw7masdv2p6wb9rkmd299lmlkx97sw1kvxvg2w";

     

       68
       68
       +
           };

     

       95
       69
        
           preConfigure = ''

     

       96
       70
        
             cp ${kodi_src}/tools/depends/target/ffmpeg/{CMakeLists.txt,*.cmake} .

     

       97
       71
        
             sed -i 's/ --cpu=''${CPU}//' CMakeLists.txt

     
···

       110
       84
        
       

     

       111
       85
        
         # We can build these externally but FindLibDvd.cmake forces us to build it

     

       112
       86
        
         # them, so we currently just use them for the src.

     

       113
       113
       -
         libdvdcss = kodiDependency rec {

     

       114
       114
       -
           name              = "libdvdcss";

     

       115
       115
       -
           version           = "1.4.2";

     

       116
       116
       -
           rev               = "${version}-${rel}-Beta-5";

     

       117
       117
       -
           sha256            = "0j41ydzx0imaix069s3z07xqw9q95k7llh06fc27dcn6f7b8ydyl";

     

       118
       118
       -
           buildInputs       = [ linuxHeaders ];

     

       119
       119
       -
           nativeBuildInputs = [ cmake pkg-config ];

     

       120
       120
       -
           postPatch = ''

     

       121
       121
       -
             rm -rf msvc

     

       122
       122
       -
       

     

       123
       123
       -
             substituteInPlace config.h.cm \

     

       124
       124
       -
               --replace '#cmakedefine O_BINARY "''${O_BINARY}"' '#define O_BINARY 0'

     

       125
       125
       -
           '';

     

       126
       126
       -
           cmakeFlags = [

     

       127
       127
       -
             "-DBUILD_SHARED_LIBS=1"

     

       128
       128
       -
             "-DHAVE_LINUX_DVD_STRUCT=1"

     

       129
       129
       -
           ];

     

       87
       87
       +
         libdvdcss = fetchFromGitHub {

     

       88
       88
       +
           owner = "xbmc";

     

       89
       89
       +
           repo = "libdvdcss";

     

       90
       90
       +
           rev = "1.4.2-${rel}-Beta-5";

     

       91
       91
       +
           sha256 = "0j41ydzx0imaix069s3z07xqw9q95k7llh06fc27dcn6f7b8ydyl";

     

       130
       92
        
         };

     

       131
       93
        
       

     

       132
       132
       -
         libdvdnav = kodiDependency rec {

     

       133
       133
       -
           name              = "libdvdnav";

     

       134
       134
       -
           version           = "6.0.0";

     

       135
       135
       -
           rev               = "${version}-${rel}-Alpha-3";

     

       136
       136
       -
           sha256            = "0qwlf4lgahxqxk1r2pzl866mi03pbp7l1fc0rk522sc0ak2s9jhb";

     

       137
       137
       -
           buildInputs       = [ libdvdcss libdvdread ];

     

       138
       138
       -
           nativeBuildInputs = [ cmake pkg-config ];

     

       139
       139
       -
           postPatch         = cmakeProtoPatch;

     

       140
       140
       -
           postInstall = ''

     

       141
       141
       -
             mv $out/lib/liblibdvdnav.so $out/lib/libdvdnav.so

     

       142
       142
       -
           '';

     

       94
       94
       +
         libdvdnav = fetchFromGitHub {

     

       95
       95
       +
           owner = "xbmc";

     

       96
       96
       +
           repo = "libdvdnav";

     

       97
       97
       +
           rev = "6.0.0-${rel}-Alpha-3";

     

       98
       98
       +
           sha256 = "0qwlf4lgahxqxk1r2pzl866mi03pbp7l1fc0rk522sc0ak2s9jhb";

     

       143
       99
        
         };

     

       144
       100
        
       

     

       145
       145
       -
         libdvdread = kodiDependency rec {

     

       146
       146
       -
           name              = "libdvdread";

     

       147
       147
       -
           version           = "6.0.0";

     

       148
       148
       -
           rev               = "${version}-${rel}-Alpha-3";

     

       149
       149
       -
           sha256            = "1xxn01mhkdnp10cqdr357wx77vyzfb5glqpqyg8m0skyi75aii59";

     

       150
       150
       -
           buildInputs       = [ libdvdcss ];

     

       151
       151
       -
           nativeBuildInputs = [ cmake pkg-config ];

     

       152
       152
       -
           configureFlags    = [ "--with-libdvdcss" ];

     

       153
       153
       -
           postPatch         = cmakeProtoPatch;

     

       101
       101
       +
         libdvdread = fetchFromGitHub {

     

       102
       102
       +
           owner = "xbmc";

     

       103
       103
       +
           repo = "libdvdread";

     

       104
       104
       +
           rev = "6.0.0-${rel}-Alpha-3";

     

       105
       105
       +
           sha256 = "1xxn01mhkdnp10cqdr357wx77vyzfb5glqpqyg8m0skyi75aii59";

     

       154
       106
        
         };

     

       155
       107
        
       

     

       156
       108
        
         kodi_platforms =

     
···

       184
       136
        
             bluez giflib glib harfbuzz lcms2 libpthreadstubs

     

       185
       137
        
             ffmpeg flatbuffers fmt fstrcmp rapidjson

     

       186
       138
        
             lirc

     

       187
       187
       -
             # libdvdcss libdvdnav libdvdread

     

       188
       139
        
           ]

     

       189
       140
        
           ++ lib.optional x11Support [

     

       190
       141
        
             libX11 xorgproto libXt libXmu libXext.dev libXdmcp

     
···

       231
       182
        
       

     

       232
       183
        
           cmakeFlags = [

     

       233
       184
        
             "-DAPP_RENDER_SYSTEM=${if useGbm then "gles" else "gl"}"

     

       234
       234
       -
             "-Dlibdvdcss_URL=${libdvdcss.src}"

     

       235
       235
       -
             "-Dlibdvdnav_URL=${libdvdnav.src}"

     

       236
       236
       -
             "-Dlibdvdread_URL=${libdvdread.src}"

     

       185
       185
       +
             "-Dlibdvdcss_URL=${libdvdcss}"

     

       186
       186
       +
             "-Dlibdvdnav_URL=${libdvdnav}"

     

       187
       187
       +
             "-Dlibdvdread_URL=${libdvdread}"

     

       237
       188
        
             "-DGIT_VERSION=${kodiReleaseDate}"

     

       238
       189
        
             "-DENABLE_EVENTCLIENTS=ON"

     

       239
       190
        
             "-DENABLE_INTERNAL_CROSSGUID=OFF"

     
···

       270
       221
        
           postInstall = ''

     

       271
       222
        
             for p in $(ls $out/bin/) ; do

     

       272
       223
        
               wrapProgram $out/bin/$p \

     

       273
       273
       -
                 --prefix PATH            ":" "${lib.makeBinPath ([ python3Packages.python glxinfo ] ++ lib.optional x11Support xdpyinfo)}" \

     

       224
       224
       +
                 --prefix PATH            ":" "${lib.makeBinPath ([ python3Packages.python glxinfo ] ++ lib.optional x11Support xdpyinfo ++ lib.optional sambaSupport samba)}" \

     

       274
       225
        
                 --prefix LD_LIBRARY_PATH ":" "${lib.makeLibraryPath

     

       275
       226
        
                     ([ curl systemd libmad libvdpau libcec libcec_platform libass ]

     

       276
       227
        
                        ++ lib.optional nfsSupport libnfs

+32 -22

pkgs/applications/video/natron/default.nix

···

       1
       1
        
       { lib, stdenv, fetchurl, qt4, pkg-config, boost, expat, cairo, python2Packages,

     

       2
       2
        
         cmake, flex, bison, pango, librsvg, librevenge, libxml2, libcdr, libzip,

     

       3
       3
        
         poppler, imagemagick, openexr, ffmpeg_3, opencolorio, openimageio,

     

       4
       4
       -
         qmake4Hook, libpng, libGL, lndir }:

     

       4
       4
       +
         qmake4Hook, libpng, libGL, lndir, libraw, openjpeg, libwebp, fetchFromGitHub }:

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
       -
         minorVersion = "2.1";

     

       8
       8
       -
         version = "${minorVersion}.9";

     

       7
       7
       +
         minorVersion = "2.3";

     

       8
       8
       +
         version = "${minorVersion}.15";

     

       9
       9
        
         OpenColorIO-Configs = fetchurl {

     

       10
       10
       -
           url = "https://github.com/MrKepzie/OpenColorIO-Configs/archive/Natron-v${minorVersion}.tar.gz";

     

       11
       11
       -
           sha256 = "9eec5a02ca80c9cd8e751013cb347ea982fdddd592a4a9215cce462e332dac51";

     

       10
       10
       +
           url = "https://github.com/NatronGitHub/OpenColorIO-Configs/archive/Natron-v${minorVersion}.tar.gz";

     

       11
       11
       +
           sha256 = "AZK9J+RnMyxOYcAQOAQZj5QciPQ999m6jrtBt5rdpkA=";

     

       12
       12
        
         };

     

       13
       13
        
         seexpr = stdenv.mkDerivation rec {

     

       14
       14
        
           version = "1.0.1";

     
···

       20
       20
        
           nativeBuildInputs = [ cmake ];

     

       21
       21
        
           buildInputs = [ libpng flex bison ];

     

       22
       22
        
         };

     

       23
       23
       -
         buildPlugin = { pluginName, sha256, nativeBuildInputs ? [], buildInputs ? [], preConfigure ? "" }:

     

       23
       23
       +
         buildPlugin = { pluginName, sha256, nativeBuildInputs ? [], buildInputs ? [], preConfigure ? "", postPatch ? "" }:

     

       24
       24
        
           stdenv.mkDerivation {

     

       25
       25
       -
             name = "openfx-${pluginName}-${version}";

     

       25
       25
       +
             pname = "openfx-${pluginName}";

     

       26
       26
       +
             version = version;

     

       26
       27
        
             src = fetchurl {

     

       27
       27
       -
               url = "https://github.com/MrKepzie/Natron/releases/download/${version}/openfx-${pluginName}-${version}.tar.xz";

     

       28
       28
       +
               url = "https://github.com/NatronGitHub/openfx-${pluginName}/releases/download/Natron-${version}/openfx-${pluginName}-Natron-${version}.tar.xz";

     

       28
       29
        
               inherit sha256;

     

       29
       30
        
             };

     

       30
       30
       -
             inherit nativeBuildInputs buildInputs;

     

       31
       31
       +
             inherit nativeBuildInputs buildInputs postPatch;

     

       31
       32
        
             preConfigure = ''

     

       32
       33
        
               makeFlagsArray+=("CONFIG=release")

     

       33
       34
        
               makeFlagsArray+=("PLUGINPATH=$out/Plugins/OFX/Natron")

     
···

       42
       43
        
           url = "https://raw.githubusercontent.com/lvandeve/lodepng/a70c086077c0eaecbae3845e4da4424de5f43361/lodepng.h";

     

       43
       44
        
           sha256 = "14drdikd0vws3wwpyqq7zzm5z3kg98svv4q4w0hr45q6zh6hs0bq";

     

       44
       45
        
         };

     

       46
       46
       +
         cimgversion = "89b9d062ec472df3d33989e6d5d2a8b50ba0775c";

     

       45
       47
        
         CImgh = fetchurl {

     

       46
       46
       -
           url = "https://raw.githubusercontent.com/dtschump/CImg/572c12d82b2f59ece21be8f52645c38f1dd407e6/CImg.h";

     

       47
       47
       -
           sha256 = "0n4qfxj8j6rmj4svf68gg2pzg8d1pb74bnphidnf8i2paj6lwniz";

     

       48
       48
       +
           url = "https://raw.githubusercontent.com/dtschump/CImg/${cimgversion}/CImg.h";

     

       49
       49
       +
           sha256 = "sha256-NbYpZDNj2oZ+wqoEkRwwCjiujdr+iGOLA0Pa0Ynso6U=";

     

       50
       50
       +
         };

     

       51
       51
       +
         inpainth = fetchurl {

     

       52
       52
       +
           url = "https://raw.githubusercontent.com/dtschump/CImg/${cimgversion}/plugins/inpaint.h";

     

       53
       53
       +
           sha256 = "sha256-cd28a3VOs5002GkthHkbIUrxZfKuGhqIYO4Oxe/2HIQ=";

     

       48
       54
        
         };

     

       49
       55
        
         plugins = map buildPlugin [

     

       50
       56
        
           ({

     

       51
       57
        
             pluginName = "arena";

     

       52
       52
       -
             sha256 = "0qba13vn9qdfax7nqlz1ps27zspr5kh795jp1xvbmwjzjzjpkqkf";

     

       58
       58
       +
             sha256 = "tUb6myG03mRieUAfgRZfv5Ap+cLvbpNrLMYCGTiAq8c=";

     

       53
       59
        
             nativeBuildInputs = [ pkg-config ];

     

       54
       60
        
             buildInputs = [

     

       55
       61
        
               pango librsvg librevenge libcdr opencolorio libxml2 libzip

     
···

       65
       71
        
           })

     

       66
       72
        
           ({

     

       67
       73
        
             pluginName = "io";

     

       68
       68
       -
             sha256 = "0s196i9fkgr9iw92c94mxgs1lkxbhynkf83vmsgrldflmf0xjky7";

     

       74
       74
       +
             sha256 = "OQg6a5wNy9TFFySjmgd1subvXRxY/ZnSOCkaoUo+ZaA=";

     

       69
       75
        
             nativeBuildInputs = [ pkg-config ];

     

       70
       76
        
             buildInputs = [

     

       71
       77
        
               libpng ffmpeg_3 openexr opencolorio openimageio boost libGL

     

       72
       72
       -
               seexpr

     

       78
       78
       +
               seexpr libraw openjpeg libwebp

     

       73
       79
        
             ];

     

       74
       80
        
           })

     

       75
       81
        
           ({

     

       76
       82
        
             pluginName = "misc";

     

       77
       77
       -
             sha256 = "02h79jrll0c17azxj16as1mks3lmypm4m3da4mms9sg31l3n82qi";

     

       83
       83
       +
             sha256 = "XkdQyWI9ilF6IoP3yuHulNUZRPLX1m4lq/+RbXsrFEQ=";

     

       78
       84
        
             buildInputs = [

     

       79
       85
        
               libGL

     

       80
       86
        
             ];

     

       81
       81
       -
             preConfigure = ''

     

       82
       82
       -
               cp ${CImgh} CImg/CImg.h

     

       87
       87
       +
             postPatch = ''

     

       88
       88
       +
               cp '${inpainth}' CImg/Inpaint/inpaint.h

     

       89
       89
       +
               patch -p0 -dCImg < CImg/Inpaint/inpaint.h.patch # taken from the Makefile; it gets skipped if the file already exists

     

       90
       90
       +
               cp '${CImgh}' CImg/CImg.h

     

       83
       91
        
             '';

     

       84
       92
        
           })

     

       85
       93
        
         ];

     

       86
       94
        
       in

     

       87
       95
        
       stdenv.mkDerivation {

     

       88
       96
        
         inherit version;

     

       89
       89
       -
         name = "natron-${version}";

     

       97
       97
       +
         pname = "natron";

     

       90
       98
        
       

     

       91
       91
       -
         src = fetchurl {

     

       92
       92
       -
           url = "https://github.com/MrKepzie/Natron/releases/download/${version}/Natron-${version}.tar.xz";

     

       93
       93
       -
           sha256 = "1wdc0zqriw2jhlrhzs6af3kagrv22cm086ffnbr1x43mgc9hfhjp";

     

       99
       99
       +
         src = fetchFromGitHub {

     

       100
       100
       +
           owner = "NatronGitHub";

     

       101
       101
       +
           repo = "Natron";

     

       102
       102
       +
           rev = "v${version}";

     

       103
       103
       +
           fetchSubmodules = true;

     

       104
       104
       +
           sha256 = "sha256-KuXJmmIsvwl4uqmAxXqWU+273jsdWrCuUSwWn5vuu8M=";

     

       94
       105
        
         };

     

       95
       106
        
       

     

       96
       107
        
         nativeBuildInputs = [ qmake4Hook pkg-config python2Packages.wrapPython ];

     
···

       124
       135
        
           license = lib.licenses.gpl2;

     

       125
       136
        
           maintainers = [ maintainers.puffnfresh ];

     

       126
       137
        
           platforms = platforms.linux;

     

       127
       127
       -
           broken = true;

     

       128
       138
        
         };

     

       129
       139
        
       }

+2 -2

pkgs/development/libraries/botan/2.0.nix

···

       2
       2
        
       

     

       3
       3
        
       callPackage ./generic.nix (args // {

     

       4
       4
        
         baseVersion = "2.17";

     

       5
       5
       -
         revision = "2";

     

       6
       6
       -
         sha256 = "0v0yiq0qxcrsn5b34j6bz8i6pds8dih2ds90ylmy1msm5gz7vqpb";

     

       5
       5
       +
         revision = "3";

     

       6
       6
       +
         sha256 = "121vn1aryk36cpks70kk4c4cfic5g0qs82bf92xap9258ijkn4kr";

     

       7
       7
        
         postPatch = ''

     

       8
       8
        
           sed -e 's@lang_flags "@&--std=c++11 @' -i src/build-data/cc/{gcc,clang}.txt

     

       9
       9
        
         '';

+2 -2

pkgs/development/libraries/smarty3/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "smarty3";

     

       5
       5
       -
         version = "3.1.36";

     

       5
       5
       +
         version = "3.1.39";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "smarty-php";

     

       9
       9
        
           repo = "smarty";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "0jljzw1xl2kjwf9cylp1ddnjhz7wbm499s03r479891max1m2mlf";

     

       11
       11
       +
           sha256 = "0n5hmnw66gxqikp6frgfd9ywsvr2azyg5nl7ix89digqlzcljkbg";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         installPhase = ''

+3 -2

pkgs/development/python-modules/awkward/default.nix

···

       10
       10
        
       

     

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "awkward";

     

       13
       13
       -
         version = "1.0.2";

     

       13
       13
       +
         version = "1.1.2";

     

       14
       14
        
       

     

       15
       15
        
         src = fetchPypi {

     

       16
       16
        
           inherit pname version;

     

       17
       17
       -
           sha256 = "3468cb80cab51252a1936e5e593c7df4588ea0e18dcb6fb31e3d2913ba883928";

     

       17
       17
       +
           sha256 = "4ae8371d9e6d5bd3e90f3686b433cebc0541c88072655d2c75ec58e79b5d6943";

     

       18
       18
        
         };

     

       19
       19
        
       

     

       20
       20
        
         nativeBuildInputs = [ cmake ];

     
···

       25
       25
        
       

     

       26
       26
        
         checkInputs = [ pytestCheckHook numba ];

     

       27
       27
        
         dontUseSetuptoolsCheck = true;

     

       28
       28
       +
         disabledTestPaths = [ "tests-cuda" ];

     

       28
       29
        
       

     

       29
       30
        
         meta = with lib; {

     

       30
       31
        
           description = "Manipulate JSON-like data with NumPy-like idioms";

+2 -2

pkgs/development/python-modules/bitbox02/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildPythonPackage rec {

     

       4
       4
        
         pname = "bitbox02";

     

       5
       5
       -
         version = "5.2.0";

     

       5
       5
       +
         version = "5.3.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchPypi {

     

       8
       8
        
           inherit pname version;

     

       9
       9
       -
           sha256 = "52b0b617660601939b30c8b588c28910946448b1b6d69ca231d5e3e47a322b71";

     

       9
       9
       +
           sha256 = "fe0e8aeb9b32fd7d76bb3e9838895973a74dfd532a8fb8ac174a1a60214aee26";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         propagatedBuildInputs = [ base58 ecdsa hidapi noiseprotocol protobuf semver typing-extensions ];

+35

pkgs/development/python-modules/bitlist/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , nose

     

       5
       5
       +
       , parts

     

       6
       6
       +
       , pytestCheckHook

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       buildPythonPackage rec {

     

       10
       10
       +
         pname = "bitlist";

     

       11
       11
       +
         version = "0.3.1";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchPypi {

     

       14
       14
       +
           inherit pname version;

     

       15
       15
       +
           sha256 = "04dz64r21a39p8wph5qlhvs5y873qgk6xxjlzw8n695b8jm3ixir";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         propagatedBuildInputs = [

     

       19
       19
       +
           parts

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         checkInputs = [

     

       23
       23
       +
           pytestCheckHook

     

       24
       24
       +
           nose

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         pythonImportsCheck = [ "bitlist" ];

     

       28
       28
       +
       

     

       29
       29
       +
         meta = with lib; {

     

       30
       30
       +
           description = "Python library for working with little-endian list representation of bit strings";

     

       31
       31
       +
           homepage = "https://github.com/lapets/bitlist";

     

       32
       32
       +
           license = with licenses; [ mit ];

     

       33
       33
       +
           maintainers = with maintainers; [ fab ];

     

       34
       34
       +
         };

     

       35
       35
       +
       }

+27 -8

pkgs/development/python-modules/cairosvg/default.nix

···

       1
       1
       -
       { lib, buildPythonPackage, fetchPypi, isPy3k, fetchpatch

     

       2
       2
       -
       , cairocffi, cssselect2, defusedxml, pillow, tinycss2

     

       3
       3
       -
       , pytest, pytestrunner, pytestcov, pytest-flake8, pytest-isort }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , isPy3k

     

       5
       5
       +
       , cairocffi

     

       6
       6
       +
       , cssselect2

     

       7
       7
       +
       , defusedxml

     

       8
       8
       +
       , pillow

     

       9
       9
       +
       , tinycss2

     

       10
       10
       +
       , pytestCheckHook

     

       11
       11
       +
       , pytest-runner

     

       12
       12
       +
       , pytest-flake8

     

       13
       13
       +
       , pytest-isort

     

       14
       14
       +
       }:

     

       4
       15
        
       

     

       5
       16
        
       buildPythonPackage rec {

     

       6
       17
        
         pname = "CairoSVG";

     

       7
       7
       -
         version = "2.5.1";

     

       8
       8
       -
       

     

       18
       18
       +
         version = "2.5.2";

     

       9
       19
        
         disabled = !isPy3k;

     

       10
       20
        
       

     

       11
       21
        
         src = fetchPypi {

     

       12
       22
        
           inherit pname version;

     

       13
       13
       -
           sha256 = "bfa0deea7fa0b9b2f29e41b747a915c249dbca731a4667c2917e47ff96e773e0";

     

       23
       23
       +
           sha256 = "sha256-sLmSnPXboAUXjXRqgDb88AJVUPSYylTbYYczIjhHg7w=";

     

       14
       24
        
         };

     

       15
       25
        
       

     

       26
       26
       +
         buildInputs = [ pytest-runner ];

     

       27
       27
       +
       

     

       16
       28
        
         propagatedBuildInputs = [ cairocffi cssselect2 defusedxml pillow tinycss2 ];

     

       17
       29
        
       

     

       18
       18
       -
         checkInputs = [ pytest pytestrunner pytestcov pytest-flake8 pytest-isort ];

     

       30
       30
       +
         checkInputs = [ pytestCheckHook pytest-flake8 pytest-isort ];

     

       31
       31
       +
       

     

       32
       32
       +
         pytestFlagsArray = [

     

       33
       33
       +
           "cairosvg/test_api.py"

     

       34
       34
       +
         ];

     

       35
       35
       +
       

     

       36
       36
       +
         pythonImportsCheck = [ "cairosvg" ];

     

       19
       37
        
       

     

       20
       38
        
         meta = with lib; {

     

       21
       39
        
           homepage = "https://cairosvg.org";

     

       22
       22
       -
           license = licenses.lgpl3;

     

       40
       40
       +
           license = licenses.lgpl3Plus;

     

       23
       41
        
           description = "SVG converter based on Cairo";

     

       42
       42
       +
           maintainers = with maintainers; [ SuperSandro2000 ];

     

       24
       43
        
         };

     

       25
       44
        
       }

+3 -2

pkgs/development/python-modules/celery/default.nix

···

       1
       1
        
       { lib, buildPythonPackage, fetchPypi

     

       2
       2
       -
       , billiard, click, click-didyoumean, click-repl, kombu, pytz, vine

     

       2
       2
       +
       , billiard, click, click-didyoumean, click-plugins, click-repl, kombu, pytz, vine

     

       3
       3
        
       , boto3, case, moto, pytest, pytest-celery, pytest-subtests, pytest-timeout

     

       4
       4
        
       }:

     

       5
       5
        
       

     
···

       17
       17
        
             --replace "moto==1.3.7" moto

     

       18
       18
        
         '';

     

       19
       19
        
       

     

       20
       20
       -
         propagatedBuildInputs = [ billiard click click-didyoumean click-repl kombu pytz vine ];

     

       20
       20
       +
         propagatedBuildInputs = [ billiard click click-didyoumean click-plugins click-repl kombu pytz vine ];

     

       21
       21
        
       

     

       22
       22
        
         checkInputs = [ boto3 case moto pytest pytest-celery pytest-subtests pytest-timeout ];

     

       23
       23
        
       

     
···

       38
       38
        
           homepage = "https://github.com/celery/celery/";

     

       39
       39
        
           description = "Distributed task queue";

     

       40
       40
        
           license = licenses.bsd3;

     

       41
       41
       +
           maintainers = [ ];

     

       41
       42
        
         };

     

       42
       43
        
       }

+34

pkgs/development/python-modules/certvalidator/default.nix

···

       1
       1
       +
       { lib, buildPythonPackage, fetchFromGitHub

     

       2
       2
       +
       , asn1crypto, oscrypto

     

       3
       3
       +
       , cacert

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildPythonPackage rec {

     

       7
       7
       +
         pname = "certvalidator";

     

       8
       8
       +
         version = "0.11.1";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "wbond";

     

       12
       12
       +
           repo = pname;

     

       13
       13
       +
           rev = version;

     

       14
       14
       +
           sha256 = "sha256-yVF7t4FuU3C9fDg67JeM7LWZZh/mv5F4EKmjlO4AuBY=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         propagatedBuildInputs = [ asn1crypto oscrypto ];

     

       18
       18
       +
       

     

       19
       19
       +
         checkInputs = [ cacert ];

     

       20
       20
       +
         checkPhase = ''

     

       21
       21
       +
           # Tests are run with a custom executor/loader

     

       22
       22
       +
           # The regex to skip specific tests relies on negative lookahead of regular expressions

     

       23
       23
       +
           # We're skipping the few tests that rely on the network, fetching CRLs, OCSP or remote certificates

     

       24
       24
       +
           python -c 'import dev.tests; dev.tests.run("^(?!.*test_(basic_certificate_validator_tls|fetch|revocation|build_path)).*$")'

     

       25
       25
       +
         '';

     

       26
       26
       +
         pythonImportsCheck = [ "certvalidator" ];

     

       27
       27
       +
       

     

       28
       28
       +
         meta = with lib; {

     

       29
       29
       +
           homepage = "https://github.com/wbond/certvalidator";

     

       30
       30
       +
           description = "Validates X.509 certificates and paths";

     

       31
       31
       +
           license = licenses.mit;

     

       32
       32
       +
           maintainers = with maintainers; [ baloo ];

     

       33
       33
       +
         };

     

       34
       34
       +
       }

+2 -2

pkgs/development/python-modules/configshell/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildPythonPackage rec {

     

       4
       4
        
         pname = "configshell";

     

       5
       5
       -
         version = "1.1.28";

     

       5
       5
       +
         version = "1.1.29";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "open-iscsi";

     

       9
       9
        
           repo = "${pname}-fb";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "1ym2hkvmmacgy21wnjwzyrcxyl3sx4bcx4hc51vf4lzcnj589l68";

     

       11
       11
       +
           sha256 = "0mjj3c9335sph8rhwww7j4zvhyk896fbmx887vibm89w3jpvjjr9";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         propagatedBuildInputs = [ pyparsing six urwid ];

+2 -2

pkgs/development/python-modules/cypari2/default.nix

···

       11
       11
        
       buildPythonPackage rec {

     

       12
       12
        
         pname = "cypari2";

     

       13
       13
        
         # upgrade may break sage, please test the sage build or ping @timokau on upgrade

     

       14
       14
       -
         version = "2.1.2";

     

       14
       14
       +
         version = "2.1.1";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchPypi {

     

       17
       17
        
           inherit pname version;

     

       18
       18
       -
           sha256 = "03cd45edab8716ebbfdb754e65fea72e873c73dc91aec098fe4a01e35324ac7a";

     

       18
       18
       +
           sha256 = "df1ef62e771ec36e5a456f5fc8b51bc6745b70f0efdd0c7a30c3f0b5f1fb93db";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         # This differs slightly from the default python installPhase in that it pip-installs

+30 -27

pkgs/development/python-modules/etebase/default.nix

···

       1
       1
       -
       { lib, stdenv

     

       2
       2
       -
       , wheel

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , buildPythonPackage

     

       3
       5
        
       , rustPlatform

     

       4
       4
       -
       , pipInstallHook

     

       6
       6
       +
       , pkg-config

     

       7
       7
       +
       , rustfmt

     

       5
       8
        
       , setuptools-rust

     

       6
       6
       -
       , python

     

       7
       7
       -
       , msgpack

     

       8
       8
       -
       , requests

     

       9
       9
        
       , openssl

     

       10
       10
       -
       , perl

     

       11
       11
       -
       , rustfmt

     

       12
       12
       -
       , fetchFromGitHub

     

       13
       10
        
       , Security

     

       11
       11
       +
       , msgpack

     

       14
       12
        
       }:

     

       15
       13
        
       

     

       16
       16
       -
       rustPlatform.buildRustPackage rec {

     

       14
       14
       +
       buildPythonPackage rec {

     

       17
       15
        
         pname = "etebase";

     

       18
       18
       -
         version = "0.31.1";

     

       16
       16
       +
         version = "0.31.2";

     

       19
       17
        
       

     

       20
       18
        
         src = fetchFromGitHub {

     

       21
       19
        
           owner = "etesync";

     

       22
       20
        
           repo = "etebase-py";

     

       23
       21
        
           rev = "v${version}";

     

       24
       24
       -
           sha256 = "163iw64l8lwawf84qswcjsq9p8qddv9ysjrr3dzqpqxb2yb0sy39";

     

       22
       22
       +
           hash = "sha256-enGmfXW8eV6FgdHfJqXr1orAsGbxDz9xUY6T706sf5U=";

     

       25
       23
        
         };

     

       26
       24
        
       

     

       27
       27
       -
         cargoSha256 = "0w8ypl6kj1mf6ahbdiwbd4jw6ldxdaig47zwk91jjsww5lbyx4lf";

     

       25
       25
       +
         cargoDeps = rustPlatform.fetchCargoTarball {

     

       26
       26
       +
           inherit src;

     

       27
       27
       +
           name = "${pname}-${version}";

     

       28
       28
       +
           hash = "sha256-4eJvFf6aY+DYkrYgam5Ok9941PX4uQOmtRznEY0+1TE=";

     

       29
       29
       +
         };

     

       30
       30
       +
       

     

       31
       31
       +
         format = "pyproject";

     

       28
       32
        
       

     

       29
       33
        
         nativeBuildInputs = [

     

       34
       34
       +
           pkg-config

     

       30
       35
        
           rustfmt

     

       31
       31
       -
           perl

     

       32
       32
       -
           openssl

     

       33
       33
       -
           pipInstallHook

     

       34
       36
        
           setuptools-rust

     

       35
       35
       -
           wheel

     

       36
       36
       -
         ];

     

       37
       37
       +
         ] ++ (with rustPlatform; [

     

       38
       38
       +
           cargoSetupHook

     

       39
       39
       +
           rust.cargo

     

       40
       40
       +
           rust.rustc

     

       41
       41
       +
         ]);

     

       37
       42
        
       

     

       38
       38
       -
         buildInputs = lib.optionals stdenv.isDarwin [ Security ];

     

       43
       43
       +
         buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ Security ];

     

       39
       44
        
       

     

       40
       45
        
         propagatedBuildInputs = [

     

       41
       41
       -
           python

     

       42
       46
        
           msgpack

     

       43
       47
        
         ];

     

       44
       48
        
       

     

       45
       45
       -
         doCheck = true;

     

       46
       46
       -
       

     

       47
       47
       -
         buildPhase = ''

     

       48
       48
       -
           ${python.interpreter} setup.py bdist_wheel

     

       49
       49
       +
         postPatch = ''

     

       50
       50
       +
           # Use system OpenSSL, which gets security updates.

     

       51
       51
       +
           substituteInPlace Cargo.toml \

     

       52
       52
       +
             --replace ', features = ["vendored"]' ""

     

       49
       53
        
         '';

     

       50
       54
        
       

     

       51
       51
       -
         installPhase = ''

     

       52
       52
       -
           pipInstallPhase

     

       53
       53
       -
         '';

     

       55
       55
       +
         pythonImportsCheck = [ "etebase" ];

     

       56
       56
       +
       

     

       54
       57
        
       

     

       55
       58
        
         meta = with lib; {

     

       56
       59
        
           homepage = "https://www.etebase.com/";

+39

pkgs/development/python-modules/fe25519/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , bitlist

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fetchPypi

     

       5
       5
       +
       , fountains

     

       6
       6
       +
       , parts

     

       7
       7
       +
       , nose

     

       8
       8
       +
       , pytestCheckHook

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       buildPythonPackage rec {

     

       12
       12
       +
         pname = "fe25519";

     

       13
       13
       +
         version = "0.2.0";

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchPypi {

     

       16
       16
       +
           inherit pname version;

     

       17
       17
       +
           sha256 = "1m85qvw9dwxk81mv9k45c9n75pk8wqn70qkinqh56h5zv56vgq24";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         propagatedBuildInputs = [

     

       21
       21
       +
           bitlist

     

       22
       22
       +
           fountains

     

       23
       23
       +
           parts

     

       24
       24
       +
         ];

     

       25
       25
       +
       

     

       26
       26
       +
         checkInputs = [

     

       27
       27
       +
           nose

     

       28
       28
       +
           pytestCheckHook

     

       29
       29
       +
         ];

     

       30
       30
       +
       

     

       31
       31
       +
         pythonImportsCheck = [ "fe25519" ];

     

       32
       32
       +
       

     

       33
       33
       +
         meta = with lib; {

     

       34
       34
       +
           description = "Python field operations for Curve25519's prime";

     

       35
       35
       +
           homepage = "https://github.com/BjoernMHaase/fe25519";

     

       36
       36
       +
           license = with licenses; [ cc0 ];

     

       37
       37
       +
           maintainers = with maintainers; [ fab ];

     

       38
       38
       +
         };

     

       39
       39
       +
       }

+3 -1

pkgs/development/python-modules/flower/default.nix

···

       35
       35
        
       

     

       36
       36
        
         checkInputs = [ mock ];

     

       37
       37
        
       

     

       38
       38
       +
         pythonImportsCheck = [ "flower" ];

     

       39
       39
       +
       

     

       38
       40
        
         meta = with lib; {

     

       39
       41
        
           description = "Celery Flower";

     

       40
       42
        
           homepage = "https://github.com/mher/flower";

     

       41
       43
        
           license = licenses.bsdOriginal;

     

       42
       44
        
           maintainers = [ maintainers.arnoldfarkas ];

     

       43
       43
       -
           broken = (celery.version == "5.0.2"); # currently broken with celery>=5.0 by https://github.com/mher/flower/pull/1021

     

       45
       45
       +
           broken = (celery.version >= "5.0.2"); # currently broken with celery>=5.0 by https://github.com/mher/flower/pull/1021

     

       44
       46
        
         };

     

       45
       47
        
       }

+30

pkgs/development/python-modules/fountains/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , bitlist

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildPythonPackage rec {

     

       8
       8
       +
         pname = "fountains";

     

       9
       9
       +
         version = "0.2.1";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchPypi {

     

       12
       12
       +
           inherit pname version;

     

       13
       13
       +
           sha256 = "0jk5y099g6ggaq5lwp0jlg4asyhcdxnl3him3ibmzc1k9nnknp30";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         propagatedBuildInputs = [

     

       17
       17
       +
           bitlist

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         # Project has no test

     

       21
       21
       +
         doCheck = false;

     

       22
       22
       +
         pythonImportsCheck = [ "fountains" ];

     

       23
       23
       +
       

     

       24
       24
       +
         meta = with lib; {

     

       25
       25
       +
           description = "Python library for generating and embedding data for unit testing";

     

       26
       26
       +
           homepage = "https://github.com/reity/fountains";

     

       27
       27
       +
           license = with licenses; [ mit ];

     

       28
       28
       +
           maintainers = with maintainers; [ fab ];

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+41

pkgs/development/python-modules/ge25519/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , bitlist

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fe25519

     

       5
       5
       +
       , fetchPypi

     

       6
       6
       +
       , fountains

     

       7
       7
       +
       , nose

     

       8
       8
       +
       , parts

     

       9
       9
       +
       , pytestCheckHook

     

       10
       10
       +
       }:

     

       11
       11
       +
       

     

       12
       12
       +
       buildPythonPackage rec {

     

       13
       13
       +
         pname = "ge25519";

     

       14
       14
       +
         version = "0.2.0";

     

       15
       15
       +
       

     

       16
       16
       +
         src = fetchPypi {

     

       17
       17
       +
           inherit pname version;

     

       18
       18
       +
           sha256 = "1wgv0vqg8iv9y5d7if14gmcgslwd5zzgk322w9jaxdfbndldddik";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         propagatedBuildInputs = [

     

       22
       22
       +
           fe25519

     

       23
       23
       +
           parts

     

       24
       24
       +
           bitlist

     

       25
       25
       +
           fountains

     

       26
       26
       +
         ];

     

       27
       27
       +
       

     

       28
       28
       +
         checkInputs = [

     

       29
       29
       +
           nose

     

       30
       30
       +
           pytestCheckHook

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         pythonImportsCheck = [ "ge25519" ];

     

       34
       34
       +
       

     

       35
       35
       +
         meta = with lib; {

     

       36
       36
       +
           description = "Python implementation of Ed25519 group elements and operations";

     

       37
       37
       +
           homepage = "https://github.com/nthparty/ge25519";

     

       38
       38
       +
           license = with licenses; [ mit ];

     

       39
       39
       +
           maintainers = with maintainers; [ fab ];

     

       40
       40
       +
         };

     

       41
       41
       +
       }

+25

pkgs/development/python-modules/parts/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildPythonPackage rec {

     

       7
       7
       +
         pname = "parts";

     

       8
       8
       +
         version = "1.0.2";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchPypi {

     

       11
       11
       +
           inherit pname version;

     

       12
       12
       +
           sha256 = "1ym238hxwsw15ivvf6gzmkmla08b9hwhdyc3v6rs55wga9j3a4db";

     

       13
       13
       +
         };

     

       14
       14
       +
       

     

       15
       15
       +
         # Project has no tests

     

       16
       16
       +
         doCheck = false;

     

       17
       17
       +
         pythonImportsCheck = [ "parts" ];

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with lib; {

     

       20
       20
       +
           description = "Python library for common list functions related to partitioning lists";

     

       21
       21
       +
           homepage = "https://github.com/lapets/parts";

     

       22
       22
       +
           license = with licenses; [ mit ];

     

       23
       23
       +
           maintainers = with maintainers; [ fab ];

     

       24
       24
       +
         };

     

       25
       25
       +
       }

+5 -5

pkgs/development/python-modules/pg8000/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
       -
       , scramp

     

       5
       5
       -
       , isPy3k

     

       6
       4
        
       , passlib

     

       5
       5
       +
       , pythonOlder

     

       6
       6
       +
       , scramp

     

       7
       7
        
       }:

     

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
        
         pname = "pg8000";

     

       11
       11
       -
         version = "1.17.0";

     

       12
       12
       -
         disabled = !isPy3k;

     

       11
       11
       +
         version = "1.18.0";

     

       12
       12
       +
         disabled = pythonOlder "3.6";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchPypi {

     

       15
       15
        
           inherit pname version;

     

       16
       16
       -
           sha256 = "sha256-FBmMWv6yiRBuQO5uXkwFKcU2mTn2yliKAos3GnX+IN0=";

     

       16
       16
       +
           sha256 = "1nkjxf95ldda41mkmahbikhd1fvxai5lfjb4a5gyhialpz4g5fim";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         propagatedBuildInputs = [ passlib scramp ];

+4 -2

pkgs/development/python-modules/pipx/default.nix

···

       6
       6
        
       , argcomplete

     

       7
       7
        
       , packaging

     

       8
       8
        
       , importlib-metadata

     

       9
       9
       +
       , colorama

     

       9
       10
        
       , pytestCheckHook

     

       10
       11
        
       }:

     

       11
       12
        
       

     

       12
       13
        
       buildPythonPackage rec {

     

       13
       14
        
         pname = "pipx";

     

       14
       14
       -
         version = "0.16.0.0";

     

       15
       15
       +
         version = "0.16.1.0";

     

       15
       16
        
       

     

       16
       17
        
         disabled = pythonOlder "3.6";

     

       17
       18
        
       

     
···

       20
       21
        
           owner = "pipxproject";

     

       21
       22
        
           repo = pname;

     

       22
       23
        
           rev = version;

     

       23
       23
       -
           sha256 = "08mn7vm8iw20pg0gfn491y1jx8wcyjijps6f1hy7ipzd5ckynscn";

     

       24
       24
       +
           sha256 = "081raqsaq7i2x4yxhxppv930jhajdwmngin5wazy7vqhiy3xc669";

     

       24
       25
        
         };

     

       25
       26
        
       

     

       26
       27
        
         propagatedBuildInputs = [

     

       27
       28
        
           userpath

     

       28
       29
        
           argcomplete

     

       29
       30
        
           packaging

     

       31
       31
       +
           colorama

     

       30
       32
        
         ] ++ lib.optionals (pythonOlder "3.8") [

     

       31
       33
        
           importlib-metadata

     

       32
       34
        
         ];

+2 -2

pkgs/development/python-modules/pypugjs/default.nix

···

       3
       3
        
       

     

       4
       4
        
       buildPythonPackage rec {

     

       5
       5
        
         pname = "pypugjs";

     

       6
       6
       -
         version = "5.9.8";

     

       6
       6
       +
         version = "5.9.9";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchPypi {

     

       9
       9
        
           inherit pname version;

     

       10
       10
       -
           sha256 = "1iy8k56rbslxcylhamdik2bd6gqqirrix55mrdn29zz9gl6vg1xi";

     

       10
       10
       +
           sha256 = "0s0a239940z6rsssa13yz6pfkjk4300j35hs7qysyz45f3ixq19j";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         propagatedBuildInputs = [ six chardet ];

+38

pkgs/development/python-modules/python-nmap/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildPythonPackage

     

       3
       3
       +
       , fetchPypi

     

       4
       4
       +
       , nmap

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       buildPythonPackage rec {

     

       8
       8
       +
         pname = "python-nmap";

     

       9
       9
       +
         version = "0.6.4";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchPypi {

     

       12
       12
       +
           inherit pname version;

     

       13
       13
       +
           sha256 = "013q2797d9sf6mrj7x1hqfcql5gqgg50zgiifp2yypfa4k8cwjsx";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         propagatedBuildInputs = [ nmap ];

     

       17
       17
       +
       

     

       18
       18
       +
         postPatch = ''

     

       19
       19
       +
           substituteInPlace setup.cfg --replace "universal=3" "universal=1"

     

       20
       20
       +
         '';

     

       21
       21
       +
       

     

       22
       22
       +
         # Tests requires sudo and performs scans

     

       23
       23
       +
         doCheck = false;

     

       24
       24
       +
         pythonImportsCheck = [ "nmap" ];

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with lib; {

     

       27
       27
       +
           description = "Python library which helps in using nmap";

     

       28
       28
       +
           longDescription = ''

     

       29
       29
       +
             python-nmap is a Python library which helps in using nmap port scanner. It

     

       30
       30
       +
             allows to easily manipulate nmap scan results and will be a perfect tool

     

       31
       31
       +
             for systems administrators who want to automatize scanning task and reports.

     

       32
       32
       +
             It also supports nmap script outputs.

     

       33
       33
       +
           '';

     

       34
       34
       +
           homepage = "http://xael.org/pages/python-nmap-en.html";

     

       35
       35
       +
           license = with licenses; [ gpl3Plus ];

     

       36
       36
       +
           maintainers = with maintainers; [ fab ];

     

       37
       37
       +
         };

     

       38
       38
       +
       }

+10 -3

pkgs/development/python-modules/scramp/default.nix

···

       1
       1
       -
       { lib, buildPythonPackage, fetchFromGitHub, pytestCheckHook }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , asn1crypto

     

       3
       3
       +
       , buildPythonPackage

     

       4
       4
       +
       , fetchFromGitHub

     

       5
       5
       +
       , pytestCheckHook

     

       6
       6
       +
       }:

     

       2
       7
        
       

     

       3
       8
        
       buildPythonPackage rec {

     

       4
       9
        
         pname = "scramp";

     

       5
       5
       -
         version = "1.2.0";

     

       10
       10
       +
         version = "1.2.2";

     

       6
       11
        
       

     

       7
       12
        
         src = fetchFromGitHub {

     

       8
       13
        
           owner = "tlocke";

     

       9
       14
        
           repo = "scramp";

     

       10
       15
        
           rev = version;

     

       11
       11
       -
           sha256 = "15jb7z5l2lijxr60fb9v55i3f81h6d83c0b7fv5q0fv5q259nv0a";

     

       16
       16
       +
           sha256 = "sha256-d/kfrhvU96eH8TQX7n1hVRclEFWLseEvOxiR6VaOdrg=";

     

       12
       17
        
         };

     

       18
       18
       +
       

     

       19
       19
       +
         propagatedBuildInputs = [ asn1crypto ];

     

       13
       20
        
       

     

       14
       21
        
         checkInputs = [ pytestCheckHook ];

     

       15
       22

+18

pkgs/development/python-modules/signify/certificate-expiration-date.patch

···

       1
       1
       +
       diff --git a/tests/test_authenticode.py b/tests/test_authenticode.py

     

       2
       2
       +
       index 7e2c709..2f27e09 100644

     

       3
       3
       +
       --- a/tests/test_authenticode.py

     

       4
       4
       +
       +++ b/tests/test_authenticode.py

     

       5
       5
       +
       @@ -153,10 +153,12 @@ class AuthenticodeParserTestCase(unittest.TestCase):

     

       6
       6
       +
                """this certificate is revoked"""

     

       7
       7
       +
                with open(str(root_dir / "test_data" / "jameslth"), "rb") as f:

     

       8
       8
       +
                    pefile = SignedPEFile(f)

     

       9
       9
       +
       -            pefile.verify()

     

       10
       10
       +
       +            pefile.verify(verification_context_kwargs=

     

       11
       11
       +
       +                          {'timestamp': datetime.datetime(2021, 1, 1, tzinfo=datetime.timezone.utc)})

     

       12
       12
       +
       

     

       13
       13
       +
            def test_jameslth_revoked(self):

     

       14
       14
       +
                """this certificate is revoked"""

     

       15
       15
       +
       +        # TODO: this certificate is now expired, so it will not show up as valid anyway

     

       16
       16
       +
                with open(str(root_dir / "test_data" / "jameslth"), "rb") as f:

     

       17
       17
       +
                    pefile = SignedPEFile(f)

     

       18
       18
       +
                    with self.assertRaises(VerificationError):

+36

pkgs/development/python-modules/signify/default.nix

···

       1
       1
       +
       { lib, buildPythonPackage, fetchFromGitHub, pythonOlder, pytestCheckHook

     

       2
       2
       +
       , certvalidator, pyasn1, pyasn1-modules

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       buildPythonPackage rec {

     

       6
       6
       +
         pname = "signify";

     

       7
       7
       +
         version = "0.3.0";

     

       8
       8
       +
         disabled = pythonOlder "3.5";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "ralphje";

     

       12
       12
       +
           repo = pname;

     

       13
       13
       +
           rev = "v${version}";

     

       14
       14
       +
           sha256 = "sha256-JxQECpwHhPm8TCVW/bCnEpu5I/WETyZVBx29SQE4NmE=";

     

       15
       15
       +
         };

     

       16
       16
       +
         patches = [

     

       17
       17
       +
           # Upstream patch is available here:

     

       18
       18
       +
           #  https://github.com/ralphje/signify/commit/8c345be954e898a317825bb450bed5ba0304b2b5.patch

     

       19
       19
       +
           # But update a couple other things and dont apply cleanly. This is an extract of the part

     

       20
       20
       +
           # we care about and breaks the tests after 2021-03-01

     

       21
       21
       +
           ./certificate-expiration-date.patch

     

       22
       22
       +
         ];

     

       23
       23
       +
       

     

       24
       24
       +
         propagatedBuildInputs = [ certvalidator pyasn1 pyasn1-modules ];

     

       25
       25
       +
       

     

       26
       26
       +
         checkInputs = [ pytestCheckHook ];

     

       27
       27
       +
         pytestFlagsArray = [ "-v" ];

     

       28
       28
       +
         pythonImportsCheck = [ "signify" ];

     

       29
       29
       +
       

     

       30
       30
       +
         meta = with lib; {

     

       31
       31
       +
           homepage = "https://github.com/ralphje/signify";

     

       32
       32
       +
           description = "library that verifies PE Authenticode-signed binaries";

     

       33
       33
       +
           license = licenses.mit;

     

       34
       34
       +
           maintainers = with maintainers; [ baloo ];

     

       35
       35
       +
         };

     

       36
       36
       +
       }

+26

pkgs/development/tools/continuous-integration/drone-runner-exec/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , buildGoModule

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       buildGoModule rec {

     

       7
       7
       +
         pname = "drone-runner-exec";

     

       8
       8
       +
         version = "unstable-2020-04-19";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "drone-runners";

     

       12
       12
       +
           repo = "drone-runner-exec";

     

       13
       13
       +
           rev = "c0a612ef2bdfdc6d261dfbbbb005c887a0c3668d";

     

       14
       14
       +
           sha256 = "sha256-0UIJwpC5Y2TQqyZf6C6neICYBZdLQBWAZ8/K1l6KVRs=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         vendorSha256 = "sha256-ypYuQKxRhRQGX1HtaWt6F6BD9vBpD8AJwx/4esLrJsw=";

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with lib; {

     

       20
       20
       +
           description = "Drone pipeline runner that executes builds directly on the host machine";

     

       21
       21
       +
           homepage = "https://github.com/drone-runners/drone-runner-exec";

     

       22
       22
       +
           # https://polyformproject.org/licenses/small-business/1.0.0/

     

       23
       23
       +
           license = licenses.unfree;

     

       24
       24
       +
           maintainers = with maintainers; [ mic92 ];

     

       25
       25
       +
         };

     

       26
       26
       +
       }

+2 -2

pkgs/development/tools/rubocop/Gemfile.lock

···

       6
       6
        
           parser (3.0.0.0)

     

       7
       7
        
             ast (~> 2.4.1)

     

       8
       8
        
           rainbow (3.0.0)

     

       9
       9
       -
           regexp_parser (2.0.3)

     

       9
       9
       +
           regexp_parser (2.1.1)

     

       10
       10
        
           rexml (3.2.4)

     

       11
       11
       -
           rubocop (1.10.0)

     

       11
       11
       +
           rubocop (1.11.0)

     

       12
       12
        
             parallel (~> 1.10)

     

       13
       13
        
             parser (>= 3.0.0.0)

     

       14
       14
        
             rainbow (>= 2.2.2, < 4.0)

-1

pkgs/development/tools/rubocop/default.nix

···

       14
       14
        
           homepage = "https://docs.rubocop.org/";

     

       15
       15
        
           license = licenses.mit;

     

       16
       16
        
           maintainers = with maintainers; [ marsam leemachin ];

     

       17
       17
       -
           platforms = platforms.unix;

     

       18
       17
        
         };

     

       19
       18
        
       }

+4 -4

pkgs/development/tools/rubocop/gemset.nix

···

       45
       45
        
           platforms = [];

     

       46
       46
        
           source = {

     

       47
       47
        
             remotes = ["https://rubygems.org"];

     

       48
       48
       -
             sha256 = "0zm86k9q8m5jkcnpb1f93wsvc57saldfj8czxkx1aw031i95inip";

     

       48
       48
       +
             sha256 = "0vg7imjnfcqjx7kw94ccj5r78j4g190cqzi1i59sh4a0l940b9cr";

     

       49
       49
        
             type = "gem";

     

       50
       50
        
           };

     

       51
       51
       -
           version = "2.0.3";

     

       51
       51
       +
           version = "2.1.1";

     

       52
       52
        
         };

     

       53
       53
        
         rexml = {

     

       54
       54
        
           groups = ["default"];

     
···

       66
       66
        
           platforms = [];

     

       67
       67
        
           source = {

     

       68
       68
        
             remotes = ["https://rubygems.org"];

     

       69
       69
       -
             sha256 = "1ncd6w4sc112j86j9j12ws7flxfi8dk8nal2kyxg7phdfr703qlz";

     

       69
       69
       +
             sha256 = "0zrzsgx35mcr81c51gyx63s7yngcfgk33dbkx5j0npkaks4fcm7r";

     

       70
       70
        
             type = "gem";

     

       71
       71
        
           };

     

       72
       72
       -
           version = "1.10.0";

     

       72
       72
       +
           version = "1.11.0";

     

       73
       73
        
         };

     

       74
       74
        
         rubocop-ast = {

     

       75
       75
        
           dependencies = ["parser"];

+2 -2

pkgs/os-specific/linux/targetcli/default.nix

···

       2
       2
        
       

     

       3
       3
        
       python3.pkgs.buildPythonApplication rec {

     

       4
       4
        
         pname = "targetcli";

     

       5
       5
       -
         version = "2.1.53";

     

       5
       5
       +
         version = "2.1.54";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "open-iscsi";

     

       9
       9
        
           repo = "${pname}-fb";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "1qrq7y5hnghzbxgrxgl153n8jlhw31kqjbr93jsvlvhz5b3ci750";

     

       11
       11
       +
           sha256 = "1kbbvx0lba96ynr5iwws9jpi319m4rzph4bmcj7yfb37k8mi161v";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         propagatedBuildInputs = with python3.pkgs; [ configshell rtslib ];

+3 -3

pkgs/servers/consul/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "consul";

     

       5
       5
       -
         version = "1.9.3";

     

       5
       5
       +
         version = "1.9.4";

     

       6
       6
        
         rev = "v${version}";

     

       7
       7
        
       

     

       8
       8
        
         # Note: Currently only release tags are supported, because they have the Consul UI

     
···

       17
       17
        
           owner = "hashicorp";

     

       18
       18
        
           repo = pname;

     

       19
       19
        
           inherit rev;

     

       20
       20
       -
           sha256 = "sha256-/PjtLZtMSq/+S1mWe0oJ+dRCmCq0mlgvreL2awm0PcE=";

     

       20
       20
       +
           sha256 = "1ck55i8snpm583p21y1hac0w76wiwyjpgfxkzscd4whp2jnzhhif";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         passthru.tests.consul = nixosTests.consul;

     
···

       26
       26
        
         # has a split module structure in one repo

     

       27
       27
        
         subPackages = ["." "connect/certgen"];

     

       28
       28
        
       

     

       29
       29
       -
         vendorSha256 = "sha256-eIW3xQgy2doirGwKGE6OFGgXtKs8LYx3sfsnIu8n5Hg=";

     

       29
       29
       +
         vendorSha256 = "0y744zpj49zvn5vqqb9wmfs1fs0lir71h2kcmhidmn9j132vg1bq";

     

       30
       30
        
       

     

       31
       31
        
         doCheck = false;

     

       32
       32

+3 -2

pkgs/servers/fishnet/assets.nix

···

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           owner = "niklasf";

     

       16
       16
        
           repo = pname;

     

       17
       17
       -
           rev = "b4fa30e57ec8976fb1c10bd36737bc784351b93e";

     

       18
       18
       -
           sha256 = "0gfs9lm4ih3h3fmgqylw05ii1h0d6mpjfxadnw3wymnjsspfb0m4";

     

       17
       17
       +
           rev = "acd36ab6ccee67a652b6d84aedc4c2828abac5c6";

     

       18
       18
       +
           sha256 = "0mh4gh6qij70clp64m4jw6q7dafr7gwjqpvpaf9vc6h10g1rhzrx";

     

       19
       19
        
         };

     

       20
       20
        
       

     

       21
       21
        
         relAssetsPath = "share/${pname}";

     
···

       53
       53
        
           homepage = "https://github.com/niklasf/fishnet-assets";

     

       54
       54
        
           license = licenses.gpl3Only;

     

       55
       55
        
           maintainers = with maintainers; [ tu-maurice ];

     

       56
       56
       +
           platforms = [ "x86_64-linux" ];

     

       56
       57
        
         };

     

       57
       58
        
       }

+4 -3

pkgs/servers/fishnet/default.nix

···

       12
       12
        
       in

     

       13
       13
        
       rustPlatform.buildRustPackage rec {

     

       14
       14
        
         pname = "fishnet";

     

       15
       15
       -
         version = "2.2.4";

     

       15
       15
       +
         version = "2.2.5";

     

       16
       16
        
       

     

       17
       17
        
         src = fetchFromGitHub {

     

       18
       18
        
           owner = "niklasf";

     

       19
       19
        
           repo = pname;

     

       20
       20
        
           rev = "v${version}";

     

       21
       21
       -
           sha256 = "19dh69b6mqx16195w9d20fah4jl8hhbxm84xq4zwsgl4khmw7zqz";

     

       21
       21
       +
           sha256 = "0gif9wagm9bzq7j3biasqvzp9lfvmxqr5wagqqybmhbn8ipj20a8";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
       -
         cargoSha256 = "0zl2fnmqncyjd52wkn6dddx9lm9ywpw7swy895yq299z2bbbkv3h";

     

       24
       24
       +
         cargoSha256 = "0hqyh0nzfrm7m34kqixrlbc7w8d0k7v6psw8jg6zpwpfcmhqq15j";

     

       25
       25
        
       

     

       26
       26
        
         preBuild = ''

     

       27
       27
        
           rmdir ./assets

     
···

       33
       33
        
           homepage = "https://github.com/niklasf/fishnet";

     

       34
       34
        
           license = licenses.gpl3Plus;

     

       35
       35
        
           maintainers = with maintainers; [ tu-maurice ];

     

       36
       36
       +
           platforms = [ "x86_64-linux" ];

     

       36
       37
        
         };

     

       37
       38
        
       }

+1 -1

pkgs/servers/home-assistant/component-packages.nix

···

       556
       556
        
           "niko_home_control" = ps: with ps; [ ]; # missing inputs: niko-home-control

     

       557
       557
        
           "nilu" = ps: with ps; [ ]; # missing inputs: niluclient

     

       558
       558
        
           "nissan_leaf" = ps: with ps; [ ]; # missing inputs: pycarwings2

     

       559
       559
       -
           "nmap_tracker" = ps: with ps; [ getmac ]; # missing inputs: python-nmap

     

       559
       559
       +
           "nmap_tracker" = ps: with ps; [ getmac python-nmap ];

     

       560
       560
        
           "nmbs" = ps: with ps; [ ]; # missing inputs: pyrail

     

       561
       561
        
           "no_ip" = ps: with ps; [ ];

     

       562
       562
        
           "noaa_tides" = ps: with ps; [ ]; # missing inputs: noaa-coops

+4 -4

pkgs/servers/urserver/default.nix

···

       9
       9
        
       

     

       10
       10
        
       stdenv.mkDerivation rec {

     

       11
       11
        
         pname = "urserver";

     

       12
       12
       -
         version = "3.6.0.745";

     

       12
       12
       +
         version = "3.9.0.2465";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchurl {

     

       15
       15
       -
           url = "https://www.unifiedremote.com/static/builds/server/linux-x64/745/urserver-${version}.tar.gz";

     

       16
       16
       -
           sha256 = "1ib9317bg9n4knwnlbrn1wfkyrjalj8js3a6h7zlcl8h8xc0szc8";

     

       15
       15
       +
           url = "https://www.unifiedremote.com/static/builds/server/linux-x64/${builtins.elemAt (builtins.splitVersion version) 3}/urserver-${version}.tar.gz";

     

       16
       16
       +
           sha256 = "sha256-3DIroodWCMbq1fzPjhuGLk/2fY/qFxFISLzjkjJ4i90=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [

     

       20
       20
        
           autoPatchelfHook

     

       21
       21
       +
           makeWrapper

     

       21
       22
        
         ];

     

       22
       23
        
       

     

       23
       24
        
         buildInputs = [

     
···

       25
       26
        
           bluez

     

       26
       27
        
           libX11

     

       27
       28
        
           libXtst

     

       28
       28
       -
           makeWrapper

     

       29
       29
        
         ];

     

       30
       30
        
       

     

       31
       31
        
         installPhase = ''

+6 -11

pkgs/tools/admin/awscli2/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , python3

     

       3
       3
       -
       , groff

     

       4
       4
       -
       , less

     

       5
       5
       -
       , fetchFromGitHub

     

       6
       6
       -
       }:

     

       1
       1
       +
       { lib, python3, groff, less, fetchFromGitHub }:

     

       7
       2
        
       let

     

       8
       3
        
         py = python3.override {

     

       9
       4
        
           packageOverrides = self: super: {

     

       10
       5
        
             botocore = super.botocore.overridePythonAttrs (oldAttrs: rec {

     

       11
       11
       -
               version = "2.0.0dev85";

     

       6
       6
       +
               version = "2.0.0dev97";

     

       12
       7
        
               src = fetchFromGitHub {

     

       13
       8
        
                 owner = "boto";

     

       14
       9
        
                 repo = "botocore";

     

       15
       15
       -
                 rev = "962bb5d356096c57e25a5579d09e4b4d928c886d";

     

       16
       16
       -
                 sha256 = "09bk8d0r3245kbi96641gvfl3q4jjhw55gjldc2cpml6mv36hhnb";

     

       10
       10
       +
                 rev = "f240d284994b521b0bd099161bc0ab5786caf700";

     

       11
       11
       +
                 sha256 = "sha256-Ot3w/4OcQ+pXq6bJnQqV5uvG50/uIOa1pwMWqor5NXM=";

     

       17
       12
        
               };

     

       18
       13
        
             });

     

       19
       14
        
             prompt_toolkit = super.prompt_toolkit.overridePythonAttrs (oldAttrs: rec {

     
···

       29
       24
        
       in

     

       30
       25
        
       with py.pkgs; buildPythonApplication rec {

     

       31
       26
        
         pname = "awscli2";

     

       32
       32
       -
         version = "2.1.17"; # N.B: if you change this, change botocore to a matching version too

     

       27
       27
       +
         version = "2.1.29"; # N.B: if you change this, change botocore to a matching version too

     

       33
       28
        
       

     

       34
       29
        
         src = fetchFromGitHub {

     

       35
       30
        
           owner = "aws";

     

       36
       31
        
           repo = "aws-cli";

     

       37
       32
        
           rev = version;

     

       38
       38
       -
           sha256 = "1pla97sylzhvj7r5cschv4bg23hpl0ax1m5cx4291fppjnrn2yp9";

     

       33
       33
       +
           sha256 = "sha256-6SVDJeyPJQX4XIH8RYRzJG2LFDHxIrW/b1a0JZ5kIFY=";

     

       39
       34
        
         };

     

       40
       35
        
       

     

       41
       36
        
         postPatch = ''

+6 -6

pkgs/tools/admin/nomachine-client/default.nix

···

       1
       1
        
       { lib, stdenv, file, fetchurl, makeWrapper,

     

       2
       2
        
         autoPatchelfHook, jsoncpp, libpulseaudio }:

     

       3
       3
        
       let

     

       4
       4
       -
         versionMajor = "7.0";

     

       5
       5
       -
         versionMinor = "211";

     

       6
       6
       -
         versionBuild_x86_64 = "4";

     

       7
       7
       -
         versionBuild_i686 = "4";

     

       4
       4
       +
         versionMajor = "7.2";

     

       5
       5
       +
         versionMinor = "3";

     

       6
       6
       +
         versionBuild_x86_64 = "8";

     

       7
       7
       +
         versionBuild_i686 = "8";

     

       8
       8
        
       in

     

       9
       9
        
         stdenv.mkDerivation rec {

     

       10
       10
        
           pname = "nomachine-client";

     
···

       14
       14
        
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       15
       15
        
               fetchurl {

     

       16
       16
        
                 url = "https://download.nomachine.com/download/${versionMajor}/Linux/nomachine_${version}_${versionBuild_x86_64}_x86_64.tar.gz";

     

       17
       17
       -
                 sha256 = "06habqsl5gp13sym519r3qp188qwqqfw8p48wcs4zj3kcri6fjz0";

     

       17
       17
       +
                 sha256 = "1x60vmngq4927qvy6ljmyvwlz5lapilld3495w3y3jdllwd3dxp4";

     

       18
       18
        
               }

     

       19
       19
        
             else if stdenv.hostPlatform.system == "i686-linux" then

     

       20
       20
        
               fetchurl {

     

       21
       21
        
                 url = "https://download.nomachine.com/download/${versionMajor}/Linux/nomachine_${version}_${versionBuild_i686}_i686.tar.gz";

     

       22
       22
       -
                 sha256 = "1y4lr95mwilwr7gqsxqvygq4w3dcp4cjh8m06wdi3avwdzrjkgj9";

     

       22
       22
       +
                 sha256 = "0dx921g6w3gk0x4p771qqxbbi16vl11hmdzzwhfczrq90pgzrhks";

     

       23
       23
        
               }

     

       24
       24
        
             else

     

       25
       25
        
               throw "NoMachine client is not supported on ${stdenv.hostPlatform.system}";

+9 -4

pkgs/tools/misc/dpt-rp1-py/default.nix

···

       1
       1
        
       { lib, python3Packages, fetchFromGitHub }:

     

       2
       2
        
       python3Packages.buildPythonApplication rec {

     

       3
       3
        
         pname = "dpt-rp1-py";

     

       4
       4
       -
         version = "unstable-2018-10-16";

     

       4
       4
       +
         version = "0.1.12";

     

       5
       5
        
       

     

       6
       6
        
         src = fetchFromGitHub {

     

       7
       7
        
           owner = "janten";

     

       8
       8
        
           repo = pname;

     

       9
       9
       -
           rev = "4551b4432f8470de5f2ad9171105f731a6259395";

     

       10
       10
       -
           sha256 = "176y5j31aci1vpi8v6r5ki55432fbdsazh9bsyzr90im9zimkffl";

     

       9
       9
       +
           rev = "v${version}";

     

       10
       10
       +
           sha256 = "0xw853s5bx2lr57w6ldfjzi1ppc6px66zd7hzk8y2kg82q6bnasq";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
        
         doCheck = false;

     

       14
       14
        
       

     

       15
       15
        
         propagatedBuildInputs = with python3Packages; [

     

       16
       16
       +
           anytree

     

       17
       17
       +
           fusepy

     

       16
       18
        
           httpsig

     

       17
       17
       -
           requests

     

       18
       19
        
           pbkdf2

     

       20
       20
       +
           pyyaml

     

       21
       21
       +
           requests

     

       22
       22
       +
           tqdm

     

       19
       23
        
           urllib3

     

       24
       24
       +
           zeroconf

     

       20
       25
        
         ];

     

       21
       26
        
       

     

       22
       27
        
         meta = with lib; {

+3 -3

pkgs/tools/misc/mcfly/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "mcfly";

     

       5
       5
       -
         version = "0.5.3";

     

       5
       5
       +
         version = "0.5.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "cantino";

     

       9
       9
        
           repo = "mcfly";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "1p51wdv47cyg6dmb81fm0d92x1kp7bwwpgax6vlh669nkddiwvmm";

     

       11
       11
       +
           sha256 = "sha256-OYHUawlVHUlKMOWFqeJgg8EIe6Hbe+tKi57sJC5zH1U=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         postInstall = ''

     
···

       20
       20
        
           install -Dm644 -t $out/share/mcfly mcfly.fish

     

       21
       21
        
         '';

     

       22
       22
        
       

     

       23
       23
       -
         cargoSha256 = "0gcdgca8w8i978b067rwm5zrc81rxb704006k9pbcwizkq2281yy";

     

       23
       23
       +
         cargoSha256 = "sha256-aiOw1esERlhOTBCldxoldMCrxMxcGpYXEvjSFQ8xU8A=";

     

       24
       24
        
       

     

       25
       25
        
         meta = with lib; {

     

       26
       26
        
           homepage = "https://github.com/cantino/mcfly";

+2 -2

pkgs/tools/networking/dsniff/default.nix

···

       53
       53
        
           domain = "salsa.debian.org";

     

       54
       54
        
           owner = "pkg-security-team";

     

       55
       55
        
           repo = "dsniff";

     

       56
       56
       -
           rev = "debian/${version}+debian-29";

     

       57
       57
       -
           sha256 = "10zz9krf65jsqvlcr72ycp5cd27xwr18jkc38zqp2i4j6x0caj2g";

     

       56
       56
       +
           rev = "debian/${version}+debian-30";

     

       57
       57
       +
           sha256 = "1fk2k0sfdp5g27i11g0sbzm7al52raz5yr1aibzssnysv7l9xgzh";

     

       58
       58
        
           name = "dsniff.tar.gz";

     

       59
       59
        
         };

     

       60
       60

+36

pkgs/tools/networking/zs-wait4host/default.nix

···

       1
       1
       +
       { bash, coreutils, fetchurl, fping, lib, stdenvNoCC }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenvNoCC.mkDerivation rec {

     

       4
       4
       +
         pname = "zs-wait4host";

     

       5
       5
       +
         version = "0.3.2";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchurl {

     

       8
       8
       +
           url = "https://ytrizja.de/distfiles/${pname}-${version}.tar.gz";

     

       9
       9
       +
           sha256 = "9F1264BDoGlRR7bWlRXhfyvxWio4ydShKmabUQEIz9I=";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         buildInputs = [ bash coreutils fping ];

     

       13
       13
       +
       

     

       14
       14
       +
         postPatch = ''

     

       15
       15
       +
           for i in zs-wait4host zs-wait4host-inf; do

     

       16
       16
       +
             substituteInPlace "$i" \

     

       17
       17
       +
               --replace '$(zs-guess-fping)' '${fping}/bin/fping' \

     

       18
       18
       +
               --replace ' sleep ' ' ${coreutils}/bin/sleep ' \

     

       19
       19
       +
               --replace '[ "$FPING" ] || exit 1' ""

     

       20
       20
       +
           done

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         installPhase = ''

     

       24
       24
       +
           runHook preInstall

     

       25
       25
       +
           install -D -t $out/bin zs-wait4host zs-wait4host-inf

     

       26
       26
       +
           runHook postInstall

     

       27
       27
       +
         '';

     

       28
       28
       +
       

     

       29
       29
       +
         meta = with lib; {

     

       30
       30
       +
           description = "Wait for a host to come up/go down";

     

       31
       31
       +
           homepage = "https://ytrizja.de/";

     

       32
       32
       +
           license = licenses.gpl3Plus;

     

       33
       33
       +
           maintainers = with maintainers; [ zseri ];

     

       34
       34
       +
           platforms = platforms.all;

     

       35
       35
       +
         };

     

       36
       36
       +
       }

+48

pkgs/tools/security/prs/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , rustPlatform

     

       3
       3
       +
       , fetchFromGitLab

     

       4
       4
       +
       , pkg-config

     

       5
       5
       +
       , python3

     

       6
       6
       +
       , dbus

     

       7
       7
       +
       , glib

     

       8
       8
       +
       , gpgme

     

       9
       9
       +
       , gtk3

     

       10
       10
       +
       , libxcb

     

       11
       11
       +
       }:

     

       12
       12
       +
       

     

       13
       13
       +
       rustPlatform.buildRustPackage rec {

     

       14
       14
       +
         pname = "prs";

     

       15
       15
       +
         version = "0.2.2";

     

       16
       16
       +
       

     

       17
       17
       +
         src = fetchFromGitLab {

     

       18
       18
       +
           owner = "timvisee";

     

       19
       19
       +
           repo = "prs";

     

       20
       20
       +
           rev = "v${version}";

     

       21
       21
       +
           sha256 = "05l9zaaadv2a7ngwkxggp5vrjlnpvf2wr4ijhprx3jkw8b2cxii7";

     

       22
       22
       +
         };

     

       23
       23
       +
       

     

       24
       24
       +
         cargoSha256 = "0fjkvr5mdqiy70qx4liwnh78y6mqdv6vbg3nayinh2h34p0z609y";

     

       25
       25
       +
       

     

       26
       26
       +
         postPatch = ''

     

       27
       27
       +
           # The GPGME backend is recommended

     

       28
       28
       +
           for f in "gtk3/Cargo.toml" "cli/Cargo.toml"; do

     

       29
       29
       +
             substituteInPlace "$f" --replace \

     

       30
       30
       +
               'default = ["backend-gnupg-bin"' 'default = ["backend-gpgme"'

     

       31
       31
       +
           done

     

       32
       32
       +
         '';

     

       33
       33
       +
       

     

       34
       34
       +
         nativeBuildInputs = [ gpgme pkg-config python3 ];

     

       35
       35
       +
       

     

       36
       36
       +
         buildInputs = [ dbus glib gpgme gtk3 libxcb ];

     

       37
       37
       +
       

     

       38
       38
       +
         meta = with lib; {

     

       39
       39
       +
           description = "Secure, fast & convenient password manager CLI using GPG and git to sync";

     

       40
       40
       +
           homepage = "https://gitlab.com/timvisee/prs";

     

       41
       41
       +
           changelog = "https://gitlab.com/timvisee/prs/-/blob/v${version}/CHANGELOG.md";

     

       42
       42
       +
           license = with licenses; [

     

       43
       43
       +
             lgpl3Only # lib

     

       44
       44
       +
             gpl3Only  # everything else

     

       45
       45
       +
           ];

     

       46
       46
       +
           maintainers = with maintainers; [ dotlambda ];

     

       47
       47
       +
         };

     

       48
       48
       +
       }

+16 -2

pkgs/tools/security/yara/default.nix

···

       1
       1
        
       { lib, stdenv

     

       2
       2
       +
       , fetchpatch

     

       2
       3
        
       , fetchFromGitHub

     

       3
       4
        
       , autoreconfHook

     

       4
       5
        
       , pcre

     
···

       10
       11
        
       }:

     

       11
       12
        
       

     

       12
       13
        
       stdenv.mkDerivation rec {

     

       13
       13
       -
         version = "4.0.1";

     

       14
       14
       +
         version = "4.0.5";

     

       14
       15
        
         pname = "yara";

     

       15
       16
        
       

     

       16
       17
        
         src = fetchFromGitHub {

     

       17
       18
        
           owner = "VirusTotal";

     

       18
       19
        
           repo = "yara";

     

       19
       20
        
           rev = "v${version}";

     

       20
       20
       -
           sha256 = "0dy8jf0pdn0wilxy1pj6pqjxg7icxkwax09w54np87gl9p00f5rk";

     

       21
       21
       +
           sha256 = "1gkdll2ygdlqy1f27a5b84gw2bq75ss7acsx06yhiss90qwdaalq";

     

       21
       22
        
         };

     

       22
       23
        
       

     

       23
       24
        
         nativeBuildInputs = [ autoreconfHook pkg-config ];

     
···

       29
       30
        
         ;

     

       30
       31
        
       

     

       31
       32
        
         preConfigure = "./bootstrap.sh";

     

       33
       33
       +
       

     

       34
       34
       +
         # If static builds are disabled, `make all-am` will fail to find libyara.a and

     

       35
       35
       +
         # cause a build failure. It appears that somewhere between yara 4.0.1 and

     

       36
       36
       +
         # 4.0.5, linking the yara binaries dynamically against libyara.so was broken.

     

       37
       37
       +
         #

     

       38
       38
       +
         # This was already fixed in yara master. Backport the patch to yara 4.0.5.

     

       39
       39
       +
         patches = [

     

       40
       40
       +
           (fetchpatch {

     

       41
       41
       +
             name = "fix-build-with-no-static.patch";

     

       42
       42
       +
             url = "https://github.com/VirusTotal/yara/commit/52e6866023b9aca26571c78fb8759bc3a51ba6dc.diff";

     

       43
       43
       +
             sha256 = "074cf99j0rqiyacp60j1hkvjqxia7qwd11xjqgcr8jmfwihb38nr";

     

       44
       44
       +
           })

     

       45
       45
       +
         ];

     

       32
       46
        
       

     

       33
       47
        
         configureFlags = [

     

       34
       48
        
           (lib.withFeature withCrypto "crypto")

+3 -1

pkgs/tools/text/kramdown-rfc2629/Gemfile.lock

···

       2
       2
        
         remote: https://rubygems.org/

     

       3
       3
        
         specs:

     

       4
       4
        
           certified (1.0.0)

     

       5
       5
       +
           json_pure (2.5.1)

     

       5
       6
        
           kramdown (1.17.0)

     

       6
       6
       -
           kramdown-rfc2629 (1.2.13)

     

       7
       7
       +
           kramdown-rfc2629 (1.3.37)

     

       7
       8
        
             certified (~> 1.0)

     

       9
       9
       +
             json_pure (~> 2.0)

     

       8
       10
        
             kramdown (~> 1.17.0)

     

       9
       11
        
       

     

       10
       12
        
       PLATFORMS

+13 -3

pkgs/tools/text/kramdown-rfc2629/gemset.nix

···

       9
       9
        
           };

     

       10
       10
        
           version = "1.0.0";

     

       11
       11
        
         };

     

       12
       12
       +
         json_pure = {

     

       13
       13
       +
           groups = ["default"];

     

       14
       14
       +
           platforms = [];

     

       15
       15
       +
           source = {

     

       16
       16
       +
             remotes = ["https://rubygems.org"];

     

       17
       17
       +
             sha256 = "030hmc268wchqsccbjk41hvbyg99krpa72i3q0y3wwqzfh8hi736";

     

       18
       18
       +
             type = "gem";

     

       19
       19
       +
           };

     

       20
       20
       +
           version = "2.5.1";

     

       21
       21
       +
         };

     

       12
       22
        
         kramdown = {

     

       13
       23
        
           groups = ["default"];

     

       14
       24
        
           platforms = [];

     
···

       20
       30
        
           version = "1.17.0";

     

       21
       31
        
         };

     

       22
       32
        
         kramdown-rfc2629 = {

     

       23
       23
       -
           dependencies = ["certified" "kramdown"];

     

       33
       33
       +
           dependencies = ["certified" "json_pure" "kramdown"];

     

       24
       34
        
           groups = ["default"];

     

       25
       35
        
           platforms = [];

     

       26
       36
        
           source = {

     

       27
       37
        
             remotes = ["https://rubygems.org"];

     

       28
       28
       -
             sha256 = "0s53m46qlcdakik0czvx0p41mk46l9l36331cps8gpf364wf3l9d";

     

       38
       38
       +
             sha256 = "16m08q5bgib3i54bb9p3inrxb1xksiybs9zj1rnncq492gcqqv4j";

     

       29
       39
        
             type = "gem";

     

       30
       40
        
           };

     

       31
       31
       -
           version = "1.2.13";

     

       41
       41
       +
           version = "1.3.37";

     

       32
       42
        
         };

     

       33
       43
        
       }

pkgs/top-level/all-packages.nix

···

       3782
       3782
        
       

     

       3783
       3783
        
         drone-cli = callPackage ../development/tools/continuous-integration/drone-cli { };

     

       3784
       3784
        
       

     

       3785
       3785
       +
         drone-runner-exec = callPackage ../development/tools/continuous-integration/drone-runner-exec { };

     

       3786
       3786
       +
       

     

       3785
       3787
        
         dropbear = callPackage ../tools/networking/dropbear { };

     

       3786
       3788
        
       

     

       3787
       3789
        
         dsview = libsForQt5.callPackage ../applications/science/electronics/dsview { };

     
···

       7339
       7341
        
           openssl = openssl_1_0_2;

     

       7340
       7342
        
         };

     

       7341
       7343
        
       

     

       7344
       7344
       +
         prs = callPackage ../tools/security/prs { };

     

       7345
       7345
       +
       

     

       7342
       7346
        
         psw = callPackage ../tools/misc/psw { };

     

       7343
       7347
        
       

     

       7344
       7348
        
         pws = callPackage ../tools/misc/pws { };

     
···

       9405
       9409
        
         zinit = callPackage ../shells/zsh/zinit {} ;

     

       9406
       9410
        
       

     

       9407
       9411
        
         zs-apc-spdu-ctl = callPackage ../tools/networking/zs-apc-spdu-ctl { };

     

       9412
       9412
       +
       

     

       9413
       9413
       +
         zs-wait4host = callPackage ../tools/networking/zs-wait4host { };

     

       9408
       9414
        
       

     

       9409
       9415
        
         zstxtns-utils = callPackage ../tools/text/zstxtns-utils { };

     

       9410
       9416

+16

pkgs/top-level/python-packages.nix

···

       989
       989
        
       

     

       990
       990
        
         bitcoin-price-api = callPackage ../development/python-modules/bitcoin-price-api { };

     

       991
       991
        
       

     

       992
       992
       +
         bitlist = callPackage ../development/python-modules/bitlist { };

     

       993
       993
       +
       

     

       992
       994
        
         bitmath = callPackage ../development/python-modules/bitmath { };

     

       993
       995
        
       

     

       994
       996
        
         bitstring = callPackage ../development/python-modules/bitstring { };

     
···

       1243
       1245
        
         certifi = callPackage ../development/python-modules/certifi { };

     

       1244
       1246
        
       

     

       1245
       1247
        
         certipy = callPackage ../development/python-modules/certipy { };

     

       1248
       1248
       +
       

     

       1249
       1249
       +
         certvalidator = callPackage ../development/python-modules/certvalidator { };

     

       1246
       1250
        
       

     

       1247
       1251
        
         cffi = callPackage ../development/python-modules/cffi { };

     

       1248
       1252
        
       

     
···

       2242
       2246
        
       

     

       2243
       2247
        
         fdint = callPackage ../development/python-modules/fdint { };

     

       2244
       2248
        
       

     

       2249
       2249
       +
         fe25519 = callPackage ../development/python-modules/fe25519 { };

     

       2250
       2250
       +
       

     

       2245
       2251
        
         feedgen = callPackage ../development/python-modules/feedgen { };

     

       2246
       2252
        
       

     

       2247
       2253
        
         feedgenerator = callPackage ../development/python-modules/feedgenerator { inherit (pkgs) glibcLocales; };

     
···

       2455
       2461
        
         foundationdb52 = callPackage ../servers/foundationdb/python.nix { foundationdb = pkgs.foundationdb52; };

     

       2456
       2462
        
         foundationdb60 = callPackage ../servers/foundationdb/python.nix { foundationdb = pkgs.foundationdb60; };

     

       2457
       2463
        
         foundationdb61 = callPackage ../servers/foundationdb/python.nix { foundationdb = pkgs.foundationdb61; };

     

       2464
       2464
       +
       

     

       2465
       2465
       +
         fountains = callPackage ../development/python-modules/fountains { };

     

       2458
       2466
        
       

     

       2459
       2467
        
         foxdot = callPackage ../development/python-modules/foxdot { };

     

       2460
       2468
        
       

     
···

       2540
       2548
        
       

     

       2541
       2549
        
         gdrivefs = callPackage ../development/python-modules/gdrivefs { };

     

       2542
       2550
        
       

     

       2551
       2551
       +
         ge25519 = callPackage ../development/python-modules/ge25519 { };

     

       2552
       2552
       +
       

     

       2543
       2553
        
         geant4 = disabledIf (!isPy3k) (toPythonModule (pkgs.geant4.override {

     

       2544
       2554
        
           enablePython = true;

     

       2545
       2555
        
           python3 = python;

     
···

       4768
       4778
        
         parsy = callPackage ../development/python-modules/parsy { };

     

       4769
       4779
        
       

     

       4770
       4780
        
         partd = callPackage ../development/python-modules/partd { };

     

       4781
       4781
       +
       

     

       4782
       4782
       +
         parts = callPackage ../development/python-modules/parts { };

     

       4771
       4783
        
       

     

       4772
       4784
        
         parver = callPackage ../development/python-modules/parver { };

     

       4773
       4785
        
         arpeggio = callPackage ../development/python-modules/arpeggio { };

     
···

       6497
       6509
        
             inherit (pkgs) pkg-config;

     

       6498
       6510
        
           };

     

       6499
       6511
        
       

     

       6512
       6512
       +
         python-nmap = callPackage ../development/python-modules/python-nmap { };

     

       6513
       6513
       +
       

     

       6500
       6514
        
         python-nomad = callPackage ../development/python-modules/python-nomad { };

     

       6501
       6515
        
       

     

       6502
       6516
        
         python-oauth2 = callPackage ../development/python-modules/python-oauth2 { };

     
···

       7371
       7385
        
         simpy = callPackage ../development/python-modules/simpy { };

     

       7372
       7386
        
       

     

       7373
       7387
        
         singledispatch = callPackage ../development/python-modules/singledispatch { };

     

       7388
       7388
       +
       

     

       7389
       7389
       +
         signify = callPackage ../development/python-modules/signify { };

     

       7374
       7390
        
       

     

       7375
       7391
        
         sip = callPackage ../development/python-modules/sip { };

     

       7376
       7392