[Notes] [Git][BuildStream/buildstream][537-mirror-fallback-does-not-work

Jonathan Maw pushed to branch 537-mirror-fallback-does-not-work-for-git at BuildStream / buildstream

Commits:

942a06f4

by Mathieu Bridon at 2018-08-06T09:53:03Z

doc: Mention the Fedora packages

These aren't official yet, but they should work.

c04b8421

by Mathieu Bridon at 2018-08-06T10:53:57Z

Merge branch 'bochecha/fedora-packages' into 'master'

doc: Mention the Fedora packages

See merge request BuildStream/buildstream!604

12c79366

by toscalix at 2018-08-06T10:56:40Z

removed space in task template so checkboxes work as expected

bd2b3d8d

by Agustin Benito Bethencourt at 2018-08-06T11:49:12Z

Merge branch 'toscalix' into 'master'

removed space in task template so checkboxes work as expected

See merge request BuildStream/buildstream!588

d1b640d0
by James Ennis at 2018-08-06T13:10:12Z
```
install_linux_distro.rst: Fix broken links
```

be163e8d

by Jonathan Maw at 2018-08-06T14:01:58Z

Merge branch 'jennis/fix_links_in_docs' into 'master'

Fix two links in the installing docs

See merge request BuildStream/buildstream!610

4d6dbabe

by Tiago Gomes at 2018-08-06T15:03:25Z

PullQueue: fix resource used

Improve fetchers, builders and pushers documentation.

Closes #550.

a8073264

by Tiago Gomes at 2018-08-06T16:55:03Z

Merge branch 'tiagogomes/issue-550' into 'master'

PullQueue: fix resource used

Closes #550

See merge request BuildStream/buildstream!611

3d26ff6e

by Ed Baunton at 2018-08-07T05:04:50Z

remote.py: Add support for marking downloaded files executable

Add an optional flag to make files executable after having downloaded them.

Instead of leaving the permissioning of downloaded file in remote.py up
to the user's umask; expressly set permissions to 0644 or 0755 if
executable.

Bump format version to 13.

60a552a5

by Tristan Van Berkom at 2018-08-07T06:13:53Z

Merge branch 'edbaunton/executable-remote-source' into 'master'

remote.py: Add support for marking downloaded files executable

See merge request BuildStream/buildstream!581

01ff0177

by Javier Jardón at 2018-08-07T07:29:30Z

source/install_linux_distro.rst: Make clearer ArchLinux packages available

9b469fe6

by Tristan Van Berkom at 2018-08-07T09:12:46Z

Merge branch 'jjardon/doc_arch_releases' into 'master'

source/install_linux_distro.rst: Make clearer ArchLinux packages available

See merge request BuildStream/buildstream!613

289de2ef

by Adam Jones at 2018-08-07T09:24:58Z

Add systemd service file examples to artifacts documentation

change code style to ini

e42325b9

by Javier Jardón at 2018-08-07T10:29:46Z

Merge branch 'adamjones/systemd-cas' into 'master'

Include systemd file examples for google-cas cache

Closes #419

See merge request BuildStream/buildstream!524

6d349610

by Javier Jardón at 2018-08-07T10:53:23Z

source/install_linux_distro.rst: Fix formatting

493d19d2

by James Ennis at 2018-08-07T11:08:36Z

install_linux_distro.rst: Change install instructions for python-arpy package on Arch

  - python-arpy is unobtainable via pacman
  - Also a minor change to how we display install instructions
  from Fedora's dnf package manager

fc9869e2

by James Ennis at 2018-08-07T11:56:21Z

Merge branch 'jennis/change_arch_install_instructions' into 'master'

Change install instructions for python-arpy package on Arch

See merge request BuildStream/buildstream!614

91e6f3dd

by Jonathan Maw at 2018-08-07T12:09:47Z

tests: Test that fetching passes when upstream is absent

cfa99437

by Jonathan Maw at 2018-08-07T12:09:48Z

source.py: Fix documentation on get_source_fetchers

5330a555

by Jonathan Maw at 2018-08-08T09:05:28Z

git.py: Use the configured list of submodules when fetching with aliases

When the source's URL uses an alias (i.e. Source.translate_url()
actually changes the URL), we use the list of submodules defined in the
config as the list of submodules used.
This is because the source would otherwise have to fetch the main repo
to know which submodules it actually has.
This is inconvenient when using mirroring, because when the upstream
repo is unreachable it'll fail when it doesn't have to.

