commit 3cc4563eb2f435ddc0da0a4a39f509a7ff7ffb7c · pyrox.dev/nixpkgs

+40 -83

pkgs/by-name/nu/nuget-to-nix/nuget-to-nix.sh

···

       1
       1
        
       #!@runtimeShell@

     

       2
       2
       +
       # shellcheck shell=bash

     

       2
       3
        
       

     

       3
       4
        
       set -euo pipefail

     

       4
       5
        
       shopt -s nullglob

     
···

       8
       9
        
       # used for glob ordering of package names

     

       9
       10
        
       export LC_ALL=C

     

       10
       11
        
       

     

       12
       12
       +
       >&2 echo "WARNING: nuget-to-nix has deprecated in favor of nuget-to-json."

     

       13
       13
       +
       

     

       11
       14
        
       if [ $# -eq 0 ]; then

     

       12
       12
       -
         >&2 echo "Usage: $0 <packages directory> [path to a file with a list of excluded packages] > deps.nix"

     

       13
       13
       -
         exit 1

     

       15
       15
       +
           >&2 echo "Usage:"

     

       16
       16
       +
           >&2 echo "  $0 <packages directory> [path to a file with a list of excluded packages] > deps.nix"

     

       17
       17
       +
           >&2 echo "  $0 --convert deps.json > deps.nix"

     

       18
       18
       +
           exit 1

     

       14
       19
        
       fi

     

       15
       20
        
       

     

       16
       16
       -
       pkgs=$1

     

       17
       17
       -
       tmp=$(realpath "$(mktemp -td nuget-to-nix.XXXXXX)")

     

       18
       18
       -
       trap 'rm -r "$tmp"' EXIT

     

       19
       19
       -
       

     

       20
       20
       -
       excluded_list=$(realpath "${2:-/dev/null}")

     

       21
       21
       -
       

     

       22
       22
       -
       export DOTNET_NOLOGO=1

     

       23
       23
       -
       export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

       24
       24
       -
       

     

       25
       25
       -
       mapfile -t sources < <(dotnet nuget list source --format short | awk '/^E / { print $2 }')

     

       26
       26
       -
       wait "$!"

     

       27
       27
       -
       

     

       28
       28
       -
       declare -a remote_sources

     

       29
       29
       -
       declare -A base_addresses

     

       30
       30
       -
       

     

       31
       31
       -
       for index in "${sources[@]}"; do

     

       32
       32
       -
           if [[ -d "$index" ]]; then

     

       33
       33
       -
               continue

     

       21
       21
       +
       jsonDeps=

     

       22
       22
       +
       if [ "$1" == "--convert" ]; then

     

       23
       23
       +
           if [ ! -e "$2" ]; then

     

       24
       24
       +
               echo "File not found."

     

       25
       25
       +
               exit 1

     

       34
       26
        
           fi

     

       35
       27
        
       

     

       36
       36
       -
           remote_sources+=($index)

     

       37
       37
       -
       

     

       38
       38
       -
           base_address=$(

     

       39
       39
       -
           curl --compressed --netrc -fsL "$index" | \

     

       40
       40
       -
             jq -r '.resources[] | select(."@type" == "PackageBaseAddress/3.0.0")."@id"')

     

       41
       41
       -
           if [[ ! "$base_address" == */ ]]; then

     

       42
       42
       -
             base_address="$base_address/"

     

       28
       28
       +
           if IFS='' read -r -d '' jsonDeps <"$2"; then

     

       29
       29
       +
               echo "Null bytes found in file." >&2

     

       30
       30
       +
               exit 1

     

       43
       31
        
           fi

     

       44
       44
       -
           base_addresses[$index]="$base_address"

     

       45
       45
       -
       done

     

       46
       46
       -
       

     

       47
       47
       -
       echo "{ fetchNuGet }: ["

     

       48
       48
       -
       

     

       49
       49
       -
       cd "$pkgs"

     

       50
       50
       -
       for package in *; do

     

       51
       51
       -
         [[ -d "$package" ]] || continue

     

       52
       52
       -
         cd "$package"

     

       53
       53
       -
         for version in *; do

     

       54
       54
       -
           id=$(xmlstarlet sel -t -v /_:package/_:metadata/_:id "$version"/*.nuspec)

     

       55
       55
       -
       

     

       56
       56
       -
           if grep -qxF "$id.$version.nupkg" "$excluded_list"; then

     

       57
       57
       -
             continue

     

       32
       32
       +
       else

     

       33
       33
       +
           if ! jsonDeps=$(nuget-to-json "$@"); then

     

       34
       34
       +
               echo "nuget-to-json failed."

     

       35
       35
       +
               exit 1

     

       58
       36
        
           fi

     

       37
       37
       +
       fi

     

       59
       38
        
       

     

       60
       60
       -
           # packages in the nix store should have an empty metadata file

     

       61
       61
       -
           used_source="$(jq -r 'if has("source") then .source else "" end' "$version"/.nupkg.metadata)"

     

       62
       62
       -
           found=false

     

       39
       39
       +
       # pkgs/by-name/az/azure-functions-core-tools/deps.json

     

       40
       40
       +
       IFS='' readarray -d '' depsParts < <(jq 'map([.pname, .version, .sha256, .hash, .url]) | flatten[]' --raw-output0 <<<"$jsonDeps")

     

       41
       41
       +
       index=0

     

       63
       42
        
       

     

       64
       64
       -
           if [[ -z "$used_source" || -d "$used_source" ]]; then

     

       65
       65
       -
             continue

     

       66
       66
       -
           fi

     

       43
       43
       +
       echo '{ fetchNuGet }: ['

     

       67
       44
        
       

     

       68
       68
       -
           for source in "${remote_sources[@]}"; do

     

       69
       69
       -
             url="${base_addresses[$source]}$package/$version/$package.$version.nupkg"

     

       70
       70
       -
             if [[ "$source" == "$used_source" ]]; then

     

       71
       71
       -
               hash="$(nix-hash --type sha256 --flat --sri "$version/$package.$version".nupkg)"

     

       72
       72
       -
               found=true

     

       73
       73
       -
               break

     

       74
       74
       -
             else

     

       75
       75
       -
               if hash=$(nix-prefetch-url "$url" 2>"$tmp"/error); then

     

       76
       76
       -
                 hash="$(nix-hash --to-sri --type sha256 "$hash")"

     

       77
       77
       -
                 # If multiple remote sources are enabled, nuget will try them all

     

       78
       78
       -
                 # concurrently and use the one that responds first. We always use the

     

       79
       79
       -
                 # first source that has the package.

     

       80
       80
       -
                 echo "$package $version is available at $url, but was restored from $used_source" 1>&2

     

       81
       81
       -
                 found=true

     

       82
       82
       -
                 break

     

       83
       83
       -
               else

     

       84
       84
       -
                 if ! grep -q 'HTTP error 404' "$tmp/error"; then

     

       85
       85
       -
                   cat "$tmp/error" 1>&2

     

       86
       86
       -
                   exit 1

     

       87
       87
       -
                 fi

     

       88
       88
       -
               fi

     

       89
       89
       -
             fi

     

       90
       90
       -
           done

     

       45
       45
       +
       while [ "$index" -lt "${#depsParts[@]}" ]; do

     

       46
       46
       +
           pname="${depsParts[index]}"

     

       47
       47
       +
           version="${depsParts[++index]}"

     

       48
       48
       +
           sha256="${depsParts[++index]}"

     

       49
       49
       +
           hash="${depsParts[++index]}"

     

       50
       50
       +
           url="${depsParts[++index]}"

     

       51
       51
       +
           ((++index)) # Go to next pname

     

       91
       52
        
       

     

       92
       92
       -
           if [[ $found = false ]]; then

     

       93
       93
       -
             echo "couldn't find $package $version" >&2

     

       94
       94
       -
             exit 1

     

       95
       95
       -
           fi

     

       96
       96
       -
       

     

       97
       97
       -
           if [[ "$source" != https://api.nuget.org/v3/index.json ]]; then

     

       98
       98
       -
             echo "  (fetchNuGet { pname = \"$id\"; version = \"$version\"; hash = \"$hash\"; url = \"$url\"; })"

     

       53
       53
       +
           echo -n "  (fetchNuGet { pname = \"$pname\"; version = \"$version\"; "

     

       54
       54
       +
           if [ "$sha256" != null ]; then

     

       55
       55
       +
               echo -n "sha256 = \"$sha256\"; "

     

       99
       56
        
           else

     

       100
       100
       -
             echo "  (fetchNuGet { pname = \"$id\"; version = \"$version\"; hash = \"$hash\"; })"

     

       57
       57
       +
               echo -n "hash = \"$hash\"; "

     

       58
       58
       +
           fi

     

       59
       59
       +
           if [ "$url" != "null" ]; then

     

       60
       60
       +
               echo -n "url = \"$url\"; "

     

       101
       61
        
           fi

     

       102
       102
       -
         done

     

       103
       103
       -
         cd ..

     

       62
       62
       +
           echo '})'

     

       104
       63
        
       done

     

       105
       64
        
       

     

       106
       106
       -
       cat << EOL

     

       107
       107
       -
       ]

     

       108
       108
       -
       EOL

     

       65
       65
       +
       echo ']'

+23 -24

pkgs/by-name/nu/nuget-to-nix/package.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
       -
         runCommandLocal,

     

       4
       3
        
         runtimeShell,

     

       5
       4
        
         substituteAll,

     

       6
       5
        
         nix,

     
···

       10
       9
        
         curl,

     

       11
       10
        
         gnugrep,

     

       12
       11
        
         gawk,

     

       12
       12
       +
         nuget-to-json,

     

       13
       13
        
         cacert,

     

       14
       14
        
       }:

     

       15
       15
        
       

     

       16
       16
       -
       runCommandLocal "nuget-to-nix"

     

       17
       17
       -
         {

     

       18
       18
       -
           script = substituteAll {

     

       19
       19
       -
             src = ./nuget-to-nix.sh;

     

       20
       20
       -
             inherit runtimeShell cacert;

     

       16
       16
       +
       substituteAll {

     

       17
       17
       +
         name = "nuget-to-nix";

     

       18
       18
       +
         dir = "bin";

     

       21
       19
        
       

     

       22
       22
       -
             binPath = lib.makeBinPath [

     

       23
       23
       -
               nix

     

       24
       24
       -
               coreutils

     

       25
       25
       -
               jq

     

       26
       26
       -
               xmlstarlet

     

       27
       27
       -
               curl

     

       28
       28
       -
               gnugrep

     

       29
       29
       -
               gawk

     

       30
       30
       -
             ];

     

       31
       31
       -
           };

     

       20
       20
       +
         src = ./nuget-to-nix.sh;

     

       21
       21
       +
         isExecutable = true;

     

       22
       22
       +
       

     

       23
       23
       +
         inherit runtimeShell cacert;

     

       24
       24
       +
         binPath = lib.makeBinPath [

     

       25
       25
       +
           nix

     

       26
       26
       +
           coreutils

     

       27
       27
       +
           jq

     

       28
       28
       +
           xmlstarlet

     

       29
       29
       +
           curl

     

       30
       30
       +
           gnugrep

     

       31
       31
       +
           gawk

     

       32
       32
       +
           nuget-to-json

     

       33
       33
       +
         ];

     

       32
       34
        
       

     

       33
       33
       -
           meta = {

     

       34
       34
       -
             description = "Convert a nuget packages directory to a lockfile for buildDotnetModule";

     

       35
       35
       -
             mainProgram = "nuget-to-nix";

     

       36
       36
       -
           };

     

       37
       37
       -
         }

     

       38
       38
       -
         ''

     

       39
       39
       -
           install -Dm755 $script $out/bin/nuget-to-nix

     

       40
       40
       -
         ''

     

       35
       35
       +
         meta = {

     

       36
       36
       +
           description = "Convert a nuget packages directory to a lockfile for buildDotnetModule";

     

       37
       37
       +
           mainProgram = "nuget-to-nix";

     

       38
       38
       +
         };

     

       39
       39
       +
       }