remove NDK download handling in favor of fdroid/sdkmanager

tests/build.TestCase

@@ -12,7 +12,7 @@ import tempfile
 import textwrap
 import unittest
 import yaml
-import zipfile
+from pathlib import Path
 from unittest import mock
 
 localmodule = os.path.realpath(
@@ -214,6 +214,7 @@ class BuildTest(unittest.TestCase):
             self.assertEqual(versionCode, vc)
             self.assertEqual(versionName, vn)
 
+    @mock.patch('sdkmanager.build_package_list', lambda use_net: None)
     def test_build_local_ndk(self):
         """Test if `fdroid build` detects installed NDKs and auto-installs when missing"""
         with tempfile.TemporaryDirectory() as testdir, TmpCwd(
@@ -235,6 +236,8 @@ class BuildTest(unittest.TestCase):
             build.versionCode = 1
             build.versionName = '1.0'
             build.ndk = 'r21e'  # aka 21.4.7075529
+            ndk_version = '21.4.7075529'
+            ndk_dir = Path(config['sdk_path']) / 'ndk' / ndk_version
             vcs = mock.Mock()
 
             def make_fake_apk(output, build):
@@ -242,13 +245,12 @@ class BuildTest(unittest.TestCase):
                     fp.write('APK PLACEHOLDER')
                 return output
 
-            def fake_download_file(_ignored, local_filename):
-                _ignored  # silence the linters
-                with zipfile.ZipFile(local_filename, 'x') as zipfp:
-                    zipfp.writestr(
-                        'android-ndk-r21e/source.properties',
-                        'Pkg.Revision = 21.4.7075529\n',
-                    )
+            # pylint: disable=unused-argument
+            def fake_sdkmanager_install(to_install, android_home=None):
+                ndk_dir.mkdir(parents=True)
+                self.assertNotEqual(ndk_version, to_install)  # converts r21e to version
+                with (ndk_dir / 'source.properties').open('w') as fp:
+                    fp.write('Pkg.Revision = %s\n' % ndk_version)
 
             # use "as _ignored" just to make a pretty layout
             with mock.patch(
@@ -258,8 +260,6 @@ class BuildTest(unittest.TestCase):
             ) as _ignored, mock.patch(
                 'fdroidserver.common.get_apk_id',
                 return_value=(app.id, build.versionCode, build.versionName),
-            ) as _ignored, mock.patch(
-                'fdroidserver.common.is_apk_and_debuggable', return_value=False
             ) as _ignored, mock.patch(
                 'fdroidserver.common.sha256sum',
                 return_value='ad7ce5467e18d40050dc51b8e7affc3e635c85bd8c59be62de32352328ed467e',
@@ -268,7 +268,7 @@ class BuildTest(unittest.TestCase):
             ) as _ignored, mock.patch(
                 'fdroidserver.build.FDroidPopen', FakeProcess
             ) as _ignored, mock.patch(
-                'fdroidserver.net.download_file', wraps=fake_download_file
+                'sdkmanager.install', wraps=fake_sdkmanager_install
             ) as _ignored:
                 _ignored  # silence the linters
                 with self.assertRaises(
@@ -290,7 +290,10 @@ class BuildTest(unittest.TestCase):
                         refresh=False,
                     )
                 # now run `fdroid build --onserver`
-                self.assertTrue('r21e' not in config['ndk_paths'])
+                print('now run `fdroid build --onserver`')
+                self.assertFalse(ndk_dir.exists())
+                self.assertFalse('r21e' in config['ndk_paths'])
+                self.assertFalse(ndk_version in config['ndk_paths'])
                 fdroidserver.build.build_local(
                     app,
                     build,
@@ -305,7 +308,89 @@ class BuildTest(unittest.TestCase):
                     onserver=True,
                     refresh=False,
                 )
-                self.assertTrue(os.path.exists(config['ndk_paths']['r21e']))
+                self.assertTrue(ndk_dir.exists())
+                self.assertTrue(os.path.exists(config['ndk_paths'][ndk_version]))
+                # All paths in the config must be strings, never pathlib.Path instances
+                self.assertIsInstance(config['ndk_paths'][ndk_version], str)
+
+    @mock.patch('sdkmanager.build_package_list', lambda use_net: None)
+    @mock.patch('fdroidserver.build.FDroidPopen', FakeProcess)
+    @mock.patch('fdroidserver.common.get_native_code', lambda _ignored: 'x86')
+    @mock.patch('fdroidserver.common.is_apk_and_debuggable', lambda _ignored: False)
+    @mock.patch(
+        'fdroidserver.common.sha256sum',
+        lambda f: 'ad7ce5467e18d40050dc51b8e7affc3e635c85bd8c59be62de32352328ed467e',
+    )
+    def test_build_local_ndk_some_installed(self):
+        """Test if `fdroid build` detects installed NDKs and auto-installs when missing"""
+        with tempfile.TemporaryDirectory() as testdir, TmpCwd(
+            testdir
+        ), tempfile.TemporaryDirectory() as sdk_path:
+            ndk_r24 = os.path.join(sdk_path, 'ndk', '24.0.8215888')
+            os.makedirs(ndk_r24)
+            with open(os.path.join(ndk_r24, 'source.properties'), 'w') as fp:
+                fp.write('Pkg.Revision = 24.0.8215888\n')
+            config = {'ndk_paths': {'r24': ndk_r24}, 'sdk_path': sdk_path}
+            fdroidserver.common.config = config
+            fdroidserver.build.config = config
+            fdroidserver.build.options = mock.Mock()
+            fdroidserver.build.options.scan_binary = False
+            fdroidserver.build.options.notarball = True
+            fdroidserver.build.options.skipscan = True
+
+            app = fdroidserver.metadata.App()
+            app.id = 'mocked.app.id'
+            build = fdroidserver.metadata.Build()
+            build.commit = '1.0'
+            build.output = app.id + '.apk'
+            build.versionCode = 1
+            build.versionName = '1.0'
+            build.ndk = 'r21e'  # aka 21.4.7075529
+            ndk_version = '21.4.7075529'
+            ndk_dir = Path(config['sdk_path']) / 'ndk' / ndk_version
+            vcs = mock.Mock()
+
+            def make_fake_apk(output, build):
+                with open(build.output, 'w') as fp:
+                    fp.write('APK PLACEHOLDER')
+                return output
+
+            # pylint: disable=unused-argument
+            def fake_sdkmanager_install(to_install, android_home=None):
+                ndk_dir.mkdir(parents=True)
+                self.assertNotEqual(ndk_version, to_install)  # converts r21e to version
+                with (ndk_dir / 'source.properties').open('w') as fp:
+                    fp.write('Pkg.Revision = %s\n' % ndk_version)
+
+            # use "as _ignored" just to make a pretty layout
+            with mock.patch(
+                'fdroidserver.common.replace_build_vars', wraps=make_fake_apk
+            ) as _ignored, mock.patch(
+                'fdroidserver.common.get_apk_id',
+                return_value=(app.id, build.versionCode, build.versionName),
+            ) as _ignored, mock.patch(
+                'sdkmanager.install', wraps=fake_sdkmanager_install
+            ) as _ignored:
+                _ignored  # silence the linters
+                self.assertFalse(ndk_dir.exists())
+                self.assertFalse('r21e' in config['ndk_paths'])
+                self.assertFalse(ndk_version in config['ndk_paths'])
+                fdroidserver.build.build_local(
+                    app,
+                    build,
+                    vcs,
+                    build_dir=testdir,
+                    output_dir=testdir,
+                    log_dir=os.getcwd(),
+                    srclib_dir=None,
+                    extlib_dir=None,
+                    tmp_dir=None,
+                    force=False,
+                    onserver=True,
+                    refresh=False,
+                )
+                self.assertTrue(ndk_dir.exists())
+                self.assertTrue(os.path.exists(config['ndk_paths'][ndk_version]))
 
     def test_build_local_clean(self):
         """Test if `fdroid build` cleans ant and gradle build products"""

tests/common.TestCase

@@ -5,6 +5,7 @@
 import difflib
 import git
 import glob
+import importlib
 import inspect
 import json
 import logging
@@ -20,9 +21,8 @@ import unittest
 import textwrap
 import yaml
 import gzip
-import stat
 from distutils.version import LooseVersion
-from zipfile import BadZipFile, ZipFile, ZipInfo
+from zipfile import BadZipFile, ZipFile
 from unittest import mock
 from pathlib import Path
 
@@ -2164,7 +2164,7 @@ class CommonTest(unittest.TestCase):
         )
         self.assertEqual(
             {'com.example': [12345, 67890], 'org.fdroid.fdroid': [1]},
-            fdroidserver.common.read_pkg_args(appid_versionCode_pairs, allow_vercodes)
+            fdroidserver.common.read_pkg_args(appid_versionCode_pairs, allow_vercodes),
         )
         appid_versionCode_pairs = (
             'com.example:67890',
@@ -2210,42 +2210,79 @@ class CommonTest(unittest.TestCase):
             fdroidserver.common.metadata_find_developer_signing_files(appid, vc),
         )
 
+    @mock.patch('sdkmanager.build_package_list', lambda use_net: None)
     def test_auto_install_ndk(self):
         """Test all possible field data types for build.ndk"""
+        fdroidserver.common.config = {'sdk_path': self.testdir}
+        sdk_path = self.testdir
         build = fdroidserver.metadata.Build()
 
         none_entry = mock.Mock()
-        with mock.patch('fdroidserver.common._install_ndk', none_entry):
+        with mock.patch('sdkmanager.install', none_entry):
             fdroidserver.common.auto_install_ndk(build)
             none_entry.assert_not_called()
 
         empty_list = mock.Mock()
         build.ndk = []
-        with mock.patch('fdroidserver.common._install_ndk', empty_list):
+        with mock.patch('sdkmanager.install', empty_list):
             fdroidserver.common.auto_install_ndk(build)
             empty_list.assert_not_called()
 
         release_entry = mock.Mock()
         build.ndk = 'r21e'
-        with mock.patch('fdroidserver.common._install_ndk', release_entry):
+        with mock.patch('sdkmanager.install', release_entry):
             fdroidserver.common.auto_install_ndk(build)
-            release_entry.assert_called_once_with('r21e')
+            release_entry.assert_called_once_with('ndk;r21e', sdk_path)
 
         revision_entry = mock.Mock()
         build.ndk = '21.4.7075529'
-        with mock.patch('fdroidserver.common._install_ndk', revision_entry):
+        with mock.patch('sdkmanager.install', revision_entry):
             fdroidserver.common.auto_install_ndk(build)
-            revision_entry.assert_called_once_with('21.4.7075529')
+            revision_entry.assert_called_once_with('ndk;21.4.7075529', sdk_path)
 
         list_entry = mock.Mock()
         calls = []
         build.ndk = ['r10e', '11.0.2655954', 'r12b', 'r21e']
         for n in build.ndk:
-            calls.append(mock.call(n))
-        with mock.patch('fdroidserver.common._install_ndk', list_entry):
+            calls.append(mock.call(f'ndk;{n}', sdk_path))
+        with mock.patch('sdkmanager.install', list_entry):
             fdroidserver.common.auto_install_ndk(build)
             list_entry.assert_has_calls(calls)
 
+    @unittest.skipIf(importlib.util.find_spec('sdkmanager') is None, 'needs sdkmanager')
+    @mock.patch('sdkmanager.build_package_list', lambda use_net: None)
+    @mock.patch('sdkmanager._install_zipball_from_cache', lambda a, b: None)
+    @mock.patch('sdkmanager._generate_package_xml', lambda a, b, c: None)
+    def test_auto_install_ndk_mock_dl(self):
+        """Test NDK installs by actually calling sdkmanager"""
+        import sdkmanager
+        import pkg_resources
+
+        sdkmanager_version = LooseVersion(
+            pkg_resources.get_distribution('sdkmanager').version
+        )
+        if sdkmanager_version < LooseVersion('0.6.4'):
+            raise unittest.SkipTest('needs fdroid sdkmanager >= 0.6.4')
+
+        fdroidserver.common.config = {'sdk_path': 'placeholder'}
+        build = fdroidserver.metadata.Build()
+        url = 'https://dl.google.com/android/repository/android-ndk-r24-linux.zip'
+        path = sdkmanager.get_cachedir() / os.path.basename(url)
+        sdkmanager.packages = {
+            ('ndk', '24.0.8215888'): url,
+            ('ndk', 'r24'): url,
+        }
+        build.ndk = 'r24'
+        firstrun = mock.Mock()
+        with mock.patch('sdkmanager.download_file', firstrun):
+            fdroidserver.common.auto_install_ndk(build)
+            firstrun.assert_called_once_with(url, path)
+        build.ndk = '24.0.8215888'
+        secondrun = mock.Mock()
+        with mock.patch('sdkmanager.download_file', secondrun):
+            fdroidserver.common.auto_install_ndk(build)
+            secondrun.assert_called_once_with(url, path)
+
     @unittest.skip("This test downloads and unzips a 1GB file.")
     def test_install_ndk(self):
         """NDK r10e is a special case since its missing source.properties"""
@@ -2257,101 +2294,6 @@ class CommonTest(unittest.TestCase):
         fdroidserver.common.fill_config_defaults(config)
         self.assertEqual({'r10e': r10e}, config['ndk_paths'])
 
-    def test_install_ndk_versions(self):
-        """Test whether NDK version parsing is working properly"""
-
-        def fake_download(url, zipball):
-            print(url, zipball)
-            with ZipFile(zipball, 'w') as zipfp:
-                zipfp.writestr(os.path.basename(url), url)
-
-        with tempfile.TemporaryDirectory(
-            prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir
-        ) as sdk_path:
-            config = {'sdk_path': sdk_path}
-            fdroidserver.common.config = config
-            for r, sha256 in (
-                (
-                    'r10e',
-                    'ee5f405f3b57c4f5c3b3b8b5d495ae12b660e03d2112e4ed5c728d349f1e520c',
-                ),
-                ('r20', '57435158f109162f41f2f43d5563d2164e4d5d0364783a9a6fab3ef12cb06ce0'),
-                (
-                    '23.0.7599858',
-                    'e3eacf80016b91d4cd2c8ca9f34eebd32df912bb799c859cc5450b6b19277b4f',
-                ),
-            ):
-                with mock.patch(
-                    'fdroidserver.net.download_file', side_effect=fake_download
-                ) as _ignored, mock.patch(
-                    'fdroidserver.common.get_ndk_version', return_value=r
-                ) as _ignored, mock.patch(
-                    'fdroidserver.common.sha256sum', return_value=sha256
-                ):
-                    _ignored  # silence the linters
-                    fdroidserver.common._install_ndk(r)
-
-    def test_install_ndk_with_symlinks(self):
-        """Some NDK zipballs might have symlinks in them."""
-
-        def fake_download(url, zipball):
-            print(url, zipball)
-            unix_st_mode = (
-                stat.S_IFLNK
-                | stat.S_IRUSR
-                | stat.S_IWUSR
-                | stat.S_IXUSR
-                | stat.S_IRGRP
-                | stat.S_IWGRP
-                | stat.S_IXGRP
-                | stat.S_IROTH
-                | stat.S_IWOTH
-                | stat.S_IXOTH
-            )
-            with ZipFile(zipball, 'w') as zipfp:
-                zipfp.writestr('ndk/' + os.path.basename(url), url)
-
-                zipInfo = ZipInfo('ndk/basename')
-                zipInfo.create_system = 3
-                zipInfo.external_attr = unix_st_mode << 16
-                zipfp.writestr(zipInfo, os.path.basename(url))
-
-                zipInfo = ZipInfo('ndk/bad_abs_link')
-                zipInfo.create_system = 3
-                zipInfo.external_attr = unix_st_mode << 16
-                zipfp.writestr(zipInfo, '/etc/passwd')
-
-                zipInfo = ZipInfo('ndk/bad_rel_link')
-                zipInfo.create_system = 3
-                zipInfo.external_attr = unix_st_mode << 16
-                zipfp.writestr(zipInfo, '../../../../../../../etc/passwd')
-
-                zipInfo = ZipInfo('ndk/bad_rel_link2')
-                zipInfo.create_system = 3
-                zipInfo.external_attr = unix_st_mode << 16
-                zipfp.writestr(zipInfo, 'foo/../../../../../../../../../etc/passwd')
-
-        config = {'sdk_path': self.tmpdir}
-        fdroidserver.common.config = config
-        r = 'r20'
-        sha256 = '57435158f109162f41f2f43d5563d2164e4d5d0364783a9a6fab3ef12cb06ce0'
-        with mock.patch(
-            'fdroidserver.net.download_file', side_effect=fake_download
-        ) as _ignored, mock.patch(
-            'fdroidserver.common.get_ndk_version', return_value=r
-        ) as _ignored, mock.patch(
-            'fdroidserver.common.sha256sum', return_value=sha256
-        ):
-            _ignored  # silence the linters
-            fdroidserver.common._install_ndk(r)
-
-        self.assertTrue(os.path.exists(os.path.join(self.tmpdir, 'ndk', 'r20')))
-        self.assertTrue(os.path.exists(os.path.join(self.tmpdir, 'ndk', 'r20', 'basename')))
-        self.assertFalse(os.path.exists(os.path.join(self.tmpdir, 'ndk', 'r20', 'bad_abs_link')))
-        self.assertFalse(os.path.exists(os.path.join(self.tmpdir, 'ndk', 'r20', 'bad_rel_link')))
-        self.assertFalse(os.path.exists(os.path.join(self.tmpdir, 'ndk', 'r20', 'bad_rel_link2')))
-        os.system('ls -l ' + os.path.join(self.tmpdir, 'ndk', 'r20'))
-
     def test_fill_config_defaults(self):
         """Test the auto-detection of NDKs installed in standard paths"""
         ndk_bundle = os.path.join(self.tmpdir, 'ndk-bundle')
@@ -2360,7 +2302,7 @@ class CommonTest(unittest.TestCase):
             fp.write('Pkg.Desc = Android NDK\nPkg.Revision = 17.2.4988734\n')
         config = {'sdk_path': self.tmpdir}
         fdroidserver.common.fill_config_defaults(config)
-        self.assertEqual({'r17c': ndk_bundle}, config['ndk_paths'])
+        self.assertEqual({'17.2.4988734': ndk_bundle}, config['ndk_paths'])
 
         r21e = os.path.join(self.tmpdir, 'ndk', '21.4.7075529')
         os.makedirs(r21e)
@@ -2368,7 +2310,10 @@ class CommonTest(unittest.TestCase):
             fp.write('Pkg.Desc = Android NDK\nPkg.Revision = 21.4.7075529\n')
         config = {'sdk_path': self.tmpdir}
         fdroidserver.common.fill_config_defaults(config)
-        self.assertEqual({'r17c': ndk_bundle, 'r21e': r21e}, config['ndk_paths'])
+        self.assertEqual(
+            {'17.2.4988734': ndk_bundle, '21.4.7075529': r21e},
+            config['ndk_paths'],
+        )
 
         r10e = os.path.join(self.tmpdir, 'ndk', 'r10e')
         os.makedirs(r10e)
@@ -2377,7 +2322,8 @@ class CommonTest(unittest.TestCase):
         config = {'sdk_path': self.tmpdir}
         fdroidserver.common.fill_config_defaults(config)
         self.assertEqual(
-            {'r10e': r10e, 'r17c': ndk_bundle, 'r21e': r21e}, config['ndk_paths']
+            {'r10e': r10e, '17.2.4988734': ndk_bundle, '21.4.7075529': r21e},
+            config['ndk_paths'],
         )
 
     @unittest.skipIf(not os.path.isdir('/usr/lib/jvm/default-java'), 'uses Debian path')
@@ -2411,7 +2357,7 @@ class CommonTest(unittest.TestCase):
         with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
             repo = git.Repo.init(Path.cwd())
             f = Path("test")
-            date = 10**9
+            date = 10 ** 9
             for tag in tags:
                 date += 1
                 f.write_text(tag)

tests/ndk-release-checksums.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-
-import git
-import gitlab
-import json
-import os
-import re
-import requests
-import subprocess
-import sys
-from colorama import Fore, Style
-
-
-checksums = None
-versions = dict()
-
-while not checksums:
-    r = requests.get(
-        'https://gitlab.com/fdroid/android-sdk-transparency-log/-/raw/master/checksums.json',
-        timeout=300,
-    )
-    if r.status_code == 200:
-        checksums = r.json()
-
-with open('fdroidserver/common.py') as fp:
-    common_py = fp.read()
-
-to_compile = re.search(r'\nNDKS = [^\]]+\]', common_py).group()
-if not to_compile:
-    sys.exit(1)
-code = compile(to_compile, '<string>', 'exec')
-config = {}
-exec(code, None, config)  # nosec this is just a CI script
-
-ndks = []
-errors = 0
-release = None
-revision = None
-for k, entries in checksums.items():
-    if k.endswith('.zip') and k.startswith(
-        'https://dl.google.com/android/repository/android-ndk'
-    ):
-        m = re.search(r'-(r[1-9][0-9]?[a-z]?)-linux', k)
-        if m:
-            d = {'url': k, 'release': m.group(1), 'sha256': checksums[k][0]['sha256']}
-            for entry in entries:
-                if 'source.properties' in entry:
-                    n = re.search(
-                        r'[1-9][0-9]\.[0-9]\.[0-9]{7}', entry['source.properties']
-                    )
-                    if n:
-                        d['revision'] = n.group()
-            ndks.append(d)
-            for d in config['NDKS']:
-                if k == d['url']:
-                    sha256 = d['sha256']
-                    found = False
-                    for entry in entries:
-                        if sha256 == entry['sha256']:
-                            found = True
-                    if not found:
-                        print(
-                            Fore.RED
-                            + (
-                                'ERROR: checksum mismatch: %s != %s'
-                                % (sha256, entry['sha256'])
-                            )
-                            + Style.RESET_ALL
-                        )
-                        errors += 1
-
-with open('fdroidserver/common.py', 'w') as fp:
-    fp.write(
-        common_py.replace(
-            to_compile, '\nNDKS = ' + json.dumps(ndks, indent=4, sort_keys=True)
-        )
-    )
-
-if os.getenv('CI_PROJECT_NAMESPACE') != 'fdroid':
-    p = subprocess.run(['git', '--no-pager', 'diff'])
-    print(p.stdout)
-    sys.exit(errors)
-
-
-# This only runs after commits are pushed to fdroid/fdroidserver
-git_repo = git.repo.Repo('.')
-modified = git_repo.git().ls_files(modified=True).split()
-if git_repo.is_dirty() and 'fdroidserver/common.py' in modified:
-    branch = git_repo.create_head(os.path.basename(__file__), force=True)
-    branch.checkout()
-    git_repo.index.add(['fdroidserver/common.py'])
-    author = git.Actor('fdroid-bot', 'fdroid-bot@f-droid.org')
-    git_repo.index.commit('Android NDK %s (%s)' % (release, revision), author=author)
-    project_path = 'fdroid-bot/' + os.getenv('CI_PROJECT_NAME')
-    url = 'https://gitlab-ci-token:%s@%s/%s.git' % (
-        os.getenv('PERSONAL_ACCESS_TOKEN'),
-        os.getenv('CI_SERVER_HOST'),
-        project_path,
-    )
-    remote_name = 'fdroid-bot'
-    try:
-        remote = git_repo.create_remote(remote_name, url)
-    # See https://github.com/PyCQA/pylint/issues/2856 .
-    # pylint: disable-next=no-member
-    except git.exc.GitCommandError:
-        remote = git.remote.Remote(git_repo, remote_name)
-        remote.set_url(url)
-    remote.push(force=True)
-    git.remote.Remote.rm(git_repo, remote_name)
-
-    private_token = os.getenv('PERSONAL_ACCESS_TOKEN')
-    if not private_token:
-        print(
-            Fore.RED
-            + 'ERROR: GitLab Token not found in PERSONAL_ACCESS_TOKEN!'
-            + Style.RESET_ALL
-        )
-        sys.exit(1)
-    gl = gitlab.Gitlab(
-        os.getenv('CI_SERVER_URL'), api_version=4, private_token=private_token
-    )
-    project = gl.projects.get(project_path, lazy=True)
-    description = (
-        'see <https://gitlab.com/fdroid/android-sdk-transparency-log/-/blob/master/checksums.json>'
-        '\n\n<p><small>generated by <a href="%s/-/jobs/%s">GitLab CI Job #%s</a></small></p>'
-        % (os.getenv('CI_PROJECT_URL'), os.getenv('CI_JOB_ID'), os.getenv('CI_JOB_ID'))
-    )
-    mr = project.mergerequests.create(
-        {
-            'source_branch': branch.name,
-            'target_project_id': 36527,  # fdroid/fdroidserver
-            'target_branch': 'master',
-            'title': 'update NDK',
-            'description': description,
-            'labels': ['fdroid-bot', 'buildserver'],
-            'remove_source_branch': True,
-        }
-    )
-    mr.save()