GitMirrors can now be instantiated without having their path and ref
defined, provided the 'parent' mirror is defined. It will retrieve the
path and ref as-needed instead.

If the source's URL does not use an alias, it will behave as normally.

12 changed files:

.gitlab/issue_templates/bst_task.md
buildstream/_scheduler/queues/pullqueue.py
buildstream/_versions.py
buildstream/data/userconfig.yaml
buildstream/plugins/sources/git.py
buildstream/plugins/sources/remote.py
buildstream/source.py
doc/source/install_artifacts.rst
doc/source/install_linux_distro.rst
tests/frontend/mirror.py
tests/sources/remote.py
+ tests/sources/remote/unique-keys/target-custom-executable.bst

Changes:

.gitlab/issue_templates/bst_task.md

@@ -6,9 +6,9 @@
  [//]: # (Short summary of the action to be executed)
 -* [  ] Action 1
 -* [  ] Action 2
 -* [  ] Action 3
 +* [ ] Action 1
 +* [ ] Action 2
 +* [ ] Action 3
  ## Acceptance Criteria

buildstream/_scheduler/queues/pullqueue.py

@@ -29,7 +29,7 @@ class PullQueue(Queue):
      action_name = "Pull"
      complete_name = "Pulled"
 -    resources = [ResourceType.UPLOAD]
 +    resources = [ResourceType.DOWNLOAD]
      def process(self, element):
          # returns whether an artifact was downloaded or not

buildstream/_versions.py

@@ -23,7 +23,7 @@
  # This version is bumped whenever enhancements are made
  # to the `project.conf` format or the core element format.
+ #
 -BST_FORMAT_VERSION = 12
 +BST_FORMAT_VERSION = 13
  # The base BuildStream artifact version

buildstream/data/userconfig.yaml

@@ -35,13 +35,13 @@ cache:
+ #
  scheduler:
 -  # Maximum number of simultaneous source downloading tasks.
 +  # Maximum number of simultaneous downloading tasks.
    fetchers: 10
    # Maximum number of simultaneous build tasks.
    builders: 4
 -  # Maximum number of simultaneous artifact uploading tasks.
 +  # Maximum number of simultaneous uploading tasks.
    pushers: 4
    # Maximum number of retries for network tasks.

buildstream/plugins/sources/git.py

@@ -91,16 +91,18 @@ GIT_MODULES = '.gitmodules'
+ #
  class GitMirror(SourceFetcher):
 -    def __init__(self, source, path, url, ref):
 +    def __init__(self, source, path, url, ref, *, parent=None):
          super().__init__()
          self.source = source
 -        self.path = path
 +        self.parent = parent
          self.url = url
 -        self.ref = ref
          self.mirror = os.path.join(source.get_mirror_directory(), utils.url_directory_name(url))
          self.mark_download_url(url)
 +        self._path = path
 +        self._ref = ref
++
      # Ensures that the mirror exists
      def ensure(self, alias_override=None):
@@ -223,8 +225,7 @@ class GitMirror(SourceFetcher):
                           fail="Failed to checkout git ref {}".format(self.ref),
                           cwd=fullpath)
 -    # List the submodules (path/url tuples) present at the given ref of this repo
 -    def submodule_list(self):
 +    def _read_gitmodules(self):
          modules = "{}:{}".format(self.ref, GIT_MODULES)
          exit_code, output = self.source.check_output(
              [self.source.host_git, 'show', modules], cwd=self.mirror)
@@ -247,10 +248,15 @@ class GitMirror(SourceFetcher):
          for section in parser.sections():
              # validate section name against the 'submodule "foo"' pattern
              if re.match(r'submodule "(.*)"', section):
 -                path = parser.get(section, 'path')
 -                url = parser.get(section, 'url')
 +                yield (parser, section)
 -                yield (path, url)
 +    # List the submodules (path/url tuples) present at the given ref of this repo
 +    def submodule_list(self):
 +        for parser, section in self._read_gitmodules():
 +            path = parser.get(section, 'path')
 +            url = parser.get(section, 'url')
++
 +            yield (path, url)
      # Fetch the ref which this mirror requires its submodule to have,
      # at the given ref of this mirror.
@@ -287,6 +293,33 @@ class GitMirror(SourceFetcher):
              return None
 +    def get_submodule_path(self, url):
 +        for parser, section in self._read_gitmodules():
 +            parsed_url = parser.get(section, 'url')
 +            if parsed_url == url:
 +                return parser.get(section, 'path')
