commit 0544a7f672749c88b7569f49b33ed5f2437a2e15 · pyrox.dev/nixpkgs

+86 -66
pkgs/common-updater/scripts/mark-broken
···

       1
       1
        
       #!/usr/bin/env bash

     

       2
       2
       -
       set -e

     

       2
       2
       +
       

     

       3
       3
       +
       # This script is meant to be used to mark failing hydra builds as broken in the meta attrs

     

       4
       4
       +
       # To use the script, you should pass the list of failing attrs as arguments to the script.

     

       5
       5
       +
       #

     

       6
       6
       +
       # Example: `cat failing-attrs | xargs ./pkgs/common-update/scripts/mark-broken`

     

       7
       7
       +
       #

     

       8
       8
       +
       # Generating a list of failing attrs: (this should be improved at a later date)

     

       9
       9
       +
       #   - Go to the most recent hydra evaluation with all builds completed

     

       10
       10
       +
       #   - Select the "builds still failing" tab

     

       11
       11
       +
       #   - Highlight and select all packages, should be prefixed with `nixpkgs.`

     

       12
       12
       +
       #   - Use regex and editor foo to leave only the attr names

     

       13
       13
       +
       #   - Use the above example command to then execute the script

     

       14
       14
       +
       #

     

       15
       15
       +
       # OTHER NOTES:

     

       16
       16
       +
       #   - The `denyFileList` and `denyAttrList` will likely need to be updated slightly

     

       17
       17
       +
       #     to align with the conventions used in nixpkgs at execution time

     

       18
       18
       +
       #   - Any attrs which failed for any reason will be written to `failed-marks.txt`.

     

       19
       19
       +
       #     Those attrs will likely need manual attention as disablement will likely be conditional.

     

       3
       20
        
       

     

       4
       21
        
       scriptName=mark-broken # do not use the .wrapped name

     

       5
       22
        
       

     

       6
       6
       -
       die() {

     

       7
       7
       -
           echo "$scriptName: error: $1" >&2

     

       8
       8
       -
           exit 1

     

       23
       23
       +
       failMark() {

     

       24
       24
       +
               local attr=$1

     

       25
       25
       +
               shift 1

     

       26
       26
       +
       

     

       27
       27
       +
               echo "$attr: $@" >&2

     

       28
       28
       +
               echo $attr >> failed-marks.txt

     

       9
       29
        
       }

     

       10
       30
        
       

     

       11
       31
        
       usage() {

     

       12
       12
       -
           echo "Usage: $scriptName <attr> [--new-value=<new-value>]"

     

       32
       32
       +
           echo "Usage: $scriptName <attrs>"

     

       13
       33
        
       }

     

       14
       34
        
       

     

       15
       15
       -
       args=()

     

       16
       16
       -
       

     

       17
       17
       -
       for arg in "$@"; do

     

       18
       18
       -
           case $arg in

     

       19
       19
       -
               --new-value=*)

     

       20
       20
       -
                   newValue="${arg#*=}"

     

       21
       21
       -
               ;;

     

       22
       22
       -
               --help)

     

       23
       23
       -
                   usage

     

       24
       24
       -
                   exit 0

     

       25
       25
       -
               ;;

     

       26
       26
       -
               --*)

     

       27
       27
       -
                   echo "$scriptName: Unknown argument: $arg"

     

       28
       28
       -
                   usage

     

       29
       29
       -
                   exit 1

     

       30
       30
       -
               ;;

     

       31
       31
       -
               *)

     

       32
       32
       -
                   args["${#args[*]}"]=$arg

     

       33
       33
       -
               ;;

     

       34
       34
       -
           esac

     

       35
       35
       -
       done

     

       36
       36
       -
       

     

       37
       37
       -
       attr=${args[0]}

     

       38
       38
       -
       

     

       39
       39
       -
       if (( "${#args[*]}" < 1 )); then

     

       35
       35
       +
       if (( "${#@}" < 1 )); then

     

       40
       36
        
           echo "$scriptName: Too few arguments"

     

       41
       37
        
           usage

     

       42
       38
        
           exit 1

     

       43
       39
        
       fi

     

       44
       40
        
       

     

       45
       45
       -
       if (( "${#args[*]}" > 1 )); then

     

       46
       46
       -
           echo "$scriptName: Too many arguments"

     

       47
       47
       -
           usage

     

       48
       48
       -
           exit 1

     

       49
       49
       -
       fi

     

       41
       41
       +
       # in case we resolve to an auto-generated file, just skip these entries

     

       42
       42
       +
       denyFileList=(

     

       43
       43
       +
               node-packages.nix # node, it will mark all node packages as broken

     

       44
       44
       +
               generic-builder.nix # haskell, it will mark all haskell packages as broken

     

       45
       45
       +
       )

     

       50
       46
        
       

     

       51
       51
       -
       if [ -z $newValue ]; then

     

       52
       52
       -
         newValue="true"

     

       53
       53
       -
       fi

     

       47
       47
       +
       # ignore older versions of parameterized packages sets, these likely need

     

       48
       48
       +
       # to be conditionally disabled

     

       49
       49
       +
       denyAttrList=(

     

       50
       50
       +
               python27Packages

     

       51
       51
       +
               python37Packages

     

       52
       52
       +
               libsForQt512

     

       53
       53
       +
               linuxPackages_

     

       54
       54
       +
               rubyPackages_

     

       55
       55
       +
       )

     

       54
       56
        
       

     

       55
       55
       -
       nixFile=$(nix-instantiate --eval --json -E "with import ./. {}; (builtins.unsafeGetAttrPos \"description\" $attr.meta).file" | jq -r .)

     

       56
       56
       -
       if [[ ! -f "$nixFile" ]]; then

     

       57
       57
       -
           die "Couldn't evaluate 'builtins.unsafeGetAttrPos \"description\" $attr.meta' to locate the .nix file!"

     

       58
       58
       -
       fi

     

       57
       57
       +
       function attemptToMarkBroken() {

     

       58
       58
       +
               local attr=$1

     

       59
       59
        
       

     

       60
       60
       -
       # Insert broken attribute

     

       61
       61
       -
       sed -i.bak "$nixFile" -r \

     

       62
       62
       -
         -e "/^\s*broken\s*=.*$/d" \

     

       63
       63
       -
         -e "s/(\s*)meta\s*=.*\{/&\n\1  broken = $newValue;/"

     

       60
       60
       +
               # skip likely to be noisy attrs

     

       61
       61
       +
               for badAttr in ${denyAttrList[@]};do

     

       62
       62
       +
                       if [[ $attr =~ $badAttr ]]; then

     

       63
       63
       +
                               failMark $attr "attr contained $badAttr, skipped."

     

       64
       64
       +
                               return

     

       65
       65
       +
                       fi

     

       66
       66
       +
               done

     

       64
       67
        
       

     

       65
       65
       -
       if cmp -s "$nixFile" "$nixFile.bak"; then

     

       66
       66
       -
           mv "$nixFile.bak" "$nixFile"

     

       67
       67
       -
           die "Failed to mark the package as broken! Does it have a meta attribute?"

     

       68
       68
       -
       fi

     

       68
       68
       +
               nixFile=$(nix-instantiate --eval --json -E "with import ./. {}; (builtins.unsafeGetAttrPos \"description\" $attr.meta).file" 2>/dev/null | jq -r .)

     

       69
       69
       +
               if [[ ! -f "$nixFile" ]]; then

     

       70
       70
       +
                   failMark $attr "Couldn't locate correct file"

     

       71
       71
       +
                   return

     

       72
       72
       +
               fi

     

       69
       73
        
       

     

       70
       70
       -
       if [[ "$newValue" == "true" ]]; then

     

       71
       71
       -
           # broken should evaluate to true in any case now

     

       72
       72
       -
           markedSuccessfully=$(nix-instantiate --eval -E "with import ./. {}; $attr.meta.broken" || true)

     

       73
       73
       -
           if [[ ! "$markedSuccessfully" == "true" ]]; then

     

       74
       74
       -
               mv "$nixFile.bak" "$nixFile"

     

       75
       75
       -
               die "Couldn't verify the broken attribute to be set correctly, restoring backup!"

     

       76
       76
       -
           fi

     

       77
       77
       -
       else

     

       78
       78
       -
           # we can not check if broken evaluates to the correct value, but we can check that it does evaluate

     

       79
       79
       -
           if ! nix-instantiate --eval -E "with import ./. {}; $attr.meta.broken" >/dev/null; then

     

       80
       80
       -
               mv "$nixFile.bak" "$nixFile"

     

       81
       81
       -
               die "Couldn't verify the broken attribute to be set correctly, restoring backup!"

     

       82
       82
       -
           fi

     

       83
       83
       -
       fi

     

       74
       74
       +
               # skip files which are auto-generated

     

       75
       75
       +
               for filename in ${denyFileList[@]};do

     

       76
       76
       +
                       if [[ "$filename" == $(basename $nixFile) ]]; then

     

       77
       77
       +
                               failMark $attr "filename matched $filename, skipped."

     

       78
       78
       +
                               return

     

       79
       79
       +
                       fi

     

       80
       80
       +
               done

     

       81
       81
       +
       

     

       82
       82
       +
               # Insert broken attribute

     

       83
       83
       +
               sed -i.bak "$nixFile" -r \

     

       84
       84
       +
                 -e "/^\s*broken\s*=.*$/d" \

     

       85
       85
       +
                 -e "s/(\s*)meta\s*=.*\{/&\n\1  broken = true;/"

     

       84
       86
        
       

     

       85
       85
       -
       rm -f "$nixFile.bak"

     

       86
       86
       -
       rm -f "$attr.fetchlog"

     

       87
       87
       +
               if cmp -s "$nixFile" "$nixFile.bak"; then

     

       88
       88
       +
                   mv "$nixFile.bak" "$nixFile"

     

       89
       89
       +
                   failMark $attr "Does it have a meta attribute?"

     

       90
       90
       +
                   return

     

       91
       91
       +
               fi

     

       92
       92
       +
       

     

       93
       93
       +
               # broken should evaluate to true in any case now

     

       94
       94
       +
               markedSuccessfully=$(nix-instantiate --eval -E "with import ./. {}; $attr.meta.broken")

     

       95
       95
       +
               if [[ "$markedSuccessfully" != "true" ]]; then

     

       96
       96
       +
                   mv "$nixFile.bak" "$nixFile"

     

       97
       97
       +
                   failMark $attr "$attr.meta.broken doesn't evaluate to true."

     

       98
       98
       +
                   return

     

       99
       99
       +
               fi

     

       100
       100
       +
       

     

       101
       101
       +
               rm -f "$nixFile.bak"

     

       102
       102
       +
       }

     

       103
       103
       +
       

     

       104
       104
       +
       for attr in $@; do

     

       105
       105
       +
               attemptToMarkBroken $attr

     

       106
       106
       +
       done