summaryrefslogtreecommitdiffstats
path: root/maintainers/scripts/find-tarballs.nix
blob: 2de3cd1a093bd6974d1ff1dc78f889dc81ca9aff (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
# This expression returns a list of all fetchurl calls used by ‘expr’.

{
  expr,
  lib ? import ../../lib,
}:

let
  inherit (lib)
    addErrorContext
    attrNames
    concatLists
    const
    filter
    genericClosure
    isAttrs
    isDerivation
    isList
    mapAttrsToList
    optional
    optionals
    ;

  root = expr;

  uniqueFiles = map (x: x.file) (genericClosure {
    startSet = map (file: {
      key = with file; (if type == null then "" else type + "+") + hash;
      inherit file;
    }) files;
    operator = const [ ];
  });

  files = map (drv: {
    urls = drv.urls or [ drv.url ];
    hash = drv.outputHash;
    isPatch = (drv ? postFetch && drv.postFetch != "");
    type = drv.outputHashAlgo;
    name = drv.name;
  }) fetchurlDependencies;

  fetchurlDependencies = filter (
    drv:
    drv.outputHash or "" != "" && drv.outputHashMode or "flat" == "flat" && (drv ? url || drv ? urls)
  ) dependencies;

  dependencies = map (x: x.value) (genericClosure {
    startSet = map keyDrv (derivationsIn' root);
    operator = { key, value }: map keyDrv (immediateDependenciesOf value);
  });

  derivationsIn' =
    x:
    if !canEval x then
      [ ]
    else if isDerivation x then
      optional (canEval x.drvPath) x
    else if isList x then
      concatLists (map derivationsIn' x)
    else if isAttrs x then
      concatLists (
        mapAttrsToList (n: v: addErrorContext "while finding tarballs in '${n}':" (derivationsIn' v)) x
      )
    else
      [ ];

  keyDrv =
    drv:
    if canEval drv.drvPath then
      {
        key = drv.drvPath;
        value = drv;
      }
    else
      { };

  immediateDependenciesOf =
    drv:
    concatLists (
      mapAttrsToList (n: v: derivationsIn v) (
        removeAttrs drv (
          [
            "meta"
            "passthru"
          ]
          ++ optionals (drv ? passthru) (attrNames drv.passthru)
        )
      )
    );

  derivationsIn =
    x:
    if !canEval x then
      [ ]
    else if isDerivation x then
      optional (canEval x.drvPath) x
    else if isList x then
      concatLists (map derivationsIn x)
    else
      [ ];

  canEval = val: (builtins.tryEval val).success;

in
uniqueFiles