++
 +        raise SourceError("{}: No submodule found with url '{}'".format(self.source, url))
++
 +    @property
 +    def path(self):
 +        if self._path is None:
 +            self._path = self.parent.get_submodule_path()
++
 +        return self._path
++
 +    @property
 +    def ref(self):
 +        # The top-level GitMirror may have ref as None, submodules don't.
 +        if self._ref is None and self.parent:
 +            self._ref = self.parent.submodule_ref(self.path)
++
 +        return self._ref
++
 +    @ref.setter
 +    def ref(self, ref):
 +        self._ref = ref
++
  class GitSource(Source):
      # pylint: disable=attribute-defined-outside-init
@@ -303,6 +336,8 @@ class GitSource(Source):
          self.checkout_submodules = self.node_get_member(node, bool, 'checkout-submodules', True)
          self.submodules = []
 +        self.using_source_fetchers = (self.original_url != self.translate_url(self.original_url))
++
          # Parse a dict of submodule overrides, stored in the submodule_overrides
          # and submodule_checkout_overrides dictionaries.
          self.submodule_overrides = {}
@@ -311,6 +346,11 @@ class GitSource(Source):
          for path, _ in self.node_items(modules):
              submodule = self.node_get_member(modules, Mapping, path)
              url = self.node_get_member(submodule, str, 'url', None)
++
 +            if self.using_source_fetchers:
 +                submodule_mirror = GitMirror(self, None, url, None, parent=self.mirror)
 +                self.submodules.append(submodule_mirror)
++
              self.submodule_overrides[path] = url
              if 'checkout' in submodule:
                  checkout = self.node_get_member(submodule, bool, 'checkout')
@@ -376,6 +416,24 @@ class GitSource(Source):
          return ret
 +    def fetch(self):
++
 +        with self.timed_activity("Fetching {}".format(self.mirror.url), silent_nested=True):
++
 +            # Here we are only interested in ensuring that our mirror contains
 +            # the self.mirror.ref commit.
 +            self.mirror.ensure()
 +            if not self.mirror.has_ref():
 +                self.mirror.fetch()
++
 +            self.mirror.assert_ref()
++
 +            # Here after performing any fetches, we need to also ensure that
 +            # we've cached the desired refs in our mirrors of submodules.
 +            #
 +            self.refresh_submodules()
 +            self.fetch_submodules()
++
      def init_workspace(self, directory):
          # XXX: may wish to refactor this as some code dupe with stage()
          self.refresh_submodules()
@@ -408,8 +466,11 @@ class GitSource(Source):
                      mirror.stage(directory)
      def get_source_fetchers(self):
 -        self.refresh_submodules()
 -        return [self.mirror] + self.submodules
 +        # If the url does not contain an alias, then it does not need SourceFetchers
 +        if self.mirror.url == self.translate_url(self.mirror.url):
 +            return []
 +        else:
 +            return [self.mirror] + self.submodules
      ###########################################################
      #                     Local Functions                     #
@@ -432,6 +493,11 @@ class GitSource(Source):
      # Assumes that we have our mirror and we have the ref which we point to
+     #
      def refresh_submodules(self):
++
 +        # When using source fetchers, the submodule list is defined by the 'submodules' config field
 +        if self.using_source_fetchers:
 +            return
++
          self.mirror.ensure()
          submodules = []
@@ -454,6 +520,19 @@ class GitSource(Source):
          self.submodules = submodules
 +    # Ensures that we have mirrored git repositories for all
 +    # the submodules existing at the given commit of the main git source.
 +    #
 +    # Also ensure that these mirrors have the required commits
 +    # referred to at the given commit of the main git source.
 +    #
 +    def fetch_submodules(self):
 +        for mirror in self.submodules:
 +            mirror.ensure()
 +            if not mirror.has_ref():
 +                mirror.fetch()
 +                mirror.assert_ref()
++
  # Plugin entry point
  def setup():

buildstream/plugins/sources/remote.py

@@ -35,6 +35,10 @@ remote - stage files from remote urls
     # If not specified, the basename of the url will be used.
     # filename: customfilename
 +   # Optionally specify whether the downloaded file should be
 +   # marked executable.
 +   # executable: true
++
     # Specify the url. Using an alias defined in your project
     # configuration is encouraged. 'bst track' will update the
     # sha256sum in 'ref' to the downloaded file's sha256sum.
