test cases: Add test case for wrap-file with sftp

Author: ampleyfly

test cases/unit/130 wrap file sftp/Makefile

@@ -0,0 +1,2 @@
+foo.tar.gz: foo/foo.c foo/foo.h foo/meson.build
+	tar -c -z -f $@ $^

test cases/unit/130 wrap file sftp/foo.tar.gz

@@ -0,0 +1,5 @@
+#include "foo.h"
+
+int foo_double(int x) {
+    return 2 * x;
+}

test cases/unit/130 wrap file sftp/foo/foo.c

@@ -0,0 +1,6 @@
+#ifndef FOO_H
+#define FOO_H
+
+int foo_double(int x);
+
+#endif

test cases/unit/130 wrap file sftp/foo/foo.h

@@ -0,0 +1,5 @@
+project('foo', 'c')
+
+libfoo = library('foo', ['foo.c', 'foo.h'])
+
+libfoo_dep = declare_dependency(include_directories: '.', link_with: libfoo)

test cases/unit/130 wrap file sftp/foo/meson.build

@@ -0,0 +1,6 @@
+#include "foo.h"
+
+int main(int argc, char **argv) {
+    (void)foo_double(argc);
+    return 0;
+}

test cases/unit/130 wrap file sftp/top/doubler.c

@@ -0,0 +1,6 @@
+project('proj', 'c')
+
+libfoo_proj = subproject('foo')
+libfoo_dep = libfoo_proj.get_variable('libfoo_dep')
+
+executable('doubler', 'doubler.c', dependencies: [libfoo_dep])

test cases/unit/130 wrap file sftp/top/meson.build

@@ -13,6 +13,9 @@
 import pickle
 import zipfile, tarfile
 import sys
+import socket
+import stat
+import hashlib
 from unittest import mock, SkipTest, skipIf, skipUnless, expectedFailure
 from contextlib import contextmanager
 from glob import glob
@@ -5373,3 +5376,108 @@ def test_fortran_new_module_in_dep(self) -> None:
         output = entry['output']
 
         self.build(output, extra_args=['-j1'])
+
+    @skipIfNoExecutable('sshd')
+    @skipIfNoExecutable('sftp')
+    # Not tested on Windows, since there is not yet an OpenSSH server available
+    def test_wrap_file_sftp(self) -> None:
+        testdir = os.path.join(self.unit_test_dir, '130 wrap file sftp')
+
+        def write_file(path, contents):
+            with open(path, 'w', encoding='utf-8') as f:
+                f.write(contents)
+
+        def read_file(path):
+            with open(path, 'r', encoding='utf-8') as f:
+                return f.read()
+
+        def generate_key(path):
+            subprocess.run(['ssh-keygen', '-f', path, '-N', ''], check=True)
+            os.chmod(path, stat.S_IREAD | stat.S_IWRITE)
+            with open(path + '.pub', 'r', encoding='utf-8') as f:
+                return f.read()
+
+        def find_free_port():
+            with socket.socket() as sock:
+                sock.bind(('', 0))
+                return sock.getsockname()[1]
+
+        def generate_wrap_file(tmpdir, ssh_server_port, user_key_path, host_public_key, source_hash):
+            os.mkdir(os.path.join(tmpdir, 'subprojects'))
+            write_file(os.path.join(tmpdir, 'subprojects', 'foo.wrap'),
+                textwrap.dedent(f'''\
+                    [wrap-file]
+                    directory = foo
+
+                    source_url = sftp://localhost:{ssh_server_port}/foo.tar.gz
+                    source_filename = foo.tar.gz
+                    source_hash = {source_hash}
+                    source_hostkey = {host_public_key}
+                    source_identityfile = {user_key_path}
+                '''))
+
+        def generate_sshd_config(sshdir, user_public_key, ssh_server_port, sftpdir):
+            authorized_keys_path = os.path.join(sshdir, 'authorized_keys')
+            write_file(authorized_keys_path, user_public_key)
+            sshd_config_path = os.path.join(sshdir, 'sshd_config')
+            write_file(sshd_config_path,
+                textwrap.dedent(f'''\
+                    ListenAddress localhost:{ssh_server_port}
+                    PidFile "{os.path.join(sshdir, 'sshd_pid')}"
+                    AuthorizedKeysFile "{authorized_keys_path}"
+                    Subsystem sftp internal-sftp -d {sftpdir}
+                    PasswordAuthentication no
+                '''))
+            return sshd_config_path
+
+        def start_sshd(config_path, host_key_path):
+            sshd_path = shutil.which('sshd')
+            sshd = subprocess.Popen([sshd_path, '-f',  config_path, '-h', host_key_path, '-D'])
+            try:
+                sshd.wait(1)
+                return None
+            except subprocess.TimeoutExpired:
+                # It seems sshd started successfully
+                return sshd
+
+        def hash_file(path):
+            h = hashlib.sha256()
+            with open(path, 'rb') as f:
+                h.update(f.read())
+            return h.hexdigest()
+
+        # sshd doesn't like the permissions of /tmp, so keep ssh related files
+        # in a temporary directory inside testdir.
+        # Cannot serve sftp from a path containing spaces, so use a tmp dir for that.
+        with (tempfile.TemporaryDirectory() as projdir,
+                tempfile.TemporaryDirectory(dir=testdir) as sshdir,
+                tempfile.TemporaryDirectory() as sftpdir):
+            shutil.copytree(os.path.join(testdir, 'top'), projdir, dirs_exist_ok=True)
+            shutil.copy(os.path.join(testdir, 'foo.tar.gz'), sftpdir)
+            source_hash = hash_file(os.path.join(testdir, 'foo.tar.gz'))
+            host_key_path = os.path.join(sshdir, 'host_key')
+            user_key_path = os.path.join(sshdir, 'user_key')
+            host_public_key = generate_key(host_key_path)
+            user_public_key = generate_key(user_key_path)
+
+            # As there is no reliable way to avoid the port being taken between
+            # us finding a free port and starting the server, support a number
+            # of retries.
+            attempts = 0
+            while attempts < 3:
+                port = find_free_port()
+                sshd_config_path = generate_sshd_config(sshdir, user_public_key, port, sftpdir)
+                sshd = start_sshd(sshd_config_path, host_key_path)
+                if sshd is None:
+                    print(f'Failed to start sshd, probably due to port being taken. Trying again.')
+                    attempts += 1
+                    continue
+                generate_wrap_file(projdir, port, user_key_path, host_public_key, source_hash)
+                try:
+                    self.init(projdir)
+                    self.build('doubler')
+                    return
+                finally:
+                    sshd.terminate()
+                    sshd.wait()
+            raise self.fail(f'Failed to start sshd after {attempts} attempts.')