commit 8bf8b8fd68b644f3c1ab3a52464173212da2dfaf · pyrox.dev/nixpkgs

+7 -22

nixos/tests/vscode-remote-ssh.nix

···

       11
       11
        
       

     

       12
       12
        
         inherit (import ./ssh-keys.nix pkgs) snakeOilPrivateKey snakeOilPublicKey;

     

       13
       13
        
       

     

       14
       14
       -
         # Every VS Code server build corresponds to a specific commit of VS Code, so we

     

       15
       15
       -
         # want this to match the commit of VS Code in Nixpkgs.

     

       16
       16
       -
         # e.g. git rev-parse 1.77.0

     

       17
       17
       -
         rev = "b3e4e68a0bc097f0ae7907b217c1119af9e03435";

     

       18
       18
       -
         shortRev = builtins.substring 0 8 rev;

     

       19
       19
       -
       

     

       20
       20
       -
         # Our tests run without networking so the remote-ssh extension will always fail to

     

       21
       21
       -
         # download the VSCode server so we can copy it onto the server ourselves.

     

       22
       22
       -
         vscode-server = pkgs.srcOnly {

     

       23
       23
       -
           name = "vscode-server-${shortRev}";

     

       24
       24
       -
           src = pkgs.fetchurl {

     

       25
       25
       -
             name = "vscode-server-${shortRev}.tar.gz";

     

       26
       26
       -
             url = "https://update.code.visualstudio.com/commit:${rev}/server-linux-x64/stable";

     

       27
       27
       -
             sha256 = "1gpsxlv4p3v3kh7b7b2i1lvm5g30xrq1vb7csqwhs4zjlbwfhdb2";

     

       28
       28
       -
           };

     

       29
       29
       -
         };

     

       14
       14
       +
         inherit (pkgs.vscode.passthru) rev vscodeServer;

     

       30
       15
        
       in {

     

       31
       16
        
         name = "vscode-remote-ssh";

     

       32
       17
        
         meta.maintainers = with lib.maintainers; [ Enzime ];

     
···

       61
       46
        
         testScript = let

     

       62
       47
        
           jq = "${pkgs.jq}/bin/jq";

     

       63
       48
        
       

     

       64
       64
       -
           ssh-config = builtins.toFile "ssh.conf" ''

     

       49
       49
       +
           sshConfig = builtins.toFile "ssh.conf" ''

     

       65
       50
        
             UserKnownHostsFile=/dev/null

     

       66
       51
        
             StrictHostKeyChecking=no

     

       67
       52
        
           '';

     

       68
       53
        
       

     

       69
       69
       -
           vscode-config = builtins.toFile "settings.json" ''

     

       54
       54
       +
           vscodeConfig = builtins.toFile "settings.json" ''

     

       70
       55
        
             {

     

       71
       56
        
               "window.zoomLevel": 1,

     

       72
       57
        
               "security.workspace.trust.startupPrompt": "always"

     
···

       80
       65
        
               server.succeed("rm -r ~/.vscode-server")

     

       81
       66
        
       

     

       82
       67
        
             server.succeed("mkdir -p ~/.vscode-server/bin")

     

       83
       83
       -
             server.succeed("cp -r ${vscode-server} ~/.vscode-server/bin/${rev}")

     

       68
       68
       +
             server.succeed("cp -r ${vscodeServer} ~/.vscode-server/bin/${rev}")

     

       84
       69
        
       

     

       85
       70
        
             client.succeed("sudo -u alice code --remote=ssh-remote+root@server /root")

     

       86
       71
        
             client.wait_for_window("Visual Studio Code")

     
···

       108
       93
        
           server.wait_for_open_port(22)

     

       109
       94
        
       

     

       110
       95
        
           VSCODE_COMMIT = server.execute("${jq} -r .commit ${pkgs.vscode}/lib/vscode/resources/app/product.json")[1].rstrip()

     

       111
       111
       -
           SERVER_COMMIT = server.execute("${jq} -r .commit ${vscode-server}/product.json")[1].rstrip()

     

       96
       96
       +
           SERVER_COMMIT = server.execute("${jq} -r .commit ${vscodeServer}/product.json")[1].rstrip()

     

       112
       97
        
       

     

       113
       98
        
           print(f"{VSCODE_COMMIT=} {SERVER_COMMIT=}")

     

       114
       99
        
           assert VSCODE_COMMIT == SERVER_COMMIT, "VSCODE_COMMIT and SERVER_COMMIT do not match"

     
···

       116
       101
        
           client.wait_until_succeeds("ping -c1 server")

     

       117
       102
        
           client.succeed("sudo -u alice mkdir ~alice/.ssh")

     

       118
       103
        
           client.succeed("sudo -u alice install -Dm 600 ${snakeOilPrivateKey} ~alice/.ssh/id_ecdsa")

     

       119
       119
       -
           client.succeed("sudo -u alice install ${ssh-config} ~alice/.ssh/config")

     

       120
       120
       -
           client.succeed("sudo -u alice install -Dm 644 ${vscode-config} ~alice/.config/Code/User/settings.json")

     

       104
       104
       +
           client.succeed("sudo -u alice install ${sshConfig} ~alice/.ssh/config")

     

       105
       105
       +
           client.succeed("sudo -u alice install -Dm 644 ${vscodeConfig} ~alice/.config/Code/User/settings.json")

     

       121
       106
        
       

     

       122
       107
        
           client.wait_for_x()

     

       123
       108
        
           client.wait_for_file("~alice/.Xauthority")

pkgs/applications/editors/vscode/generic.nix

···

       13
       13
        
       , version, src, meta, sourceRoot, commandLineArgs

     

       14
       14
        
       , executableName, longName, shortName, pname, updateScript

     

       15
       15
        
       , dontFixup ? false

     

       16
       16
       +
       , rev ? null, vscodeServer ? null

     

       17
       17
       +
       

     

       16
       18
        
       # sourceExecutableName is the name of the binary in the source archive, over

     

       17
       19
        
       # which we have no control

     

       18
       20
        
       , sourceExecutableName ? executableName

     
···

       30
       32
        
             inherit executableName longName tests updateScript;

     

       31
       33
        
             fhs = fhs {};

     

       32
       34
        
             fhsWithPackages = f: fhs { additionalPkgs = f; };

     

       35
       35
       +
           } // lib.optionalAttrs (vscodeServer != null) {

     

       36
       36
       +
             inherit rev vscodeServer;

     

       33
       37
        
           };

     

       34
       38
        
       

     

       35
       39
        
           desktopItem = makeDesktopItem {

+3 -10

pkgs/applications/editors/vscode/update-vscode.sh

···

       14
       14
        
         exit 1

     

       15
       15
        
       fi

     

       16
       16
        
       

     

       17
       17
       -
       NIXPKGS_ROOT="$(git rev-parse --show-toplevel)"

     

       18
       18
       -
       

     

       19
       19
       -
       if [ ! -f "$NIXPKGS_ROOT/nixos/tests/vscode-remote-ssh.nix" ]; then

     

       20
       20
       -
         echo "ERROR: cannot find nixos/tests/vscode-remote-ssh.nix"

     

       21
       21
       -
         exit 1

     

       22
       22
       -
       fi

     

       23
       23
       -
       

     

       24
       17
        
       # VSCode

     

       25
       18
        
       

     

       26
       19
        
       VSCODE_VER=$(curl --fail --silent https://api.github.com/repos/Microsoft/vscode/releases/latest | jq --raw-output .tag_name)

     
···

       35
       28
        
       

     

       36
       29
        
       sed -i "s/x86_64-linux = \".\{52\}\"/x86_64-linux = \"${VSCODE_X64_LINUX[0]}\"/" "$ROOT/vscode.nix"

     

       37
       30
        
       

     

       38
       38
       -
       tar xf $VSCODE_X64_LINUX[1] -C $TEMP_FOLDER

     

       31
       31
       +
       tar xf ${VSCODE_X64_LINUX[1]} -C $TEMP_FOLDER

     

       39
       32
        
       VSCODE_COMMIT=$(jq --raw-output .commit $TEMP_FOLDER/VSCode-linux-x64/resources/app/product.json)

     

       40
       40
       -
       sed -i "s/rev = \".\{40\}\"/rev = \"${VSCODE_COMMIT}\"/" "$NIXPKGS_ROOT/nixos/tests/vscode-remote-ssh.nix"

     

       33
       33
       +
       sed -i "s/rev = \".\{40\}\"/rev = \"${VSCODE_COMMIT}\"/" "$ROOT/vscode.nix"

     

       41
       34
        
       

     

       42
       35
        
       SERVER_X64_LINUX_URL="https://update.code.visualstudio.com/commit:${VSCODE_COMMIT}/server-linux-x64/stable"

     

       43
       36
        
       SERVER_X64_LINUX_SHA256=$(nix-prefetch-url ${SERVER_X64_LINUX_URL})

     

       44
       44
       -
       sed -i "s/sha256 = \".\{51,52\}\"/sha256 = \"${SERVER_X64_LINUX_SHA256}\"/" "$NIXPKGS_ROOT/nixos/tests/vscode-remote-ssh.nix"

     

       37
       37
       +
       sed -i "s/sha256 = \".\{51,52\}\"/sha256 = \"${SERVER_X64_LINUX_SHA256}\"/" "$ROOT/vscode.nix"

     

       45
       38
        
       

     

       46
       39
        
       VSCODE_X64_DARWIN_URL="https://update.code.visualstudio.com/${VSCODE_VER}/darwin/stable"

     

       47
       40
        
       VSCODE_X64_DARWIN_SHA256=$(nix-prefetch-url ${VSCODE_X64_DARWIN_URL})

+14

pkgs/applications/editors/vscode/vscode.nix

···

       3
       3
        
       , callPackage

     

       4
       4
        
       , fetchurl

     

       5
       5
        
       , nixosTests

     

       6
       6
       +
       , srcOnly

     

       6
       7
        
       , isInsiders ? false

     

       7
       8
        
       , commandLineArgs ? ""

     

       8
       9
        
       , useVSCodeRipgrep ? stdenv.isDarwin

     
···

       36
       37
        
           version = "1.79.0";

     

       37
       38
        
           pname = "vscode";

     

       38
       39
        
       

     

       40
       40
       +
           # This is used for VS Code - Remote SSH test

     

       41
       41
       +
           rev = "b380da4ef1ee00e224a15c1d4d9793e27c2b6302";

     

       42
       42
       +
       

     

       39
       43
        
           executableName = "code" + lib.optionalString isInsiders "-insiders";

     

       40
       44
        
           longName = "Visual Studio Code" + lib.optionalString isInsiders " - Insiders";

     

       41
       45
        
           shortName = "Code" + lib.optionalString isInsiders " - Insiders";

     
···

       51
       55
        
           tests = {};

     

       52
       56
        
       

     

       53
       57
        
           sourceRoot = "";

     

       58
       58
       +
       

     

       59
       59
       +
           # As tests run without networking, we need to download this for the Remote SSH server

     

       60
       60
       +
           vscodeServer = srcOnly {

     

       61
       61
       +
             name = "vscode-server-${rev}.tar.gz";

     

       62
       62
       +
             src = fetchurl {

     

       63
       63
       +
               name = "vscode-server-${rev}.tar.gz";

     

       64
       64
       +
               url = "https://update.code.visualstudio.com/commit:${rev}/server-linux-x64/stable";

     

       65
       65
       +
               sha256 = "0732wpl4fjknhn423k23zrcqz9psjj1iy8lqa0fc8970n1m7i58b";

     

       66
       66
       +
             };

     

       67
       67
       +
           };

     

       54
       68
        
       

     

       55
       69
        
           tests = { inherit (nixosTests) vscode-remote-ssh; };

     

       56
       70