@@ -43,6 +47,8 @@ remote - stage files from remote urls
     # Specify the ref. It's a sha256sum of the file you download.
     ref: 6c9f6f68a131ec6381da82f2bff978083ed7f4f7991d931bfa767b7965ebc94b
++
++
  .. note::
     The ``remote`` plugin is available since :ref:`format version 10 <project_format_version>`
@@ -60,22 +66,31 @@ class RemoteSource(DownloadableFileSource):
          super().configure(node)
          self.filename = self.node_get_member(node, str, 'filename', os.path.basename(self.url))
 +        self.executable = self.node_get_member(node, bool, 'executable', False)
          if os.sep in self.filename:
              raise SourceError('{}: filename parameter cannot contain directories'.format(self),
                                reason="filename-contains-directory")
 -        self.node_validate(node, DownloadableFileSource.COMMON_CONFIG_KEYS + ['filename'])
 +        self.node_validate(node, DownloadableFileSource.COMMON_CONFIG_KEYS + ['filename', 'executable'])
      def get_unique_key(self):
 -        return super().get_unique_key() + [self.filename]
 +        return super().get_unique_key() + [self.filename, self.executable]
      def stage(self, directory):
          # Same as in local plugin, don't use hardlinks to stage sources, they
          # are not write protected in the sandbox.
          dest = os.path.join(directory, self.filename)
          with self.timed_activity("Staging remote file to {}".format(dest)):
++
              utils.safe_copy(self._get_mirror_file(), dest)
 +            # To prevent user's umask introducing variability here, explicitly set
 +            # file modes.
 +            if self.executable:
 +                os.chmod(dest, 0o755)
 +            else:
 +                os.chmod(dest, 0o644)
++
  def setup():
      return RemoteSource

buildstream/source.py

@@ -393,8 +393,8 @@ class Source(Plugin):
          """Get the objects that are used for fetching
          If this source doesn't download from multiple URLs,
 -        returning None and falling back on the default behaviour
 -        is recommended.
 +        returning an empty list and falling back on the default
 +        behaviour is recommended.
          Returns:
             list: A list of SourceFetchers. If SourceFetchers are not supported,

doc/source/install_artifacts.rst

@@ -143,6 +143,50 @@ Instance with push and requiring client authentication:
      bst-artifact-server --port 11002 --server-key server.key --server-cert server.crt --client-certs authorized.crt --enable-push /home/artifacts/artifacts
 +Managing the cache with systemd
 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
++
 +It is better to run the cache as a systemd service, especially if it is running on a dedicated server, as this will allow systemd to manage the cache, incase the server ever encounters any issues.
++
 +Below are two examples of how to run the cache server as a systemd service, one is for pull only and the other is configured for push & pull.
++
 +.. code:: ini
++
 +   #
 +   # Pull
 +   #
 +   [Unit]
 +   Description=Buildstream Artifact pull server
 +   After=remote-fs.target network-online.target
++
 +   [Service]
 +   Environment="LC_ALL=C.UTF-8"
 +   ExecStart=/usr/local/bin/bst-artifact-server --port 11001 --server-key {{certs_path}}/privkey.pem --
 +   server-cert {{certs_path}}/fullchain.pem {{artifacts_path}}
 +   User=artifacts
++
 +   [Install]
 +   WantedBy=multi-user.target
++
++
 +   #
 +   # Pull/Push
 +   #
 +   [Unit]
 +   Description=Buildstream Artifact pull/push server
 +   After=remote-fs.target network-online.target
++
 +   [Service]
 +   Environment="LC_ALL=C.UTF-8"
 +   ExecStart=/usr/local/bin/bst-artifact-server --port 11002 --server-key {{certs_path}}/privkey.pem --
 +   server-cert {{certs_path}}/fullchain.pem --client-certs /home/artifacts/authorized.crt --enable-push /
 +   {{artifacts_path}}
 +   User=artifacts
++
 +   [Install]
 +   WantedBy=multi-user.target
++
 +Here we define when systemd should start the service, which is after the networking stack has been started, we then define how to run the cache with the desired configuration, under the artifacts user. The {{ }} are there to denote where you should change these files to point to your desired locations.
  User configuration
  ~~~~~~~~~~~~~~~~~~

doc/source/install_linux_distro.rst

@@ -57,9 +57,20 @@ Install the dependencies with::
  For the default plugins::
    sudo pacman -S \
 -      bzr git lzip ostree patch python-arpy python-gobject
 +      bzr git lzip ostree patch python-gobject
 +The package *python-arpy* is required by the deb source plugin. This is not
 +obtainable via `pacman`, you must get *python-arpy* from AUR:
 +https://aur.archlinux.org/packages/python-arpy/
++
 +To install::
++
 +  wget https://aur.archlinux.org/cgit/aur.git/snapshot/python-arpy.tar.gz
 +  tar -xvf python-arpy.tar.gz
 +  cd python-arpy
 +  makepkg -si
++
  Debian
  ++++++
  Install the dependencies with::
@@ -132,8 +143,8 @@ For the default plugins::
  Ubuntu 16.04 LTS
  ^^^^^^^^^^^^^^^^
 -On Ubuntu 16.04, neither `bubblewrap<https://github.com/projectatomic/bubblewrap/>`
 -or `ostree<https://github.com/ostreedev/ostree>` are available in the official repositories.
 +On Ubuntu 16.04, neither `bubblewrap <https://github.com/projectatomic/bubblewrap/>`_
 +or `ostree <https://github.com/ostreedev/ostree>`_ are available in the official repositories.
  You will need to install them in whichever way you see fit. Refer the the upstream documentation
  for advice on this.
@@ -216,8 +227,21 @@ Installing from distro packages
  Arch Linux
  ~~~~~~~~~~
 -Install `buildstream <https://aur.archlinux.org/packages/buildstream>`_
 -from `AUR <https://wiki.archlinux.org/index.php/Arch_User_Repository#Installing_packages>`_.
 -Alternatively, use
 -`buildstream-git <https://aur.archlinux.org/packages/buildstream-git>`_
 -for the lastest version of the development branch.
 +Packages for Arch exist in `AUR <https://wiki.archlinux.org/index.php/Arch_User_Repository#Installing_packages>`_.
 +Two different package versions are available:
++
 +* Latest release: `buildstream <https://aur.archlinux.org/packages/buildstream>`_
 +* Latest development snapshot: `buildstream-git <https://aur.archlinux.org/packages/buildstream-git>`_
++
++
 +Fedora
 +~~~~~~
++
 +BuildStream is not yet in the official Fedora repositories, but you can
 +install it from a Copr::
++
 +  sudo dnf copr enable bochecha/buildstream
 +  sudo dnf install buildstream
++
 +Optionally, install the ``buildstream-docs`` package to have the BuildStream
 +documentation in Devhelp or GNOME Builder.

tests/frontend/mirror.py

@@ -139,6 +139,63 @@ def test_mirror_fetch(cli, tmpdir, datafiles, kind):
      result.assert_success()
 +@pytest.mark.datafiles(DATA_DIR)
 +@pytest.mark.parametrize("kind", [(kind) for kind in ALL_REPO_KINDS])
 +def test_mirror_fetch_upstream_absent(cli, tmpdir, datafiles, kind):
 +    bin_files_path = os.path.join(str(datafiles), 'files', 'bin-files', 'usr')
 +    dev_files_path = os.path.join(str(datafiles), 'files', 'dev-files', 'usr')
 +    upstream_repodir = os.path.join(str(tmpdir), 'upstream')
 +    mirror_repodir = os.path.join(str(tmpdir), 'mirror')
 +    project_dir = os.path.join(str(tmpdir), 'project')
 +    os.makedirs(project_dir)
 +    element_dir = os.path.join(project_dir, 'elements')
++
 +    # Create repo objects of the upstream and mirror
 +    upstream_repo = create_repo(kind, upstream_repodir)
 +    ref = upstream_repo.create(dev_files_path)
 +    mirror_repo = upstream_repo.copy(mirror_repodir)
++
 +    element = {
 +        'kind': 'import',
 +        'sources': [
 +            upstream_repo.source_config(ref=ref)
 +        ]
 +    }
++
 +    element_name = 'test.bst'
 +    element_path = os.path.join(element_dir, element_name)
 +    full_repo = element['sources'][0]['url']
 +    upstream_map, repo_name = os.path.split(full_repo)
 +    alias = 'foo-' + kind
 +    aliased_repo = alias + ':' + repo_name
 +    element['sources'][0]['url'] = aliased_repo
 +    full_mirror = mirror_repo.source_config()['url']
 +    mirror_map, _ = os.path.split(full_mirror)
 +    os.makedirs(element_dir)
 +    _yaml.dump(element, element_path)
++
 +    project = {
 +        'name': 'test',
 +        'element-path': 'elements',
 +        'aliases': {
 +            alias: 'http://www.example.com/'
 +        },
 +        'mirrors': [
 +            {
 +                'name': 'middle-earth',
 +                'aliases': {
 +                    alias: [mirror_map + "/"],
 +                },
 +            },
 +        ]
 +    }
 +    project_file = os.path.join(project_dir, 'project.conf')
 +    _yaml.dump(project, project_file)
++
 +    result = cli.run(project=project_dir, args=['fetch', element_name])
 +    result.assert_success()
++
++
  @pytest.mark.datafiles(DATA_DIR)
  def test_mirror_fetch_multi(cli, tmpdir, datafiles):
      output_file = os.path.join(str(tmpdir), "output.txt")

tests/sources/remote.py

  import os
 +import stat
  import pytest
  from buildstream._exceptions import ErrorDomain
@@ -82,7 +83,14 @@ def test_simple_file_build(cli, tmpdir, datafiles):
      result.assert_success()
      # Note that the url of the file in target.bst is actually /dir/file
      # but this tests confirms we take the basename
 -    assert(os.path.exists(os.path.join(checkoutdir, 'file')))
 +    checkout_file = os.path.join(checkoutdir, 'file')
 +    assert(os.path.exists(checkout_file))
++
 +    mode = os.stat(checkout_file).st_mode
 +    # Assert not executable by anyone
 +    assert(not (mode & (stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)))
 +    # Assert not writeable by anyone other than me
 +    assert(not (mode & (stat.S_IWGRP | stat.S_IWOTH)))
  @pytest.mark.datafiles(os.path.join(DATA_DIR, 'single-file-custom-name'))
@@ -119,6 +127,7 @@ def test_unique_key(cli, tmpdir, datafiles):
      generate_project(project, tmpdir)
      assert cli.get_element_state(project, 'target.bst') == "fetch needed"
      assert cli.get_element_state(project, 'target-custom.bst') == "fetch needed"
 +    assert cli.get_element_state(project, 'target-custom-executable.bst') == "fetch needed"
      # Try to fetch it
      result = cli.run(project=project, args=[
          'fetch', 'target.bst'
@@ -127,7 +136,31 @@ def test_unique_key(cli, tmpdir, datafiles):
      # We should download the file only once
      assert cli.get_element_state(project, 'target.bst') == 'buildable'
      assert cli.get_element_state(project, 'target-custom.bst') == 'buildable'
 +    assert cli.get_element_state(project, 'target-custom-executable.bst') == 'buildable'
      # But the cache key is different because the 'filename' is different.
      assert cli.get_element_key(project, 'target.bst') != \
 -        cli.get_element_key(project, 'target-custom.bst')
 +        cli.get_element_key(project, 'target-custom.bst') != \
 +        cli.get_element_key(project, 'target-custom-executable.bst')
++
++
 +@pytest.mark.datafiles(os.path.join(DATA_DIR, 'unique-keys'))
 +def test_executable(cli, tmpdir, datafiles):
 +    '''This test confirms that the 'ecxecutable' parameter is honoured.
 +    '''
 +    project = os.path.join(datafiles.dirname, datafiles.basename)
 +    generate_project(project, tmpdir)
 +    checkoutdir = os.path.join(str(tmpdir), "checkout")
 +    assert cli.get_element_state(project, 'target-custom-executable.bst') == "fetch needed"
 +    # Try to fetch it
 +    result = cli.run(project=project, args=[
 +        'build', 'target-custom-executable.bst'
 +    ])
++
 +    result = cli.run(project=project, args=[
 +        'checkout', 'target-custom-executable.bst', checkoutdir
 +    ])
 +    mode = os.stat(os.path.join(checkoutdir, 'some-custom-file')).st_mode
 +    assert (mode & stat.S_IEXEC)
 +    # Assert executable by anyone
 +    assert(mode & (stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH))

tests/sources/remote/unique-keys/target-custom-executable.bst

 +kind: import
 +description: test
 +sources:
 +- kind: remote
 +  url: tmpdir:/dir/file
 +  ref: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
 +  filename: some-custom-file
 +  executable: true

[Notes] [Git][BuildStream/buildstream][537-mirror-fallback-does-not-work-for-git] 20 commits: doc: Mention the Fedora packages

Jonathan Maw pushed to branch 537-mirror-fallback-does-not-work-for-git at BuildStream / buildstream

Commits:

12 changed files:

Changes: